@pheem49/mint 1.15.0 → 1.17.0

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

@@ -281,42 +281,36 @@ 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.");
+            if let Some(ref workspace_root) = root {
+                println!(
+                    "No learned skills found in workspace: {}",
+                    workspace_root.display()
+                );
+            } else {
+                println!("No learned skills found.");
+            }
         } else {
-            println!("Learned AI Skills:");
-            for (name, (skill, loc)) in &unique_skills {
-                if *loc == "Taught" {
+            if let Some(ref workspace_root) = root {
+                println!(
+                    "Learned AI Skills (Workspace: {}):",
+                    workspace_root.display()
+                );
+            } else {
+                println!("Learned AI Skills:");
+            }
+            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

@@ -5,6 +5,7 @@ use clap::Subcommand;
 use mint_core::MintConfig;
 
 pub mod agent;
+pub mod browser;
 pub mod config;
 pub mod eval;
 pub mod git;
@@ -102,6 +103,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)]
@@ -114,8 +120,16 @@ pub enum Command {
     },
     /// Start the browser automation environment and enable browser actions.
     Auto,
+    /// Run browser automation workflows using the shared Mint Browser engine.
+    Browser {
+        #[command(subcommand)]
+        command: browser::BrowserCommand,
+    },
     /// Launch the web UI and local API server.
     Web {
+        /// Open the default browser once the web UI and API are ready.
+        #[arg(long, default_value_t = false, conflicts_with = "tailscale")]
+        open: bool,
         /// Force development mode with Hot Module Replacement (HMR)
         #[arg(long, default_value_t = false, conflicts_with = "tailscale")]
         dev: bool,
@@ -144,6 +158,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 +310,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();
@@ -309,7 +361,12 @@ pub async fn dispatch(cmd: Command, config: &mut MintConfig, cli: &crate::Cli) -
             Ok(())
         }
         Command::Auto => agent::handle_auto().await,
-        Command::Web { dev, tailscale } => agent::handle_web(dev, tailscale).await,
+        Command::Browser { command } => browser::handle(command, config, cli.plan).await,
+        Command::Web {
+            dev,
+            tailscale,
+            open,
+        } => agent::handle_web(dev, tailscale, open).await,
         Command::Api { port } => agent::handle_api(port).await,
         Command::Gateway { command } => agent::handle_gateway(command).await,
         Command::Chat {
@@ -336,6 +393,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/commands/tailnet_web.rs

@@ -22,13 +22,7 @@ impl Drop for ChildGuard {
 }
 
 fn project_root() -> Result<PathBuf> {
-    let cwd = std::env::current_dir()?;
-    let exe = std::env::current_exe()?;
-    exe.ancestors()
-        .chain(cwd.ancestors())
-        .find(|path| path.join("package.json").exists())
-        .map(PathBuf::from)
-        .context("Could not find the Mint project root (package.json)")
+    super::agent::find_mint_root()
 }
 
 fn tailscale(args: &[&str]) -> Result<String> {
@@ -152,6 +146,7 @@ pub async fn run() -> Result<()> {
             .context("Could not start the production Web UI")?,
     );
     wait_for_port(9000).await?;
+    mint_core::companion::navigation::configure_web(url.clone());
 
     let api_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), 3000);
     let mut api = tokio::spawn(mint_core::api_server::start_api_server_on(api_addr));

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

@@ -0,0 +1,268 @@
+//! Return to this terminal when its exact conversation/window is identifiable.
+use mint_core::companion::navigation::{self, NavigationOutcome, Surface};
+use std::{
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+    sync::Mutex,
+};
+
+static ACTIVE_CHAT: Mutex<String> = Mutex::new(String::new());
+
+pub fn set_chat(chat_id: &str) {
+    *ACTIVE_CHAT.lock().unwrap() = chat_id.to_owned();
+}
+
+pub fn configure(chat_id: &str) {
+    set_chat(chat_id);
+    let executable = std::env::current_exe().ok();
+    let launch_dir = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+    let _embedded = std::env::var("TERM_PROGRAM").is_ok_and(|v| v == "vscode")
+        || std::env::var_os("VSCODE_PID").is_some()
+        || std::env::var_os("TMUX").is_some()
+        || std::env::var_os("STY").is_some();
+    #[cfg(target_os = "linux")]
+    let window = if _embedded {
+        None
+    } else {
+        std::env::var("WINDOWID")
+            .ok()
+            .filter(|id| id.parse::<u64>().is_ok_and(|id| id != 0))
+    };
+    #[cfg(target_os = "macos")]
+    let tty = if !_embedded && std::env::var("TERM_PROGRAM").as_deref() == Ok("Apple_Terminal") {
+        Command::new("tty")
+            .stdin(Stdio::inherit())
+            .output()
+            .ok()
+            .filter(|o| o.status.success())
+            .map(|o| String::from_utf8_lossy(&o.stdout).trim().to_owned())
+    } else {
+        None
+    };
+    navigation::configure(Surface::Tui, move |session, new_terminal| {
+        if !new_terminal {
+            if *ACTIVE_CHAT.lock().unwrap() != session.chat_id {
+                return Ok(NavigationOutcome::NeedsTerminal);
+            }
+            #[cfg(target_os = "linux")]
+            if let Some(window) = &window {
+                let activated = Command::new("xdotool")
+                    .args(["windowactivate", window])
+                    .stdout(Stdio::null())
+                    .stderr(Stdio::null())
+                    .status()
+                    .is_ok_and(|s| s.success());
+                let focused = Command::new("xdotool")
+                    .arg("getactivewindow")
+                    .output()
+                    .ok()
+                    .is_some_and(|o| {
+                        o.status.success()
+                            && String::from_utf8_lossy(&o.stdout)
+                                .trim()
+                                .parse::<u64>()
+                                .ok()
+                                == window.parse::<u64>().ok()
+                    });
+                if activated && focused {
+                    return Ok(NavigationOutcome::Opened);
+                }
+            }
+            #[cfg(target_os = "macos")]
+            if let Some(tty) = &tty {
+                let tty = apple_string(tty);
+                let script = format!(
+                    "tell application \"Terminal\"\nrepeat with w in windows\nrepeat with t in tabs of w\nif tty of t is {tty} then\nset selected tab of w to t\nset index of w to 1\nactivate\nreturn \"focused\"\nend if\nend repeat\nend repeat\nend tell"
+                );
+                if Command::new("osascript")
+                    .args(["-e", &script])
+                    .output()
+                    .ok()
+                    .is_some_and(|o| {
+                        o.status.success() && String::from_utf8_lossy(&o.stdout).trim() == "focused"
+                    })
+                {
+                    return Ok(NavigationOutcome::Opened);
+                }
+            }
+            return Ok(NavigationOutcome::NeedsTerminal);
+        }
+        let executable = executable
+            .as_ref()
+            .ok_or("Could not locate the Mint executable")?;
+        let cwd = session
+            .workspace
+            .as_deref()
+            .map(Path::new)
+            .unwrap_or(&launch_dir);
+        open_terminal(executable, cwd, &session.chat_id)?;
+        Ok(NavigationOutcome::Opened)
+    });
+}
+
+fn resume_args(executable: &Path, cwd: &Path, chat: &str) -> Vec<String> {
+    vec![
+        executable.to_string_lossy().into_owned(),
+        "--cwd".into(),
+        cwd.to_string_lossy().into_owned(),
+        "--tui".into(),
+        "--resume".into(),
+        chat.into(),
+    ]
+}
+
+fn open_terminal(executable: &Path, cwd: &Path, chat: &str) -> Result<(), String> {
+    if !executable.is_file() {
+        return Err("The Mint executable is no longer available. Restart Mint.".into());
+    }
+    if !cwd.is_dir() {
+        return Err("The conversation workspace is no longer available.".into());
+    }
+    let args = resume_args(executable, cwd, chat);
+    #[cfg(target_os = "linux")]
+    {
+        for (terminal, separator) in [
+            ("x-terminal-emulator", "-e"),
+            ("gnome-terminal", "--"),
+            ("konsole", "-e"),
+            ("xfce4-terminal", "--execute"),
+            ("kitty", "--"),
+            ("alacritty", "-e"),
+            ("xterm", "-e"),
+        ] {
+            match Command::new(terminal)
+                .arg(separator)
+                .args(&args)
+                .current_dir(cwd)
+                .stdin(Stdio::null())
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .spawn()
+            {
+                Ok(mut child) => {
+                    std::thread::sleep(std::time::Duration::from_millis(150));
+                    match child.try_wait().map_err(|error| error.to_string())? {
+                        Some(status) if !status.success() => {
+                            return Err(format!("{terminal} could not open the Mint conversation"));
+                        }
+                        Some(_) => return Ok(()),
+                        None => {
+                            std::thread::spawn(move || {
+                                let _ = child.wait();
+                            });
+                            return Ok(());
+                        }
+                    }
+                }
+                Err(error) if error.kind() == std::io::ErrorKind::NotFound => continue,
+                Err(error) => return Err(format!("Could not open {terminal}: {error}")),
+            }
+        }
+        return Err("No supported terminal was found. Open Mint with --tui --resume and this conversation ID.".into());
+    }
+    #[cfg(target_os = "macos")]
+    {
+        let command = args
+            .iter()
+            .map(|a| shell_quote(a))
+            .collect::<Vec<_>>()
+            .join(" ");
+        let script = format!(
+            "tell application \"Terminal\"\ndo script {}\nactivate\nend tell",
+            apple_string(&command)
+        );
+        let status = Command::new("osascript")
+            .args(["-e", &script])
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .map_err(|e| e.to_string())?;
+        return if status.success() {
+            Ok(())
+        } else {
+            Err("Could not open Terminal".into())
+        };
+    }
+    #[cfg(target_os = "windows")]
+    {
+        // Values travel through environment variables, never PowerShell source.
+        let arguments = args[1..]
+            .iter()
+            .map(|a| windows_quote(a))
+            .collect::<Vec<_>>()
+            .join(" ");
+        let status = Command::new("powershell.exe").args(["-NoProfile", "-NonInteractive", "-Command", "Start-Process -ErrorAction Stop -FilePath $env:MINT_COMPANION_EXE -ArgumentList $env:MINT_COMPANION_ARGS"])
+            .env("MINT_COMPANION_EXE", executable).env("MINT_COMPANION_ARGS", arguments).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null()).status().map_err(|e| e.to_string())?;
+        return if status.success() {
+            Ok(())
+        } else {
+            Err("Could not open a new Mint terminal".into())
+        };
+    }
+    #[allow(unreachable_code)]
+    Err("Opening terminals is unsupported on this platform".into())
+}
+
+#[cfg(target_os = "macos")]
+fn shell_quote(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "'\"'\"'"))
+}
+#[cfg(target_os = "macos")]
+fn apple_string(value: &str) -> String {
+    format!(
+        "\"{}\"",
+        value
+            .replace('\\', "\\\\")
+            .replace('"', "\\\"")
+            .replace('\n', "\\n")
+            .replace('\r', "\\r")
+    )
+}
+#[cfg(target_os = "windows")]
+fn windows_quote(value: &str) -> String {
+    let mut result = String::from("\"");
+    let mut slashes = 0;
+    for character in value.chars() {
+        if character == '\\' {
+            slashes += 1;
+            continue;
+        }
+        result.extend(std::iter::repeat_n(
+            '\\',
+            if character == '"' {
+                slashes * 2 + 1
+            } else {
+                slashes
+            },
+        ));
+        result.push(character);
+        slashes = 0;
+    }
+    result.extend(std::iter::repeat_n('\\', slashes * 2));
+    result.push('"');
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn resume_keeps_paths_and_chat_id_as_separate_arguments() {
+        assert_eq!(
+            resume_args(
+                Path::new("/opt/Mint App/mint"),
+                Path::new("/work/project one"),
+                "cli::a ' & ไทย"
+            ),
+            [
+                "/opt/Mint App/mint",
+                "--cwd",
+                "/work/project one",
+                "--tui",
+                "--resume",
+                "cli::a ' & ไทย"
+            ]
+        );
+    }
+}

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 {