@pheem49/mint 1.5.5 → 1.6.1

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

@@ -0,0 +1,390 @@
+use anyhow::Result;
+use crossterm::event::{self, Event, KeyCode};
+use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
+use mint_core::{load_config, save_config};
+use std::io::{self, Write};
+
+struct ToolOption {
+    name: &'static str,
+    key: &'static str,
+    enabled: bool,
+}
+
+pub async fn run() -> Result<Option<String>> {
+    let mut config = load_config()?;
+
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("\x1b[32m       Mint CLI Tool Manager Wizard\x1b[0m");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("Configure which agent tools are enabled or disabled:");
+    println!(
+        "  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Space: Toggle | a: All | i: Invert | Enter: Confirm]\x1b[0m"
+    );
+    println!();
+
+    let mut options = vec![
+        ToolOption {
+            name: "list_files (List Workspace Files)",
+            key: "list_files",
+            enabled: !config.disabled_tools.contains(&"list_files".to_string()),
+        },
+        ToolOption {
+            name: "read_file (Read File Content)",
+            key: "read_file",
+            enabled: !config.disabled_tools.contains(&"read_file".to_string()),
+        },
+        ToolOption {
+            name: "search_code (Search Code Text)",
+            key: "search_code",
+            enabled: !config.disabled_tools.contains(&"search_code".to_string()),
+        },
+        ToolOption {
+            name: "symbols (Index/Search Symbols)",
+            key: "symbols",
+            enabled: !config.disabled_tools.contains(&"symbols".to_string()),
+        },
+        ToolOption {
+            name: "semantic_index (Semantic Indexing)",
+            key: "semantic_index",
+            enabled: !config
+                .disabled_tools
+                .contains(&"semantic_index".to_string()),
+        },
+        ToolOption {
+            name: "semantic_search (Semantic Search)",
+            key: "semantic_search",
+            enabled: !config
+                .disabled_tools
+                .contains(&"semantic_search".to_string()),
+        },
+        ToolOption {
+            name: "knowledge_search (Search Local Knowledge)",
+            key: "knowledge_search",
+            enabled: !config
+                .disabled_tools
+                .contains(&"knowledge_search".to_string()),
+        },
+        ToolOption {
+            name: "web_search (Search Web)",
+            key: "web_search",
+            enabled: !config.disabled_tools.contains(&"web_search".to_string()),
+        },
+        ToolOption {
+            name: "memory_recall (Recall Long-term Memory)",
+            key: "memory_recall",
+            enabled: !config.disabled_tools.contains(&"memory_recall".to_string()),
+        },
+        ToolOption {
+            name: "git_status (Read Git Status)",
+            key: "git_status",
+            enabled: !config.disabled_tools.contains(&"git_status".to_string()),
+        },
+        ToolOption {
+            name: "git_diff (Read Git Diff)",
+            key: "git_diff",
+            enabled: !config.disabled_tools.contains(&"git_diff".to_string()),
+        },
+        ToolOption {
+            name: "git_log (Read Git Log)",
+            key: "git_log",
+            enabled: !config.disabled_tools.contains(&"git_log".to_string()),
+        },
+        ToolOption {
+            name: "git_branch (Read Git Branch)",
+            key: "git_branch",
+            enabled: !config.disabled_tools.contains(&"git_branch".to_string()),
+        },
+        ToolOption {
+            name: "create_plan (Create Task Plan)",
+            key: "create_plan",
+            enabled: !config.disabled_tools.contains(&"create_plan".to_string()),
+        },
+        ToolOption {
+            name: "update_plan (Update Task Plan)",
+            key: "update_plan",
+            enabled: !config.disabled_tools.contains(&"update_plan".to_string()),
+        },
+        ToolOption {
+            name: "request_user_approval (Request User Approval)",
+            key: "request_user_approval",
+            enabled: !config
+                .disabled_tools
+                .contains(&"request_user_approval".to_string()),
+        },
+        ToolOption {
+            name: "ask_user (Ask User)",
+            key: "ask_user",
+            enabled: !config.disabled_tools.contains(&"ask_user".to_string()),
+        },
+        ToolOption {
+            name: "detect_project (Detect Project Type)",
+            key: "detect_project",
+            enabled: !config
+                .disabled_tools
+                .contains(&"detect_project".to_string()),
+        },
+        ToolOption {
+            name: "list_tests (List Tests)",
+            key: "list_tests",
+            enabled: !config.disabled_tools.contains(&"list_tests".to_string()),
+        },
+        ToolOption {
+            name: "read_diagnostics (Read Diagnostics)",
+            key: "read_diagnostics",
+            enabled: !config
+                .disabled_tools
+                .contains(&"read_diagnostics".to_string()),
+        },
+        ToolOption {
+            name: "view_image (View Image)",
+            key: "view_image",
+            enabled: !config.disabled_tools.contains(&"view_image".to_string()),
+        },
+        ToolOption {
+            name: "note_write (Write Notes)",
+            key: "note_write",
+            enabled: !config.disabled_tools.contains(&"note_write".to_string()),
+        },
+        ToolOption {
+            name: "run_plugin (Run Native Plugins)",
+            key: "run_plugin",
+            enabled: !config.disabled_tools.contains(&"run_plugin".to_string()),
+        },
+        ToolOption {
+            name: "mcp_tool (Call MCP Tools)",
+            key: "mcp_tool",
+            enabled: !config.disabled_tools.contains(&"mcp_tool".to_string()),
+        },
+        ToolOption {
+            name: "run_shell (Run Shell Commands)",
+            key: "run_shell",
+            enabled: !config.disabled_tools.contains(&"run_shell".to_string()),
+        },
+        ToolOption {
+            name: "verify (Run Verification Checks)",
+            key: "verify",
+            enabled: !config.disabled_tools.contains(&"verify".to_string()),
+        },
+        ToolOption {
+            name: "apply_patch (Patch Files)",
+            key: "apply_patch",
+            enabled: !config.disabled_tools.contains(&"apply_patch".to_string()),
+        },
+        ToolOption {
+            name: "write_file (Write Files)",
+            key: "write_file",
+            enabled: !config.disabled_tools.contains(&"write_file".to_string()),
+        },
+    ];
+
+    let mut cursor = 0;
+    print_options(&options, cursor);
+    enable_raw_mode()?;
+
+    loop {
+        match event::poll(std::time::Duration::from_millis(100)) {
+            Ok(true) => {
+                if let Event::Key(key_event) = event::read()? {
+                    if key_event.kind == event::KeyEventKind::Press {
+                        let is_ctrl_c = matches!(key_event.code, KeyCode::Char('c'))
+                            && key_event
+                                .modifiers
+                                .contains(crossterm::event::KeyModifiers::CONTROL);
+                        if is_ctrl_c {
+                            disable_raw_mode()?;
+                            println!("\n\x1b[31mSetup cancelled.\x1b[0m");
+                            return Ok(None);
+                        }
+
+                        match key_event.code {
+                            KeyCode::Up => {
+                                if cursor > 0 {
+                                    cursor -= 1;
+                                } else {
+                                    cursor = options.len() - 1;
+                                }
+                                disable_raw_mode()?;
+                                print!("\x1b[{}A\x1b[J", options.len());
+                                print_options(&options, cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Down => {
+                                if cursor < options.len() - 1 {
+                                    cursor += 1;
+                                } else {
+                                    cursor = 0;
+                                }
+                                disable_raw_mode()?;
+                                print!("\x1b[{}A\x1b[J", options.len());
+                                print_options(&options, cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Char(' ') => {
+                                options[cursor].enabled = !options[cursor].enabled;
+                                disable_raw_mode()?;
+                                print!("\x1b[{}A\x1b[J", options.len());
+                                print_options(&options, cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Char('a') => {
+                                for opt in &mut options {
+                                    opt.enabled = true;
+                                }
+                                disable_raw_mode()?;
+                                print!("\x1b[{}A\x1b[J", options.len());
+                                print_options(&options, cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Char('i') => {
+                                for opt in &mut options {
+                                    opt.enabled = !opt.enabled;
+                                }
+                                disable_raw_mode()?;
+                                print!("\x1b[{}A\x1b[J", options.len());
+                                print_options(&options, cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Enter => {
+                                break;
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+            }
+            Ok(false) => {}
+            Err(_) => {
+                break;
+            }
+        }
+    }
+    disable_raw_mode()?;
+    println!();
+
+    let disabled: Vec<String> = options
+        .iter()
+        .filter(|o| !o.enabled)
+        .map(|o| o.key.to_string())
+        .collect();
+
+    config.disabled_tools = disabled;
+    save_config(&config)?;
+
+    println!("\x1b[32mSuccessfully updated tool configurations!\x1b[0m\n");
+
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("\x1b[32m       Choose where to run Mint AI Agent\x1b[0m");
+    println!("\x1b[36m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m");
+    println!("Select the environment you want to launch:");
+    println!("  \x1b[90m[Keyboard Controls: ↑/↓: Navigate | Enter: Confirm]\x1b[0m");
+    println!();
+
+    let run_options = vec![
+        ToolOption {
+            name: "1. CLI (Interactive Terminal Assistant)",
+            key: "cli",
+            enabled: false,
+        },
+        ToolOption {
+            name: "2. Desktop App (Download & Install)",
+            key: "app_link",
+            enabled: false,
+        },
+        ToolOption {
+            name: "3. Web (Vite Web App UI)",
+            key: "web",
+            enabled: false,
+        },
+    ];
+
+    let mut run_cursor = 0;
+    print_run_options(&run_options, run_cursor);
+    enable_raw_mode()?;
+
+    loop {
+        match event::poll(std::time::Duration::from_millis(100)) {
+            Ok(true) => {
+                if let Event::Key(key_event) = event::read()? {
+                    if key_event.kind == event::KeyEventKind::Press {
+                        let is_ctrl_c = matches!(key_event.code, KeyCode::Char('c'))
+                            && key_event
+                                .modifiers
+                                .contains(crossterm::event::KeyModifiers::CONTROL);
+                        if is_ctrl_c {
+                            disable_raw_mode()?;
+                            println!("\n\x1b[31mRun selection cancelled.\x1b[0m");
+                            return Ok(None);
+                        }
+
+                        match key_event.code {
+                            KeyCode::Up => {
+                                if run_cursor > 0 {
+                                    run_cursor -= 1;
+                                } else {
+                                    run_cursor = run_options.len() - 1;
+                                }
+                                disable_raw_mode()?;
+                                print!("\x1b[{}A\x1b[J", run_options.len());
+                                print_run_options(&run_options, run_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Down => {
+                                if run_cursor < run_options.len() - 1 {
+                                    run_cursor += 1;
+                                } else {
+                                    run_cursor = 0;
+                                }
+                                disable_raw_mode()?;
+                                print!("\x1b[{}A\x1b[J", run_options.len());
+                                print_run_options(&run_options, run_cursor);
+                                enable_raw_mode()?;
+                            }
+                            KeyCode::Enter => {
+                                break;
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+            }
+            Ok(false) => {}
+            Err(_) => {
+                break;
+            }
+        }
+    }
+    disable_raw_mode()?;
+    println!();
+
+    Ok(Some(run_options[run_cursor].key.to_string()))
+}
+
+fn print_options(options: &[ToolOption], cursor: usize) {
+    for (i, opt) in options.iter().enumerate() {
+        let checkbox = if opt.enabled {
+            "\x1b[32m◉\x1b[0m"
+        } else {
+            "\x1b[90m○\x1b[0m"
+        };
+        if i == cursor {
+            println!(
+                "  \x1b[36m❯\x1b[0m {} \x1b[36m{}\x1b[0m",
+                checkbox, opt.name
+            );
+        } else {
+            println!("    {} {}", checkbox, opt.name);
+        }
+    }
+    let _ = io::stdout().flush();
+}
+
+fn print_run_options(options: &[ToolOption], cursor: usize) {
+    for (i, opt) in options.iter().enumerate() {
+        if i == cursor {
+            println!("  \x1b[36m❯\x1b[0m \x1b[36m{}\x1b[0m", opt.name);
+        } else {
+            println!("    {}", opt.name);
+        }
+    }
+    let _ = io::stdout().flush();
+}

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

@@ -0,0 +1,8 @@
+use std::path::Path;
+
+use anyhow::Result;
+use mint_core::{LearnedSkill, learn_skill};
+
+pub fn learn(path: &Path) -> Result<LearnedSkill> {
+    Ok(learn_skill(path)?)
+}

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

@@ -0,0 +1,279 @@
+use std::path::PathBuf;
+use std::process::Command;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use anyhow::{Context, Result, bail};
+
+const PACKAGE: &str = "@pheem49/mint";
+
+pub fn run(check_only: bool, dry_run: bool, approved: bool) -> Result<()> {
+    let current = env!("CARGO_PKG_VERSION");
+    let output = Command::new(npm())
+        .args(["view", PACKAGE, "version", "--json"])
+        .output()
+        .context("unable to run npm update check")?;
+    if !output.status.success() {
+        bail!(
+            "npm update check failed: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+    }
+    let latest = String::from_utf8_lossy(&output.stdout)
+        .trim()
+        .trim_matches('"')
+        .to_owned();
+    write_cache(&latest);
+    if compare_versions(current, &latest) >= 0 {
+        println!("Mint is already up to date ({current}).");
+        return Ok(());
+    }
+    println!("Mint {latest} is available. Current version: {current}.");
+    if check_only {
+        return Ok(());
+    }
+    if !approved {
+        bail!("update installation requires --approve");
+    }
+    let mut command = Command::new(npm());
+    command.args(["install", "-g", &format!("{PACKAGE}@latest")]);
+    if dry_run {
+        command.arg("--dry-run");
+    }
+    let status = command
+        .status()
+        .context("unable to run npm global update")?;
+    if !status.success() {
+        bail!("npm global update failed with status {status}");
+    }
+    println!(
+        "{}",
+        if dry_run {
+            "Update dry run complete."
+        } else {
+            "Mint updated. Restart mint to use the new version."
+        }
+    );
+    Ok(())
+}
+
+fn npm() -> &'static str {
+    if cfg!(target_os = "windows") {
+        "npm.cmd"
+    } else {
+        "npm"
+    }
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+struct UpdateCache {
+    last_checked: u64,
+    latest_version: String,
+}
+
+fn cache_path() -> Option<PathBuf> {
+    #[cfg(test)]
+    {
+        Some(std::env::temp_dir().join("update-cache.json"))
+    }
+    #[cfg(not(test))]
+    {
+        dirs::config_dir().map(|dir| dir.join("mint").join("update-cache.json"))
+    }
+}
+
+fn get_current_timestamp() -> u64 {
+    SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_secs())
+        .unwrap_or(0)
+}
+
+fn write_cache(latest_version: &str) -> Option<()> {
+    let path = cache_path()?;
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent).ok()?;
+    }
+    let cache = UpdateCache {
+        last_checked: get_current_timestamp(),
+        latest_version: latest_version.to_owned(),
+    };
+    let json = serde_json::to_string_pretty(&cache).ok()?;
+    std::fs::write(path, json).ok()?;
+    Some(())
+}
+
+pub fn get_cached_update_notice() -> Option<(String, String)> {
+    let path = cache_path()?;
+    if !path.exists() {
+        return None;
+    }
+    let data = std::fs::read_to_string(path).ok()?;
+    let cache: UpdateCache = serde_json::from_str(&data).ok()?;
+    let current = env!("CARGO_PKG_VERSION");
+    if compare_versions(current, &cache.latest_version) < 0 {
+        Some((current.to_owned(), cache.latest_version))
+    } else {
+        None
+    }
+}
+
+pub fn should_check_for_update() -> bool {
+    let path = match cache_path() {
+        Some(p) => p,
+        None => return false,
+    };
+    if !path.exists() {
+        return true;
+    }
+    let data = match std::fs::read_to_string(path) {
+        Ok(d) => d,
+        Err(_) => return true,
+    };
+    let cache: UpdateCache = match serde_json::from_str(&data) {
+        Ok(c) => c,
+        Err(_) => return true,
+    };
+    let now = get_current_timestamp();
+    // Check once every 24 hours (86400 seconds)
+    now.saturating_sub(cache.last_checked) > 86400
+}
+
+pub fn check_for_update_quietly() -> Option<(String, String)> {
+    let current = env!("CARGO_PKG_VERSION");
+    let output = Command::new(npm())
+        .args(["view", PACKAGE, "version", "--json"])
+        .output()
+        .ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let latest = String::from_utf8_lossy(&output.stdout)
+        .trim()
+        .trim_matches('"')
+        .to_owned();
+    write_cache(&latest);
+    if compare_versions(current, &latest) < 0 {
+        Some((current.to_owned(), latest))
+    } else {
+        None
+    }
+}
+
+pub fn print_update_notice(current: &str, latest: &str) {
+    let command_msg = "Run sh -c 'curl -fsSL https://raw.githubusercontent.com/Pheem49/Mint/main/install.sh | MINT_NON_INTERACTIVE=1 sh' to update.";
+    let notes_label = "See full release notes:";
+    let notes_url = "https://github.com/Pheem49/Mint/releases/latest";
+
+    // Text lengths (including 1 leading space)
+    let title_clean_len = 1
+        + 3
+        + format!("Update available! {} -> {}", current, latest)
+            .chars()
+            .count();
+    let command_msg_len = 1 + command_msg.len();
+    let notes_label_len = 1 + notes_label.len();
+    let notes_url_len = 1 + notes_url.len();
+
+    let max_len = command_msg_len
+        .max(title_clean_len)
+        .max(notes_label_len)
+        .max(notes_url_len)
+        + 1; // plus 1 for trailing space before right border
+
+    let border = "─".repeat(max_len);
+    println!("\x1b[33m╭{}╮\x1b[0m", border);
+
+    // Line 1: Title
+    let title_display = format!(
+        " ✨ Update available! \x1b[1;32m{}\x1b[0;33m -> \x1b[1;32m{}\x1b[0;33m",
+        current, latest
+    );
+    let padding1 = max_len - title_clean_len;
+    println!(
+        "\x1b[33m│\x1b[0m{}{}\x1b[33m│\x1b[0m",
+        title_display,
+        " ".repeat(padding1)
+    );
+
+    // Line 2: Command
+    let padding2 = max_len - command_msg_len;
+    println!(
+        "\x1b[33m│\x1b[0m \x1b[37m{}\x1b[0m{}\x1b[33m│\x1b[0m",
+        command_msg,
+        " ".repeat(padding2)
+    );
+
+    // Line 3: Empty separator
+    println!("\x1b[33m│\x1b[0m{}\x1b[33m│\x1b[0m", " ".repeat(max_len));
+
+    // Line 4: Notes label
+    let padding4 = max_len - notes_label_len;
+    println!(
+        "\x1b[33m│\x1b[0m \x1b[90m{}\x1b[0m{}\x1b[33m│\x1b[0m",
+        notes_label,
+        " ".repeat(padding4)
+    );
+
+    // Line 5: Notes URL
+    let padding5 = max_len - notes_url_len;
+    println!(
+        "\x1b[33m│\x1b[0m \x1b[36m{}\x1b[0m{}\x1b[33m│\x1b[0m",
+        notes_url,
+        " ".repeat(padding5)
+    );
+
+    println!("\x1b[33m╰{}╯\x1b[0m\n", border);
+}
+
+fn compare_versions(left: &str, right: &str) -> i8 {
+    let parse = |value: &str| {
+        value
+            .trim_start_matches('v')
+            .split('-')
+            .next()
+            .unwrap_or_default()
+            .split('.')
+            .map(|part| part.parse::<u64>().unwrap_or(0))
+            .collect::<Vec<_>>()
+    };
+    let left = parse(left);
+    let right = parse(right);
+    for index in 0..left.len().max(right.len()).max(3) {
+        match left
+            .get(index)
+            .unwrap_or(&0)
+            .cmp(right.get(index).unwrap_or(&0))
+        {
+            std::cmp::Ordering::Greater => return 1,
+            std::cmp::Ordering::Less => return -1,
+            std::cmp::Ordering::Equal => {}
+        }
+    }
+    0
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn compares_semantic_versions() {
+        assert_eq!(compare_versions("1.5.4", "1.6.0"), -1);
+        assert_eq!(compare_versions("v2.0.0-alpha.1", "2.0.0"), 0);
+    }
+
+    #[test]
+    fn test_write_and_read_cache() {
+        let path = cache_path().unwrap();
+        if path.exists() {
+            let _ = std::fs::remove_file(&path);
+        }
+        assert!(get_cached_update_notice().is_none());
+        assert!(write_cache("99.9.9").is_some());
+        let notice = get_cached_update_notice();
+        assert!(notice.is_some());
+        let (_current, latest) = notice.unwrap();
+        assert_eq!(latest, "99.9.9");
+        let _ = std::fs::remove_file(&path);
+    }
+}

package/crates/mint-core/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "mint-core"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[dependencies]
+base64.workspace = true
+chrono.workspace = true
+dirs.workspace = true
+futures-util.workspace = true
+image.workspace = true
+quick-xml.workspace = true
+regex.workspace = true
+reqwest.workspace = true
+rusqlite.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+sha2.workspace = true
+thiserror.workspace = true
+tokio.workspace = true
+tokio-tungstenite.workspace = true