@pheem49/mint 1.17.0 → 1.18.0

package/crates/mint-cli/src/interactive/tool_activity.rs

@@ -6,7 +6,7 @@ use ratatui::{
 };
 use serde_json::Value;
 use std::time::{Duration, Instant};
-use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
+use unicode_width::UnicodeWidthStr;
 
 #[derive(Debug)]
 pub(super) struct ToolActivity {
@@ -63,8 +63,10 @@ impl ToolActivity {
                 return ToolStatus::Skipped;
             }
             if result.lines().any(|line| {
-                line.strip_prefix("exit: ")
-                    .is_some_and(|code| !matches!(code.trim(), "0" | "unknown"))
+                line.strip_prefix("exit: ").is_some_and(|code| {
+                    let c = code.trim();
+                    !matches!(c, "0" | "unknown") && !c.starts_with("running_in_background")
+                })
             }) || ["error:", "blocked:", "blocked by hook:"]
                 .iter()
                 .any(|prefix| result.trim_start().to_ascii_lowercase().starts_with(prefix))
@@ -152,6 +154,9 @@ impl ToolActivity {
         };
 
         if self.shell() {
+            if let Some(summary) = extract_field(&["toolSummary", "summary"]) {
+                return summary;
+            }
             if let Some(cmd) =
                 extract_field(&["command", "cmd", "script", "exec", "code", "bash", "sh"])
             {
@@ -179,6 +184,28 @@ impl ToolActivity {
             if let Some(p) = extract_field(&["path"]) {
                 return p;
             }
+        } else if matches!(self.action.as_str(), "create_plan" | "update_plan") {
+            let summary = extract_field(&["summary", "title"]);
+            let steps_count = self
+                .input
+                .get("steps")
+                .and_then(Value::as_array)
+                .map(Vec::len)
+                .unwrap_or(0);
+            let steps_label = if steps_count > 0 {
+                Some(format!(
+                    "{steps_count} step{}",
+                    if steps_count == 1 { "" } else { "s" }
+                ))
+            } else {
+                None
+            };
+            match (summary, steps_label) {
+                (Some(s), Some(steps)) => return format!("{s} ({steps})"),
+                (Some(s), None) => return s,
+                (None, Some(steps)) => return steps,
+                (None, None) => {}
+            }
         }
 
         for key in [
@@ -219,6 +246,46 @@ impl ToolActivity {
         }
         String::new()
     }
+
+    pub fn subagent_action_summary(action: &str, input: &Value) -> String {
+        if let Some(tool_summary) = input.get("toolSummary").and_then(Value::as_str) {
+            let trimmed = tool_summary.trim();
+            if !trimmed.is_empty() && !mint_core::is_dummy_value(trimmed) {
+                return format!("Running {}", trimmed);
+            }
+        }
+        for key in [
+            "description",
+            "command",
+            "cmd",
+            "path",
+            "query",
+            "pattern",
+            "url",
+        ] {
+            if let Some(val) = input.get(key).and_then(Value::as_str) {
+                if let Some(line) = val.lines().find(|l| !l.trim().is_empty()) {
+                    let trimmed = line.trim();
+                    if trimmed.is_empty() || mint_core::is_dummy_value(trimmed) {
+                        continue;
+                    }
+                    return match key {
+                        "command" | "cmd" => format!("Running `{trimmed}`"),
+                        "pattern" | "query" => format!("Searching for {trimmed}"),
+                        "path" => {
+                            if action == "write_file" || action == "edit_file" {
+                                format!("Editing {trimmed}")
+                            } else {
+                                format!("Reading {trimmed}")
+                            }
+                        }
+                        _ => trimmed.to_string(),
+                    };
+                }
+            }
+        }
+        action.replace('_', " ")
+    }
     pub fn lines(&self, width: u16) -> Vec<Line<'static>> {
         let output = self
             .result
@@ -438,23 +505,7 @@ pub(super) fn running_summary(tools: &[ToolActivity]) -> Option<String> {
 }
 
 fn clip(text: &str, width: usize) -> String {
-    if UnicodeWidthStr::width(text) <= width {
-        return text.to_owned();
-    }
-    let mut used = 0;
-    let mut clipped = String::new();
-    for ch in text.chars() {
-        let next = ch.width().unwrap_or(0);
-        if used + next > width.saturating_sub(1) {
-            break;
-        }
-        used += next;
-        clipped.push(ch);
-    }
-    if width > 0 {
-        clipped.push('…');
-    }
-    clipped
+    super::format::truncate_to_width(text, width)
 }
 
 #[cfg(test)]
@@ -663,5 +714,27 @@ mod tests {
             status: None,
         };
         assert_eq!(dummy_only.subject(), "");
+
+        let create_plan_tool = ToolActivity {
+            entry: 0,
+            call_id: None,
+            action: "create_plan".into(),
+            input: serde_json::json!({
+                "summary": "Fix streaming and plan rendering",
+                "steps": [
+                    {"title": "Stream native text", "status": "in_progress"},
+                    {"title": "Render PlanUpdated", "status": "pending"}
+                ]
+            }),
+            subagent: None,
+            started: Instant::now(),
+            elapsed: None,
+            result: None,
+            status: None,
+        };
+        assert_eq!(
+            create_plan_tool.subject(),
+            "Fix streaming and plan rendering (2 steps)"
+        );
     }
 }

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

@@ -11,6 +11,7 @@ use std::sync::{Arc, Mutex};
 mod chat_tui;
 pub mod command_ui;
 mod commands;
+mod composer;
 mod confirm;
 mod format;
 mod input_box;
@@ -53,6 +54,41 @@ pub static SESSION_APPROVED: std::sync::atomic::AtomicBool =
 pub static SECURITY_SESSION_APPROVED: std::sync::atomic::AtomicBool =
     std::sync::atomic::AtomicBool::new(false);
 
+static CLI_MIC_RECORDING: Mutex<Option<mint_core::mic_transcribe::MicRecordingHandle>> =
+    Mutex::new(None);
+
+pub(crate) fn is_cli_voice_recording() -> bool {
+    CLI_MIC_RECORDING
+        .lock()
+        .map(|guard| guard.is_some())
+        .unwrap_or(false)
+}
+
+pub(crate) fn start_cli_voice_recording() -> std::result::Result<(), String> {
+    let mut guard = CLI_MIC_RECORDING
+        .lock()
+        .map_err(|_| "Voice recorder lock poisoned".to_string())?;
+    if guard.is_some() {
+        return Err("A voice recording is already in progress.".to_string());
+    }
+    let handle = mint_core::mic_transcribe::start_recording().map_err(|e| e.to_string())?;
+    *guard = Some(handle);
+    Ok(())
+}
+
+pub(crate) fn stop_cli_voice_recording() -> std::result::Result<Option<Vec<u8>>, String> {
+    let handle = CLI_MIC_RECORDING
+        .lock()
+        .map_err(|_| "Voice recorder lock poisoned".to_string())?
+        .take();
+    match handle {
+        Some(h) => mint_core::mic_transcribe::stop_recording(h)
+            .map(Some)
+            .map_err(|e| e.to_string()),
+        None => Ok(None),
+    }
+}
+
 pub struct InteractiveSession {
     pub chat_id: String,
     pub config: MintConfig,
@@ -793,6 +829,7 @@ pub async fn run_interactive_chat_with_session(
         match slash_result {
             Some(SlashResult::Handled) => continue,
             Some(SlashResult::Exit) => {
+                let _ = stop_cli_voice_recording();
                 print_exit_message(&session);
                 break;
             }

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

@@ -31,12 +31,15 @@ pub use commands::Command;
 mod browser_cli_regressions {
     use super::*;
     #[test]
-    fn browser_workflow_command_accepts_a_file_and_headed_override() {
+    fn browser_workflow_command_accepts_a_file_and_rejects_headed_override() {
         let parsed =
-            Cli::try_parse_from(["mint", "browser", "run", "--file", "task.json", "--headed"])
-                .unwrap();
+            Cli::try_parse_from(["mint", "browser", "run", "--file", "task.json"]).unwrap();
         assert!(matches!(parsed.command, Some(Command::Browser { .. })));
         assert!(Cli::try_parse_from(["mint", "browser", "run"]).is_err());
+        assert!(
+            Cli::try_parse_from(["mint", "browser", "run", "--file", "task.json", "--headed"])
+                .is_err()
+        );
     }
 }
 pub use interactive::{

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

@@ -20,42 +20,7 @@ pub fn is_table_line(line: &str) -> bool {
 }
 
 pub fn unicode_width(s: &str) -> usize {
-    let mut count = 0;
-    let mut chars = s.chars().peekable();
-    while let Some(c) = chars.next() {
-        if c == '\u{1b}' && chars.peek() == Some(&'[') {
-            chars.next();
-            for c2 in chars.by_ref() {
-                if c2.is_ascii_alphabetic() {
-                    break;
-                }
-            }
-            continue;
-        }
-        let val = c as u32;
-        if (0x0E31..=0x0E31).contains(&val)
-            || (0x0E34..=0x0E3A).contains(&val)
-            || (0x0E47..=0x0E4E).contains(&val)
-        {
-            continue;
-        }
-        if is_cjk(c) {
-            count += 2;
-        } else {
-            count += 1;
-        }
-    }
-    count
-}
-
-pub fn is_cjk(c: char) -> bool {
-    let val = c as u32;
-    (0x4E00..=0x9FFF).contains(&val)
-        || (0x3400..=0x4DBF).contains(&val)
-        || (0x20000..=0x2A6DF).contains(&val)
-        || (0xAC00..=0xD7AF).contains(&val)
-        || (0x3040..=0x309F).contains(&val)
-        || (0x30A0..=0x30FF).contains(&val)
+    crate::interactive::display_width(s)
 }
 
 /// Splits `text` into lines that each fit within `max_width` (measured with
@@ -150,7 +115,7 @@ pub fn render_markdown_table(table_lines: &[String]) -> String {
     render_markdown_table_with_width(table_lines, term_width)
 }
 
-fn render_markdown_table_with_width(table_lines: &[String], term_width: u16) -> String {
+pub(crate) fn render_markdown_table_with_width(table_lines: &[String], term_width: u16) -> String {
     let mut rows: Vec<Vec<String>> = Vec::new();
     for line in table_lines {
         let trimmed = line.trim();