@pheem49/mint 1.7.1 → 1.8.1

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

@@ -253,6 +253,16 @@ fn request_chat_id(request: &ChatRequest) -> &str {
 
 const MAX_STEPS: usize = 32;
 const MAX_OBSERVATION_BYTES: usize = 16_000;
+fn is_port_9222_open() -> bool {
+    use std::net::TcpStream;
+    use std::time::Duration;
+    if let Ok(addr) = "127.0.0.1:9222".parse() {
+        TcpStream::connect_timeout(&addr, Duration::from_millis(50)).is_ok()
+    } else {
+        false
+    }
+}
+
 pub fn build_system_prompt(config: &MintConfig) -> String {
     let mut allowed_actions = vec![
         "list_files",
@@ -284,6 +294,14 @@ pub fn build_system_prompt(config: &MintConfig) -> String {
         "apply_patch",
         "write_file",
     ];
+
+    if is_port_9222_open() {
+        allowed_actions.push("browser_open");
+        allowed_actions.push("browser_click");
+        allowed_actions.push("browser_type");
+        allowed_actions.push("browser_read");
+    }
+
     allowed_actions.retain(|action| !config.disabled_tools.contains(&action.to_string()));
     allowed_actions.push("finish");
 
@@ -319,6 +337,19 @@ pub fn build_system_prompt(config: &MintConfig) -> String {
     if allowed_actions.contains(&"web_search") {
         input_formats.push("- web_search: {\"query\":\"search terms\",\"limit\":5}");
     }
+    if allowed_actions.contains(&"browser_open") {
+        input_formats.push("- browser_open: {\"url\":\"https://example.com\"}");
+    }
+    if allowed_actions.contains(&"browser_click") {
+        input_formats.push("- browser_click: {\"selector\":\"button.submit-btn\"}");
+    }
+    if allowed_actions.contains(&"browser_type") {
+        input_formats
+            .push("- browser_type: {\"selector\":\"input.search-bar\", \"text\":\"search query\"}");
+    }
+    if allowed_actions.contains(&"browser_read") {
+        input_formats.push("- browser_read: {}");
+    }
     if allowed_actions.contains(&"memory_recall") {
         input_formats.push("- memory_recall: {\"query\":\"what did user say about X\"}");
     }
@@ -420,6 +451,20 @@ pub fn build_system_prompt(config: &MintConfig) -> String {
     if allowed_actions.contains(&"web_search") {
         rules.push("7. Use web_search when the user asks to look something up online or needs current information.");
     }
+    if allowed_actions.contains(&"browser_open") {
+        rules.push("7a. Use browser_open to navigate the virtual browser to a URL.");
+    }
+    if allowed_actions.contains(&"browser_click") {
+        rules.push("7b. Use browser_click to click elements on the page.");
+    }
+    if allowed_actions.contains(&"browser_type") {
+        rules.push("7c. Use browser_type to enter text/input into form fields or search boxes.");
+    }
+    if allowed_actions.contains(&"browser_read") {
+        rules.push(
+            "7d. Use browser_read to read the text content of the active page to analyze it.",
+        );
+    }
     if allowed_actions.contains(&"memory_recall") {
         rules.push("8. Use memory_recall to search past interactions before asking the user to repeat context.");
     }
@@ -590,6 +635,12 @@ struct AgentInput {
     title: String,
     #[serde(default)]
     status: String,
+    #[serde(default)]
+    url: String,
+    #[serde(default)]
+    selector: String,
+    #[serde(default)]
+    text: String,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -632,7 +683,7 @@ where
         ))
     })?;
     let resolved_task = resolve_github_links(task, config).await;
-    let skills = crate::skills::learned_skills_context().unwrap_or_default();
+    let skills = crate::skills::learned_skills_context(Some(&root)).unwrap_or_default();
     let mut observation = initial_observation(&resolved_task, &root, &skills);
     let mut pending_image = image_data_uri;
 
@@ -1076,6 +1127,91 @@ where
                 )),
             }
         }
