@pheem49/mint 1.8.0 → 1.8.2

package/crates/mint-cli/src/agent.rs

@@ -184,13 +184,19 @@ pub async fn run_code_agent_with_options(
     }
     let progress_live_status = Arc::clone(&live_status);
     let progress_cb = |progress: AgentProgress| match progress {
-        AgentProgress::Thinking { elapsed_secs } => {
+        AgentProgress::Thinking {
+            elapsed_secs,
+            agent_name,
+            model_name,
+        } => {
             if !options.fast_mode {
                 if let Ok(mut status) = progress_live_status.lock() {
-                    status.thinking = Some(format!(
-                        "Thinking ({} • Esc to interrupt)",
-                        format_elapsed(Duration::from_secs(elapsed_secs))
-                    ));
+                    let label = if let (Some(a), Some(m)) = (agent_name, model_name) {
+                        format!("{} ({}) is thinking ({} • Esc to interrupt)", a, m, format_elapsed(Duration::from_secs(elapsed_secs)))
+                    } else {
+                        format!("Thinking ({} • Esc to interrupt)", format_elapsed(Duration::from_secs(elapsed_secs)))
+                    };
+                    status.thinking = Some(label);
                     render_live_status(&mut status);
                 }
             }
@@ -325,6 +331,16 @@ pub async fn run_code_agent_with_options(
                     render_live_status(&mut status);
                 }
             }
+            // Parse web search sources from the result and store them for display
+            if action == "web_search"
+                && !result.starts_with("Web search error:")
+                && result != "No web search results found."
+            {
+                if let Ok(mut status) = progress_live_status.lock() {
+                    let sources = parse_web_search_sources(&result);
+                    status.web_sources.extend(sources);
+                }
+            }
         }
     };
 
@@ -337,9 +353,23 @@ pub async fn run_code_agent_with_options(
                 clear_live_status(&mut status);
             }
         }
-        let formatted_summary = format_markdown_bold(&summary);
-        print!("\n{MINT}Mint:{RESET} ");
+        let formatted_summary = format_markdown_bold(&sanitize_latex(&summary));
+        print!("\n  {MINT}Mint:{RESET} ");
         render_live_summary(&formatted_summary);
+
+        // Print web search sources if any were collected
+        if let Ok(mut status) = chunk_live_status.lock() {
+            if !status.web_sources.is_empty() {
+                println!();
+                println!("  {DIM}Sources:{RESET}");
+                for (i, (title, url)) in status.web_sources.iter().enumerate() {
+                    println!("  {DIM}{}.{RESET} {BLUE}{}{RESET}", i + 1, title);
+                    println!("     {DIM}{}{RESET}", url);
+                }
+                status.web_sources.clear();
+            }
+        }
+
         println!();
     };
 
