@pheem49/mint 1.14.0 → 1.16.0

package/crates/mint-cli/src/commands/agent.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use anyhow::Result;
 use clap::Subcommand;
 use mint_core::{
-    CHAT_CLI_ID, ChatRequest, ImageGenRequest, MintConfig, TaskStore, generate_images, load_config,
+    CHAT_CLI_ID, ChatRequest, ImageGenRequest, MintConfig, TaskStore, load_config,
     orchestrate_chat_with_fallback, save_config,
 };
 
@@ -237,13 +237,9 @@ pub(crate) async fn launch_mint_target(target: String, dev: bool) -> Result<()>
             } else {
                 "dev:web"
             };
-            std::process::Command::new("npm")
-                .current_dir(&project_root)
-                .args(["run", web_cmd])
-                .stdout(std::process::Stdio::null())
-                .stderr(std::process::Stdio::null())
-                .spawn()
+            let frontend = mint_core::bg_shell::start_web_frontend(&project_root, &config, web_cmd)
                 .map_err(|e| anyhow::anyhow!("Failed to launch web app: {e}"))?;
+            mint_core::bg_shell::watch_web_owner();
 
             println!("\n{MINT}✔ Mint Web is running!{RESET}\n");
             println!("    {BLUE}Web UI:{RESET}     {MINT}http://localhost:9000{RESET}");
@@ -260,7 +256,20 @@ pub(crate) async fn launch_mint_target(target: String, dev: bool) -> Result<()>
             println!("{DIM}(API Requests & Error logs will be displayed below){RESET}\n");
 
             println!("{DIM}Press Ctrl+C to stop{RESET}\n");
-            mint_core::start_api_server(3000).await?;
+            tokio::select! {
+                result = mint_core::start_api_server(3000) => result?,
+                result = async {
+                    loop {
+                        let job = mint_core::bg_shell::snapshot(&frontend.id)?;
+                        if !matches!(job.status, mint_core::bg_shell::JobStatus::Running | mint_core::bg_shell::JobStatus::Stopping) {
+                            anyhow::bail!("Mint Web frontend stopped ({:?}):\n{}\n{}", job.status, job.stdout, job.stderr);
+                        }
+                        tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+                    }
+                    #[allow(unreachable_code)]
+                    Ok::<(), anyhow::Error>(())
+                } => result?,
+            }
         }
         _ => {}
     }