+        "browser_open" => {
+            let url = if !input.url.is_empty() {
+                &input.url
+            } else if !input.path.is_empty() {
+                &input.path
+            } else {
+                return Err(OrchestrationError::Agent(
+                    "browser_open requires 'url'".into(),
+                ));
+            };
+            if crate::is_browser_running(config).await {
+                let result = crate::browser::navigate(config, url)
+                    .await
+                    .map_err(|e| OrchestrationError::Agent(e))?;
+                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])
+                        .spawn()
+                        .is_ok()
+                } else {
+                    std::process::Command::new("xdg-open")
+                        .arg(url)
+                        .spawn()
+                        .is_ok()
+                };
+                if opened {
+                    Ok(format!(
+                        "Mint Auto is not active. Opened {url} in your default browser instead."
+                    ))
+                } else {
+                    Err(OrchestrationError::Agent(
+                        "Failed to open URL in default browser.".into(),
+                    ))
+                }
+            }
+        }
+        "browser_click" => {
+            let selector = if !input.selector.is_empty() {
+                &input.selector
+            } else if !input.path.is_empty() {
+                &input.path
+            } else {
+                return Err(OrchestrationError::Agent(
+                    "browser_click requires 'selector'".into(),
+                ));
+            };
+            let result = crate::browser::click(config, selector)
+                .await
+                .map_err(|e| OrchestrationError::Agent(e))?;
+            Ok(result)
+        }
+        "browser_type" => {
+            let selector = if !input.selector.is_empty() {
+                &input.selector
+            } else if !input.path.is_empty() {
+                &input.path
+            } else {
+                return Err(OrchestrationError::Agent(
+                    "browser_type requires 'selector'".into(),
+                ));
+            };
+            let text = if !input.text.is_empty() {
+                &input.text
+            } else if !input.query.is_empty() {
+                &input.query
+            } else {
+                return Err(OrchestrationError::Agent(
+                    "browser_type requires 'text'".into(),
+                ));
+            };
+            let result = crate::browser::type_text(config, selector, text)
+                .await
+                .map_err(|e| OrchestrationError::Agent(e))?;
+            Ok(result)
+        }
+        "browser_read" => {
+            let result = crate::browser::read_page_text(config)
+                .await
+                .map_err(|e| OrchestrationError::Agent(e))?;
+            Ok(result)
+        }
         "memory_recall" => {
             let query = required(&input.query, "query")?;
             let query_lower = query.to_ascii_lowercase();

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

@@ -53,10 +53,32 @@ pub fn learn_skill(path: &Path) -> Result<LearnedSkill, SkillError> {
     Ok(MemoryStore::open_default()?.add_learned_skill(name, &path.to_string_lossy(), &content)?)
 }
 
-pub fn learned_skills_context() -> Result<String, SkillError> {
-    let skills = MemoryStore::open_default()?.learned_skills(20)?;
-    let value = skills
-        .into_iter()
+pub fn learned_skills_context(workspace_root: Option<&Path>) -> Result<String, SkillError> {
+    let mut skills = MemoryStore::open_default()?.learned_skills(20)?;
+
+    if let Some(home) = dirs::home_dir() {
+        let global_skills_path = home.join(".config").join("mint").join("mint-skills");
+        if !global_skills_path.exists() {
+            let _ = std::fs::create_dir_all(&global_skills_path);
+        }
+        load_skills_from_dir(&global_skills_path, &mut skills);
+    }
+
+    if let Some(root) = workspace_root {
+        let workspace_skills_path1 = root.join(".agents").join("skills");
+        load_skills_from_dir(&workspace_skills_path1, &mut skills);
+
+        let workspace_skills_path2 = root.join("skills");
+        load_skills_from_dir(&workspace_skills_path2, &mut skills);
+    }
+
+    let mut unique_skills = std::collections::BTreeMap::new();
+    for skill in skills {
+        unique_skills.insert(skill.name.clone(), skill);
+    }
+
+    let value = unique_skills
+        .into_values()
         .map(|skill| format!("Skill: {}\n{}", skill.name, skill.content))
         .collect::<Vec<_>>()
         .join("\n\n");
@@ -69,3 +91,90 @@ pub fn learned_skills_context() -> Result<String, SkillError> {
     }
     Ok(format!("{}\n...<learned skills truncated>", &value[..end]))
 }
+
+pub fn load_skills_from_dir(dir: &Path, list: &mut Vec<LearnedSkill>) {
+    if !dir.is_dir() {
+        return;
+    }
+    if let Ok(entries) = fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            let path = entry.path();
+            if path.is_dir() {
+                for filename in &["SKILL.md", "SKILL.txt", "skill.md", "skill.txt"] {
+                    let skill_file = path.join(filename);
+                    if skill_file.is_file() {
+                        if let Ok(content) = fs::read_to_string(&skill_file) {
+                            let name = path
+                                .file_name()
+                                .and_then(|n| n.to_str())
+                                .unwrap_or("skill")
+                                .to_string();
+                            list.push(LearnedSkill {
+                                id: 0,
+                                name,
+                                source_path: skill_file.to_string_lossy().to_string(),
+                                content,
+                                created_at: String::new(),
+                            });
+                        }
+                        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(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fs_skills_loading() {
+        let test_dir = std::env::temp_dir().join("mint_skills_test_unique_dir");
+        let _ = std::fs::remove_dir_all(&test_dir);
+        let workspace_path = test_dir.join(".agents").join("skills");
+        std::fs::create_dir_all(&workspace_path).unwrap();
+
+        // Write a file skill
+        let file_skill_path = workspace_path.join("rust-style.md");
+        std::fs::write(&file_skill_path, "Use 4 spaces for Rust indent.").unwrap();
+
+        // Write a directory skill
+        let dir_skill_path = workspace_path.join("js-style");
+        std::fs::create_dir_all(&dir_skill_path).unwrap();
+        std::fs::write(dir_skill_path.join("SKILL.md"), "Use 2 spaces for JS.").unwrap();
+
+        let mut list = Vec::new();
+        load_skills_from_dir(&workspace_path, &mut list);
+
+        let _ = std::fs::remove_dir_all(&test_dir);
+
+        assert_eq!(list.len(), 2);
+
+        let rust_skill = list.iter().find(|s| s.name == "rust-style").unwrap();
+        assert_eq!(rust_skill.content, "Use 4 spaces for Rust indent.");
+
+        let js_skill = list.iter().find(|s| s.name == "js-style").unwrap();
+        assert_eq!(js_skill.content, "Use 2 spaces for JS.");
+    }
+}

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

@@ -51,31 +51,18 @@ pub fn load_workflows() -> Result<Vec<Value>, WorkflowError> {
 fn save_default_workflows(path: &PathBuf) -> Result<(), WorkflowError> {
     let directory = path.parent().ok_or(WorkflowError::MissingDirectory)?;
     fs::create_dir_all(directory).map_err(WorkflowError::CreateDirectory)?;
-    let workflows = json!([
-        {
-            "id": "wf-1",
-            "name": "Check Mic on Zoom",
-            "trigger": { "type": "process_running", "processName": "zoom" },
-            "action": {
-                "type": "system_info",
-                "message": "Looks like you opened Zoom. Should I check your system resources?",
-                "target": ""
-            }
-        },
-        {
-            "id": "wf-2",
-            "name": "Coding Time",
-            "trigger": { "type": "process_running", "processName": "code" },
-            "action": {
-                "type": "open_app",
-                "message": "Coding time. Want me to open Spotify?",
-                "target": "spotify"
-            }
-        }
-    ]);
+    let workflows = json!([]);
     let raw = serde_json::to_string_pretty(&workflows).map_err(WorkflowError::Serialize)?;
     fs::write(path, format!("{raw}\n")).map_err(|source| WorkflowError::Write {
         path: path.clone(),
         source,
     })
 }
+
+pub fn save_workflows(workflows: &[Value]) -> Result<(), WorkflowError> {
+    let path = workflows_path()?;
+    let directory = path.parent().ok_or(WorkflowError::MissingDirectory)?;
+    fs::create_dir_all(directory).map_err(WorkflowError::CreateDirectory)?;
+    let raw = serde_json::to_string_pretty(workflows).map_err(WorkflowError::Serialize)?;
+    fs::write(&path, format!("{raw}\n")).map_err(|source| WorkflowError::Write { path, source })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pheem49/mint",
-  "version": "1.7.1",
+  "version": "1.8.1",
   "description": "A native Tauri desktop AI assistant with a Rust backend and React UI.",
   "scripts": {
     "dev:web": "vite --config vite.config.web.ts",
@@ -58,6 +58,7 @@
   "dependencies": {
     "@tauri-apps/api": "^2.0.0",
     "@vitejs/plugin-react": "^6.0.1",
+    "@xyflow/react": "^12.11.1",
     "material-icon-theme": "5.34.0",
     "pixi-live2d-display": "^0.4.0",
     "pixi.js": "^6.5.10",

package/src/renderer/src/App.tsx

@@ -6,7 +6,6 @@ const WidgetWindow = lazy(() => import('./components/WidgetWindow'))
 const ProactiveGlow = lazy(() => import('./components/ProactiveGlow'))
 const ScreenPicker = lazy(() => import('./components/ScreenPicker'))
 const MintDashboard = lazy(() => import('./components/MintDashboard'))
-
 export default function App() {
   const [hash, setHash] = useState(window.location.hash || '#/')
 
@@ -29,5 +28,6 @@ export default function App() {
   if (route.startsWith('/proactive-glow')) content = <ProactiveGlow />
   if (route.startsWith('/screen-picker')) content = <ScreenPicker />
 
+
   return <Suspense fallback={null}>{content}</Suspense>
 }