@pheem49/mint 1.15.0 → 1.16.0

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

@@ -0,0 +1,328 @@
+//! Compact terminal tool cards, with unmodified input and output for review.
+use mint_core::integrations::mcp_result::ToolStatus;
+use ratatui::{
+    style::{Color, Style},
+    text::{Line, Span},
+};
+use serde_json::Value;
+use std::time::{Duration, Instant};
+use unicode_width::{UnicodeWidthChar, UnicodeWidthStr};
+
+#[derive(Debug)]
+pub(super) struct ToolActivity {
+    pub entry: usize,
+    pub call_id: Option<String>,
+    pub action: String,
+    pub input: Value,
+    pub subagent: Option<String>,
+    pub started: Instant,
+    pub elapsed: Option<Duration>,
+    pub result: Option<String>,
+    pub status: Option<ToolStatus>,
+}
+
+impl ToolActivity {
+    pub fn running(&self) -> bool {
+        self.status.is_none()
+    }
+    pub fn shell(&self) -> bool {
+        matches!(
+            self.action.as_str(),
+            "run_shell" | "shell_output" | "kill_shell"
+        )
+    }
+    pub fn matches(
+        &self,
+        call_id: Option<&str>,
+        action: &str,
+        input: &Value,
+        subagent: Option<&str>,
+    ) -> bool {
+        if let Some(id) = call_id {
+            self.call_id.as_deref() == Some(id) && self.subagent.as_deref() == subagent
+        } else {
+            self.action == action && self.input == *input && self.subagent.as_deref() == subagent
+        }
+    }
+    pub fn finish(&mut self, result: &str, status: Option<ToolStatus>) {
+        self.elapsed = Some(self.started.elapsed());
+        self.result = Some(result.to_owned());
+        self.status = Some(status.unwrap_or_else(|| {
+            if result
+                .trim_start()
+                .to_ascii_lowercase()
+                .starts_with("user denied")
+            {
+                return ToolStatus::Cancelled;
+            }
+            if result.lines().any(|line| {
+                line.strip_prefix("exit: ")
+                    .is_some_and(|code| !matches!(code.trim(), "0" | "unknown"))
+            }) || ["error:", "blocked:", "blocked by hook:"]
+                .iter()
+                .any(|prefix| result.trim_start().to_ascii_lowercase().starts_with(prefix))
+            {
+                ToolStatus::Failed
+            } else {
+                ToolStatus::Success
+            }
+        }));
+    }
+    pub fn heading(&self) -> String {
+        let name = if self.shell() {
+            "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::Cancelled)
+                if self
+                    .result
+                    .as_deref()
+                    .is_some_and(|text| text.starts_with("Interrupted")) =>
+            {
+                ("○", "interrupted")
+            }
+            Some(ToolStatus::Cancelled) => ("○", "cancelled"),
+        };
+        let elapsed = if self.running() {
+            Some(self.started.elapsed())
+        } else {
+            self.elapsed
+        };
+        let duration = elapsed
+            .map(|elapsed| format!("{:.1}s", elapsed.as_secs_f64()))
+            .unwrap_or_else(|| "time unavailable".into());
+        let mut title = format!("{icon} {name} {status} · {duration}");
+        if let Some(result) = &self.result {
+            let codes: Vec<_> = result
+                .lines()
+                .filter_map(|line| line.strip_prefix("exit: "))
+                .collect();
+            if !codes.is_empty() {
+                title.push_str(&format!(" · exit {}", codes.join(", ")));
+            }
+        }
+        if let Some(agent) = &self.subagent {
+            title.push_str(&format!(" · {agent}"));
+        }
+        title
+    }
+    pub fn subject(&self) -> String {
+        for key in [
+            "description",
+            "command",
+            "cmd",
+            "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()) {
+                    return line.trim().to_owned();
+                }
+            }
+        }
+        self.input.to_string()
+    }
+    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),
+                Style::default().fg(color),
+            ),
+            Line::styled(
+                clip(&format!("  {}", self.subject()), width as usize),
+                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 {
+        let command = self
+            .input
+            .get("command")
+            .or_else(|| self.input.get("cmd"))
+            .and_then(Value::as_str);
+        let input = command
+            .map(str::to_owned)
+            .unwrap_or_else(|| serde_json::to_string_pretty(&self.input).unwrap_or_default());
+        format!(
+            "{}\nTool: {}\n\n{}\n{}\n\nOutput\n{}",
+            self.heading(),
+            self.action,
+            if command.is_some() {
+                "Command"
+            } else {
+                "Input"
+            },
+            input,
+            self.result.as_deref().unwrap_or("Waiting for result…")
+        )
+    }
+}
+
+/// Pinned status: counts plus the newest running calls, independent of transcript scrolling.
+pub(super) fn running_lines(tools: &[ToolActivity], width: usize, tick: usize) -> Vec<String> {
+    let Some(summary) = running_summary(tools) else {
+        return Vec::new();
+    };
+    let frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let spinner = frames[tick % frames.len()];
+    let mut lines = vec![clip(&format!("● {summary}"), width)];
+    let mut running: Vec<_> = tools
+        .iter()
+        .rev()
+        .filter(|tool| tool.running())
+        .take(2)
+        .collect();
+    running.reverse();
+    for tool in running {
+        let prefix = format!("      {spinner} [{}] ", tool.action);
+        let suffix = format!(" ({:.1}s)", tool.started.elapsed().as_secs_f64());
+        let available = width.saturating_sub(
+            UnicodeWidthStr::width(prefix.as_str()) + UnicodeWidthStr::width(suffix.as_str()),
+        );
+        let line = format!("{prefix}{}{suffix}", clip(&tool.subject(), available));
+        lines.push(clip(&line, width));
+    }
+    lines
+}
+
+pub(super) fn running_summary(tools: &[ToolActivity]) -> Option<String> {
+    let shells = tools
+        .iter()
+        .filter(|tool| tool.running() && tool.shell())
+        .count();
+    let other = tools
+        .iter()
+        .filter(|tool| tool.running() && !tool.shell())
+        .count();
+    let shell_label = format!(
+        "{shells} shell command{}",
+        if shells == 1 { "" } else { "s" }
+    );
+    let other_label = format!("{other} tool{}", if other == 1 { "" } else { "s" });
+    match (shells, other) {
+        (0, 0) => None,
+        (_, 0) => Some(format!("Running {shell_label}")),
+        (0, _) => Some(format!("Running {other_label}")),
+        _ => Some(format!(
+            "Running {} tasks · {shell_label} · {other_label}",
+            shells + other
+        )),
+    }
+}
+
+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
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn pinned_running_status_animates_and_clips_commands_without_losing_timer() {
+        let mut tool = ToolActivity {
+            entry: 0,
+            call_id: None,
+            action: "run_shell".into(),
+            input: serde_json::json!({"command":"x".repeat(300)}),
+            subagent: None,
+            started: Instant::now() - Duration::from_secs(3),
+            elapsed: None,
+            result: None,
+            status: None,
+        };
+        let first = running_lines(std::slice::from_ref(&tool), 60, 0);
+        let next = running_lines(std::slice::from_ref(&tool), 60, 1);
+        assert!(first[1].contains('⠋'));
+        assert!(next[1].contains('⠙'));
+        assert!(first[1].ends_with("(3.0s)"));
+        assert!(UnicodeWidthStr::width(first[1].as_str()) <= 60);
+        tool.finish("exit: 0", None);
+        assert!(running_lines(&[tool], 60, 2).is_empty());
+    }
+
+    #[test]
+    fn blocked_tools_are_failed_instead_of_successful() {
+        for result in ["Blocked: pinned server", "Blocked by hook: denied"] {
+            let mut tool = ToolActivity {
+                entry: 0,
+                call_id: None,
+                action: "read_file".into(),
+                input: serde_json::json!({"path":"example"}),
+                subagent: None,
+                started: Instant::now(),
+                elapsed: None,
+                result: None,
+                status: None,
+            };
+            tool.finish(result, None);
+            assert!(matches!(tool.status, Some(ToolStatus::Failed)), "{result}");
+            assert_eq!(tool.lines(80)[0].style.fg, Some(Color::Red));
+        }
+    }
+
+    #[test]
+    fn denied_shell_command_is_cancelled_and_keeps_the_denial_in_details() {
+        let mut tool = ToolActivity {
+            entry: 0,
+            call_id: None,
+            action: "run_shell".into(),
+            input: serde_json::json!({"command":"echo example"}),
+            subagent: None,
+            started: Instant::now(),
+            elapsed: None,
+            result: None,
+            status: None,
+        };
+        tool.finish("User denied shell command: echo example", None);
+        assert!(matches!(tool.status, Some(ToolStatus::Cancelled)));
+        assert!(
+            tool.details()
+                .contains("User denied shell command: echo example")
+        );
+    }
+}

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

