@pheem49/mint 1.15.0 → 1.17.0

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,
     };
@@ -366,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) => {
@@ -430,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}"));
@@ -443,16 +450,34 @@ 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);
+    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);
         }
-        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 +486,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 +742,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 +883,17 @@ 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()
+    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)
+        .collect()
 }
 
 #[cfg(test)]

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,
@@ -46,9 +60,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 +106,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 +180,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 +223,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(())
 }
 
@@ -321,8 +331,19 @@ 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();
 
@@ -331,6 +352,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 +401,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 +553,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(())
+}

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

@@ -0,0 +1,187 @@
+use ratatui::{
+    style::{Color, Style},
+    text::{Line, Span},
+};
+use serde_json::Value;
+#[derive(Clone)]
+pub(crate) struct Control {
+    pub id: String,
+    pub instance: String,
+    pub action: String,
+    pub label: String,
+    pub input: bool,
+    pub value: String,
+}
+fn clean(text: &str) -> String {
+    text.chars()
+        .filter(|c| !c.is_control() || *c == '\n')
+        .take(4096)
+        .collect()
+}
+pub(crate) fn node_lines(node: &Value) -> Vec<String> {
+    match node["type"].as_str().unwrap_or("") {
+        "text" | "badge" => clean(node["text"].as_str().unwrap_or(""))
+            .lines()
+            .map(str::to_owned)
+            .collect(),
+        "stack" => node["children"]
+            .as_array()
+            .into_iter()
+            .flatten()
+            .flat_map(node_lines)
+            .collect(),
+        "button" => vec![format!(
+            "[ {} ]",
+            clean(node["label"].as_str().unwrap_or(""))
+        )],
+        "input" => vec![format!(
+            "{}: {}",
+            clean(node["label"].as_str().unwrap_or("")),
+            node["value"].as_str().unwrap_or("")
+        )],
+        "progress" => vec![format!(
+            "{}: {:.0}/{:.0}",
+            clean(node["label"].as_str().unwrap_or("")),
+            node["value"].as_f64().unwrap_or(0.0),
+            node["max"].as_f64().unwrap_or(1.0)
+        )],
+        "table" => {
+            let mut lines = vec![
+                node["columns"]
+                    .as_array()
+                    .map(|c| {
+                        c.iter()
+                            .map(|s| clean(s.as_str().unwrap_or("")))
+                            .collect::<Vec<_>>()
+                            .join(" | ")
+                    })
+                    .unwrap_or_default(),
+            ];
+            for row in node["rows"].as_array().into_iter().flatten() {
+                lines.push(
+                    row.as_array()
+                        .map(|r| {
+                            r.iter()
+                                .map(|v| {
+                                    clean(
+                                        &v.as_str()
+                                            .map(str::to_owned)
+                                            .unwrap_or_else(|| v.to_string()),
+                                    )
+                                })
+                                .collect::<Vec<_>>()
+                                .join(" | ")
+                        })
+                        .unwrap_or_default(),
+                );
+            }
+            lines
+        }
+        _ => vec![],
+    }
+}
+fn styled_lines(node: &Value, inherited: Style) -> Vec<Line<'static>> {
+    let color = match node["color"].as_str() {
+        Some("yellow") => Some(Color::Yellow),
+        Some("cyan") => Some(Color::Cyan),
+        Some("blue") => Some(Color::Blue),
+        Some("magenta") => Some(Color::Magenta),
+        Some("red") => Some(Color::Red),
+        Some("default") => Some(Color::Reset),
+        _ => None,
+    };
+    let style = color.map(|c| inherited.fg(c)).unwrap_or(inherited);
+    if node["type"] == "stack" {
+        let children = node["children"].as_array().into_iter().flatten();
+        if node["direction"] == "row" {
+            let mut spans = vec![];
+            for child in children {
+                let lines = styled_lines(child, style);
+                for line in lines {
+                    if !spans.is_empty() {
+                        spans.push(Span::raw(" "));
+                    }
+                    spans.extend(line.spans);
+                }
+            }
+            vec![Line::from(spans)]
+        } else {
+            children
+                .flat_map(|child| styled_lines(child, style))
+                .collect()
+        }
+    } else {
+        node_lines(node)
+            .into_iter()
+            .map(|text| Line::from(Span::styled(text, style)))
+            .collect()
+    }
+}
+pub(crate) fn controls(mods: &[Value]) -> Vec<Control> {
+    fn walk(node: &Value, m: &Value, result: &mut Vec<Control>) {
+        if matches!(node["type"].as_str(), Some("button" | "input")) {
+            result.push(Control {
+                id: m["id"].as_str().unwrap_or("").into(),
+                instance: m["instanceId"].as_str().unwrap_or("").into(),
+                action: node["action"].as_str().unwrap_or("").into(),
+                label: clean(node["label"].as_str().unwrap_or("")),
+                input: node["type"] == "input",
+                value: node["value"].as_str().unwrap_or("").into(),
+            });
+        }
+        for child in node["children"].as_array().into_iter().flatten() {
+            walk(child, m, result);
+        }
+    }
+    let mut result = vec![];
+    for m in mods {
+        if m["enabled"] == true {
+            walk(&m["snapshot"]["ui"]["above_composer"], m, &mut result);
+            walk(&m["snapshot"]["ui"]["side_panel"], m, &mut result);
+        }
+    }
+    result
+}
+pub(crate) fn slot_lines(mods: &[Value], slot: &str) -> Vec<Line<'static>> {
+    let mut lines = vec![];
+    for m in mods {
+        if m["enabled"] != true {
+            continue;
+        }
+        if slot == "side_panel" {
+            lines.push(Line::raw(clean(m["name"].as_str().unwrap_or("Mod"))));
+        }
+        lines.extend(styled_lines(&m["snapshot"]["ui"][slot], Style::default()));
+        if let Some(error) = m["error"].as_str() {
+            lines.push(Line::raw(format!("Error: {}", clean(error))));
+        }
+        if let Some(error) = m["reloadError"].as_str() {
+            lines.push(Line::raw(format!("Reload: {}", clean(error))));
+        }
+    }
+    lines
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn keyboard_controls_include_actions_from_both_ui_slots() {
+        let mods = vec![
+            json!({"id":"example","enabled":true,"instanceId":"revision",
+            "snapshot":{"ui":{
+                "above_composer":{"type":"button","label":"Inspect","action":"inspect"},
+                "side_panel":{"type":"input","label":"Draft","action":"save","value":"existing"}
+            }}}),
+        ];
+        let available = controls(&mods);
+        assert_eq!(available.len(), 2);
+        assert!(
+            available
+                .iter()
+                .any(|c| c.action == "inspect" && c.instance == "revision")
+        );
+    }
+}