opencrabs 0.3.75

//! String utility functions.

/// Truncate a string to at most `max_bytes` bytes, ensuring the cut lands on a
/// valid UTF-8 char boundary. Returns the longest prefix that fits.
pub fn truncate_str(s: &str, max_bytes: usize) -> &str {
    if s.len() <= max_bytes {
        return s;
    }
    let mut end = max_bytes;
    while end > 0 && !s.is_char_boundary(end) {
        end -= 1;
    }
    &s[..end]
}

/// Returns true if `s` looks like a file path rather than a slash command.
///
/// Slash commands are `/` followed by a single word with no additional slashes
/// and no file extension (e.g. `/help`, `/models`, `/deploy`).
///
/// File paths have additional `/` segments (e.g. `/Users/alice/file.pdf`)
/// or a recognizable file extension on the first word (e.g. `/report.pdf check this`).
///
/// This prevents drag-and-dropped file paths from triggering "Unknown command" errors.
pub fn looks_like_file_path(s: &str) -> bool {
    if !s.starts_with('/') {
        return false;
    }
    // If it contains another `/` after the leading slash, it's a path
    // (e.g. `/Users/...`, `/tmp/...`, `./` resolved to absolute)
    if s[1..].contains('/') {
        return true;
    }
    // If the first word (before any space) has a file extension, treat as path
    // e.g. `/report.pdf check this` → the `/report.pdf` part is a file
    let first_word = s.split_whitespace().next().unwrap_or(s);
    if let Some(ext) = std::path::Path::new(first_word).extension()
        && !ext.is_empty()
    {
        return true;
    }
    false
}

/// Collapse the current user's `$HOME` prefix to `~` in paths/commands.
/// `/Users/alice/srv/foo/bar.rs` → `~/srv/foo/bar.rs`. Keeps absolute
/// paths OUTSIDE home untouched so `/tmp/...` or `/etc/...` still render
/// faithfully. No-op if home isn't resolvable or doesn't appear in `s`.
pub fn tilde_home(s: &str) -> String {
    let home = match dirs::home_dir() {
        Some(h) => h,
        None => return s.to_string(),
    };
    let home_str = home.to_string_lossy();
    if home_str.is_empty() {
        return s.to_string();
    }
    // Replace all occurrences — bash commands like `cd /Users/me/a && cp /Users/me/b /Users/me/c`
    // benefit from every instance being collapsed.
    s.replace(home_str.as_ref(), "~")
}

/// Shorten a string to fit `max_bytes` while preserving both ends —
/// essential for file paths where the filename (tail) is usually the
/// most informative part. `~/a/b/c/d/very_long_name.rs` truncated to
/// 30 bytes becomes `~/a/b/…/very_long_name.rs` rather than
/// `~/a/b/c/d/very_long_na` which loses the `.rs` extension entirely.
///
/// Respects UTF-8 char boundaries on both sides of the ellipsis.
pub fn truncate_middle(s: &str, max_bytes: usize) -> String {
    if s.len() <= max_bytes {
        return s.to_string();
    }
    const ELLIPSIS: &str = "…"; // 3 bytes
    if max_bytes <= ELLIPSIS.len() + 2 {
        // Too small to preserve both ends meaningfully — fall back to head truncation.
        return truncate_str(s, max_bytes).to_string();
    }
    let budget = max_bytes - ELLIPSIS.len();
    // Slight bias toward keeping the tail since filenames / final args
    // carry more signal than the leading path components.
    let tail_bytes = budget.div_ceil(2);
    let head_bytes = budget - tail_bytes;

    let mut head_end = head_bytes;
    while head_end > 0 && !s.is_char_boundary(head_end) {
        head_end -= 1;
    }
    let mut tail_start = s.len() - tail_bytes;
    while tail_start < s.len() && !s.is_char_boundary(tail_start) {
        tail_start += 1;
    }
    if tail_start <= head_end {
        return truncate_str(s, max_bytes).to_string();
    }
    format!("{}{}{}", &s[..head_end], ELLIPSIS, &s[tail_start..])
}

/// Format a token count as a compact human-readable string (e.g. "150K", "1.2M").
fn format_token_count(tokens: u32) -> String {
    let tokens = tokens as f64;
    if tokens >= 1_000_000.0 {
        format!("{:.1}M", tokens / 1_000_000.0)
    } else if tokens >= 1_000.0 {
        format!("{:.0}K", tokens / 1_000.0)
    } else if tokens > 0.0 {
        format!("{}", tokens as u32)
    } else {
        "0".to_string()
    }
}

