@pheem49/mint 1.16.0 → 1.17.0

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

@@ -55,6 +55,13 @@ 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"))
@@ -70,15 +77,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 +95,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 +123,262 @@ 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(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;
+            }
+        }
+
         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 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…")
         )
@@ -301,7 +499,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 +523,145 @@ 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(), "");
+    }
 }

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

@@ -370,6 +370,8 @@ pub async fn run_interactive_chat_with_session(
         jobs: BackgroundJobs::new(),
     };
 
+    crate::companion_navigation::configure(&session.chat_id);
+
     let mut tui = if use_tui {
         match chat_tui::ChatTui::enter(&session.current_dir) {
             Ok(terminal) => {
@@ -434,6 +436,7 @@ pub async fn run_interactive_chat_with_session(
         ) {
             Ok(Some(target_id)) => {
                 session.chat_id = target_id.clone();
+                crate::companion_navigation::set_chat(&session.chat_id);
                 mint_core::live_sync::update_live_sync_chat_id(&session.chat_id);
                 ui.reload_transcript(&session.chat_id, &session.current_dir);
                 ui.push_notice(format!("Switched to session: {target_id}"));
@@ -447,6 +450,33 @@ pub async fn run_interactive_chat_with_session(
         }
     }
 
+    let needs_onboarding = session.config.api_key.is_empty()
+        && session.config.anthropic_api_key.is_empty()
+        && session.config.openai_api_key.is_empty()
+        && session.config.openrouter_api_key.is_empty()
+        && session.config.deepseek_api_key.is_empty()
+        && session.config.hf_api_key.is_empty()
+        && session.config.local_api_base_url.is_empty()
+        && session.config.ollama_model.is_empty();
+
+    if needs_onboarding && !prompt_resume_at_start {
+        let mut ui: Box<dyn CommandUi> = match tui.as_mut() {
+            Some((terminal, state, handle)) => {
+                Box::new(FullScreenCommandUi::new(terminal, state, handle))
+            }
+            None => Box::new(ClassicCommandUi::new()),
+        };
+        let should_onboard = ui
+            .prompt_confirm(
+                "No AI provider configured yet. Run the onboarding wizard now?",
+                true,
+            )
+            .unwrap_or(false);
+        if should_onboard {
+            let _ = ui.prompt_onboard(&mut session.config);
+        }
+    }
+
     let mut startup_update = crate::updater::get_cached_update_notice();
     let mut update_handle = if crate::updater::should_check_for_update() {
         Some(tokio::task::spawn_blocking(
@@ -853,11 +883,13 @@ pub fn copy_dir_all(src: impl AsRef<Path>, dst: impl AsRef<Path>) -> std::io::Re
     Ok(())
 }
 pub fn load_all_available_skills(current_dir: &Path) -> Vec<mint_core::LearnedSkill> {
-    MemoryStore::open_default()
-        .ok()
-        .and_then(|memory| {
-            mint_core::skill_inventory::list_available_skills(&memory, Some(current_dir)).ok()
-        })
+    let memory = MemoryStore::open_default().unwrap_or_else(|_| {
+        MemoryStore::open(std::env::temp_dir().join(format!(
+            "mint-fallback-memory-{}.sqlite",
+            std::process::id()
+        )))
+    });
+    mint_core::skill_inventory::list_available_skills(&memory, Some(current_dir))
         .unwrap_or_default()
         .into_iter()
         .map(|entry| entry.skill)

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

@@ -8,6 +8,7 @@ mod actions;
 mod agent;
 mod background;
 pub mod commands;
+mod companion_navigation;
 mod cron_wizard;
 mod gateway;
 mod gmail;
@@ -25,6 +26,19 @@ pub(crate) mod terminal_theme;
 mod updater;
 
 pub use commands::Command;
+
+#[cfg(test)]
+mod browser_cli_regressions {
+    use super::*;
+    #[test]
+    fn browser_workflow_command_accepts_a_file_and_headed_override() {
+        let parsed =
+            Cli::try_parse_from(["mint", "browser", "run", "--file", "task.json", "--headed"])
+                .unwrap();
+        assert!(matches!(parsed.command, Some(Command::Browser { .. })));
+        assert!(Cli::try_parse_from(["mint", "browser", "run"]).is_err());
+    }
+}
 pub use interactive::{
     SESSION_APPROVED, active_model, confirm, confirm_security, print_welcome_banner,
     run_interactive_chat, run_interactive_chat_with_options,
@@ -317,11 +331,18 @@ fn log_panic_to_file(message: &str) {
     }
 }
 
-#[tokio::main]
-async fn main() -> Result<()> {
+fn main() -> Result<()> {
     if std::env::args().nth(1).as_deref() == Some("--mint-mod-host") {
         return mint_mod_runtime::worker_main().map_err(anyhow::Error::msg);
     }
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .thread_stack_size(8 * 1024 * 1024)
+        .build()?
+        .block_on(async_main())
+}
+
+async fn async_main() -> Result<()> {
     let _background_shutdown = mint_core::bg_shell::ShutdownGuard;
     install_panic_hook();
     let mut cli = Cli::parse();