@pheem49/mint 1.15.0 → 1.16.0

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

@@ -2,6 +2,11 @@ use std::path::Path;
 
 use super::super::*;
 
+fn is_skill_edit(root: &Path, path: &Path) -> Result<bool, OrchestrationError> {
+    crate::skills::skill_edit_requires_approval(root, path)
+        .map_err(|error| OrchestrationError::Agent(error.to_string()))
+}
+
 /// Handles the subset of `execute_tool` actions related to files.
 /// Only called for actions `execute_tool` has already routed here, so the
 /// fallback arm is unreachable in practice.
@@ -10,7 +15,7 @@ pub(in crate::orchestration) async fn execute(
     input: &AgentInput,
     root: &Path,
     config: &MintConfig,
-    _chat_id: &str,
+    chat_id: &str,
     approve_cb: &mut (dyn FnMut(&AgentApproval) -> Result<ApprovalOutcome, String> + Send),
 ) -> Result<String, OrchestrationError> {
     match action {
@@ -21,7 +26,23 @@ pub(in crate::orchestration) async fn execute(
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))?)
         }
         "read_file" => {
-            let path = workspace_path(root, required(&input.path, "path")?)?;
+            if input.start_line.is_none()
+                && input.end_line.is_none()
+                && let Some(skill) = crate::skills::skill_for_read_path(root, &input.path)
+            {
+                let memory = MemoryStore::open_default()?;
+                return crate::skills::read_skill_file(&memory, &skill, chat_id, config)
+                    .map_err(|error| OrchestrationError::Agent(error.to_string()));
+            }
+            // Explicit line-range reads are previews, never successful full skill loads.
+            // Known global skills may live outside the workspace, but still require
+            // the same path capability checks as any other file read.
+            let known_skill = crate::skills::skill_for_read_path(root, &input.path);
+            let path = if let Some(skill) = known_skill {
+                PathBuf::from(skill.source_path)
+            } else {
+                workspace_path(root, required(&input.path, "path")?)?
+            };
             let start = input.start_line.unwrap_or(1);
             let end = input.end_line.unwrap_or_else(|| start.saturating_add(239));
             Ok(read_code_file(&path, start, end, config)
@@ -86,12 +107,22 @@ pub(in crate::orchestration) async fn execute(
                 .collect::<Vec<_>>()
                 .join("\n");
 
-            let approved = approve_cb(&AgentApproval::ApplyPatch {
-                path: patch.path.to_string_lossy().into_owned(),
-                hunks: patch.hunks.clone(),
-                diff,
-            })
-            .map_err(OrchestrationError::Agent)?;
+            let approval = if is_skill_edit(root, &proposal.edits[0].path)?
+                || is_skill_edit(root, &root.join(&patch.path))?
+            {
+                AgentApproval::SkillWrite {
+                    path: patch.path.to_string_lossy().into_owned(),
+                    content: edit.content.clone(),
+                    diff,
+                }
+            } else {
+                AgentApproval::ApplyPatch {
+                    path: patch.path.to_string_lossy().into_owned(),
+                    hunks: patch.hunks.clone(),
+                    diff,
+                }
+            };
+            let approved = approve_cb(&approval).map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -122,12 +153,22 @@ pub(in crate::orchestration) async fn execute(
                 .collect::<Vec<_>>()
                 .join("\n");
 
-            let approved = approve_cb(&AgentApproval::WriteFile {
-                path: path_str.to_owned(),
-                content: input.file_content.clone(),
-                diff,
-            })
-            .map_err(OrchestrationError::Agent)?;
+            let approval = if is_skill_edit(root, &proposal.edits[0].path)?
+                || is_skill_edit(root, &root.join(path_str))?
+            {
+                AgentApproval::SkillWrite {
+                    path: path_str.to_owned(),
+                    content: edit.content.clone(),
+                    diff,
+                }
+            } else {
+                AgentApproval::WriteFile {
+                    path: path_str.to_owned(),
+                    content: input.file_content.clone(),
+                    diff,
+                }
+            };
+            let approved = approve_cb(&approval).map_err(OrchestrationError::Agent)?;
 
             match approved {
                 ApprovalOutcome::Approved => {
@@ -145,3 +186,109 @@ pub(in crate::orchestration) async fn execute(
         ),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn skill_writes_require_separate_approval_even_when_file_edits_are_allowed() {
+        let root =
+            std::env::temp_dir().join(format!("mint-skill-approval-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&root).unwrap();
+        let config = MintConfig {
+            allowed_write_paths: vec![root.clone()],
+            allowed_read_paths: vec![root.clone()],
+            ..MintConfig::default()
+        };
+        let input = AgentInput {
+            path: ".agents/skills/example/SKILL.md".into(),
+            file_content: "---\ndescription: example\n---\nOriginal instructions".into(),
+            ..Default::default()
+        };
+        let mut requests = Vec::new();
+        let mut approve = |approval: &AgentApproval| {
+            let value = serde_json::to_value(approval).unwrap();
+            requests.push(value.clone());
+            Ok(if value.get("SkillWrite").is_some() {
+                ApprovalOutcome::Denied
+            } else {
+                ApprovalOutcome::Approved
+            })
+        };
+        execute(
+            "write_file",
+            &input,
+            &root,
+            &config,
+            "skill-test",
+            &mut approve,
+        )
+        .await
+        .unwrap();
+        assert!(
+            !root.join(&input.path).exists(),
+            "ordinary file approval must not authorize skill creation"
+        );
+        assert!(
+            requests[0]["SkillWrite"]["diff"]
+                .as_str()
+                .unwrap()
+                .contains("Original instructions")
+        );
+
+        let path = root.join(&input.path);
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        std::fs::write(&path, &input.file_content).unwrap();
+        let patch = AgentInput {
+            patch: Some(AgentPatch {
+                path: PathBuf::from(&input.path),
+                hunks: vec![CodePatchHunk {
+                    old_text: "Original instructions".into(),
+                    new_text: "Changed instructions".into(),
+                    replace_all: false,
+                }],
+            }),
+            ..Default::default()
+        };
+        execute(
+            "apply_patch",
+            &patch,
+            &root,
+            &config,
+            "skill-test",
+            &mut |approval| {
+                Ok(
+                    if serde_json::to_value(approval)
+                        .unwrap()
+                        .get("SkillWrite")
+                        .is_some()
+                    {
+                        ApprovalOutcome::Denied
+                    } else {
+                        ApprovalOutcome::Approved
+                    },
+                )
+            },
+        )
+        .await
+        .unwrap();
+        assert_eq!(std::fs::read_to_string(&path).unwrap(), input.file_content);
+        execute(
+            "apply_patch",
+            &patch,
+            &root,
+            &config,
+            "skill-test",
+            &mut |_| Ok(ApprovalOutcome::Approved),
+        )
+        .await
+        .unwrap();
+        assert!(
+            std::fs::read_to_string(&path)
+                .unwrap()
+                .contains("Changed instructions")
+        );
+        std::fs::remove_dir_all(root).unwrap();
+    }
+}

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

@@ -10,7 +10,7 @@ pub(in crate::orchestration) async fn execute(
     input: &AgentInput,
     _root: &Path,
     config: &MintConfig,
-    _chat_id: &str,
+    chat_id: &str,
     _approve_cb: &mut (dyn FnMut(&AgentApproval) -> Result<ApprovalOutcome, String> + Send),
 ) -> Result<String, OrchestrationError> {
     match action {
@@ -263,49 +263,34 @@ pub(in crate::orchestration) async fn execute(
                 num_images: Some(1),
                 ..Default::default()
             };
-            let res = crate::image_gen::generate_images(config, &req)
+            let res = crate::image_workflow::generate_and_save_images(config, &req)
                 .await
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
-            let data_uris: Vec<String> = res.images.iter().map(|i| i.data_uri.clone()).collect();
-            if let Ok(saved) = crate::pictures::save_chat_images(
-                data_uris,
-                Some(res.provider.clone()),
-                Some(prompt_text.to_string()),
-            ) {
-                if !saved.is_empty() {
-                    let saved_path = saved[0].path.display().to_string();
-                    let json_payload = serde_json::json!({
-                        "prompt": prompt_text,
-                        "model": res.model,
-                        "provider": res.provider,
-                        "images": saved.iter()
-                            .map(|s| serde_json::json!({ "url": format!("/api/pictures/{}", s.filename) }))
+            crate::library::LibraryStore::open_default()
+                .and_then(|store| {
+                    store.link_generated(
+                        &res.images
+                            .iter()
+                            .map(|image| image.id.clone())
                             .collect::<Vec<_>>(),
-                    });
-                    let json_str = serde_json::to_string_pretty(&json_payload).unwrap_or_default();
-                    let data = format!(
-                        "Image generated successfully with model `{}` ({}). Saved to: {}\n\n```image_gen_json\n{}\n```\n\nNote: Image generation succeeded. In your finish summary, you MUST include the exact ```image_gen_json ... ``` code block from above in your response so the user sees the generated image card.",
-                        res.model, res.provider, saved_path, json_str
-                    );
-                    return Ok(data);
-                }
-            }
-            if let Some(first) = res.images.first() {
-                let json_payload = serde_json::json!({
-                    "prompt": prompt_text,
-                    "model": res.model,
-                    "provider": res.provider,
-                    "images": [{ "url": first.data_uri }],
-                });
-                let json_str = serde_json::to_string_pretty(&json_payload).unwrap_or_default();
-                let data = format!(
-                    "Image generated successfully with model `{}` ({}).\n\n```image_gen_json\n{}\n```\n\nNote: Image generation succeeded. In your finish summary, you MUST include the exact ```image_gen_json ... ``` code block from above in your response so the user sees the generated image card.",
-                    res.model, res.provider, json_str
-                );
-                Ok(data)
-            } else {
-                Ok("No image returned from provider".to_string())
-            }
+                        chat_id,
+                    )
+                })
+                .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+            let saved_path = res.images[0].path.display().to_string();
+            let json_payload = serde_json::json!({
+                "prompt": res.prompt,
+                "model": res.model,
+                "provider": res.provider,
+                "images": res.images.iter()
+                    .map(|s| serde_json::json!({ "url": format!("/api/pictures/{}", s.filename) }))
+                    .collect::<Vec<_>>(),
+            });
+            let json_str = serde_json::to_string_pretty(&json_payload).unwrap_or_default();
+            Ok(format!(
+                "Image generated successfully with model `{}` ({}). Saved to: {}\n\n```image_gen_json\n{}\n```\n\nNote: Image generation succeeded. In your finish summary, you MUST include the exact ```image_gen_json ... ``` code block from above in your response so the user sees the generated image card.",
+                res.model, res.provider, saved_path, json_str
+            ))
         }
         "generate_video" | "veo.generate" | "video_generate" => {
             let prompt_text = if !input.prompt.trim().is_empty() {
@@ -334,6 +319,17 @@ pub(in crate::orchestration) async fn execute(
             let res = crate::video_gen::generate_video(config, &req)
                 .await
                 .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
+            crate::library::LibraryStore::open_default()
+                .and_then(|store| {
+                    store.link_generated(
+                        &res.videos
+                            .iter()
+                            .map(|video| video.id.clone())
+                            .collect::<Vec<_>>(),
+                        chat_id,
+                    )
+                })
+                .map_err(|e| OrchestrationError::Agent(e.to_string()))?;
             if let Some(first) = res.videos.first() {
                 let vid_md = format!(
                     "<video controls src=\"{}\" width=\"100%\" style=\"max-height:400px; border-radius:8px;\"></video>\n\n✓ Video generated successfully with Veo `{}` ({})",

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

@@ -102,9 +102,10 @@ pub(in crate::orchestration) async fn execute(
                             || skill.name.to_ascii_lowercase().contains(&query_lower)
                         {
                             results.push(format!(
-                                "[Skill: {}]\n{}",
+                                "[Skill: {}]\nDescription: {}\nPath: {}\nRead through read_file before using this skill.",
                                 skill.name,
-                                truncate_for_context(&skill.content, 300)
+                                skill.description.as_deref().unwrap_or("No description provided"),
+                                skill.source_path
                             ));
                         }
                     }

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

@@ -10,3 +10,5 @@ pub(super) mod plugins_mcp;
 pub(super) mod project;
 pub(super) mod shell;
 pub(super) mod web;
+
+pub(super) mod mods;

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

@@ -0,0 +1,161 @@
+use super::super::*;
+
+pub(in crate::orchestration) async fn execute(
+    action: &str,
+    input: &AgentInput,
+    root: &Path,
+    config: &MintConfig,
+    chat: &str,
+    approve: &mut (dyn FnMut(&AgentApproval) -> Result<ApprovalOutcome, String> + Send),
+) -> Result<String, OrchestrationError> {
+    let result: Result<String, String> = (|| {
+        if action == "mod_help" {
+            return Ok(include_str!("../../../../../docs/mods/AUTHORING.md").into());
+        }
+        if action == "mod_list" {
+            return Ok(serde_json::json!({"mods":crate::mods::list(root,chat)?}).to_string());
+        }
+        let source: crate::mods::Source =
+            serde_json::from_value(input.arguments.clone()).map_err(|e| e.to_string())?;
+        let draft = crate::mods::save_draft(root, &source)?;
+        let preview = crate::mods::validate(root, &source)
+            .map_err(|error| format!("{error}\nDraft saved at {}", draft.display()))?;
+        if action == "mod_validate" {
+            return Ok(serde_json::json!({"valid":true,"preview":preview}).to_string());
+        }
+        crate::assert_path_capability(
+            &crate::mods::source_path(root, &source.manifest.id)?,
+            crate::Capability::Write,
+            config,
+        )
+        .map_err(|e| e.to_string())?;
+        let expected = input.arguments["expectedHash"].as_str();
+        let hash = crate::mods::publish(root, &source, expected)?;
+        let granted = if source.manifest.permissions.is_empty() {
+            false
+        } else {
+            let approval = AgentApproval::UserApproval {
+                title: format!("Enable {}", source.manifest.name),
+                prompt: format!(
+                    "Mod: {}\nRevision: {hash}\nPermissions: {}\n\n```typescript\n{}\n```",
+                    source.manifest.id,
+                    source.manifest.permissions.join(", "),
+                    source.source
+                ),
+            };
+            matches!(approve(&approval)?, ApprovalOutcome::Approved)
+        };
+        if source.manifest.permissions.is_empty() || granted {
+            crate::mods::enable_reviewed(
+                root,
+                chat,
+                &source.manifest.id,
+                "chat",
+                granted,
+                Some(&hash),
+            )?;
+        }
+        Ok(serde_json::json!({"path":crate::mods::source_path(root, &source.manifest.id)?,"hash":hash,"validated":true,"enabled":source.manifest.permissions.is_empty()||granted}).to_string())
+    })();
+    result.map_err(OrchestrationError::Agent)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[tokio::test]
+    async fn mod_requests_respect_plan_mode_disabled_tools_and_deliver_results() {
+        let root = std::env::temp_dir().join(format!("mint-mod-policy-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&root).unwrap();
+        let chat = uuid::Uuid::new_v4().to_string();
+        let config = MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            allowed_write_paths: vec![root.clone()],
+            disabled_tools: vec!["read_file".into()],
+            ..Default::default()
+        };
+        let source: crate::mods::Source = serde_json::from_value(serde_json::json!({"manifest":{"id":"policy-test","name":"Policy test","version":"1","sdkVersion":1,"entry":"main.ts","permissions":["tools.request"]},"source":"export function register(mint){mint.on('session_start',()=>{mint.tools.request('write_file',{path:'should-not-exist',content:'bad'});mint.tools.request('read_file',{path:'README.md'});});mint.on('tool_result',r=>{if(!r.error)throw Error('Expected policy rejection');mint.state.set('results',(mint.state.get('results')||0)+1);});}"})).unwrap();
+        crate::mods::publish(&root, &source, None).unwrap();
+        crate::mods::enable(&root, &chat, "policy-test", "chat", true).unwrap();
+        crate::mods::set_turn_policy(&root, &chat, true, None);
+        execute_mod_requests(
+            &root,
+            &chat,
+            &config,
+            false,
+            &mut |_| panic!("Policy rejection must precede approvals"),
+            &mut |_| {},
+            None,
+        )
+        .await
+        .unwrap();
+        assert!(!root.join("should-not-exist").exists());
+        let mods = crate::mods::list(&root, &chat).unwrap();
+        assert_eq!(mods[0]["snapshot"]["state"]["results"], 2);
+        assert!(
+            crate::mods::pending_requests(&root, &chat)
+                .unwrap()
+                .is_empty()
+        );
+        crate::mods::close_chat(&root, &chat);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+    #[tokio::test]
+    async fn authoring_tools_preserve_failed_drafts_and_publish_a_live_mod() {
+        let root =
+            std::env::temp_dir().join(format!("mint-mod-authoring-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&root).unwrap();
+        let chat = uuid::Uuid::new_v4().to_string();
+        let config = MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            allowed_write_paths: vec![root.clone()],
+            ..Default::default()
+        };
+        let manifest = serde_json::json!({"id":"prompt-test","name":"Prompt test","version":"1","sdkVersion":1,"entry":"main.ts","permissions":[]});
+        let invalid: crate::mods::Source = serde_json::from_value(
+            serde_json::json!({"manifest":manifest,"source":"export ???","readme":"Draft"}),
+        )
+        .unwrap();
+        let saved = crate::mods::save_draft(&root, &invalid).unwrap();
+        let mut input = AgentInput::default();
+        input.arguments = serde_json::to_value(&invalid).unwrap();
+        let mut approve = |_: &AgentApproval| panic!("Basic mod requires no permission prompt");
+        assert!(
+            execute("mod_validate", &input, &root, &config, &chat, &mut approve)
+                .await
+                .is_err()
+        );
+        assert!(saved.is_file());
+        assert!(!root.join(".mint-mods/prompt-test").exists());
+        input.arguments["source"] = serde_json::json!(
+            "export async function register(mint){await Promise.resolve();mint.ui.set('above_composer',{type:'text',text:'Created from prompt'});}"
+        );
+        let validation = execute("mod_validate", &input, &root, &config, &chat, &mut approve)
+            .await
+            .unwrap();
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(&validation).unwrap()["valid"],
+            true
+        );
+        let result = execute("mod_publish", &input, &root, &config, &chat, &mut approve)
+            .await
+            .unwrap();
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(&result).unwrap()["enabled"],
+            true
+        );
+        let published: serde_json::Value = serde_json::from_str(&result).unwrap();
+        assert_eq!(
+            published["path"],
+            serde_json::json!(root.join(".mint-mods/prompt-test"))
+        );
+        assert!(root.join(".mint-mods/prompt-test/main.ts").is_file());
+        let mods = crate::mods::list(&root, &chat).unwrap();
+        assert_eq!(
+            mods[0]["snapshot"]["ui"]["above_composer"]["text"],
+            "Created from prompt"
+        );
+        crate::mods::close_chat(&root, &chat);
+        std::fs::remove_dir_all(root).unwrap();
+    }
+}