@pheem49/mint 1.8.0 → 1.8.2

package/crates/mint-core/src/config.rs

@@ -79,10 +79,24 @@ pub struct MintConfig {
     pub blocked_paths: Vec<PathBuf>,
     pub blocked_file_names: Vec<String>,
     pub disabled_tools: Vec<String>,
+    pub agents: Vec<AgentConfig>,
+    pub enable_agent_collaboration: bool,
     #[serde(flatten)]
     pub extra: BTreeMap<String, Value>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentConfig {
+    pub id: String,
+    pub name: String,
+    pub provider: String,
+    pub model: String,
+    pub api_key: Option<String>,
+    pub system_instruction: String,
+    pub enabled: bool,
+}
+
 impl Default for MintConfig {
     fn default() -> Self {
         let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
@@ -142,12 +156,59 @@ impl Default for MintConfig {
             ],
             blocked_file_names: vec![".env".into(), "id_rsa".into(), "id_ed25519".into()],
             disabled_tools: Vec::new(),
+            agents: default_agents(),
+            enable_agent_collaboration: false,
             extra: runtime_extra_defaults(),
         }
     }
 }
 
+fn default_agents() -> Vec<AgentConfig> {
+    vec![
+        AgentConfig {
+            id: "planner".into(),
+            name: "Planner".into(),
+            provider: "gemini".into(),
+            model: "gemini-2.5-flash".into(),
+            api_key: None,
+            system_instruction: "You are the Planner agent. Your task is to analyze the user request, inspect the workspace structure, and design a step-by-step implementation plan. Create or update the implementation_plan.md file to document your proposal.".into(),
+            enabled: true,
+        },
+        AgentConfig {
+            id: "coder".into(),
+            name: "Coder".into(),
+            provider: "gemini".into(),
+            model: "gemini-2.5-flash".into(),
+            api_key: None,
+            system_instruction: "You are the Coder agent. Your task is to implement the changes specified in the approved implementation plan. Read relevant files, write clean and efficient code, and run terminal commands to build or verify. Stay focused on execution.".into(),
+            enabled: true,
+        },
+        AgentConfig {
+            id: "reviewer".into(),
+            name: "Reviewer".into(),
+            provider: "gemini".into(),
+            model: "gemini-2.5-flash".into(),
+            api_key: None,
+            system_instruction: "You are the Reviewer agent. Your task is to verify the code modifications made by the Coder. Run the automated tests, check lint errors, and ensure the implementation is correct and complete.".into(),
+            enabled: true,
+        },
+    ]
+}
+
 impl MintConfig {
+    pub fn active_model(&self) -> &str {
+        match self.ai_provider.as_str() {
+            "anthropic" => &self.anthropic_model,
+            "openai" => &self.openai_model,
+            "openrouter" => &self.openrouter_model,
+            "deepseek" => &self.deepseek_model,
+            "huggingface" => &self.hf_model,
+            "local_openai" => &self.local_model_name,
+            "ollama" => &self.ollama_model,
+            _ => &self.gemini_model,
+        }
+    }
+
     pub fn available_providers(&self) -> Vec<&'static str> {
         let mut providers = Vec::new();
         if has_value(&self.anthropic_api_key) {
@@ -208,7 +269,20 @@ pub fn set_config_value(key: &str, value: Value) -> Result<MintConfig, ConfigErr
 
 fn load_config_from(path: &Path) -> Result<MintConfig, ConfigError> {
     if !path.exists() {
-        let config = MintConfig::default();
+        let mut config = MintConfig::default();
+        if which("gk") {
+            let mut servers = BTreeMap::new();
+            servers.insert(
+                "gitkraken".to_string(),
+                serde_json::json!({
+                    "command": "gk",
+                    "args": ["mcp"]
+                }),
+            );
+            config
+                .extra
+                .insert("mcpServers".into(), serde_json::to_value(servers).unwrap());
+        }
         save_config_to(path, &config)?;
         return Ok(config);
     }
@@ -225,6 +299,32 @@ fn load_config_from(path: &Path) -> Result<MintConfig, ConfigError> {
     for (key, value) in runtime_extra_defaults() {
         config.extra.entry(key).or_insert(value);
     }
+
+    let has_gitkraken = config
+        .extra
+        .get("mcpServers")
+        .and_then(|v| v.get("gitkraken"))
+        .is_some();
+    if !has_gitkraken && which("gk") {
+        let mut servers: BTreeMap<String, Value> = config
+            .extra
+            .get("mcpServers")
+            .cloned()
+            .and_then(|v| serde_json::from_value(v).ok())
+            .unwrap_or_default();
+        servers.insert(
+            "gitkraken".to_string(),
+            serde_json::json!({
+                "command": "gk",
+                "args": ["mcp"]
+            }),
+        );
+        config
+            .extra
+            .insert("mcpServers".into(), serde_json::to_value(servers).unwrap());
+        let _ = save_config_to(path, &config);
+    }
+
     Ok(config)
 }
 
@@ -317,6 +417,21 @@ fn runtime_extra_defaults() -> BTreeMap<String, Value> {
     .expect("runtime config defaults must be a JSON object")
 }
 
+pub fn which(cmd: &str) -> bool {
+    #[cfg(windows)]
+    let check_cmd = "where";
+    #[cfg(not(windows))]
+    let check_cmd = "which";
+
+    std::process::Command::new(check_cmd)
+        .arg(cmd)
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status()
+        .map(|status| status.success())
+        .unwrap_or(false)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -384,4 +499,18 @@ mod tests {
         );
         assert_eq!(config.extra["allowedMcpTools"], serde_json::json!({}));
     }
+
+    #[test]
+    fn test_gitkraken_auto_detection() {
+        let path = std::env::temp_dir().join("mint-test-config.json");
+        let _ = std::fs::remove_file(&path);
+
+        let initial_config = MintConfig::default();
+        save_config_to(&path, &initial_config).unwrap();
+
+        let loaded = load_config_from(&path).unwrap();
+        assert!(loaded.theme.len() > 0);
+
+        let _ = std::fs::remove_file(&path);
+    }
 }

package/crates/mint-core/src/lib.rs

@@ -1,6 +1,7 @@
 #![recursion_limit = "256"]
 
 pub mod agent_loop;
+pub mod browser;
 pub mod chat;
 pub mod code_tools;
 pub mod config;
@@ -29,6 +30,10 @@ pub use chat::{
     stream_chat_with_fallback,
 };
 
+pub use browser::{
+    BrowserTab, click, is_browser_running, list_tabs, navigate, read_page_text,
+    spawn_automation_browser, type_text,
+};
 pub use code_tools::{
     AppliedCodeEdit, CodeEdit, CodeEditPreview, CodeEditProposal, CodeFile, CodeInspectionError,
     CodePatchHunk, CodePlan, CodeSearchHit, RepositorySummary, apply_code_edits, build_code_patch,
@@ -86,3 +91,17 @@ pub use channels::start_channels;
 
 pub static HTTP_CLIENT: std::sync::LazyLock<reqwest::Client> =
     std::sync::LazyLock::new(reqwest::Client::new);
+
+pub static ACTIVE_AGENTS: std::sync::LazyLock<std::sync::Mutex<std::collections::HashMap<String, tokio::task::AbortHandle>>> =
+    std::sync::LazyLock::new(|| std::sync::Mutex::new(std::collections::HashMap::new()));
+
+pub fn cancel_agent(chat_id: &str) -> bool {
+    let mut agents = ACTIVE_AGENTS.lock().unwrap();
+    if let Some(handle) = agents.remove(chat_id) {
+        handle.abort();
+        true
+    } else {
+        false
+    }
+}
+