@pheem49/mint 1.16.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 {
@@ -55,9 +55,18 @@ impl ToolActivity {
             {
                 return ToolStatus::Cancelled;
             }
+            if result
+                .trim_start()
+                .to_ascii_lowercase()
+                .starts_with("skipped")
+            {
+                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))
@@ -70,15 +79,15 @@ impl ToolActivity {
     }
     pub fn heading(&self) -> String {
         let name = if self.shell() {
-            "Shell".to_owned()
+            "run_shell".to_owned()
         } else {
             self.action.replace('_', " ")
         };
         let (icon, status) = match self.status {
             None => ("●", "running"),
-            Some(ToolStatus::Success) => ("✓", "completed"),
-            Some(ToolStatus::Failed) => ("✗", "failed"),
-            Some(ToolStatus::TimedOut) => ("✗", "timed out"),
+            Some(ToolStatus::Success) => ("●", "completed"),
+            Some(ToolStatus::Failed) => ("●", "failed"),
+            Some(ToolStatus::TimedOut) => ("●", "timed out"),
             Some(ToolStatus::Cancelled)
                 if self
                     .result
@@ -88,6 +97,9 @@ impl ToolActivity {
                 ("○", "interrupted")
             }
             Some(ToolStatus::Cancelled) => ("○", "cancelled"),
+            Some(ToolStatus::Running) => ("◌", "running"),
+            Some(ToolStatus::Unknown) => ("?", "unconfirmed"),
+            Some(ToolStatus::Skipped) => ("○", "skipped"),
         };
         let elapsed = if self.running() {
             Some(self.started.elapsed())
@@ -113,74 +125,327 @@ impl ToolActivity {
         title
     }
     pub fn subject(&self) -> String {
+        let extract_field = |keys: &[&str]| -> Option<String> {
+            for &key in keys {
+                if let Some(value) = self.input.get(key).and_then(Value::as_str) {
+                    if let Some(line) = value
+                        .lines()
+                        .find(|l| !l.trim().is_empty() && !mint_core::is_dummy_value(l))
+                    {
+                        return Some(line.trim().to_owned());
+                    }
+                }
+            }
+            if let Some(args) = self.input.get("arguments") {
+                if let Some(obj) = args.as_object() {
+                    for &key in keys {
+                        if let Some(value) = obj.get(key).and_then(Value::as_str) {
+                            if let Some(line) = value
+                                .lines()
+                                .find(|l| !l.trim().is_empty() && !mint_core::is_dummy_value(l))
+                            {
+                                return Some(line.trim().to_owned());
+                            }
+                        }
+                    }
+                }
+            }
+            None
+        };
+
+        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"])
+            {
+                return cmd;
+            }
+        } else if matches!(
+            self.action.as_str(),
+            "web_search" | "search_code" | "knowledge_search"
+        ) {
+            if let Some(q) = extract_field(&[
+                "query",
+                "q",
+                "keyword",
+                "search",
+                "prompt",
+                "searchTerm",
+                "search_term",
+            ]) {
+                return q;
+            }
+        } else if matches!(
+            self.action.as_str(),
+            "read_file" | "write_file" | "view_image"
+        ) {
+            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 [
             "description",
             "command",
             "cmd",
+            "script",
+            "exec",
+            "code",
+            "bash",
+            "sh",
             "path",
             "query",
             "pattern",
             "url",
         ] {
             if let Some(value) = self.input.get(key).and_then(Value::as_str) {
-                if let Some(line) = value.lines().find(|line| !line.trim().is_empty()) {
+                if let Some(line) = value
+                    .lines()
+                    .find(|line| !line.trim().is_empty() && !mint_core::is_dummy_value(line))
+                {
                     return line.trim().to_owned();
                 }
             }
         }
-        self.input.to_string()
+        if let Some(args) = self.input.get("arguments") {
+            if let Some(obj) = args.as_object() {
+                for key in ["command", "cmd", "script", "exec", "code", "bash", "sh"] {
+                    if let Some(value) = obj.get(key).and_then(Value::as_str) {
+                        if let Some(line) = value.lines().find(|line| {
+                            !line.trim().is_empty() && !mint_core::is_dummy_value(line)
+                        }) {
+                            return line.trim().to_owned();
+                        }
+                    }
+                }
+            }
+        }
+        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 color = match self.status {
-            None => crate::terminal_theme::TEXT,
-            Some(ToolStatus::Success) => crate::terminal_theme::ACCENT,
-            Some(ToolStatus::Cancelled) => crate::terminal_theme::WARNING,
-            _ => Color::Red,
-        };
         let output = self
             .result
             .as_ref()
             .map(|result| format!("Output · {} lines · ", result.lines().count()))
             .unwrap_or_default();
-        vec![
-            Line::styled(
-                clip(&self.heading(), width as usize),
+        let subject = self.subject();
+        let is_command = self
+            .input
+            .get("command")
+            .or_else(|| self.input.get("cmd"))
+            .or_else(|| self.input.get("script"))
+            .or_else(|| self.input.get("exec"))
+            .or_else(|| self.input.get("code"))
+            .or_else(|| self.input.get("bash"))
+            .or_else(|| self.input.get("sh"))
+            .and_then(Value::as_str)
+            .is_some()
+            || self.shell();
+        let mut lines = vec![self.heading_line(width as usize)];
+        if !subject.is_empty() {
+            let color = if is_command {
+                crate::terminal_theme::ACCENT
+            } else {
+                crate::terminal_theme::TEXT
+            };
+            lines.push(Line::styled(
+                clip(&format!("  {}", subject), width as usize),
                 Style::default().fg(color),
+            ));
+        }
+        lines.push(Line::from(vec![
+            Span::styled(
+                format!("  {output}"),
+                Style::default().fg(crate::terminal_theme::MUTED),
             ),
-            Line::styled(
-                clip(&format!("  {}", self.subject()), width as usize),
+            Span::styled(
+                "Ctrl+O details",
+                Style::default().fg(crate::terminal_theme::BLUE),
+            ),
+        ]));
+        lines
+    }
+    fn heading_line(&self, width: usize) -> Line<'static> {
+        let color = match self.status {
+            None => crate::terminal_theme::TEXT,
+            Some(ToolStatus::Success) => crate::terminal_theme::ACCENT,
+            Some(ToolStatus::Cancelled | ToolStatus::Skipped) => crate::terminal_theme::WARNING,
+            _ => Color::Red,
+        };
+        let heading = clip(&self.heading(), width);
+        let icon_end = heading.chars().next().map_or(0, char::len_utf8);
+        Line::from(vec![
+            Span::styled(heading[..icon_end].to_owned(), Style::default().fg(color)),
+            Span::styled(
+                heading[icon_end..].to_owned(),
                 Style::default().fg(crate::terminal_theme::TEXT),
             ),
-            Line::from(vec![
-                Span::styled(
-                    format!("  {output}"),
-                    Style::default().fg(crate::terminal_theme::MUTED),
-                ),
-                Span::styled(
-                    "Ctrl+O details",
-                    Style::default().fg(crate::terminal_theme::BLUE),
-                ),
-            ]),
-        ]
+        ])
     }
-    pub fn details(&self) -> String {
+    fn detail_input(&self) -> (bool, String) {
         let command = self
             .input
             .get("command")
             .or_else(|| self.input.get("cmd"))
-            .and_then(Value::as_str);
+            .and_then(Value::as_str)
+            .filter(|s| !s.trim().is_empty());
         let input = command
             .map(str::to_owned)
             .unwrap_or_else(|| serde_json::to_string_pretty(&self.input).unwrap_or_default());
+        (command.is_some(), input)
+    }
+    pub fn detail_lines(&self) -> Vec<Line<'static>> {
+        use crate::terminal_theme::{ACCENT, BLUE, TEXT};
+        let (command, input) = self.detail_input();
+        let mut lines = vec![
+            self.heading_line(usize::MAX),
+            Line::styled(format!("Tool: {}", self.action), Style::default().fg(TEXT)),
+            Line::default(),
+            Line::styled(
+                if command { "Command" } else { "Input" },
+                Style::default().fg(BLUE),
+            ),
+        ];
+        lines.extend(input.lines().map(|line| {
+            Line::styled(
+                line.to_owned(),
+                Style::default().fg(if command { ACCENT } else { TEXT }),
+            )
+        }));
+        lines.push(Line::default());
+        lines.push(Line::styled("Output", Style::default().fg(BLUE)));
+        let result_text = self.result.as_deref().unwrap_or("Waiting for result…");
+        if self.action == "web_search"
+            && !result_text.starts_with("Web search error:")
+            && result_text != "No web search results found."
+        {
+            for line in result_text.lines() {
+                let trimmed = line.trim_start();
+                if let Some((num, title)) = trimmed.split_once(". ")
+                    && num.parse::<usize>().is_ok()
+                {
+                    lines.push(Line::from(vec![
+                        Span::styled(
+                            format!("{num}. "),
+                            Style::default()
+                                .fg(BLUE)
+                                .add_modifier(ratatui::style::Modifier::BOLD),
+                        ),
+                        Span::styled(
+                            title.to_owned(),
+                            Style::default()
+                                .fg(TEXT)
+                                .add_modifier(ratatui::style::Modifier::BOLD),
+                        ),
+                    ]));
+                } else if let Some(url) = trimmed.strip_prefix("URL: ") {
+                    lines.push(Line::from(vec![
+                        Span::styled(
+                            "   URL: ",
+                            Style::default().fg(crate::terminal_theme::MUTED),
+                        ),
+                        Span::styled(url.to_owned(), Style::default().fg(ACCENT)),
+                    ]));
+                } else if let Some(img) = trimmed.strip_prefix("Image: ") {
+                    lines.push(Line::from(vec![
+                        Span::styled(
+                            "   Image: ",
+                            Style::default().fg(crate::terminal_theme::MUTED),
+                        ),
+                        Span::styled(
+                            img.to_owned(),
+                            Style::default().fg(crate::terminal_theme::MUTED),
+                        ),
+                    ]));
+                } else if trimmed.is_empty() {
+                    lines.push(Line::default());
+                } else {
+                    lines.push(Line::styled(
+                        format!("   {trimmed}"),
+                        Style::default().fg(crate::terminal_theme::MUTED),
+                    ));
+                }
+            }
+        } else {
+            lines.extend(
+                result_text
+                    .lines()
+                    .map(|line| Line::styled(line.to_owned(), Style::default().fg(TEXT))),
+            );
+        }
+        lines
+    }
+    pub fn details(&self) -> String {
+        let (command, input) = self.detail_input();
         format!(
             "{}\nTool: {}\n\n{}\n{}\n\nOutput\n{}",
             self.heading(),
             self.action,
-            if command.is_some() {
-                "Command"
-            } else {
-                "Input"
-            },
+            if command { "Command" } else { "Input" },
             input,
             self.result.as_deref().unwrap_or("Waiting for result…")
         )
@@ -240,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)]
@@ -301,7 +550,7 @@ mod tests {
             };
             tool.finish(result, None);
             assert!(matches!(tool.status, Some(ToolStatus::Failed)), "{result}");
-            assert_eq!(tool.lines(80)[0].style.fg, Some(Color::Red));
+            assert_eq!(tool.lines(80)[0].spans[0].style.fg, Some(Color::Red));
         }
     }
 
@@ -325,4 +574,167 @@ mod tests {
                 .contains("User denied shell command: echo example")
         );
     }
+
+    #[test]
+    fn command_subject_is_styled_with_accent_color() {
+        let tool = ToolActivity {
+            entry: 0,
+            call_id: None,
+            action: "run_shell".into(),
+            input: serde_json::json!({"command":"mkdir -p /tmp/test"}),
+            subagent: None,
+            started: Instant::now(),
+            elapsed: None,
+            result: None,
+            status: None,
+        };
+        let lines = tool.lines(80);
+        assert_eq!(lines[1].style.fg, Some(crate::terminal_theme::ACCENT));
+
+        let non_command = ToolActivity {
+            entry: 0,
+            call_id: None,
+            action: "read_file".into(),
+            input: serde_json::json!({"path":"/tmp/test.png"}),
+            subagent: None,
+            started: Instant::now(),
+            elapsed: None,
+            result: None,
+            status: None,
+        };
+        let non_cmd_lines = non_command.lines(80);
+        assert_eq!(non_cmd_lines[1].style.fg, Some(crate::terminal_theme::TEXT));
+    }
+
+    #[test]
+    fn web_search_detail_lines_format_titles_and_urls_distinctly() {
+        let tool = ToolActivity {
+            entry: 0,
+            call_id: None,
+            action: "web_search".into(),
+            input: serde_json::json!({"query":"cosplay"}),
+            subagent: None,
+            started: Instant::now(),
+            elapsed: None,
+            result: Some("1. Cosplay Site\n   URL: https://example.com/cosplay\n   Image: https://example.com/img.jpg\n   High quality cosplay photos".into()),
+            status: Some(ToolStatus::Success),
+        };
+        let detail_lines = tool.detail_lines();
+        // Title line should have bold styling
+        let title_line = detail_lines
+            .iter()
+            .find(|l| l.to_string().contains("1. Cosplay Site"))
+            .expect("title line found");
+        assert!(title_line.spans.iter().any(|s| {
+            s.style
+                .add_modifier
+                .contains(ratatui::style::Modifier::BOLD)
+        }));
+        // URL line should format the URL with ACCENT color
+        let url_line = detail_lines
+            .iter()
+            .find(|l| l.to_string().contains("URL: https://example.com/cosplay"))
+            .expect("url line found");
+        assert!(
+            url_line
+                .spans
+                .iter()
+                .any(|s| s.style.fg == Some(crate::terminal_theme::ACCENT))
+        );
+    }
+
+    #[test]
+    fn detail_input_ignores_empty_command_string_and_shows_input() {
+        let tool = ToolActivity {
+            entry: 0,
+            call_id: None,
+            action: "web_search".into(),
+            input: serde_json::json!({"command": "", "query": "cosplay"}),
+            subagent: None,
+            started: Instant::now(),
+            elapsed: None,
+            result: Some("No web search results found.".into()),
+            status: Some(ToolStatus::Success),
+        };
+        let (is_command, input) = tool.detail_input();
+        assert!(!is_command);
+        assert!(input.contains("\"query\": \"cosplay\""));
+
+        let lines = tool.detail_lines();
+        assert!(lines.iter().any(|l| l.to_string() == "Input"));
+        assert!(!lines.iter().any(|l| l.to_string() == "Command"));
+    }
+
+    #[test]
+    fn subject_ignores_dummy_null_strings_and_prioritizes_action() {
+        let shell_tool = ToolActivity {
+            entry: 0,
+            call_id: None,
+            action: "run_shell".into(),
+            input: serde_json::json!({
+                "command": "cd /tmp && ls",
+                "path": "null",
+                "query": "null",
+                "name": "null"
+            }),
+            subagent: None,
+            started: Instant::now(),
+            elapsed: None,
+            result: None,
+            status: None,
+        };
+        assert_eq!(shell_tool.subject(), "cd /tmp && ls");
+
+        let search_tool = ToolActivity {
+            entry: 0,
+            call_id: None,
+            action: "web_search".into(),
+            input: serde_json::json!({
+                "query": "Kuuko W",
+                "path": "null",
+                "command": "null"
+            }),
+            subagent: None,
+            started: Instant::now(),
+            elapsed: None,
+            result: None,
+            status: None,
+        };
+        assert_eq!(search_tool.subject(), "Kuuko W");
+
+        let dummy_only = ToolActivity {
+            entry: 0,
+            call_id: None,
+            action: "run_shell".into(),
+            input: serde_json::json!({"command": "null"}),
+            subagent: None,
+            started: Instant::now(),
+            elapsed: None,
+            result: None,
+            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)"
+        );
+    }
 }