@@ -18,9 +18,12 @@ mod picker;
 mod resume_picker;
 mod slash_commands;
 mod thought_viewer;
+mod tool_activity;
 
 pub(crate) use chat_tui::TuiHandle;
 pub(crate) use chat_tui::restore_terminal;
+#[cfg(test)]
+pub(crate) use chat_tui::{ChatTui, ChatViewState};
 pub use command_ui::*;
 pub use commands::*;
 pub use confirm::*;
@@ -94,6 +97,7 @@ async fn run_interactive_agent_turn(
         plan_mode: session.plan_mode,
         queueing: true,
         pinned_mcp_server,
+        image_name: None,
         chat_id: Some(session.chat_id.clone()),
         tui: None,
     };
@@ -443,16 +447,7 @@ pub async fn run_interactive_chat_with_session(
         }
     }
 
-    let mut printed_update = false;
-    if let Some((current, latest)) = crate::updater::get_cached_update_notice() {
-        if let Some((_, _, handle)) = tui.as_mut() {
-            handle.push_notice(crate::updater::format_tui_update_notice(&current, &latest));
-        } else {
-            crate::updater::print_update_notice(&current, &latest);
-        }
-        printed_update = true;
-    }
-
+    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(
             crate::updater::check_for_update_quietly,
@@ -461,6 +456,53 @@ pub async fn run_interactive_chat_with_session(
         None
     };
 
+    // Offer the menu only at startup. A slow registry must not interrupt a
+    // conversation later; its result will use the passive notice below.
+    if startup_update.is_none()
+        && let (Some((terminal, state, handle)), Some(check)) =
+            (tui.as_mut(), update_handle.as_mut())
+    {
+        handle.set_status(vec!["Checking for updates…".into()]);
+        if let Ok(state) = state.lock() {
+            terminal.draw_state(&state)?;
+        }
+        let result = tokio::time::timeout(std::time::Duration::from_secs(2), check).await;
+        handle.clear_status();
+        if let Ok(result) = result {
+            startup_update = result.ok().flatten();
+            update_handle = None;
+        }
+    }
+
+    let mut printed_update = false;
+    if let Some((current, latest)) = startup_update {
+        if let Some((terminal, _, handle)) = tui.as_mut() {
+            match terminal.prompt_update(handle, &current, &latest)? {
+                Some(0) => {
+                    terminal.suspend();
+                    match crate::updater::run(false, false, true) {
+                        Ok(()) => return Ok(()),
+                        Err(error) => {
+                            terminal.resume()?;
+                            handle.push_notice(format!(
+                                "Update failed: {error}. Run `mint update --approve` to retry."
+                            ));
+                        }
+                    }
+                }
+                Some(2) => {
+                    if let Err(error) = crate::updater::skip_version(&latest) {
+                        handle.push_notice(format!("Could not save skipped version: {error}"));
+                    }
+                }
+                _ => {}
+            }
+        } else {
+            crate::updater::print_update_notice(&current, &latest);
+        }
+        printed_update = true;
+    }
+
     // Follow-up messages typed while an agent turn is still running (into the
     // queueing box `agent::run_code_agent_with_options` keeps on screen) come
     // back out via `run_code_agent_with_saved_image`'s return value. They're
@@ -670,13 +712,13 @@ pub async fn run_interactive_chat_with_session(
 
                     let task_with_skill = format!(
                         "=== ACTIVATED SKILL: {} ===\n\
-                         {}\n\
+                         Description: {}\nPath: {}\nRead this skill file through read_file before using it.\n\
                          ===========================\n\n\
                          Task: {}",
-                        skill.name, skill.content, final_task
+                        skill.name, description, skill.source_path, final_task
                     );
 
-                    ui.push_notice(format!("Skill({}) loaded", skill.name));
+                    ui.push_notice(format!("Selected skill: {}", skill.name));
                     drop(ui);
 
                     match run_interactive_agent_turn(
@@ -811,33 +853,15 @@ 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> {
-    let mut skills = match MemoryStore::open_default() {
-        Ok(m) => m.learned_skills(100).unwrap_or_default(),
-        Err(_) => Vec::new(),
-    };
-
-    if let Some(home) = dirs::home_dir() {
-        let global_agents_path = home.join(".gemini").join("config").join("AGENTS.md");
-        mint_core::skills::load_agent_rules_file(&global_agents_path, &mut skills);
-
-        let global_skills_path = home.join(".config").join("mint").join("mint-skills");
-        mint_core::skills::load_skills_from_dir(&global_skills_path, &mut skills);
-    }
-    let workspace_agents_path1 = current_dir.join(".agents").join("AGENTS.md");
-    mint_core::skills::load_agent_rules_file(&workspace_agents_path1, &mut skills);
-    let workspace_agents_path2 = current_dir.join("AGENTS.md");
-    mint_core::skills::load_agent_rules_file(&workspace_agents_path2, &mut skills);
-
-    let workspace_skills_path1 = current_dir.join(".agents").join("skills");
-    mint_core::skills::load_skills_from_dir(&workspace_skills_path1, &mut skills);
-    let workspace_skills_path2 = current_dir.join("skills");
-    mint_core::skills::load_skills_from_dir(&workspace_skills_path2, &mut skills);
-
-    let mut unique_skills = std::collections::BTreeMap::new();
-    for skill in skills {
-        unique_skills.insert(skill.name.clone(), skill);
-    }
-    unique_skills.into_values().collect()
+    MemoryStore::open_default()
+        .ok()
+        .and_then(|memory| {
+            mint_core::skill_inventory::list_available_skills(&memory, Some(current_dir)).ok()
+        })
+        .unwrap_or_default()
+        .into_iter()
+        .map(|entry| entry.skill)
+        .collect()
 }
 
 #[cfg(test)]

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

@@ -46,9 +46,6 @@ pub(crate) async fn run_code_agent_with_saved_image(
     video_data_uri: Option<String>,
     options: agent::AgentOptions,
 ) -> Result<(Vec<String>, Option<String>)> {
-    let sent_image = image_data_uri.clone();
-    let sent_video = video_data_uri.clone();
-    let tui_handle = options.tui.clone();
     // Follow-up messages the user typed into the queueing box while this
     // turn was still running (see `agent::run_code_agent_with_options`)
     // land here; the caller is responsible for dispatching them. On error
@@ -95,9 +92,6 @@ pub(crate) async fn run_code_agent_with_saved_image(
     {
         mint_core::live_sync::note_own_interaction(row.id);
     }
-    // Save any attached images and videos that were sent with the task
-    image::save_sent_image_after_send(sent_image.as_deref(), task, tui_handle.as_ref());
-    image::save_sent_image_after_send(sent_video.as_deref(), task, tui_handle.as_ref());
     let queued = queue
         .lock()
         .map(|mut q| std::mem::take(&mut *q))
@@ -172,6 +166,9 @@ pub(crate) async fn run_oneshot_agent_task(
         queueing: false,
         pinned_mcp_server,
         chat_id: None,
+        image_name: image_path
+            .and_then(|path| path.file_name())
+            .map(|name| name.to_string_lossy().into_owned()),
         tui: None,
     };
 
@@ -212,7 +209,6 @@ pub(crate) async fn run_oneshot_agent_task(
         mint_core::live_sync::note_own_interaction(row.id);
     }
 
-    image::save_sent_image_after_send(image_data_uri.as_deref(), task, None);
     Ok(())
 }
 
@@ -323,6 +319,10 @@ fn log_panic_to_file(message: &str) {
 
 #[tokio::main]
 async 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);
+    }
+    let _background_shutdown = mint_core::bg_shell::ShutdownGuard;
     install_panic_hook();
     let mut cli = Cli::parse();
 
@@ -331,6 +331,7 @@ async fn main() -> Result<()> {
     }
 
     let mut config = load_config()?;
+    mint_core::companion::start();
     if let Some(ref m) = cli.model {
         apply_temporary_model_override(&mut config, m);
     }
@@ -379,6 +380,7 @@ async fn main() -> Result<()> {
     // its shutdown signal) funnels back here on a clean exit. `SESSIONS` is a
     // `static`, so `McpSession::Drop` won't run at process teardown — do it
     // explicitly so we don't leave orphaned MCP server processes behind.
+    mint_core::companion::shutdown();
     mint_core::close_all_mcp_sessions();
     Ok(())
 }
@@ -530,3 +532,7 @@ mod cli_tests {
         }
     }
 }
+
+mod mods_cli;
+
+mod mods_ui;

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

@@ -61,6 +61,11 @@ pub fn edit(
     Ok(update_mcp_server(name, command, args, env, icon)?)
 }
 
+pub fn set_timeout(name: &str, value: &str) -> Result<bool> {
+    let seconds = mint_core::mcp::parse_mcp_timeout(value)?;
+    Ok(mint_core::mcp::set_mcp_timeout(name, seconds)?)
+}
+
 pub fn registry() -> &'static [McpRegistryEntry] {
     mcp_registry()
 }

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

