@pheem49/mint 1.8.2 → 1.9.0

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

@@ -71,15 +71,14 @@ pub async fn resolve_github_links(message: &str, config: &MintConfig) -> String
                 .collect();
 
             let repo_key = format!("{owner}/{repo_clean}");
-            if resolved_repos.insert(repo_key.clone()) {
-                if let Ok(summary) =
+            if resolved_repos.insert(repo_key.clone())
+                && let Ok(summary) =
                     crate::code_tools::fetch_github_repo_summary(owner, &repo_clean).await
-                {
-                    resolved_msg.push_str(&format!(
+            {
+                resolved_msg.push_str(&format!(
                         "\n\n--- Auto-Resolved GitHub Metadata for {} ---\n{}\n--------------------------------------------",
                         repo_key, summary
                     ));
-                }
             }
         }
     }
@@ -210,18 +209,18 @@ fn enrich_request(
     let mut enriched = request.clone();
 
     let mut profile_instructions = String::new();
-    if let Ok(Some(name)) = memory.get_profile("name") {
-        if !name.trim().is_empty() {
-            profile_instructions.push_str(&format!("User Name: {}\n", name.trim()));
-        }
+    if let Ok(Some(name)) = memory.get_profile("name")
+        && !name.trim().is_empty()
+    {
+        profile_instructions.push_str(&format!("User Name: {}\n", name.trim()));
     }
-    if let Ok(Some(preferences)) = memory.get_profile("preferences") {
-        if !preferences.trim().is_empty() {
-            profile_instructions.push_str(&format!(
-                "User Preferences & Profile:\n{}\n",
-                preferences.trim()
-            ));
-        }
+    if let Ok(Some(preferences)) = memory.get_profile("preferences")
+        && !preferences.trim().is_empty()
+    {
+        profile_instructions.push_str(&format!(
+            "User Preferences & Profile:\n{}\n",
+            preferences.trim()
+        ));
     }
 
     if !profile_instructions.is_empty() {
@@ -239,8 +238,8 @@ fn enrich_request(
         "\n\n[Active Environment Context]\n\
          You are running on: {}\n\
          Using AI Model: {}\n",
-         config.ai_provider,
-         config.active_model()
+        config.ai_provider,
+        config.active_model()
     );
     enriched.system_instruction.push_str(&active_model_info);
 
@@ -685,7 +684,8 @@ fn resolve_agent_config(
         return (config.clone(), "".to_string(), None, None);
     }
 
-    let enabled_agents: Vec<&crate::config::AgentConfig> = config.agents.iter().filter(|a| a.enabled).collect();
+    let enabled_agents: Vec<&crate::config::AgentConfig> =
+        config.agents.iter().filter(|a| a.enabled).collect();
     if enabled_agents.is_empty() {
         return (config.clone(), "".to_string(), None, None);
     }
@@ -694,7 +694,9 @@ fn resolve_agent_config(
         enabled_agents.iter().find(|a| a.id == id).copied()
     } else {
         // Multi-Agent Pipeline Collaboration (Planner -> Coder -> Reviewer)
-        let plan_created = trajectory.iter().any(|step| step.contains("- Action: create_plan"));
+        let plan_created = trajectory
+            .iter()
+            .any(|step| step.contains("- Action: create_plan"));
         if !plan_created {
             if let Some(planner) = enabled_agents.iter().find(|a| a.id == "planner") {
                 Some(*planner)
@@ -708,7 +710,9 @@ fn resolve_agent_config(
             });
             if edits_made {
                 if let Some(last_step) = trajectory.last() {
-                    if last_step.contains("- Action: write_file") || last_step.contains("- Action: apply_patch") {
+                    if last_step.contains("- Action: write_file")
+                        || last_step.contains("- Action: apply_patch")
+                    {
                         if let Some(reviewer) = enabled_agents.iter().find(|a| a.id == "reviewer") {
                             Some(*reviewer)
                         } else {
@@ -741,21 +745,26 @@ fn resolve_agent_config(
     cfg_clone.local_model_name = agent.model.clone();
     cfg_clone.ollama_model = agent.model.clone();
 
-    if let Some(key) = &agent.api_key {
-        if !key.trim().is_empty() {
-            match agent.provider.as_str() {
-                "gemini" => cfg_clone.api_key = key.clone(),
-                "openai" => cfg_clone.openai_api_key = key.clone(),
-                "anthropic" => cfg_clone.anthropic_api_key = key.clone(),
-                "openrouter" => cfg_clone.openrouter_api_key = key.clone(),
-                "deepseek" => cfg_clone.deepseek_api_key = key.clone(),
-                "huggingface" => cfg_clone.hf_api_key = key.clone(),
-                _ => {}
-            }
+    if let Some(key) = &agent.api_key
+        && !key.trim().is_empty()
+    {
+        match agent.provider.as_str() {
+            "gemini" => cfg_clone.api_key = key.clone(),
+            "openai" => cfg_clone.openai_api_key = key.clone(),
+            "anthropic" => cfg_clone.anthropic_api_key = key.clone(),
+            "openrouter" => cfg_clone.openrouter_api_key = key.clone(),
+            "deepseek" => cfg_clone.deepseek_api_key = key.clone(),
+            "huggingface" => cfg_clone.hf_api_key = key.clone(),
+            _ => {}
         }
     }
 
-    (cfg_clone, agent.system_instruction.clone(), Some(agent.name.clone()), Some(agent.model.clone()))
+    (
+        cfg_clone,
+        agent.system_instruction.clone(),
+        Some(agent.name.clone()),
+        Some(agent.model.clone()),
+    )
 }
 
 pub async fn orchestrate_agent_loop<Approve, Progress, Chunk>(
@@ -796,18 +805,18 @@ where
 
     if let Ok(memory) = MemoryStore::open_default() {
         let mut profile_instructions = String::new();
-        if let Ok(Some(name)) = memory.get_profile("name") {
-            if !name.trim().is_empty() {
-                profile_instructions.push_str(&format!("User Name: {}\n", name.trim()));
-            }
+        if let Ok(Some(name)) = memory.get_profile("name")
+            && !name.trim().is_empty()
+        {
+            profile_instructions.push_str(&format!("User Name: {}\n", name.trim()));
         }
-        if let Ok(Some(preferences)) = memory.get_profile("preferences") {
-            if !preferences.trim().is_empty() {
-                profile_instructions.push_str(&format!(
-                    "User Preferences & Profile:\n{}\n",
-                    preferences.trim()
-                ));
-            }
+        if let Ok(Some(preferences)) = memory.get_profile("preferences")
+            && !preferences.trim().is_empty()
+        {
+            profile_instructions.push_str(&format!(
+                "User Preferences & Profile:\n{}\n",
+                preferences.trim()
+            ));
         }
 
         if !profile_instructions.is_empty() {
@@ -844,7 +853,8 @@ where
     let mut trajectory: Vec<String> = Vec::new();
 
     for step in 1..=MAX_STEPS {
-        let (active_config, agent_instruction, active_agent_name, active_model_name) = resolve_agent_config(config, agent_id, &trajectory);
+        let (active_config, agent_instruction, active_agent_name, active_model_name) =
+            resolve_agent_config(config, agent_id, &trajectory);
 
         progress(AgentProgress::Thinking {
             elapsed_secs: started_at.elapsed().as_secs(),
@@ -858,12 +868,14 @@ where
                 "\n\n[Active Environment Context]\n\
                  You are running on: {}\n\
                  Using AI Model: {}\n",
-                 active_config.ai_provider,
-                 model_name
+                active_config.ai_provider, model_name
             ));
         }
         if !agent_instruction.is_empty() {
-            active_system_prompt.push_str(&format!("\n\nYour Current Role & System Instructions:\n{}", agent_instruction));
+            active_system_prompt.push_str(&format!(
+                "\n\nYour Current Role & System Instructions:\n{}",
+                agent_instruction
+            ));
         }
 
         let (response, fallback) = send_chat_with_fallback(
@@ -1261,14 +1273,14 @@ where
             if crate::is_browser_running(config).await {
                 let result = crate::browser::navigate(config, url)
                     .await
-                    .map_err(|e| OrchestrationError::Agent(e))?;
+                    .map_err(OrchestrationError::Agent)?;
                 Ok(result)
             } else {
                 let opened = if cfg!(target_os = "macos") {
                     std::process::Command::new("open").arg(url).spawn().is_ok()
                 } else if cfg!(target_os = "windows") {
                     std::process::Command::new("cmd")
-                        .args(&["/C", "start", url])
+                        .args(["/C", "start", url])
                         .spawn()
                         .is_ok()
                 } else {
@@ -1300,7 +1312,7 @@ where
             };
             let result = crate::browser::click(config, selector)
                 .await
-                .map_err(|e| OrchestrationError::Agent(e))?;
+                .map_err(OrchestrationError::Agent)?;
             Ok(result)
         }
         "browser_type" => {
@@ -1324,13 +1336,13 @@ where
             };
             let result = crate::browser::type_text(config, selector, text)
                 .await
-                .map_err(|e| OrchestrationError::Agent(e))?;
+                .map_err(OrchestrationError::Agent)?;
             Ok(result)
         }
         "browser_read" => {
             let result = crate::browser::read_page_text(config)
                 .await
-                .map_err(|e| OrchestrationError::Agent(e))?;
+                .map_err(OrchestrationError::Agent)?;
             Ok(result)
         }
         "memory_recall" => {
@@ -1486,7 +1498,7 @@ where
                 path: file_name.to_owned(),
                 content: input.file_content.clone(),
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -1509,7 +1521,7 @@ where
                 name: name.to_owned(),
                 instruction: instruction.to_owned(),
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => Ok(execute_native_plugin(config, name, instruction)
@@ -1527,7 +1539,7 @@ where
                 tool: tool.to_owned(),
                 arguments: input.arguments.clone(),
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => Ok(serde_json::to_string_pretty(
@@ -1548,7 +1560,7 @@ where
                 command: command.to_owned(),
                 mode,
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => run_shell(root, config, command),
@@ -1593,7 +1605,7 @@ where
                 hunks: patch.hunks.clone(),
                 diff,
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -1629,7 +1641,7 @@ where
                 content: input.file_content.clone(),
                 diff,
             })
-            .map_err(|e| OrchestrationError::Agent(e))?;
+            .map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -1823,13 +1835,13 @@ fn view_image(path: &Path, config: &MintConfig) -> Result<String, OrchestrationE
     }
     let bytes = std::fs::read(&path)
         .map_err(|e| OrchestrationError::Agent(format!("cannot read image: {e}")))?;
-    Ok(serde_json::to_string_pretty(&serde_json::json!({
+    serde_json::to_string_pretty(&serde_json::json!({
         "path": path,
         "bytes": bytes.len(),
         "mime": mime,
         "dataUri": format!("data:{mime};base64,{}", BASE64_STANDARD.encode(bytes)),
     }))
-    .map_err(|e| OrchestrationError::Agent(e.to_string()))?)
+    .map_err(|e| OrchestrationError::Agent(e.to_string()))
 }
 
 fn run_shell(
@@ -1845,14 +1857,13 @@ fn run_shell(
 
     let mut hint = "";
     let cmd_lower = command.to_lowercase();
-    if output.success {
-        if cmd_lower.contains("open")
+    if output.success
+        && (cmd_lower.contains("open")
             || cmd_lower.contains("launch")
             || cmd_lower.contains("chrome")
-            || cmd_lower.contains("firefox")
-        {
-            hint = "\nNote: Opening URLs, files, folders, or launching applications are background processes. Even if there are warnings or stdout/stderr outputs, since the command exited successfully with status 0, the operation has succeeded and you should now use the 'finish' action to inform the user.";
-        }
+            || cmd_lower.contains("firefox"))
+    {
+        hint = "\nNote: Opening URLs, files, folders, or launching applications are background processes. Even if there are warnings or stdout/stderr outputs, since the command exited successfully with status 0, the operation has succeeded and you should now use the 'finish' action to inform the user.";
     }
 
     Ok(format!(
@@ -1897,7 +1908,9 @@ fn action_fingerprint(decision: &AgentDecision) -> String {
 }
 
 fn initial_observation(task: &str, root: &Path, skills: &str) -> String {
-    let now = chrono::Local::now().format("%Y-%m-%d %H:%M:%S %Z").to_string();
+    let now = chrono::Local::now()
+        .format("%Y-%m-%d %H:%M:%S %Z")
+        .to_string();
     let mut observation = format!(
         "Current Time: {now}\nTask: {task}\nWorkspace: {}\nLearned skills:\n{}\n",
         root.display(),
@@ -2271,19 +2284,19 @@ Example response:
         text_reply.to_string()
     };
 
-    if let Ok(value) = serde_json::from_str::<serde_json::Value>(&clean_json) {
-        if let Some(obj) = value.as_object() {
-            if let Some(new_name) = obj.get("name").and_then(|v| v.as_str()) {
-                let trimmed_name = new_name.trim();
-                if !trimmed_name.is_empty() && trimmed_name != current_name {
-                    memory.set_profile("name", trimmed_name)?;
-                }
+    if let Ok(value) = serde_json::from_str::<serde_json::Value>(&clean_json)
+        && let Some(obj) = value.as_object()
+    {
+        if let Some(new_name) = obj.get("name").and_then(|v| v.as_str()) {
+            let trimmed_name = new_name.trim();
+            if !trimmed_name.is_empty() && trimmed_name != current_name {
+                memory.set_profile("name", trimmed_name)?;
             }
-            if let Some(new_pref) = obj.get("preferences").and_then(|v| v.as_str()) {
-                let trimmed_pref = new_pref.trim();
-                if !trimmed_pref.is_empty() && trimmed_pref != current_pref {
-                    memory.set_profile("preferences", trimmed_pref)?;
-                }
+        }
+        if let Some(new_pref) = obj.get("preferences").and_then(|v| v.as_str()) {
+            let trimmed_pref = new_pref.trim();
+            if !trimmed_pref.is_empty() && trimmed_pref != current_pref {
+                memory.set_profile("preferences", trimmed_pref)?;
             }
         }
     }
@@ -2294,6 +2307,7 @@ Example response:
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::config::AgentConfig;
 
     #[test]
     fn preserves_request_without_history() {
@@ -2310,9 +2324,12 @@ mod tests {
             workspace_path: None,
             agent_id: None,
         };
-        assert_eq!(
-            enrich_request(&store, &request).unwrap().system_instruction,
-            "system"
+        let config = MintConfig::default();
+        assert!(
+            enrich_request(&config, &store, &request)
+                .unwrap()
+                .system_instruction
+                .starts_with("system")
         );
     }
 
@@ -2418,6 +2435,7 @@ mod tests {
     #[test]
     fn test_resolve_agent_config() {
         let mut config = MintConfig::default();
+        config.enable_agent_collaboration = true;
         config.agents = vec![
             AgentConfig {
                 id: "planner".into(),
@@ -2447,12 +2465,13 @@ mod tests {
         assert_eq!(name, Some("Planner".to_string()));
         assert_eq!(model, Some("gpt-4o".to_string()));
 
-        let (cfg, instr, name, model) = resolve_agent_config(&config, None, &[]);
+        let (cfg, instr, name, _model) = resolve_agent_config(&config, None, &[]);
         assert_eq!(cfg.ai_provider, "openai");
         assert_eq!(instr, "Planner instruction");
         assert_eq!(name, Some("Planner".to_string()));
 
-        let trajectory = vec!["Step 1:\n- Action: create_plan\n- Observation: all planned".to_string()];
+        let trajectory =
+            vec!["Step 1:\n- Action: create_plan\n- Observation: all planned".to_string()];
         let (cfg, instr, name, model) = resolve_agent_config(&config, None, &trajectory);
         assert_eq!(cfg.ai_provider, "gemini");
         assert_eq!(instr, "Coder instruction");

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

@@ -79,11 +79,10 @@ pub fn list_saved_pictures() -> Result<Vec<PictureEntry>, PictureError> {
                 .thumbnail_path
                 .as_ref()
                 .is_none_or(|thumbnail_path| !thumbnail_path.exists())
+                && let Some(thumbnail_path) = create_thumbnail_from_file(&directory, &entry)
             {
-                if let Some(thumbnail_path) = create_thumbnail_from_file(&directory, &entry) {
-                    entry.thumbnail_path = Some(thumbnail_path);
-                    changed = true;
-                }
+                entry.thumbnail_path = Some(thumbnail_path);
+                changed = true;
             }
             entry.url = Some(file_url(&entry.path));
             entry.thumbnail_url = entry.thumbnail_path.as_deref().map(file_url);

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

@@ -169,7 +169,7 @@ fn chunk_text(content: &str) -> Vec<(usize, usize, String)> {
     while start < lines.len() {
         let mut end = start;
         let mut chars = 0;
-        while end < lines.len() && (end == start || chars + lines[end].len() + 1 <= MAX_CHARS) {
+        while end < lines.len() && (end == start || chars + lines[end].len() < MAX_CHARS) {
             chars += lines[end].len() + 1;
             end += 1;
         }

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

@@ -121,7 +121,7 @@ fn run_in_sandbox(
             .arg(cwd)
             .args(["bash", "-lc", command])
             .output()?;
-        return Ok(Some(output));
+        Ok(Some(output))
     }
 
     #[cfg(target_os = "macos")]

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

@@ -92,6 +92,31 @@ pub fn learned_skills_context(workspace_root: Option<&Path>) -> Result<String, S
     Ok(format!("{}\n...<learned skills truncated>", &value[..end]))
 }
 
+pub fn parse_skill_description(content: &str) -> Option<String> {
+    let content = content.trim_start();
+    if !content.starts_with("---") {
+        return None;
+    }
+    let rest = &content[3..];
+    let end_idx = rest.find("---")?;
+    let frontmatter = &rest[..end_idx];
+    for line in frontmatter.lines() {
+        let line = line.trim();
+        if let Some(desc) = line.strip_prefix("description:") {
+            let mut val = desc.trim();
+            if (val.starts_with('"') && val.ends_with('"'))
+                || (val.starts_with('\'') && val.ends_with('\''))
+            {
+                if val.len() >= 2 {
+                    val = &val[1..val.len() - 1];
+                }
+            }
+            return Some(val.to_string());
+        }
+    }
+    None
+}
+
 pub fn load_skills_from_dir(dir: &Path, list: &mut Vec<LearnedSkill>) {
     if !dir.is_dir() {
         return;
@@ -109,36 +134,38 @@ pub fn load_skills_from_dir(dir: &Path, list: &mut Vec<LearnedSkill>) {
                                 .and_then(|n| n.to_str())
                                 .unwrap_or("skill")
                                 .to_string();
+                            let description = parse_skill_description(&content);
                             list.push(LearnedSkill {
                                 id: 0,
                                 name,
                                 source_path: skill_file.to_string_lossy().to_string(),
                                 content,
                                 created_at: String::new(),
+                                description,
                             });
                         }
                         break;
                     }
                 }
-            } else if path.is_file() {
-                if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
-                    if matches!(ext.to_ascii_lowercase().as_str(), "md" | "txt") {
-                        if let Ok(content) = fs::read_to_string(&path) {
-                            let name = path
-                                .file_stem()
-                                .and_then(|n| n.to_str())
-                                .unwrap_or("skill")
-                                .to_string();
-                            list.push(LearnedSkill {
-                                id: 0,
-                                name,
-                                source_path: path.to_string_lossy().to_string(),
-                                content,
-                                created_at: String::new(),
-                            });
-                        }
-                    }
-                }
+            } else if path.is_file()
+                && let Some(ext) = path.extension().and_then(|e| e.to_str())
+                && matches!(ext.to_ascii_lowercase().as_str(), "md" | "txt")
+                && let Ok(content) = fs::read_to_string(&path)
+            {
+                let name = path
+                    .file_stem()
+                    .and_then(|n| n.to_str())
+                    .unwrap_or("skill")
+                    .to_string();
+                let description = parse_skill_description(&content);
+                list.push(LearnedSkill {
+                    id: 0,
+                    name,
+                    source_path: path.to_string_lossy().to_string(),
+                    content,
+                    created_at: String::new(),
+                    description,
+                });
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pheem49/mint",
-  "version": "1.8.2",
+  "version": "1.9.0",
   "description": "A native Tauri desktop AI assistant with a Rust backend and React UI.",
   "scripts": {
     "dev:web": "vite --config vite.config.web.ts",

package/shared-modules/linux-audio/fluidsynth2-static.json

@@ -22,9 +22,15 @@
   ],
   "sources": [
     {
-      "type": "archive",
-      "url": "https://github.com/FluidSynth/fluidsynth/archive/refs/tags/v2.4.6.tar.gz",
-      "sha256": "a6be90fd4842b9e7246500597180af5cf213c11bfa3998a3236dd8ff47961ea8"
+        "type": "archive",
+        "url": "https://github.com/FluidSynth/fluidsynth/archive/v2.5.6.tar.gz",
+        "sha256": "0825f024c9cf7a18073739b83612d46542ecbfb349ae9147a1e9f08e2d524407"
+    },
+    {
+        "type": "git",
+        "url": "https://github.com/kthohr/gcem.git",
+        "commit": "012ae73c6d0a2cb09ffe86475f5c6fba3926e200",
+        "dest": "gcem"
     }
   ]
 }

package/shared-modules/linux-audio/fluidsynth2.json

@@ -12,8 +12,14 @@
     "sources": [
         {
             "type": "archive",
-            "url": "https://github.com/FluidSynth/fluidsynth/archive/refs/tags/v2.4.6.tar.gz",
-            "sha256": "a6be90fd4842b9e7246500597180af5cf213c11bfa3998a3236dd8ff47961ea8"
+            "url": "https://github.com/FluidSynth/fluidsynth/archive/v2.5.6.tar.gz",
+            "sha256": "0825f024c9cf7a18073739b83612d46542ecbfb349ae9147a1e9f08e2d524407"
+        },
+        {
+            "type": "git",
+            "url": "https://github.com/kthohr/gcem.git",
+            "commit": "012ae73c6d0a2cb09ffe86475f5c6fba3926e200",
+            "dest": "gcem"
         }
     ]
 }