@@ -367,30 +376,21 @@ pub async fn handle_auto() -> Result<()> {
 
     // Enable the browser tools if they are disabled
     let mut config_mut = config.clone();
-    let mut changed = false;
-    for tool in &[
-        "browser_open",
-        "browser_click",
-        "browser_type",
-        "browser_read",
-        "browser_mouse_move",
-        "browser_mouse_click",
-        "browser_key_press",
-        "browser_screenshot",
-    ] {
-        if config_mut.disabled_tools.contains(&tool.to_string()) {
-            config_mut.disabled_tools.retain(|x| x != *tool);
-            changed = true;
-        }
-    }
-    if changed {
+    if mint_core::enable_browser_tools(&mut config_mut) {
         mint_core::save_config(&config_mut)?;
         println!(
-            "✅ Enabled browser automation tools in config: browser_open, browser_click, browser_type, browser_read, browser_mouse_move, browser_mouse_click, browser_key_press, browser_screenshot"
+            "✅ Enabled browser automation tools in config: browser_open, browser_click, browser_type, browser_read, browser_mouse_move, browser_mouse_click, browser_key_press, browser_screenshot, browser_tabs, browser_observe, browser_fill, browser_select, browser_scroll, browser_wait"
         );
     }
 
-    println!("🌐 Isolated browser running with remote debugging on http://127.0.0.1:9222");
+    println!(
+        "🌐 Isolated browser running with remote debugging on {}",
+        config
+            .extra
+            .get("browserDebugUrl")
+            .and_then(serde_json::Value::as_str)
+            .unwrap_or("http://127.0.0.1:9222/json/list")
+    );
     println!("💬 Keep this terminal open while you want Mint to automate browser tasks.");
     println!("Press Ctrl+C to terminate the automation browser session.");
     println!("----------------------------------------------------------------------");
@@ -458,7 +458,10 @@ pub async fn handle_auto() -> Result<()> {
     Ok(())
 }
 
-pub async fn handle_web(dev: bool) -> Result<()> {
+pub async fn handle_web(dev: bool, tailscale: bool) -> Result<()> {
+    if tailscale {
+        return super::tailnet_web::run().await;
+    }
     launch_mint_target("web".into(), dev).await
 }
 
@@ -590,27 +593,49 @@ pub async fn handle_chat(
         .await?;
     } else {
         let image_data_uri = image_path.map(image::load_image_as_data_uri).transpose()?;
-        let (response, _) = orchestrate_chat_with_fallback(
+        let name = image_path
+            .and_then(|path| path.file_name())
+            .map(|name| name.to_string_lossy().into_owned());
+        let receipt = image::prepare_attachments(
             config,
-            &ChatRequest {
-                message: message.clone(),
-                system_instruction: system,
-                chat_id: Some(CHAT_CLI_ID.to_owned()),
-                image_data_uri: image_data_uri.clone(),
-                audio_data_uri: None,
-                video_data_uri: None,
-                document_attachment: None,
-                workspace_path: Some(std::env::current_dir()?.to_string_lossy().into_owned()),
-                agent_id: None,
-                plan_mode: false,
-                pinned_mcp_server: None,
-                messages: None,
-                tools: None,
-                temperature: config.temperature,
+            CHAT_CLI_ID,
+            &message,
+            image_data_uri.as_deref(),
+            None,
+            name.as_deref(),
+        )
+        .await?;
+        let (response, _) = mint_core::with_turn_start_listener(
+            CHAT_CLI_ID.to_owned(),
+            move |id| {
+                if let Some(receipt) = &receipt
+                    && let Err(error) = receipt.bind(id)
+                {
+                    eprintln!("Library reference: {error}")
+                }
             },
+            orchestrate_chat_with_fallback(
+                config,
+                &ChatRequest {
+                    message: message.clone(),
+                    system_instruction: system,
+                    chat_id: Some(CHAT_CLI_ID.to_owned()),
+                    image_data_uri: image_data_uri.clone(),
+                    audio_data_uri: None,
+                    video_data_uri: None,
+                    document_attachment: None,
+                    workspace_path: Some(std::env::current_dir()?.to_string_lossy().into_owned()),
+                    agent_id: None,
+                    plan_mode: false,
+                    pinned_mcp_server: None,
+                    messages: None,
+                    tools: None,
+                    temperature: config.temperature,
+                    ..Default::default()
+                },
+            ),
         )
         .await?;
-        image::save_sent_image_after_send(image_data_uri.as_deref(), &message);
         println!("{}", response.text);
     }
     Ok(())
@@ -648,39 +673,23 @@ pub async fn handle_imagine(
         mask_data_uri: None,
         mode: None,
     };
-    match generate_images(&config, &request).await {
+    match mint_core::image_workflow::generate_and_save_images(&config, &request).await {
         Ok(result) => {
             spinner.finish_and_clear();
             eprintln!("{MINT}✦ Generated {} image(s){RESET}", result.images.len());
-            let data_uris: Vec<String> = result
-                .images
-                .iter()
-                .map(|img| img.data_uri.clone())
-                .collect();
-            match mint_core::save_chat_images(
-                data_uris,
-                Some(result.provider.clone()),
-                Some(prompt.clone()),
-            ) {
-                Ok(saved) => {
-                    for entry in &saved {
-                        println!("{MINT}✓{RESET} Saved: {}", entry.path.display());
-                    }
-                    if let (Some(out_path), Some(first)) = (&output, saved.first()) {
-                        match std::fs::copy(&first.path, out_path) {
-                            Ok(_) => println!("{MINT}✓{RESET} Copied to: {}", out_path.display()),
-                            Err(e) => eprintln!(
-                                "{WARN}Warning: could not copy to output path: {e}{RESET}"
-                            ),
-                        }
-                    }
-                    if let Some(desc) = &result.description
-                        && !desc.is_empty()
-                    {
-                        println!("\n{DIM}{desc}{RESET}");
-                    }
+            for entry in &result.images {
+                println!("{MINT}✓{RESET} Saved: {}", entry.path.display());
+            }
+            if let (Some(out_path), Some(first)) = (&output, result.images.first()) {
+                match std::fs::copy(&first.path, out_path) {
+                    Ok(_) => println!("{MINT}✓{RESET} Copied to: {}", out_path.display()),
+                    Err(e) => eprintln!("{WARN}Warning: could not copy to output path: {e}{RESET}"),
                 }
-                Err(e) => eprintln!("{ERROR}Failed to save images: {e}{RESET}"),
+            }
+            if let Some(desc) = &result.description
+                && !desc.is_empty()
+            {
+                println!("\n{DIM}{desc}{RESET}");
             }
         }
         Err(e) => {

package/crates/mint-cli/src/commands/eval.rs

@@ -1,3 +1,5 @@
+const ANSI_BLUE_BOLD: &str = crate::terminal_theme::ANSI_BLUE_BOLD;
+
 use anyhow::{Context, Result};
 use mint_core::MintConfig;
 use mint_core::eval::{aggregate_benchmark_report, evaluate_task_result, load_suite_from_file};
@@ -5,13 +7,15 @@ use std::path::PathBuf;
 use std::time::Instant;
 
 pub async fn handle_eval(suite_path: PathBuf, limit: usize, config: &MintConfig) -> Result<()> {
-    println!("\x1b[1;36m┌─ Mint Benchmark Evaluation Harness ──────────────────────\x1b[0m");
+    println!("{ANSI_BLUE_BOLD}┌─ Mint Benchmark Evaluation Harness ──────────────────────\x1b[0m");
     if !suite_path.exists() {
         println!(
             "│ \x1b[31mBenchmark suite file not found: {}\x1b[0m",
             suite_path.display()
         );
-        println!("\x1b[1;36m└─────────────────────────────────────────────────────────\x1b[0m");
+        println!(
+            "{ANSI_BLUE_BOLD}└─────────────────────────────────────────────────────────\x1b[0m"
+        );
         anyhow::bail!("Suite file not found: {}", suite_path.display());
     }
 
@@ -22,7 +26,7 @@ pub async fn handle_eval(suite_path: PathBuf, limit: usize, config: &MintConfig)
         suite.name, suite.version
     );
     println!("│ Total Tasks: {}", suite.tasks.len());
-    println!("\x1b[1;36m├─────────────────────────────────────────────────────────\x1b[0m");
+    println!("{ANSI_BLUE_BOLD}├─────────────────────────────────────────────────────────\x1b[0m");
 
     let cwd = std::env::current_dir().context("failed to get current dir")?;
     let mut results = Vec::new();
@@ -131,7 +135,7 @@ pub async fn handle_eval(suite_path: PathBuf, limit: usize, config: &MintConfig)
     }
 
     let report = aggregate_benchmark_report(&suite.name, results);
-    println!("\x1b[1;36m├─ Final Evaluation Report ───────────────────────────────\x1b[0m");
+    println!("{ANSI_BLUE_BOLD}├─ Final Evaluation Report ───────────────────────────────\x1b[0m");
     println!("│ Suite:            {}", report.suite_name);
     println!(
         "│ Tasks Completed:  {}/{}",
@@ -146,7 +150,7 @@ pub async fn handle_eval(suite_path: PathBuf, limit: usize, config: &MintConfig)
     println!("│ Avg Tokens:       {}", report.avg_tokens);
     println!("│ Avg Tool Calls:   {:.1}", report.avg_tool_calls);
     println!("│ Avg Retries:      {:.1}", report.avg_retries);
-    println!("\x1b[1;36m└─────────────────────────────────────────────────────────\x1b[0m");
+    println!("{ANSI_BLUE_BOLD}└─────────────────────────────────────────────────────────\x1b[0m");
 
     let report_path = cwd.join("mint_eval_report.json");
     if let Ok(json) = serde_json::to_string_pretty(&report) {

package/crates/mint-cli/src/commands/git.rs

@@ -0,0 +1,204 @@
+use std::path::Path;
+
+use anyhow::{Result, bail};
+use clap::Subcommand;
+use crossterm::tty::IsTty;
+use mint_core::{
+    BranchChange, BranchChangeOutcome, BranchInfo, change_branch, read_branch_info, read_graph,
+};
+
+use crate::{DIM, MINT, RESET, confirm};
+
+#[derive(Debug, Subcommand)]
+pub enum GitCommand {
+    /// Show the active branch, working tree state, and known refs.
+    Status {
+        /// Print the branch state as JSON.
+        #[arg(long)]
+        json: bool,
+    },
+    /// Print local and locally known remote branches.
+    List,
+    /// Switch to an existing local branch.
+    Switch {
+        branch: String,
+        /// Allow the change when the workspace has uncommitted changes.
+        #[arg(long)]
+        allow_dirty: bool,
+    },
+    /// Create a branch from the current HEAD and switch to it.
+    Create {
+        branch: String,
+        /// Allow the change when the workspace has uncommitted changes.
+        #[arg(long)]
+        allow_dirty: bool,
+    },
+    /// Create and switch to a local tracking branch from a known remote ref.
+    Track {
+        remote_branch: String,
+        /// Allow the change when the workspace has uncommitted changes.
+        #[arg(long)]
+        allow_dirty: bool,
+    },
+    /// Print decorated repository history as a graph.
+    Graph {
+        /// Number of commits to show, from 1 to 500.
+        #[arg(long, default_value_t = 120)]
+        limit: usize,
+    },
+}
+
+pub fn handle_git(command: GitCommand) -> Result<()> {
+    let root = std::env::current_dir()?;
+    match command {
+        GitCommand::Status { json } => print_status(&root, json),
+        GitCommand::List => print_list(&root),
+        GitCommand::Switch {
+            branch,
+            allow_dirty,
+        } => {
+            let info = apply_branch_change(
+                &root,
+                BranchChange::Switch {
+                    branch: branch.clone(),
+                },
+                allow_dirty,
+                &format!("Switch to {branch}?"),
+            )?;
+            print_changed(&info)
+        }
+        GitCommand::Create {
+            branch,
+            allow_dirty,
+        } => {
+            let info = apply_branch_change(
+                &root,
+                BranchChange::Create {
+                    branch: branch.clone(),
+                },
+                allow_dirty,
+                &format!("Create and switch to {branch}?"),
+            )?;
+            print_changed(&info)
+        }
+        GitCommand::Track {
+            remote_branch,
+            allow_dirty,
+        } => {
+            let info = apply_branch_change(
+                &root,
+                BranchChange::Track {
+                    remote_branch: remote_branch.clone(),
+                },
+                allow_dirty,
+                &format!("Create a local tracking branch from {remote_branch}?"),
+            )?;
+            print_changed(&info)
+        }
+        GitCommand::Graph { limit } => {
+            let graph = read_graph(&root, limit).map_err(anyhow::Error::msg)?;
+            if graph.is_empty() {
+                println!("{DIM}No commits yet.{RESET}");
+            } else {
+                println!("{}", graph.join("\n"));
+            }
+            Ok(())
+        }
+    }
+}
+
+fn print_status(root: &Path, json: bool) -> Result<()> {
+    let info = read_branch_info(root).map_err(anyhow::Error::msg)?;
+    if json {
+        println!("{}", serde_json::to_string_pretty(&info)?);
+        return Ok(());
+    }
+    print_info(&info);
+    Ok(())
+}
+
+fn print_list(root: &Path) -> Result<()> {
+    let info = read_branch_info(root).map_err(anyhow::Error::msg)?;
+    ensure_repository(&info)?;
+    println!("Local branches");
+    for branch in &info.branches {
+        let marker = if info.current_branch.as_deref() == Some(branch) {
+            format!("{MINT}*{RESET}")
+        } else {
+            " ".to_string()
+        };
+        println!("  {marker} {branch}");
+    }
+    if !info.remote_branches.is_empty() {
+        println!("\nRemote branches {DIM}(locally known){RESET}");
+        for branch in &info.remote_branches {
+            println!("    {branch}");
+        }
+    }
+    Ok(())
+}
+
+fn print_changed(info: &BranchInfo) -> Result<()> {
+    ensure_repository(info)?;
+    let branch = info.current_branch.as_deref().unwrap_or("detached HEAD");
+    println!("{MINT}Switched to {branch}{RESET}");
+    Ok(())
+}
+
+fn print_info(info: &BranchInfo) {
+    if !info.is_repository {
+        println!("Not a Git repository.");
+        return;
+    }
+    let branch = info
+        .current_branch
+        .as_deref()
+        .or(info.detached_head.as_deref())
+        .unwrap_or("No branch");
+    let state = if info.is_dirty { "dirty" } else { "clean" };
+    println!("Branch: {branch}");
+    println!("Working tree: {state}");
+    println!("Local branches: {}", info.branches.len());
+    println!(
+        "Remote branches: {} {DIM}(locally known){RESET}",
+        info.remote_branches.len()
+    );
+}
+
+fn apply_branch_change(
+    root: &Path,
+    change: BranchChange,
+    confirmed_dirty_workspace: bool,
+    action: &str,
+) -> Result<BranchInfo> {
+    match change_branch(root, &change, confirmed_dirty_workspace).map_err(anyhow::Error::msg)? {
+        BranchChangeOutcome::Changed { info } => Ok(info),
+        BranchChangeOutcome::ConfirmationRequired { .. } => {
+            confirm_and_change(root, change, action)
+        }
+    }
+}
+
+fn confirm_and_change(root: &Path, change: BranchChange, action: &str) -> Result<BranchInfo> {
+    if !std::io::stdin().is_tty() || !std::io::stdout().is_tty() {
+        bail!("Workspace has uncommitted changes. Re-run with --allow-dirty to confirm.");
+    }
+    if confirm(&format!("Workspace has uncommitted changes. {action}"))? {
+        match change_branch(root, &change, true).map_err(anyhow::Error::msg)? {
+            BranchChangeOutcome::Changed { info } => Ok(info),
+            BranchChangeOutcome::ConfirmationRequired { .. } => {
+                bail!("Workspace still requires confirmation.")
+            }
+        }
+    } else {
+        bail!("Branch change cancelled.")
+    }
+}
+
+fn ensure_repository(info: &BranchInfo) -> Result<()> {
+    if info.is_repository {
+        Ok(())
+    } else {
+        bail!("The selected workspace is not a Git repository.")
+    }
+}

package/crates/mint-cli/src/commands/integrations.rs

@@ -38,6 +38,9 @@ pub enum McpCommand {
     /// Change a configured server in place — only the flags you pass are touched.
     Edit {
         name: String,
+        /// Maximum tool-call duration, including sending and receiving.
+        #[arg(long, value_parser = clap::value_parser!(u64).range(1..=3600))]
+        timeout_secs: Option<u64>,
         #[arg(long)]
         command: Option<String>,
         /// Repeatable; replaces the arg list. Passing none leaves args unchanged.
@@ -114,6 +117,16 @@ pub enum LinkCommand {
     Remove {
         name: String,
     },
+    Refresh {
+        name: String,
+    },
+    Notes {
+        name: String,
+    },
+    Save {
+        name: String,
+        text: String,
+    },
 }
 
 #[derive(Debug, Subcommand)]
@@ -205,6 +218,7 @@ pub async fn handle_mcp(command: McpCommand) -> Result<()> {
         }
         McpCommand::Edit {
             name,
+            timeout_secs,
             command,
             args,
             env,
@@ -220,6 +234,9 @@ pub async fn handle_mcp(command: McpCommand) -> Result<()> {
                 icon,
             )?;
             if existed {
+                if let Some(timeout) = timeout_secs {
+                    mint_core::mcp::set_mcp_timeout(&name, timeout)?;
+                }
                 println!("updated {name}");
             } else {
                 println!("{ERROR}not found:{RESET} {name}");
@@ -338,6 +355,24 @@ pub fn handle_link(command: LinkCommand) -> Result<()> {
                 }
             )
         }
+        LinkCommand::Refresh { name } => {
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&mint_core::refresh_linked_folder(&name)?)?
+            );
+        }
+        LinkCommand::Notes { name } => {
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&mint_core::list_linked_folder_notes(&name)?)?
+            );
+        }
+        LinkCommand::Save { name, text } => {
+            println!(
+                "{}",
+                serde_json::to_string_pretty(&mint_core::save_linked_folder_note(&name, &text)?)?
+            );
+        }
     }
     Ok(())
 }

package/crates/mint-cli/src/commands/knowledge.rs

@@ -258,6 +258,7 @@ async fn run_github_overview(repo: &str, config: &MintConfig) -> Result<()> {
             messages: None,
             tools: None,
             temperature: config.temperature,
+            ..Default::default()
         },
     )
     .await {
@@ -280,42 +281,22 @@ async fn run_github_overview(repo: &str, config: &MintConfig) -> Result<()> {
 pub fn handle_learn(path: Option<PathBuf>, list: bool, delete: Option<String>) -> Result<()> {
     let memory = MemoryStore::open_default()?;
     if list {
-        let mut skills = memory.learned_skills(100)?;
-
-        if let Some(home) = dirs::home_dir() {
-            let global_skills_path = home.join(".config").join("mint").join("mint-skills");
-            mint_core::skills::load_skills_from_dir(&global_skills_path, &mut skills);
-        }
-        if let Ok(root) = std::env::current_dir()
-            && let Ok(root) = root.canonicalize()
-        {
-            let workspace_skills_path1 = root.join(".agents").join("skills");
-            mint_core::skills::load_skills_from_dir(&workspace_skills_path1, &mut skills);
-
-            let workspace_skills_path2 = root.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 {
-            let loc = if skill.source_path.contains("/.config/mint/mint-skills") {
-                "Global"
-            } else if skill.source_path.contains("/skills")
-                || skill.source_path.contains("/.agents/skills")
-            {
-                "Workspace"
-            } else {
-                "Taught"
-            };
-            unique_skills.insert(skill.name.clone(), (skill, loc));
-        }
-
+        let root = std::env::current_dir().ok();
+        let unique_skills =
+            mint_core::skill_inventory::list_available_skills(&memory, root.as_deref())?;
         if unique_skills.is_empty() {
             println!("No learned skills found.");
         } else {
             println!("Learned AI Skills:");
-            for (name, (skill, loc)) in &unique_skills {
-                if *loc == "Taught" {
+            for entry in &unique_skills {
+                let skill = &entry.skill;
+                let name = &skill.name;
+                let loc = match entry.location {
+                    mint_core::skill_inventory::SkillLocation::Database => "Taught",
+                    mint_core::skill_inventory::SkillLocation::Global => "Global",
+                    mint_core::skill_inventory::SkillLocation::Workspace => "Workspace",
+                };
+                if loc == "Taught" {
                     println!("  ● [{loc}] {name}");
                 } else {
                     println!("  ● [{loc}] {name} (Source: {})", skill.source_path);