@@ -349,6 +379,7 @@ pub async fn run_code_agent_with_options(
         root,
         image_data_uri,
         Some(CHAT_CLI_ID),
+        None,
         options.fast_mode,
         approve_cb,
         progress_cb,
@@ -377,16 +408,16 @@ pub async fn run_code_agent_with_options(
     let res = res.map_err(|e| anyhow!("{}", e))?;
 
     if should_show_verification(&res.verification) {
-        println!("Verification: {}", res.verification);
+        println!("  Verification: {}", res.verification);
     }
     println!(
-        "{DIM}─ Worked for {}{RESET}",
+        "  {DIM}─ Worked for {}{RESET}",
         format_elapsed(started_at.elapsed())
     );
 
     let (tw, _) = crossterm::terminal::size().unwrap_or((80, 24));
     let width = tw as usize;
-    println!("{DIM}{}{RESET}", "─".repeat(width));
+    println!("  {DIM}{}{RESET}", "─".repeat(width.saturating_sub(2)));
 
     Ok(res)
 }
@@ -396,6 +427,34 @@ fn clear_working_status() {
     let _ = io::stdout().flush();
 }
 
+/// Parse (title, url) pairs from the formatted `web_search` ToolEnd result text.
+/// The format produced by orchestration.rs is:
+///   1. Title\n   URL: https://...\n   Snippet\n
+fn parse_web_search_sources(result: &str) -> Vec<(String, String)> {
+    let mut sources = Vec::new();
+    let mut current_title: Option<String> = None;
+    for line in result.lines() {
+        let trimmed = line.trim();
+        // Match numbered title lines: "1. Title text"
+        if let Some(rest) = trimmed.split_once(". ") {
+            if rest.0.parse::<usize>().is_ok() {
+                current_title = Some(rest.1.trim().to_owned());
+                continue;
+            }
+        }
+        // Match URL lines: "URL: https://..."
+        if let Some(url) = trimmed.strip_prefix("URL: ") {
+            if let Some(title) = current_title.take() {
+                let url = url.trim().to_owned();
+                if !url.is_empty() {
+                    sources.push((title, url));
+                }
+            }
+        }
+    }
+    sources
+}
+
 fn format_elapsed(duration: Duration) -> String {
     let total_seconds = duration.as_secs();
     let minutes = total_seconds / 60;
@@ -408,19 +467,26 @@ fn format_elapsed(duration: Duration) -> String {
 }
 
 fn render_live_summary(summary: &str) {
-    let mut chunk = String::new();
-    for character in summary.chars() {
-        chunk.push(character);
-        if chunk.chars().count() >= 96 {
-            print!("{chunk}");
-            let _ = io::stdout().flush();
-            chunk.clear();
+    let (tw, _) = crossterm::terminal::size().unwrap_or((80, 24));
+    let width = tw as usize;
+
+    let mut is_first = true;
+    for line in summary.split('\n') {
+        let indent = if is_first { "" } else { "  " };
+        let options = textwrap::Options::new(width)
+            .initial_indent(indent)
+            .subsequent_indent("  ")
+            .break_words(true);
+        let wrapped = textwrap::fill(line, &options);
+
+        if is_first {
+            print!("{wrapped}");
+            is_first = false;
+        } else {
+            print!("\n{wrapped}");
         }
     }
-    if !chunk.is_empty() {
-        print!("{chunk}");
-        let _ = io::stdout().flush();
-    }
+    let _ = io::stdout().flush();
 }
 
 fn print_colored_diff(diff: &str) {
@@ -480,6 +546,8 @@ struct LiveStatus {
     committed_tasks: usize,
     rendered_lines: usize,
     spinner_tick: usize,
+    /// Sources collected from web_search ToolEnd results (title, url)
+    web_sources: Vec<(String, String)>,
 }
 
 #[derive(Debug, Clone)]
@@ -497,13 +565,21 @@ fn explored_action_label(action: &str, input: &serde_json::Value) -> Option<Expl
                 kind: "[list_files] List",
                 target: display_tool_target(path),
             }),
-        "read_file" => input
-            .get("path")
-            .and_then(|v| v.as_str())
-            .map(|path| ExploredAction {
+        "read_file" => {
+            let path = input.get("path").and_then(|v| v.as_str())?;
+            let start = input.get("startLine").and_then(|v| v.as_u64());
+            let end = input.get("endLine").and_then(|v| v.as_u64());
+            let file_name = display_tool_target(path);
+            let target = match (start, end) {
+                (Some(s), Some(e)) => format!("{} #L{}-{}", file_name, s, e),
+                (Some(s), None) => format!("{} #L{}", file_name, s),
+                _ => file_name,
+            };
+            Some(ExploredAction {
                 kind: "[read_file] Read",
-                target: display_tool_target(path),
-            }),
+                target,
+            })
+        }
         "search_code" => {
             let query = input.get("query").and_then(|v| v.as_str())?;
             let path = input.get("path").and_then(|v| v.as_str()).unwrap_or(".");
@@ -540,6 +616,30 @@ fn display_tool_target(path: &str) -> String {
     }
 }
 
+fn strip_ansi_escapes(s: &str) -> String {
+    let mut result = String::new();
+    let mut in_escape = false;
+    for c in s.chars() {
+        if c == '\x1b' {
+            in_escape = true;
+        } else if in_escape {
+            if c.is_ascii_alphabetic() {
+                in_escape = false;
+            }
+        } else {
+            result.push(c);
+        }
+    }
+    result
+}
+
+fn is_thai_combining(c: char) -> bool {
+    matches!(c,
+        '\u{0e31}' | '\u{0e34}'..='\u{0e37}' | '\u{0e38}'..='\u{0e39}' |
+        '\u{0e47}'..='\u{0e4e}'
+    )
+}
+
 fn render_live_status(status: &mut LiveStatus) {
     clear_live_status(status);
     let mut lines = Vec::new();
@@ -547,23 +647,48 @@ fn render_live_status(status: &mut LiveStatus) {
     let activities_start = status.committed_activities.min(status.activities.len());
     let tasks_start = status.committed_tasks.min(status.tasks.len());
 
-    lines.extend(plan_lines(&status.plan_steps));
-    lines.extend(tasks_lines(&status.tasks[tasks_start..]));
-    lines.extend(activities_lines(&status.activities[activities_start..]));
-    lines.extend(explored_lines(&status.explored[explored_start..]));
+    let is_thinking = status.thinking.is_some();
+    let tick = status.spinner_tick;
+
+    lines.extend(plan_lines(&status.plan_steps, is_thinking, tick));
+    lines.extend(tasks_lines(&status.tasks[tasks_start..], is_thinking, tick));
+    lines.extend(activities_lines(
+        &status.activities[activities_start..],
+        is_thinking,
+        tick,
+    ));
+    lines.extend(explored_lines(
+        &status.explored[explored_start..],
+        is_thinking,
+        tick,
+    ));
     if let Some(thinking) = &status.thinking {
-        let frames = &["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
+        let frames = &["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
         let frame = frames[status.spinner_tick % frames.len()];
         status.spinner_tick += 1;
-        lines.push(format!("{MINT}{frame}{RESET} {BRIGHT}{thinking}{RESET}"));
+        lines.push(format!("  {MINT}{frame}{RESET} {BRIGHT}{thinking}{RESET}"));
     }
     if lines.is_empty() {
         return;
     }
+
+    let (tw, _) = crossterm::terminal::size().unwrap_or((80, 24));
+    let width = tw as usize;
+
+    let mut physical_lines_count = 0;
     for line in &lines {
+        let stripped = strip_ansi_escapes(line);
+        let line_len = stripped.chars().filter(|&c| !is_thai_combining(c)).count();
+        let physical_lines = if width > 0 {
+            (line_len + width - 1) / width
+        } else {
+            1
+        }
+        .max(1);
+        physical_lines_count += physical_lines;
         println!("{line}");
     }
-    status.rendered_lines = lines.len();
+    status.rendered_lines = physical_lines_count;
     let _ = io::stdout().flush();
 }
 
@@ -573,9 +698,13 @@ fn commit_activity_snapshot(status: &mut LiveStatus) {
     let activities_start = status.committed_activities.min(status.activities.len());
     let tasks_start = status.committed_tasks.min(status.tasks.len());
 
-    let mut lines = explored_lines(&status.explored[explored_start..]);
-    lines.extend(activities_lines(&status.activities[activities_start..]));
-    lines.extend(tasks_lines(&status.tasks[tasks_start..]));
+    let mut lines = explored_lines(&status.explored[explored_start..], false, 0);
+    lines.extend(activities_lines(
+        &status.activities[activities_start..],
+        false,
+        0,
+    ));
+    lines.extend(tasks_lines(&status.tasks[tasks_start..], false, 0));
     if lines.is_empty() {
         return;
     }
@@ -594,7 +723,14 @@ fn print_timeline_note(thought: &str) {
     if thought.is_empty() {
         return;
     }
-    println!("{DIM}• {thought}{RESET}");
+    let (tw, _) = crossterm::terminal::size().unwrap_or((80, 24));
+    let width = tw as usize;
+    let options = textwrap::Options::new(width)
+        .initial_indent("  • ")
+        .subsequent_indent("    ")
+        .break_words(true);
+    let wrapped = textwrap::fill(thought, &options);
+    println!("{DIM}{wrapped}{RESET}");
 }
 
 fn print_timeline_separator() {
@@ -615,18 +751,34 @@ fn clear_live_status(status: &mut LiveStatus) {
     let _ = io::stdout().flush();
 }
 
-fn explored_lines(actions: &[ExploredAction]) -> Vec<String> {
+fn get_bullet(name: &str, is_thinking: bool, tick: usize) -> String {
+    let char_str = if is_thinking {
+        if (tick / 4) % 2 == 0 { "●" } else { "○" }
+    } else {
+        "●"
+    };
+
+    match name {
+        "plan" => format!("{BLUE}{char_str}{RESET} plan"),
+        "tasks" => format!("{MINT}{char_str}{RESET} tasks"),
+        "activity" => format!("{BLUE}{char_str}{RESET} activity"),
+        "explored" => format!("{DIM}{char_str}{RESET} explored"),
+        _ => char_str.to_string(),
+    }
+}
+
+fn explored_lines(actions: &[ExploredAction], is_thinking: bool, tick: usize) -> Vec<String> {
     if actions.is_empty() {
         return Vec::new();
     }
     let grouped = grouped_explored_actions(actions);
-    let mut lines = vec![format!("{BLUE}○ explored{RESET}")];
+    let mut lines = vec![format!("  {}", get_bullet("explored", is_thinking, tick))];
     lines.extend(grouped.iter().take(24).enumerate().map(|(index, action)| {
-        let prefix = if index == 0 { "  └" } else { "   " };
+        let prefix = if index == 0 { "    └" } else { "     " };
         format!("{DIM}{prefix} {action}{RESET}")
     }));
     if grouped.len() > 24 {
-        lines.push(format!("{DIM}   ... {} more{RESET}", grouped.len() - 24));
+        lines.push(format!("{DIM}     ... {} more{RESET}", grouped.len() - 24));
     }
     lines
 }
@@ -658,17 +810,20 @@ fn command_was_run(result: &str) -> bool {
     result.lines().any(|line| line.starts_with("exit: "))
 }
 
-fn activities_lines(activities: &[String]) -> Vec<String> {
+fn activities_lines(activities: &[String], is_thinking: bool, tick: usize) -> Vec<String> {
     if activities.is_empty() {
         return Vec::new();
     }
-    let mut lines = vec![format!("{BLUE}◇ activity{RESET}")];
+    let mut lines = vec![format!("  {}", get_bullet("activity", is_thinking, tick))];
     lines.extend(activities.iter().take(24).enumerate().map(|(index, act)| {
-        let prefix = if index == 0 { "  └" } else { "   " };
+        let prefix = if index == 0 { "    └" } else { "     " };
         format!("{DIM}{prefix} {act}{RESET}")
     }));
     if activities.len() > 24 {
-        lines.push(format!("{DIM}   ... {} more{RESET}", activities.len() - 24));
+        lines.push(format!(
+            "{DIM}     ... {} more{RESET}",
+            activities.len() - 24
+        ));
     }
     lines
 }
@@ -685,16 +840,16 @@ fn extract_plan_steps(input: &serde_json::Value) -> Option<Vec<String>> {
     Some(steps)
 }
 
-fn plan_lines(steps: &[String]) -> Vec<String> {
+fn plan_lines(steps: &[String], is_thinking: bool, tick: usize) -> Vec<String> {
     if steps.is_empty() {
         return Vec::new();
     }
-    let mut lines = vec![format!("{BLUE}● plan{RESET}")];
+    let mut lines = vec![format!("  {}", get_bullet("plan", is_thinking, tick))];
     for (index, step) in steps.iter().enumerate() {
         let prefix = if index == steps.len() - 1 {
-            "  └"
+            "    └"
         } else {
-            "  ├"
+            "    ├"
         };
         let (checked, text) = if step.to_lowercase().starts_with("done:") {
             (format!("{MINT}[x]{RESET}"), step["done:".len()..].trim())
@@ -722,17 +877,17 @@ fn plan_lines(steps: &[String]) -> Vec<String> {
     lines
 }
 
-fn tasks_lines(tasks: &[String]) -> Vec<String> {
+fn tasks_lines(tasks: &[String], is_thinking: bool, tick: usize) -> Vec<String> {
     if tasks.is_empty() {
         return Vec::new();
     }
-    let mut lines = vec![format!("{BLUE}● tasks{RESET}")];
+    let mut lines = vec![format!("  {}", get_bullet("tasks", is_thinking, tick))];
     lines.extend(tasks.iter().take(24).enumerate().map(|(index, task)| {
-        let prefix = if index == 0 { "  └" } else { "   " };
+        let prefix = if index == 0 { "    └" } else { "     " };
         format!("{DIM}{prefix} {task}{RESET}")
     }));
     if tasks.len() > 24 {
-        lines.push(format!("{DIM}   ... {} more{RESET}", tasks.len() - 24));
+        lines.push(format!("{DIM}     ... {} more{RESET}", tasks.len() - 24));
     }
     lines
 }
@@ -881,3 +1036,36 @@ fn process_inline_bold(text: &str) -> String {
     }
     result
 }
+
+/// Replace common LaTeX math symbols with Unicode equivalents.
+/// Fixes garbled output like "ightarrow$" from models that emit LaTeX notation.
+fn sanitize_latex(text: &str) -> String {
+    let mut s = text.to_owned();
+    for (pat, uni) in [
+        // arrows
+        ("$\\rightarrow$",     "→"),
+        ("$\\leftarrow$",      "←"),
+        ("$\\Rightarrow$",     "⇒"),
+        ("$\\Leftarrow$",      "⇐"),
+        ("$\\leftrightarrow$", "↔"),
+        // comparison
+        ("$\\leq$",    "≤"),
+        ("$\\geq$",    "≥"),
+        ("$\\neq$",    "≠"),
+        ("$\\approx$", "≈"),
+        // math
+        ("$\\times$", "×"),
+        ("$\\div$",   "÷"),
+        ("$\\pm$",    "±"),
+        ("$\\infty$", "∞"),
+        ("$\\cdot$",  "·"),
+        // sets
+        ("$\\in$",     "∈"),
+        ("$\\subset$", "⊂"),
+        ("$\\cup$",    "∪"),
+        ("$\\cap$",    "∩"),
+    ] {
+        s = s.replace(pat, uni);
+    }
+    s
+}