@@ -0,0 +1,6 @@
+fn main() {
+    if let Err(error) = mint_mod_runtime::worker_main() {
+        eprintln!("{error}");
+        std::process::exit(1);
+    }
+}

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

@@ -0,0 +1,62 @@
+use anyhow::{Result, bail};
+
+pub(crate) async fn run(chat: &str, args: &[String]) -> Result<()> {
+    let root = std::env::current_dir()?;
+    let action = args.first().map(String::as_str).unwrap_or("list");
+    let id = args.get(1).map(String::as_str).unwrap_or("");
+    match action {
+        "test" => {
+            let report = mint_core::mods::test_mod(&root, id).map_err(anyhow::Error::msg)?;
+            println!("{}", serde_json::to_string_pretty(&report)?);
+            if report["failed"].as_u64().unwrap_or(0) > 0 {
+                bail!("Mod tests failed");
+            }
+        }
+        "hot-reload" => bail!("Use /mods hot-reload on|off inside an interactive Mint session"),
+        "run-tools" => {
+            let chat = mint_core::scoped_chat_id(chat, Some(&root.to_string_lossy()));
+            let requests =
+                mint_core::mods::pending_requests(&root, &chat).map_err(anyhow::Error::msg)?;
+            for request in requests {
+                println!(
+                    "{} requests {}\n{}\nRun this request? [y/N]",
+                    request["modId"],
+                    request["action"],
+                    serde_json::to_string_pretty(&request["input"])?
+                );
+                let mut answer = String::new();
+                std::io::stdin().read_line(&mut answer)?;
+                if !answer.trim().eq_ignore_ascii_case("y") {
+                    continue;
+                }
+                let op = serde_json::from_value(
+                    serde_json::json!({"workspacePath":root,"chatId":chat,"action":"run_request","command":request["id"],"grantPermissions":true}),
+                )?;
+                mint_core::mods::operate_async(op)
+                    .await
+                    .map_err(anyhow::Error::msg)?;
+            }
+        }
+        _ => {
+            if action == "enable" && id.is_empty() {
+                bail!("Usage: mint mods enable <id> [chat|workspace|global] [--grant-permissions]");
+            }
+            println!(
+                "{}",
+                mint_core::mods::slash(
+                    &root,
+                    chat,
+                    &format!(
+                        "/mods {}",
+                        args.iter()
+                            .map(|arg| format!("'{}'", arg.replace('\'', "'\"'\"'")))
+                            .collect::<Vec<_>>()
+                            .join(" ")
+                    )
+                )
+                .map_err(anyhow::Error::msg)?
+            );
+        }
+    }
+    Ok(())
+}