@pheem49/mint 1.7.1 → 1.8.1

package/src-tauri/src/lib.rs

@@ -1,4 +1,3 @@
-mod browser;
 mod desktop;
 mod discord_rpc;
 mod events;
@@ -11,8 +10,7 @@ mod updater;
 mod webhooks;
 mod workflows;
 
-use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
-use browser::{
+use mint_core::browser::{
     BrowserTab, click as browser_click, list_tabs as browser_list_tabs,
     navigate as browser_navigate, read_page_text,
 };
@@ -34,15 +32,15 @@ use mint_core::{
     AgentApproval, AgentProgress, AppliedCodeEdit, ApprovalOutcome, ChatRequest, ChatResponse,
     ChatSession, CodeEdit, CodeEditProposal, ImageGenRequest, InteractionMemory, MemoryStore,
     MintConfig, PictureEntry, TtsUrl, WeatherReport, apply_code_edits, classify_shell_command,
-    config_path, extract_document_text, google_tts_urls, list_saved_pictures, load_config,
-    load_workflows, orchestrate_agent_loop, orchestrate_chat_stream_with_fallback,
-    orchestrate_chat_with_fallback, propose_code_edits, save_chat_images, save_config,
-    start_channels, weather, workflows_path,
+    config_path, google_tts_urls, list_saved_pictures, load_config, load_workflows,
+    orchestrate_agent_loop, orchestrate_chat_stream_with_fallback, orchestrate_chat_with_fallback,
+    propose_code_edits, save_chat_images, save_config, save_workflows, start_channels, weather,
+    workflows_path,
 };
 use plugins::execute_plugin;
 
 pub struct ApprovalsState {
-    pub pending: Mutex<HashMap<String, oneshot::Sender<bool>>>,
+    pub pending: Mutex<HashMap<String, oneshot::Sender<ApprovalOutcome>>>,
 }
 
 static COUNTER: AtomicU64 = AtomicU64::new(1);
@@ -94,9 +92,6 @@ enum DesktopStreamEvent {
     Chunk { chunk: String },
     Progress { progress: AgentProgress },
 }
-
-const MAX_DOCUMENT_BYTES: usize = 10 * 1024 * 1024;
-const MAX_DOCUMENT_CONTEXT_CHARS: usize = 30_000;
 const WORKSPACE_TREE_MAX_DEPTH: usize = 9;
 const WORKSPACE_TREE_MAX_CHILDREN: usize = 400;
 const WORKSPACE_TREE_COLLAPSED_DIRS: &[&str] = &[
@@ -114,85 +109,6 @@ const WORKSPACE_TREE_COLLAPSED_DIRS: &[&str] = &[
     "target",
 ];
 
-fn request_with_document_context(
-    config: &MintConfig,
-    request: &ChatRequest,
-) -> Result<ChatRequest, String> {
-    let Some(document) = &request.document_attachment else {
-        return Ok(request.clone());
-    };
-
-    let (mime_type, encoded) = document
-        .data_uri
-        .strip_prefix("data:")
-        .and_then(|payload| payload.split_once(";base64,"))
-        .ok_or_else(|| "invalid PDF attachment data URI".to_string())?;
-
-    if !mime_type.eq_ignore_ascii_case("application/pdf") {
-        return Err("only PDF document attachments are supported".into());
-    }
-
-    let bytes = BASE64_STANDARD
-        .decode(encoded)
-        .map_err(|error| format!("invalid PDF attachment encoding: {error}"))?;
-    if bytes.len() > MAX_DOCUMENT_BYTES {
-        return Err("PDF attachment is too large (> 10 MiB)".into());
-    }
-
-    let directory = config_path()
-        .map_err(|error| error.to_string())?
-        .with_file_name("Attachments");
-    fs::create_dir_all(&directory).map_err(|error| error.to_string())?;
-    let path = directory.join(format!(
-        "mint-pdf-{}-{}.pdf",
-        COUNTER.fetch_add(1, Ordering::SeqCst),
-        sanitize_attachment_name(&document.filename)
-    ));
-    fs::write(&path, bytes).map_err(|error| error.to_string())?;
-
-    let extracted = extract_document_text(&path, config).map_err(|error| error.to_string());
-    let _ = fs::remove_file(&path);
-    let extracted = extracted?;
-    let context = truncate_document_context(&extracted);
-    let filename = document.filename.trim();
-    let filename = if filename.is_empty() {
-        "attached.pdf"
-    } else {
-        filename
-    };
-
-    let mut enriched = request.clone();
-    enriched.document_attachment = None;
-    enriched.message = format!(
-        "{}\n\nAttached PDF: {filename}\nUse the extracted PDF text below when answering. If the user asks for a summary, summarize this document.\n\n--- Extracted PDF text ---\n{context}\n--- End extracted PDF text ---",
-        request.message
-    );
-    Ok(enriched)
-}
-
-fn truncate_document_context(text: &str) -> String {
-    let mut output: String = text.chars().take(MAX_DOCUMENT_CONTEXT_CHARS).collect();
-    if text.chars().count() > MAX_DOCUMENT_CONTEXT_CHARS {
-        output.push_str("\n\n[PDF text truncated because it is long.]");
-    }
-    output
-}
-
-fn sanitize_attachment_name(filename: &str) -> String {
-    let sanitized: String = filename
-        .chars()
-        .filter(|character| {
-            character.is_ascii_alphanumeric() || matches!(character, '.' | '-' | '_')
-        })
-        .take(80)
-        .collect();
-    if sanitized.is_empty() {
-        "document".into()
-    } else {
-        sanitized
-    }
-}
-
 #[tauri::command]
 fn get_runtime_status() -> Result<RuntimeStatus, String> {
     let config = load_config().map_err(|error| error.to_string())?;
@@ -219,6 +135,26 @@ async fn get_workspace_tree(path: Option<String>) -> Result<WorkspaceTreeEntry,
         .map_err(|error| format!("workspace tree task failed: {error}"))?
 }
 
+#[tauri::command]
+async fn create_workspace_file(path: String) -> Result<(), String> {
+    std::fs::write(&path, "").map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+async fn create_workspace_folder(path: String) -> Result<(), String> {
+    std::fs::create_dir_all(&path).map_err(|error| error.to_string())
+}
+
+#[tauri::command]
+async fn delete_workspace_item(path: String) -> Result<(), String> {
+    let path_buf = std::path::PathBuf::from(path);
+    if path_buf.is_dir() {
+        std::fs::remove_dir_all(path_buf).map_err(|error| error.to_string())
+    } else {
+        std::fs::remove_file(path_buf).map_err(|error| error.to_string())
+    }
+}
+
 fn build_workspace_tree(path: Option<String>) -> Result<WorkspaceTreeEntry, String> {
     let root = workspace_root(path.as_deref())?;
     let name = root
@@ -274,6 +210,11 @@ fn workspace_root(path: Option<&str>) -> Result<PathBuf, String> {
         None => std::env::current_dir().map_err(|error| error.to_string())?,
     };
     let root = root.canonicalize().map_err(|error| error.to_string())?;
+    let root = if root.ends_with("src-tauri") {
+        root.parent().unwrap_or(&root).to_path_buf()
+    } else {
+        root
+    };
     if !root.is_dir() {
         return Err(format!("workspace is not a directory: {}", root.display()));
     }
@@ -376,7 +317,7 @@ fn inspect_shell_command(command: String) -> mint_core::ShellClassification {
 #[tauri::command]
 async fn send_chat_message(app: AppHandle, request: ChatRequest) -> Result<ChatResponse, String> {
     let config = load_config().map_err(|error| error.to_string())?;
-    let request = request_with_document_context(&config, &request)?;
+    let request = request.with_document_context(&config)?;
 
     if request.message.starts_with("/chat ") {
         let mut clean_request = request.clone();
@@ -413,15 +354,10 @@ async fn send_chat_message(app: AppHandle, request: ChatRequest) -> Result<ChatR
             )
             .map_err(|e| e.to_string())?;
 
-        let approved =
+        let outcome =
             tokio::task::block_in_place(move || tokio::runtime::Handle::current().block_on(rx))
-                .unwrap_or(false);
-
-        if approved {
-            Ok(ApprovalOutcome::Approved)
-        } else {
-            Ok(ApprovalOutcome::Denied)
-        }
+                .unwrap_or(ApprovalOutcome::Denied);
+        Ok(outcome)
     };
 
     let progress_cb = |_| {};
@@ -456,7 +392,7 @@ async fn stream_chat_message(
     on_event: Channel<DesktopStreamEvent>,
 ) -> Result<ChatResponse, String> {
     let config = load_config().map_err(|error| error.to_string())?;
-    let request = request_with_document_context(&config, &request)?;
+    let request = request.with_document_context(&config)?;
 
     if request.message.starts_with("/chat ") {
         let mut clean_request = request.clone();
@@ -496,15 +432,10 @@ async fn stream_chat_message(
             )
             .map_err(|e| e.to_string())?;
 
-        let approved =
+        let outcome =
             tokio::task::block_in_place(move || tokio::runtime::Handle::current().block_on(rx))
-                .unwrap_or(false);
-
-        if approved {
-            Ok(ApprovalOutcome::Approved)
-        } else {
-            Ok(ApprovalOutcome::Denied)
-        }
+                .unwrap_or(ApprovalOutcome::Denied);
+        Ok(outcome)
     };
 
     let on_progress_event = on_event.clone();
@@ -562,6 +493,20 @@ fn save_interaction_agent_activity(
         .map_err(|error| error.to_string())
 }
 
+#[tauri::command]
+fn save_system_interaction(
+    chat_id: String,
+    user_text: String,
+    provider: String,
+    model: String,
+) -> Result<i64, String> {
+    MemoryStore::open_default()
+        .and_then(|memory| {
+            memory.add_interaction_for_chat(&chat_id, &user_text, "", &provider, &model)
+        })
+        .map_err(|error| error.to_string())
+}
+
 #[tauri::command]
 fn get_recent_interactions(
     limit: Option<usize>,
@@ -614,6 +559,87 @@ fn set_profile_value(key: String, value: String) -> Result<(), String> {
         .map_err(|error| error.to_string())
 }
 
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+struct LearnedSkillDto {
+    id: i64,
+    name: String,
+    source_path: String,
+    content: String,
+    updated_at: String,
+    location: String,
+}
+
+#[tauri::command]
+fn list_learned_skills(workspace_path: Option<String>) -> Result<Vec<LearnedSkillDto>, String> {
+    let store = MemoryStore::open_default().map_err(|e| e.to_string())?;
+    let db_skills = store.learned_skills(100).map_err(|e| e.to_string())?;
+
+    let mut global_skills = Vec::new();
+    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);
+        }
+        mint_core::skills::load_skills_from_dir(&global_skills_path, &mut global_skills);
+    }
+
+    let mut workspace_skills = Vec::new();
+    if let Ok(root) = workspace_root(workspace_path.as_deref()) {
+        let workspace_skills_path1 = root.join(".agents").join("skills");
+        mint_core::skills::load_skills_from_dir(&workspace_skills_path1, &mut workspace_skills);
+
+        let workspace_skills_path2 = root.join("skills");
+        mint_core::skills::load_skills_from_dir(&workspace_skills_path2, &mut workspace_skills);
+    }
+
+    let mut unique_skills = std::collections::BTreeMap::new();
+    for s in db_skills {
+        unique_skills.insert(s.name.clone(), (s, "database"));
+    }
+    for s in global_skills {
+        unique_skills.insert(s.name.clone(), (s, "global"));
+    }
+    for s in workspace_skills {
+        unique_skills.insert(s.name.clone(), (s, "workspace"));
+    }
+
+    let dtos = unique_skills
+        .into_values()
+        .map(|(s, loc)| LearnedSkillDto {
+            id: s.id,
+            name: s.name,
+            source_path: s.source_path,
+            content: s.content,
+            updated_at: s.created_at,
+            location: loc.to_string(),
+        })
+        .collect();
+    Ok(dtos)
+}
+
+#[tauri::command]
+fn add_learned_skill(name: String, content: String) -> Result<LearnedSkillDto, String> {
+    let store = MemoryStore::open_default().map_err(|e| e.to_string())?;
+    let skill = store
+        .add_learned_skill(&name, "ui_manual", &content)
+        .map_err(|e| e.to_string())?;
+    Ok(LearnedSkillDto {
+        id: skill.id,
+        name: skill.name,
+        source_path: skill.source_path,
+        content: skill.content,
+        updated_at: skill.created_at,
+        location: "database".to_string(),
+    })
+}
+
+#[tauri::command]
+fn delete_learned_skill(name: String) -> Result<usize, String> {
+    let store = MemoryStore::open_default().map_err(|e| e.to_string())?;
+    store.delete_learned_skill(&name).map_err(|e| e.to_string())
+}
+
 #[tauri::command]
 fn clear_chat_history(chat_id: Option<String>) -> Result<usize, String> {
     MemoryStore::open_default()
@@ -632,16 +658,47 @@ async fn submit_tool_approval(
     state: tauri::State<'_, ApprovalsState>,
     token: String,
     approved: bool,
+    answer: Option<String>,
 ) -> Result<(), String> {
     let mut pending = state.pending.lock().map_err(|error| error.to_string())?;
     if let Some(tx) = pending.remove(&token) {
-        let _ = tx.send(approved);
+        let outcome = if let Some(ans) = answer {
+            if !ans.trim().is_empty() {
+                ApprovalOutcome::Intercepted(ans)
+            } else {
+                ApprovalOutcome::Denied
+            }
+        } else if approved {
+            ApprovalOutcome::Approved
+        } else {
+            ApprovalOutcome::Denied
+        };
+        let _ = tx.send(outcome);
         Ok(())
     } else {
         Err("No pending approval found for this token".into())
     }
 }
 
+#[derive(serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DetectedTools {
+    pub docker: bool,
+    pub git: bool,
+    pub gh: bool,
+    pub node: bool,
+}
+
+#[tauri::command]
+async fn detect_system_tools() -> Result<DetectedTools, String> {
+    Ok(DetectedTools {
+        docker: mint_core::config::which("docker"),
+        git: mint_core::config::which("git"),
+        gh: mint_core::config::which("gh"),
+        node: mint_core::config::which("node"),
+    })
+}
+
 #[derive(serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 struct DesktopImageGenResponse {
@@ -860,7 +917,15 @@ async fn click_browser_selector(selector: String) -> Result<String, String> {
     )
     .await
 }
-
+#[tauri::command]
+async fn type_in_browser(selector: String, text: String) -> Result<String, String> {
+    mint_core::browser::type_text(
+        &load_config().map_err(|error| error.to_string())?,
+        &selector,
+        &text,
+    )
+    .await
+}
 #[tauri::command]
 fn start_screen_capture(app: AppHandle) -> Result<(), String> {
     open_desktop_window(&app, "screen-picker")
@@ -929,6 +994,15 @@ fn reload_custom_workflows() -> Result<Value, String> {
     }))
 }
 
+#[tauri::command]
+fn save_custom_workflows(workflows: Vec<serde_json::Value>) -> Result<ActionResult, String> {
+    save_workflows(&workflows).map_err(|error| error.to_string())?;
+    Ok(ActionResult {
+        success: true,
+        message: "workflows saved successfully".into(),
+    })
+}
+
 fn install_tray(app: &AppHandle) -> tauri::Result<()> {
     let show = MenuItem::with_id(app, "show", "Show Mint", true, None::<&str>)?;
     let settings = MenuItem::with_id(app, "settings", "Settings", true, None::<&str>)?;
@@ -1034,7 +1108,11 @@ pub fn run() {
         })
         .invoke_handler(tauri::generate_handler![
             get_runtime_status,
+            detect_system_tools,
             get_workspace_tree,
+            create_workspace_file,
+            create_workspace_folder,
+            delete_workspace_item,
             generate_images,
             select_workspace_directory,
             get_config,
@@ -1054,6 +1132,9 @@ pub fn run() {
             get_profile_value,
             set_profile_value,
             clear_chat_history,
+            list_learned_skills,
+            add_learned_skill,
+            delete_learned_skill,
             list_pictures,
             save_pictures,
             open_folder,
@@ -1076,6 +1157,7 @@ pub fn run() {
             navigate_browser,
             read_browser_page,
             click_browser_selector,
+            type_in_browser,
             start_screen_capture,
             submit_screen_selection,
             submit_spotlight,
@@ -1085,7 +1167,9 @@ pub fn run() {
             run_next_queued_task,
             exit_app,
             open_workflows_file,
-            reload_custom_workflows
+            reload_custom_workflows,
+            save_custom_workflows,
+            save_system_interaction
         ])
         .run(tauri::generate_context!())
         .expect("error while running Mint desktop");

package/src-tauri/src/workflows.rs

@@ -5,7 +5,7 @@ use std::{
     time::{Duration, Instant},
 };
 
-use mint_core::{load_config, load_workflows};
+use mint_core::{ChatRequest, load_config, load_workflows, send_chat};
 use serde_json::json;
 use tauri::{AppHandle, Emitter, Manager};
 
@@ -53,10 +53,62 @@ pub fn start_monitor(app: AppHandle) {
                 }
                 last_triggered.insert(id.into(), Instant::now());
                 if let Some(main) = app.get_webview_window("main") {
+                    let static_message = workflow["action"]["message"]
+                        .as_str()
+                        .unwrap_or("Automation workflow triggered");
+
+                    let final_message = if let Ok(config) = load_config() {
+                        let prompt = format!(
+                            "You are Mint, a friendly desktop AI assistant. The user has triggered a workflow called '{}'. \
+                            The original notification message is: '{}'. \
+                            Please rewrite this notification message to be extremely friendly, cute, and natural. \
+                            Write in the language matching the user's configured language: '{}'. \
+                            Keep the length under 20 words and always end with a question (e.g. asking if they want to launch the action). \
+                            Only reply with the rewritten message itself, do not include any quotes, markdown formatting, or extra explanations.",
+                            workflow["name"].as_str().unwrap_or(""),
+                            static_message,
+                            config.language
+                        );
+
+                        let chat_req = ChatRequest {
+                            message: prompt,
+                            system_instruction: format!(
+                                "You are Mint, a helpful desktop assistant. Write only the friendly suggestion in the language matching '{}'. No quotes, no markdown, no other text.",
+                                config.language
+                            ),
+                            chat_id: None,
+                            image_data_uri: None,
+                            audio_data_uri: None,
+                            document_attachment: None,
+                            workspace_path: None,
+                        };
+
+                        tauri::async_runtime::block_on(async {
+                            match send_chat(&config, &chat_req).await {
+                                Ok(response) => {
+                                    let cleaned =
+                                        response.text.trim().trim_matches('"').to_string();
+                                    if !cleaned.is_empty() {
+                                        cleaned
+                                    } else {
+                                        static_message.to_string()
+                                    }
+                                }
+                                Err(err) => {
+                                    eprintln!(
+                                        "Failed to generate dynamic suggestion via AI: {:?}",
+                                        err
+                                    );
+                                    static_message.to_string()
+                                }
+                            }
+                        })
+                    } else {
+                        static_message.to_string()
+                    };
+
                     let payload = json!({
-                        "message": workflow["action"]["message"]
-                            .as_str()
-                            .unwrap_or("Automation workflow triggered"),
+                        "message": final_message,
                         "suggestions": [
                             { "label": "Yes, please", "action": workflow["action"] },
                             { "label": "Dismiss", "action": { "type": "none" } }

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Mint",
-  "version": "1.7.1",
+  "version": "1.8.1",
   "identifier": "com.pheem49.mint",
   "build": {
     "beforeDevCommand": "npm run dev:desktop",