@pheem49/mint 1.8.2 → 1.10.0

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

@@ -2,6 +2,7 @@ use std::{
     fs,
     io::Cursor,
     path::{Path, PathBuf},
+    process::Command,
     time::{SystemTime, UNIX_EPOCH},
 };
 
@@ -79,11 +80,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);
@@ -132,6 +132,11 @@ pub fn parse_data_uri(raw: &str) -> Option<(String, &'static str, Vec<u8>)> {
         "image/jpeg" | "image/jpg" => "jpg",
         "image/webp" => "webp",
         "image/gif" => "gif",
+        "video/mp4" => "mp4",
+        "video/webm" => "webm",
+        "video/quicktime" => "mov",
+        "video/x-msvideo" => "avi",
+        "video/x-matroska" => "mkv",
         _ => return None,
     };
     Some((mime_type, extension, STANDARD.decode(encoded).ok()?))
@@ -167,7 +172,13 @@ fn save_chat_images_to_directory(
         let id = filename
             .trim_end_matches(&format!(".{extension}"))
             .to_owned();
-        let thumbnail_path = create_thumbnail_from_bytes(directory, &id, &bytes);
+        let thumbnail_path = if mime_type.starts_with("image/") {
+            create_thumbnail_from_bytes(directory, &id, &bytes)
+        } else if mime_type.starts_with("video/") {
+            extract_video_thumbnail_from_bytes(directory, &id, &bytes)
+        } else {
+            None
+        };
         let entry = PictureEntry {
             id,
             filename,
@@ -222,6 +233,57 @@ fn create_thumbnail_from_bytes(directory: &Path, id: &str, bytes: &[u8]) -> Opti
     Some(path)
 }
 
+fn extract_video_thumbnail_from_bytes(directory: &Path, id: &str, bytes: &[u8]) -> Option<PathBuf> {
+    // Write video to temporary file
+    let temp_video = std::env::temp_dir().join(format!("mint-video-{}.tmp", id));
+    if fs::write(&temp_video, bytes).is_err() {
+        return None;
+    }
+
+    let temp_frame = std::env::temp_dir().join(format!("mint-frame-{}.png", id));
+
+    let res = (|| -> Option<PathBuf> {
+        let temp_video_str = temp_video.to_str()?;
+        let temp_frame_str = temp_frame.to_str()?;
+
+        let output = Command::new("ffmpeg")
+            .args(&["-i", temp_video_str])
+            .args(&["-vf", "select=eq(n\\,0)"])
+            .args(&["-vframes", "1"])
+            .args(&["-y", temp_frame_str])
+            .stderr(std::process::Stdio::null())
+            .stdout(std::process::Stdio::null())
+            .output()
+            .ok()?;
+
+        if !output.status.success() {
+            return None;
+        }
+
+        // Load extracted frame and create thumbnail
+        let frame_bytes = fs::read(&temp_frame).ok()?;
+        let image = image::load_from_memory(&frame_bytes).ok()?;
+        let thumbnail = image.thumbnail(THUMBNAIL_MAX_SIZE, THUMBNAIL_MAX_SIZE);
+
+        let thumbnail_directory = thumbnails_directory(directory);
+        ensure_directory(&thumbnail_directory).ok()?;
+        let path = thumbnail_directory.join(format!("{id}.thumb.png"));
+
+        let mut encoded = Cursor::new(Vec::new());
+        thumbnail
+            .write_to(&mut encoded, image::ImageFormat::Png)
+            .ok()?;
+        fs::write(&path, encoded.into_inner()).ok()?;
+        Some(path)
+    })();
+
+    // Always clean up temp files to avoid leaking in /tmp
+    let _ = fs::remove_file(&temp_video);
+    let _ = fs::remove_file(&temp_frame);
+
+    res
+}
+
 fn read_index(directory: &Path) -> Result<Vec<PictureEntry>, PictureError> {
     let path = directory.join("pictures.json");
     if !path.exists() {

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

@@ -53,10 +53,38 @@ 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(workspace_root: Option<&Path>) -> Result<String, SkillError> {
+pub fn load_agent_rules_file(file_path: &Path, list: &mut Vec<LearnedSkill>) {
+    if file_path.is_file() {
+        if let Ok(content) = fs::read_to_string(file_path) {
+            let name = file_path
+                .file_name()
+                .and_then(|n| n.to_str())
+                .unwrap_or("AGENTS.md")
+                .to_string();
+            let description = parse_skill_description(&content)
+                .or_else(|| Some("Workspace instructions and rules".to_string()));
+            list.push(LearnedSkill {
+                id: 0,
+                name,
+                source_path: file_path.to_string_lossy().to_string(),
+                content,
+                created_at: String::new(),
+                description,
+            });
+        }
+    }
+}
+
+pub fn learned_skills_context(
+    workspace_root: Option<&Path>,
+    chat_id: Option<&str>,
+) -> Result<String, SkillError> {
     let mut skills = MemoryStore::open_default()?.learned_skills(20)?;
 
     if let Some(home) = dirs::home_dir() {
+        let global_agents_path = home.join(".gemini").join("config").join("AGENTS.md");
+        load_agent_rules_file(&global_agents_path, &mut skills);
+
         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);
@@ -65,6 +93,12 @@ pub fn learned_skills_context(workspace_root: Option<&Path>) -> Result<String, S
     }
 
     if let Some(root) = workspace_root {
+        let workspace_agents_path1 = root.join(".agents").join("AGENTS.md");
+        load_agent_rules_file(&workspace_agents_path1, &mut skills);
+
+        let workspace_agents_path2 = root.join("AGENTS.md");
+        load_agent_rules_file(&workspace_agents_path2, &mut skills);
+
         let workspace_skills_path1 = root.join(".agents").join("skills");
         load_skills_from_dir(&workspace_skills_path1, &mut skills);
 
@@ -77,11 +111,53 @@ pub fn learned_skills_context(workspace_root: Option<&Path>) -> Result<String, S
         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");
+    let mut has_history = false;
+    if let Some(cid) = chat_id {
+        if let Ok(memory) = MemoryStore::open_default() {
+            if let Ok(interactions) = memory.recent_interactions_for_chat(cid, 1) {
+                has_history = !interactions.is_empty();
+            }
+        }
+    }
+
+    let mut formatted_skills = Vec::new();
+    for skill in unique_skills.into_values() {
+        let mut is_workspace_skill = false;
+        let mut rel_path = String::new();
+        if let Some(root) = workspace_root {
+            let skill_path = Path::new(&skill.source_path);
+            if let Ok(canonical_skill) = skill_path.canonicalize() {
+                if let Ok(canonical_root) = root.canonicalize() {
+                    if canonical_skill.starts_with(&canonical_root) {
+                        if let Ok(relative) = canonical_skill.strip_prefix(&canonical_root) {
+                            is_workspace_skill = true;
+                            rel_path = relative.to_string_lossy().to_string();
+                        }
+                    }
+                }
+            }
+        }
+
+        if is_workspace_skill {
+            let desc = skill
+                .description
+                .as_deref()
+                .unwrap_or("No description provided");
+            let status_msg = if has_history {
+                "READ. You have already read this skill in a previous turn of this conversation. Do NOT call `read_file` to read it again unless you need to re-verify its contents."
+            } else {
+                "UNREAD. You MUST execute the `read_file` tool with the path above to read this skill before starting the task."
+            };
+            formatted_skills.push(format!(
+                "Skill: {}\nDescription: {}\nPath: {}\nStatus: {}",
+                skill.name, desc, rel_path, status_msg
+            ));
+        } else {
+            formatted_skills.push(format!("Skill: {}\n{}", skill.name, skill.content));
+        }
+    }
+
+    let value = formatted_skills.join("\n\n");
     if value.len() <= MAX_CONTEXT_BYTES {
         return Ok(value);
     }
@@ -92,6 +168,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 +210,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/crates/mint-core/src/video_gen.rs

@@ -0,0 +1,235 @@
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+use thiserror::Error;
+
+use crate::{MintConfig, PictureEntry};
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VideoGenRequest {
+    pub prompt: String,
+    pub negative_prompt: Option<String>,
+    pub aspect_ratio: String,
+    pub duration: u32,
+    pub model: Option<String>,
+    pub provider: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VideoGenResponse {
+    pub videos: Vec<PictureEntry>,
+    pub model: String,
+    pub provider: String,
+    pub prompt: String,
+}
+
+#[derive(Debug, Error)]
+pub enum VideoGenError {
+    #[error("missing Gemini API key — set GEMINI_API_KEY or configure api_key in config")]
+    MissingApiKey,
+    #[error("API request failed: {0}")]
+    Request(#[from] reqwest::Error),
+    #[error("unexpected response structure: {0}")]
+    UnexpectedResponse(String),
+    #[error("video generation timed out")]
+    Timeout,
+    #[error("failed to save generated video: {0}")]
+    SaveError(String),
+    #[error(
+        "Google Veo model endpoint returned 404 Not Found. Google Veo video generation requires an API Key or Google Cloud project with Veo Model access enabled: {0}"
+    )]
+    ModelNotFound(String),
+}
+
+pub async fn generate_video(
+    config: &MintConfig,
+    request: &VideoGenRequest,
+) -> Result<VideoGenResponse, VideoGenError> {
+    let api_key = if config.api_key.trim().is_empty() {
+        std::env::var("GEMINI_API_KEY").unwrap_or_default()
+    } else {
+        config.api_key.clone()
+    };
+    if api_key.trim().is_empty() {
+        return Err(VideoGenError::MissingApiKey);
+    }
+
+    let mut model_owned = request
+        .model
+        .as_deref()
+        .map(str::trim)
+        .filter(|m| !m.is_empty())
+        .map(str::to_owned)
+        .unwrap_or_else(|| {
+            config
+                .extra
+                .get("veoModel")
+                .and_then(|v| v.as_str())
+                .unwrap_or("veo-2.0-generate-001")
+                .to_string()
+        });
+
+    if model_owned == "veo-2.0-flash-exp" {
+        model_owned = "veo-2.0-generate-001".to_string();
+    }
+
+    let client = crate::HTTP_CLIENT.clone();
+    let mut url = format!(
+        "https://generativelanguage.googleapis.com/v1beta/models/{model_owned}:predictLongRunning"
+    );
+
+    let payload = json!({
+        "instances": [
+            {
+                "prompt": request.prompt
+            }
+        ],
+        "parameters": {
+            "aspectRatio": request.aspect_ratio,
+            "durationSeconds": request.duration,
+            "sampleCount": 1
+        }
+    });
+
+    let mut response_res = client
+        .post(&url)
+        .header("x-goog-api-key", &api_key)
+        .json(&payload)
+        .send()
+        .await?;
+
+    if response_res.status() == reqwest::StatusCode::NOT_FOUND && model_owned != "veo-2.0-flash-001"
+    {
+        model_owned = "veo-2.0-flash-001".to_string();
+        url = format!(
+            "https://generativelanguage.googleapis.com/v1beta/models/{model_owned}:predictLongRunning"
+        );
+        response_res = client
+            .post(&url)
+            .header("x-goog-api-key", &api_key)
+            .json(&payload)
+            .send()
+            .await?;
+    }
+
+    if !response_res.status().is_success() {
+        let status = response_res.status();
+        let err_text = response_res.text().await.unwrap_or_default();
+        if status == reqwest::StatusCode::NOT_FOUND {
+            return Err(VideoGenError::ModelNotFound(format!(
+                "404 for model {model_owned} on generativelanguage.googleapis.com API. ({err_text})"
+            )));
+        }
+        return Err(VideoGenError::UnexpectedResponse(format!(
+            "HTTP {status}: {err_text}"
+        )));
+    }
+
+    let res: Value = response_res.json().await?;
+
+    let operation_name = res
+        .get("name")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| VideoGenError::UnexpectedResponse("Missing operation name".to_string()))?;
+
+    let poll_url = format!("https://generativelanguage.googleapis.com/v1beta/{operation_name}");
+    let mut done = false;
+    let mut final_response = None;
+
+    // Poll every 5 seconds, up to 60 times (5 minutes max)
+    for _ in 0..60 {
+        tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
+        let poll_res: Value = client
+            .get(&poll_url)
+            .header("x-goog-api-key", &api_key)
+            .send()
+            .await?
+            .error_for_status()?
+            .json()
+            .await?;
+
+        if let Some(d) = poll_res.get("done").and_then(|v| v.as_bool()) {
+            if d {
+                done = true;
+                final_response = Some(poll_res);
+                break;
+            }
+        }
+    }
+
+    if !done {
+        return Err(VideoGenError::Timeout);
+    }
+
+    let op_res = final_response.ok_or(VideoGenError::Timeout)?;
+
+    // Check if error occurred in operation
+    if let Some(err) = op_res.get("error") {
+        let msg = err["message"].as_str().unwrap_or("unknown operation error");
+        return Err(VideoGenError::UnexpectedResponse(msg.to_string()));
+    }
+
+    let response_obj = op_res
+        .get("response")
+        .ok_or_else(|| VideoGenError::UnexpectedResponse("Missing response object".to_string()))?;
+
+    // Try to find generated samples or outputs
+    let generated_samples = response_obj
+        .get("generateVideoResponse")
+        .and_then(|gvr| gvr.get("generatedSamples"))
+        .or_else(|| {
+            response_obj
+                .get("outputs")
+                .and_then(|o| o.as_array()?.first()?.get("generatedVideos"))
+        })
+        .ok_or_else(|| {
+            VideoGenError::UnexpectedResponse(
+                "No generated samples or videos in response".to_string(),
+            )
+        })?;
+
+    let sample = generated_samples
+        .as_array()
+        .and_then(|arr| arr.first())
+        .ok_or_else(|| {
+            VideoGenError::UnexpectedResponse("Generated samples array is empty".to_string())
+        })?;
+
+    let video_uri = sample
+        .get("video")
+        .and_then(|v| v.get("uri"))
+        .and_then(|u| u.as_str())
+        .ok_or_else(|| VideoGenError::UnexpectedResponse("Missing video URI".to_string()))?;
+
+    // Download the video file bytes
+    let video_bytes = client
+        .get(video_uri)
+        .header("x-goog-api-key", &api_key)
+        .send()
+        .await?
+        .error_for_status()?
+        .bytes()
+        .await?
+        .to_vec();
+
+    // Convert to data URI for saving
+    let data_b64 = STANDARD.encode(&video_bytes);
+    let data_uri = format!("data:video/mp4;base64,{data_b64}");
+
+    // Save to the pictures directory and record index entry
+    let saved = crate::pictures::save_chat_images(
+        vec![data_uri],
+        Some("veo".to_string()),
+        Some(request.prompt.clone()),
+    )
+    .map_err(|e| VideoGenError::SaveError(e.to_string()))?;
+
+    Ok(VideoGenResponse {
+        videos: saved,
+        model: model_owned,
+        provider: "veo".to_string(),
+        prompt: request.prompt.clone(),
+    })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pheem49/mint",
-  "version": "1.8.2",
+  "version": "1.10.0",
   "description": "A native Tauri desktop AI assistant with a Rust backend and React UI.",
   "scripts": {
     "dev:web": "vite --config vite.config.web.ts",
@@ -56,6 +56,7 @@
     "mint": "src/bin/index.js"
   },
   "dependencies": {
+    "@pouyanafisi/gmail-mcp": "^2.0.0",
     "@tauri-apps/api": "^2.0.0",
     "@vitejs/plugin-react": "^6.0.1",
     "@xyflow/react": "^12.11.1",
@@ -71,6 +72,11 @@
     "@tauri-apps/cli": "^2.0.0"
   },
   "overrides": {
-    "gh-pages": "^5.0.0"
+    "gh-pages": "^5.0.0",
+    "@modelcontextprotocol/sdk": "^1.24.0",
+    "nodemailer": "^9.0.0",
+    "uuid": "^11.1.1",
+    "brace-expansion": "^5.0.8",
+    "@hono/node-server": "^2.0.5"
   }
 }

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"
         }
     ]
 }