/// Format a context budget footer line: "ctx: 8K/200K 4% | 45 tok/s".
///
/// Used by channel handlers to append a context usage indicator to the
/// final message delivered to the user. Plain text so it works across all
/// channel-specific formatters (Telegram HTML, Discord markdown, Slack mrkdwn, WhatsApp).
pub fn format_ctx_footer(used: u32, max: u32, tps: Option<f64>) -> String {
    let pct = if max > 0 {
        (used as f64 / max as f64) * 100.0
    } else {
        0.0
    };
    let base = format!(
        "ctx: {}/{} {:.0}%",
        format_token_count(used),
        format_token_count(max),
        pct
    );
    if let Some(rate) = tps {
        format!("{} | {:.0} tok/s", base, rate)
    } else {
        base
    }
}

/// Build a GitHub-flavored markdown table (`| h | h |` + `| --- | --- |` +
/// rows). Telegram's native rich renderer (`sendRichMessage`) turns this into a
/// real bordered table; the HTML fallback renders a phone-friendly grid /
/// key-value list. Returns `""` for no rows so callers can skip empty sections.
///
/// Cell contents have `|` and newlines neutralized so a stray pipe in a value
/// can't shift columns or break the row.
pub fn md_table(headers: &[&str], rows: &[Vec<String>]) -> String {
    if rows.is_empty() {
        return String::new();
    }
    let clean = |s: &str| s.replace(['|', '\n'], " ");
    let mut out = String::new();
    out.push_str("| ");
    out.push_str(
        &headers
            .iter()
            .map(|h| clean(h))
            .collect::<Vec<_>>()
            .join(" | "),
    );
    out.push_str(" |\n|");
    for _ in headers {
        out.push_str(" --- |");
    }
    out.push('\n');
    for row in rows {
        out.push_str("| ");
        out.push_str(&row.iter().map(|c| clean(c)).collect::<Vec<_>>().join(" | "));
        out.push_str(" |\n");
    }
    out
}

/// Strip ctx footer lines (e.g. "ctx: 84K/200K 42% | 406 tok/s") from text.
/// Used on incoming reply quotes so the metadata never leaks into agent context.
pub fn strip_ctx_footer(text: &str) -> String {
    text.lines()
        .filter(|line| {
            let trimmed = line.trim();
            !trimmed.starts_with("ctx:") || !trimmed.contains('/') || !trimmed.contains('%')
        })
        .collect::<Vec<_>>()
        .join("\n")
        .trim_end_matches('\n')
        .to_string()
}

/// A short, human-readable status excerpt of the model's live reasoning (#742),
/// at the one-line budget the Telegram flow header uses.
///
/// The TUI wants more room and calls [`thinking_excerpt_capped`] directly, so
/// widening it there does not quietly turn every Telegram status edit into a
/// paragraph (#768).
pub fn thinking_excerpt(thinking: &str) -> Option<String> {
    thinking_excerpt_capped(thinking, THINKING_STATUS_CHARS)
}

/// One-line budget for a chat status line, where the message is edited
/// repeatedly and length is noise.
pub const THINKING_STATUS_CHARS: usize = 80;

/// As [`thinking_excerpt`], with the caller choosing how much to keep.
///
/// Walks the reasoning right-to-left, picks the latest non-trivial sentence,
/// strips a leading "I am / I'm / I will / Let me / Let us", capitalises it, and
/// caps at `max_chars`. Returns `None` for reasoning too short to summarise.
pub fn thinking_excerpt_capped(thinking: &str, max_chars: usize) -> Option<String> {
    let trimmed = thinking.trim();
    if trimmed.len() < 20 {
        return None;
    }
    // Walk sentences right-to-left, pick the latest non-trivial one.
    let mut sentences: Vec<&str> = trimmed
        .split(['.', '?', '!', '\n'])
        .map(str::trim)
        .filter(|s| s.len() >= 12)
        .collect();
    let last = sentences.pop()?;
    let cleaned = last
        .strip_prefix("I am ")
        .or_else(|| last.strip_prefix("I'm "))
        .or_else(|| last.strip_prefix("I will "))
        .or_else(|| last.strip_prefix("Let me "))
        .or_else(|| last.strip_prefix("Let us "))
        .unwrap_or(last)
        .trim();
    if cleaned.is_empty() {
        return None;
    }
    // Capitalise the first letter so "assessing X" -> "Assessing X".
    let mut chars = cleaned.chars();
    let first = chars.next()?;
    let rest: String = chars.collect();
    let pretty = format!("{}{}", first.to_uppercase(), rest);
    let capped: String = pretty.chars().take(max_chars).collect();
    Some(if pretty.chars().count() > max_chars {
        format!("{capped}…")
    } else {
        capped
    })
}

/// How much of the latest reasoning sentence the live summary keeps.
///
/// 80 cut a multi-step chain off mid-thought ("… → commit #766 → comment+close
/// #…"), which is the one moment the line is meant to be useful. 300 is about
/// three wrapped lines on a normal terminal, and the renderer caps the wrap at
/// three, so this stays a fixed budget rather than the scrolling window #742
/// replaced (#768).
pub const THINKING_EXCERPT_CHARS: usize = 300;