@pheem49/mint 1.15.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?,
+            }
         }
         _ => {}
     }
@@ -584,28 +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,
-                ..Default::default()
+            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, None);
         println!("{}", response.text);
     }
     Ok(())
@@ -643,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/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.
@@ -215,6 +218,7 @@ pub async fn handle_mcp(command: McpCommand) -> Result<()> {
         }
         McpCommand::Edit {
             name,
+            timeout_secs,
             command,
             args,
             env,
@@ -230,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}");

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

@@ -281,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);

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

@@ -102,6 +102,11 @@ pub enum Command {
         #[arg(long, default_value = "cli")]
         chat_id: String,
     },
+    /// Show persistent workspace file history, or undo its latest action.
+    History {
+        #[arg(long)]
+        undo: bool,
+    },
     /// Inspect and manage Git branches in the current workspace.
     Git {
         #[command(subcommand)]
@@ -144,6 +149,13 @@ pub enum Command {
         #[command(subcommand)]
         command: LinkCommand,
     },
+    /// Manage workspace mods. Use list, enable, disable, validate, test, usage, source, logs, export or import.
+    Mods {
+        #[arg(long, default_value = "cli")]
+        chat: String,
+        #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+        args: Vec<String>,
+    },
     /// Manage PreToolUse/PostToolUse hooks.
     Hooks {
         #[command(subcommand)]
@@ -289,6 +301,37 @@ pub async fn dispatch(cmd: Command, config: &mut MintConfig, cli: &crate::Cli) -
         Command::Agent { task } => agent::handle_agent(task).await,
         Command::Eval { suite, limit } => eval::handle_eval(suite, limit, config).await,
         Command::Rewind { step, chat_id } => agent::handle_rewind(step, chat_id),
+        Command::History { undo } => {
+            let capability = if undo {
+                mint_core::Capability::Write
+            } else {
+                mint_core::Capability::Read
+            };
+            let root =
+                mint_core::assert_path_capability(&std::env::current_dir()?, capability, config)?;
+            if undo {
+                let entry = mint_core::system::workspace_history::undo(&root, None)
+                    .map_err(anyhow::Error::msg)?;
+                println!(
+                    "{}",
+                    entry
+                        .map(|entry| entry.label)
+                        .unwrap_or_else(|| "There is no workspace action to undo.".into())
+                );
+            } else {
+                let entries = mint_core::system::workspace_history::list(&root)
+                    .map_err(anyhow::Error::msg)?;
+                for entry in entries.iter().take(20) {
+                    println!("{}", entry.label);
+                }
+                if entries.is_empty() {
+                    println!("No workspace file history yet.");
+                } else {
+                    println!("\nRun 'mint history --undo' to undo the latest action.");
+                }
+            }
+            Ok(())
+        }
         Command::Git { command } => git::handle_git(command),
         Command::Resume { id } => {
             mint_core::channels::start_channels();
@@ -336,6 +379,7 @@ pub async fn dispatch(cmd: Command, config: &mut MintConfig, cli: &crate::Cli) -
 
         Command::Mcp { command } => integrations::handle_mcp(command).await,
         Command::Link { command } => integrations::handle_link(command),
+        Command::Mods { chat, args } => crate::mods_cli::run(&chat, &args).await,
         Command::Hooks { command } => integrations::handle_hooks(command),
         Command::Gmail { command } => integrations::handle_gmail(command).await,
         Command::Plugins { command } => integrations::handle_plugins(command).await,

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

@@ -71,40 +71,38 @@ pub fn read_clipboard_image() -> Result<Option<String>> {
     }
 }
 
-pub fn save_sent_image_after_send(
-    data_uri: Option<&str>,
+/// Save CLI/TUI attachments before provider work and return the turn-binding receipt.
+pub async fn prepare_attachments(
+    config: &mint_core::MintConfig,
+    chat_id: &str,
     message: &str,
-    tui: Option<&crate::interactive::TuiHandle>,
-) {
-    if let Some(data_uri) = data_uri {
-        let mut saved_names = Vec::new();
-        for img in data_uri.split_whitespace() {
-            match mint_core::save_sent_image(img, message) {
-                Ok(entry) => {
-                    if let Some(name) = entry.path.file_name().and_then(|f| f.to_str()) {
-                        saved_names.push(name.to_string());
-                    }
-                    if tui.is_none() {
-                        println!("\x1b[90mSaved image: {}\x1b[0m", entry.path.display());
-                    }
-                }
-                Err(error) => {
-                    if let Some(tui) = tui {
-                        tui.set_notice(format!("Warning: failed to save sent image: {error}"));
-                    } else {
-                        eprintln!("\x1b[33mWarning: failed to save sent image: {error}\x1b[0m");
-                    }
-                }
-            }
-        }
-        if let Some(tui) = tui {
-            if saved_names.len() == 1 {
-                tui.set_notice(format!("Image saved to gallery ({})", saved_names[0]));
-            } else if saved_names.len() > 1 {
-                tui.set_notice(format!("{} images saved to gallery", saved_names.len()));
-            }
-        }
-    }
+    image: Option<&str>,
+    video: Option<&str>,
+    image_name: Option<&str>,
+) -> Result<Option<mint_core::library::AttachmentReceipt>> {
+    let request = mint_core::ChatRequest {
+        message: message.into(),
+        chat_id: Some(chat_id.into()),
+        image_data_uri: image.map(str::to_owned),
+        video_data_uri: video.map(str::to_owned),
+        ..Default::default()
+    };
+    let metadata = image_name.map(|name| mint_core::library::AttachmentMetadata {
+        request_id: format!(
+            "cli-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap_or_default()
+                .as_nanos()
+        ),
+        image_names: vec![name.into()],
+        video_names: vec![],
+    });
+    let (_, receipt) = mint_core::library::prepare_chat(&request, metadata.as_ref(), config)
+        .await
+        .map_err(anyhow::Error::msg)?;
+    Ok(receipt)
 }
 
 fn detect_mime(bytes: &[u8], path: &Path) -> &'static str {