@pheem49/mint 1.14.0 → 1.16.0

package/crates/mint-core/src/cron/scheduler.rs

@@ -155,7 +155,8 @@ fn approval_subject(approval: &AgentApproval) -> Option<(&'static str, String)>
             tool,
             arguments,
         } => Some(("mcp_tool", format!("{server}:{tool}:{arguments}"))),
-        AgentApproval::UserApproval { .. }
+        AgentApproval::SkillWrite { .. }
+        | AgentApproval::UserApproval { .. }
         | AgentApproval::ExitPlanMode { .. }
         | AgentApproval::EnterPlanMode { .. }
         | AgentApproval::AskUser { .. } => None,
@@ -172,7 +173,10 @@ fn cron_approve_callback(
     root: PathBuf,
 ) -> impl FnMut(&AgentApproval) -> Result<ApprovalOutcome, String> {
     move |approval: &AgentApproval| -> Result<ApprovalOutcome, String> {
-        if matches!(approval, AgentApproval::AskUser { .. }) {
+        if matches!(
+            approval,
+            AgentApproval::AskUser { .. } | AgentApproval::SkillWrite { .. }
+        ) {
             return Ok(ApprovalOutcome::Denied);
         }
         match approval_subject(approval) {
@@ -184,3 +188,31 @@ fn cron_approve_callback(
         }
     }
 }
+
+#[cfg(test)]
+mod skill_approval_tests {
+    use super::*;
+
+    #[test]
+    fn unattended_jobs_decline_skill_changes() {
+        let mut approve = cron_approve_callback(MintConfig::default(), PathBuf::from("/workspace"));
+        assert_eq!(
+            approve(&AgentApproval::SkillWrite {
+                path: ".agents/skills/example/SKILL.md".into(),
+                content: "instructions".into(),
+                diff: "+instructions".into()
+            })
+            .unwrap(),
+            ApprovalOutcome::Denied
+        );
+        assert_eq!(
+            approve(&AgentApproval::WriteFile {
+                path: "app.rs".into(),
+                content: "source".into(),
+                diff: "+source".into()
+            })
+            .unwrap(),
+            ApprovalOutcome::Approved
+        );
+    }
+}

package/crates/mint-core/src/git/branches.rs

@@ -0,0 +1,348 @@
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+use std::process::Command;
+
+/// The branch state visible to every Mint surface for one workspace.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct BranchInfo {
+    pub is_repository: bool,
+    pub current_branch: Option<String>,
+    pub detached_head: Option<String>,
+    pub branches: Vec<String>,
+    pub remote_branches: Vec<String>,
+    pub is_dirty: bool,
+}
+
+/// A requested workspace branch transition, independent of any UI.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum BranchChange {
+    Switch { branch: String },
+    Create { branch: String },
+    Track { remote_branch: String },
+}
+
+/// The Git workspace-change module either performs a transition or asks its
+/// caller to obtain an explicit confirmation for a dirty workspace.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(tag = "status", rename_all = "snake_case")]
+pub enum BranchChangeOutcome {
+    Changed { info: BranchInfo },
+    ConfirmationRequired { info: BranchInfo },
+}
+
+pub fn change_branch(
+    root: &Path,
+    change: &BranchChange,
+    confirmed_dirty_workspace: bool,
+) -> Result<BranchChangeOutcome, String> {
+    let before = read_branch_info(root)?;
+    if !before.is_repository {
+        return Err("The selected workspace is not a Git repository.".to_string());
+    }
+    if before.is_dirty && !confirmed_dirty_workspace {
+        return Ok(BranchChangeOutcome::ConfirmationRequired { info: before });
+    }
+
+    let info = match change {
+        BranchChange::Switch { branch } => switch_branch(root, branch, true)?,
+        BranchChange::Create { branch } => create_branch(root, branch, true)?,
+        BranchChange::Track { remote_branch } => checkout_remote_branch(root, remote_branch, true)?,
+    };
+    Ok(BranchChangeOutcome::Changed { info })
+}
+
+pub fn read_branch_info(root: &Path) -> Result<BranchInfo, String> {
+    let repository_check = git(root, ["rev-parse", "--is-inside-work-tree"])?;
+    if !repository_check.status.success()
+        || String::from_utf8_lossy(&repository_check.stdout).trim() != "true"
+    {
+        return Ok(BranchInfo {
+            is_repository: false,
+            current_branch: None,
+            detached_head: None,
+            branches: Vec::new(),
+            remote_branches: Vec::new(),
+            is_dirty: false,
+        });
+    }
+
+    let mut branches = read_ref_names(root, "refs/heads", "local branches")?;
+    let remote_branches = read_ref_names(root, "refs/remotes", "remote branches")?
+        .into_iter()
+        .filter(|branch| !branch.ends_with("/HEAD"))
+        .collect();
+
+    let current_output = git(root, ["symbolic-ref", "--quiet", "--short", "HEAD"])?;
+    let current_branch = current_output
+        .status
+        .success()
+        .then(|| {
+            String::from_utf8_lossy(&current_output.stdout)
+                .trim()
+                .to_string()
+        })
+        .filter(|branch| !branch.is_empty());
+    if let Some(current) = current_branch.as_ref()
+        && !branches.iter().any(|branch| branch == current)
+    {
+        branches.insert(0, current.clone());
+    }
+
+    let detached_head = if current_branch.is_none() {
+        let output = git(root, ["rev-parse", "--short", "HEAD"])?;
+        output
+            .status
+            .success()
+            .then(|| String::from_utf8_lossy(&output.stdout).trim().to_string())
+            .filter(|head| !head.is_empty())
+    } else {
+        None
+    };
+
+    let status_output = git(root, ["status", "--porcelain", "--untracked-files=normal"])?;
+    ensure_success(&status_output, "read git status")?;
+
+    Ok(BranchInfo {
+        is_repository: true,
+        current_branch,
+        detached_head,
+        branches,
+        remote_branches,
+        is_dirty: !status_output.stdout.is_empty(),
+    })
+}
+
+pub fn switch_branch(root: &Path, branch: &str, allow_dirty: bool) -> Result<BranchInfo, String> {
+    let before = read_branch_info(root)?;
+    ensure_change_allowed(&before, allow_dirty)?;
+    if !before.branches.iter().any(|candidate| candidate == branch) {
+        return Err(format!("Local branch not found: {branch}"));
+    }
+    if before.current_branch.as_deref() == Some(branch) {
+        return Ok(before);
+    }
+    run_switch(root, ["switch", "--", branch])?;
+    read_branch_info(root)
+}
+
+pub fn create_branch(root: &Path, branch: &str, allow_dirty: bool) -> Result<BranchInfo, String> {
+    let branch = branch.trim();
+    if branch.is_empty() {
+        return Err("Enter a branch name.".to_string());
+    }
+    let before = read_branch_info(root)?;
+    ensure_change_allowed(&before, allow_dirty)?;
+    validate_new_branch_name(root, branch)?;
+    if before.branches.iter().any(|candidate| candidate == branch) {
+        return Err(format!("Local branch already exists: {branch}"));
+    }
+    run_switch(root, ["switch", "-c", branch])?;
+    read_branch_info(root)
+}
+
+pub fn checkout_remote_branch(
+    root: &Path,
+    remote_branch: &str,
+    allow_dirty: bool,
+) -> Result<BranchInfo, String> {
+    let before = read_branch_info(root)?;
+    ensure_change_allowed(&before, allow_dirty)?;
+    if !before
+        .remote_branches
+        .iter()
+        .any(|candidate| candidate == remote_branch)
+    {
+        return Err(format!("Remote branch not found: {remote_branch}"));
+    }
+    run_switch(root, ["switch", "--track", remote_branch])?;
+    read_branch_info(root)
+}
+
+pub fn read_graph(root: &Path, limit: usize) -> Result<Vec<String>, String> {
+    let info = read_branch_info(root)?;
+    if !info.is_repository {
+        return Err("The selected workspace is not a Git repository.".to_string());
+    }
+    let limit = limit.clamp(1, 500).to_string();
+    let output = git(
+        root,
+        [
+            "log",
+            "--graph",
+            "--all",
+            "--decorate=short",
+            "--date=short",
+            "--pretty=format:%h%x09%ad%x09%an%x09%d%x09%s",
+            "-n",
+            &limit,
+        ],
+    )?;
+    if output.status.success() {
+        return Ok(String::from_utf8_lossy(&output.stdout)
+            .lines()
+            .map(str::to_string)
+            .collect());
+    }
+
+    let detail = String::from_utf8_lossy(&output.stderr).trim().to_string();
+    if detail.contains("does not have any commits yet") {
+        Ok(Vec::new())
+    } else if detail.is_empty() {
+        Err("Git history is unavailable.".to_string())
+    } else {
+        Err(detail)
+    }
+}
+
+fn read_ref_names(root: &Path, reference: &str, label: &str) -> Result<Vec<String>, String> {
+    let output = git(
+        root,
+        ["for-each-ref", "--format=%(refname:short)", reference],
+    )?;
+    ensure_success(&output, &format!("list {label}"))?;
+    let mut names = String::from_utf8_lossy(&output.stdout)
+        .lines()
+        .map(str::trim)
+        .filter(|branch| !branch.is_empty())
+        .map(str::to_string)
+        .collect::<Vec<_>>();
+    names.sort_by_key(|branch| branch.to_lowercase());
+    Ok(names)
+}
+
+fn ensure_change_allowed(info: &BranchInfo, allow_dirty: bool) -> Result<(), String> {
+    if !info.is_repository {
+        return Err("The selected workspace is not a Git repository.".to_string());
+    }
+    if info.is_dirty && !allow_dirty {
+        return Err(
+            "The workspace has uncommitted changes. Confirm before changing branches.".to_string(),
+        );
+    }
+    Ok(())
+}
+
+fn validate_new_branch_name(root: &Path, branch: &str) -> Result<(), String> {
+    let output = git(root, ["check-ref-format", "--branch", branch])?;
+    if output.status.success() {
+        Ok(())
+    } else {
+        Err(format!("Invalid branch name: {branch}"))
+    }
+}
+
+fn run_switch<const N: usize>(root: &Path, args: [&str; N]) -> Result<(), String> {
+    let output = git(root, args)?;
+    if output.status.success() {
+        Ok(())
+    } else {
+        let detail = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        Err(if detail.is_empty() {
+            "Git could not change branches.".to_string()
+        } else {
+            detail
+        })
+    }
+}
+
+fn ensure_success(output: &std::process::Output, action: &str) -> Result<(), String> {
+    if output.status.success() {
+        Ok(())
+    } else {
+        let detail = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        Err(if detail.is_empty() {
+            format!("Git could not {action}.")
+        } else {
+            detail
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::{
+        fs,
+        time::{SystemTime, UNIX_EPOCH},
+    };
+
+    fn repository() -> std::path::PathBuf {
+        let suffix = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_nanos();
+        let root = std::env::temp_dir().join(format!(
+            "mint-git-interface-{}-{suffix}",
+            std::process::id()
+        ));
+        fs::create_dir_all(&root).unwrap();
+        for args in [
+            vec!["init"],
+            vec!["config", "user.email", "mint@example.test"],
+            vec!["config", "user.name", "Mint Test"],
+        ] {
+            assert!(
+                Command::new("git")
+                    .args(args)
+                    .current_dir(&root)
+                    .status()
+                    .unwrap()
+                    .success()
+            );
+        }
+        fs::write(root.join("README.md"), "initial\n").unwrap();
+        assert!(
+            Command::new("git")
+                .args(["add", "."])
+                .current_dir(&root)
+                .status()
+                .unwrap()
+                .success()
+        );
+        assert!(
+            Command::new("git")
+                .args(["commit", "-m", "initial"])
+                .current_dir(&root)
+                .status()
+                .unwrap()
+                .success()
+        );
+        root
+    }
+
+    #[test]
+    fn interface_git_change_returns_confirmation_then_changed() {
+        let root = repository();
+        assert!(
+            Command::new("git")
+                .args(["branch", "next"])
+                .current_dir(&root)
+                .status()
+                .unwrap()
+                .success()
+        );
+        fs::write(root.join("README.md"), "dirty\n").unwrap();
+        let change = BranchChange::Switch {
+            branch: "next".into(),
+        };
+
+        assert!(matches!(
+            change_branch(&root, &change, false).unwrap(),
+            BranchChangeOutcome::ConfirmationRequired { .. }
+        ));
+        assert!(
+            matches!(change_branch(&root, &change, true).unwrap(), BranchChangeOutcome::Changed { info } if info.current_branch.as_deref() == Some("next"))
+        );
+        fs::remove_dir_all(root).unwrap();
+    }
+}
+
+fn git<const N: usize>(root: &Path, args: [&str; N]) -> Result<std::process::Output, String> {
+    Command::new("git")
+        .args(args)
+        .current_dir(root)
+        .output()
+        .map_err(|error| format!("failed to run git: {error}"))
+}

package/crates/mint-core/src/git/checkpoint.rs

@@ -54,6 +54,46 @@ pub fn get_head_hash(root: &Path) -> Result<String, String> {
     }
 }
 
+pub fn get_current_branch(root: &Path) -> Option<String> {
+    let output = Command::new("git")
+        .args(["rev-parse", "--abbrev-ref", "HEAD"])
+        .current_dir(root)
+        .output()
+        .ok()?;
+    if output.status.success() {
+        let branch = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        if !branch.is_empty() && branch != "HEAD" {
+            return Some(branch);
+        }
+    }
+    None
+}
+
+pub fn detect_project_language(root: &Path) -> Option<String> {
+    if root.join("Cargo.toml").exists() {
+        return Some("Rust".to_string());
+    }
+    if root.join("tsconfig.json").exists() {
+        return Some("TypeScript".to_string());
+    }
+    if root.join("package.json").exists() {
+        return Some("JavaScript".to_string());
+    }
+    if root.join("pyproject.toml").exists()
+        || root.join("requirements.txt").exists()
+        || root.join("setup.py").exists()
+    {
+        return Some("Python".to_string());
+    }
+    if root.join("go.mod").exists() {
+        return Some("Go".to_string());
+    }
+    if root.join("pom.xml").exists() || root.join("build.gradle").exists() {
+        return Some("Java".to_string());
+    }
+    None
+}
+
 pub fn list_checkpoints(chat_id: &str) -> Vec<Checkpoint> {
     let Some(path) = checkpoint_file_for_chat(chat_id) else {
         return Vec::new();

package/crates/mint-core/src/git/diff.rs

@@ -0,0 +1,206 @@
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct DiffHunk {
+    pub old_text: String,
+    pub new_text: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct WorkspaceFileChange {
+    pub path: String,
+    pub created: bool,
+    pub additions: usize,
+    pub deletions: usize,
+    pub hunks: Vec<DiffHunk>,
+}
+
+/// Read all working tree and staged Git changes in the workspace.
+pub fn read_workspace_git_diff(root: &Path) -> Result<Vec<WorkspaceFileChange>, String> {
+    if !crate::git::is_git_repo(root) {
+        return Ok(Vec::new());
+    }
+
+    // Try diff against HEAD. If HEAD doesn't exist yet (fresh repo), diff unstaged and staged.
+    let diff_output = Command::new("git")
+        .args(["diff", "-U3", "HEAD"])
+        .current_dir(root)
+        .output();
+
+    let diff_text = match diff_output {
+        Ok(out) if out.status.success() => String::from_utf8_lossy(&out.stdout).to_string(),
+        _ => {
+            // Fallback for empty repo without HEAD commit
+            let mut combined = String::new();
+            if let Ok(out) = Command::new("git")
+                .args(["diff", "-U3"])
+                .current_dir(root)
+                .output()
+            {
+                combined.push_str(&String::from_utf8_lossy(&out.stdout));
+            }
+            if let Ok(out) = Command::new("git")
+                .args(["diff", "--cached", "-U3"])
+                .current_dir(root)
+                .output()
+            {
+                combined.push_str(&String::from_utf8_lossy(&out.stdout));
+            }
+            combined
+        }
+    };
+
+    let mut changes = parse_unified_diff(&diff_text);
+    let tracked_paths: std::collections::HashSet<String> =
+        changes.iter().map(|c| c.path.clone()).collect();
+
+    // Also include untracked new files from `git status --porcelain`
+    if let Ok(status_out) = Command::new("git")
+        .args(["status", "--porcelain", "-uall"])
+        .current_dir(root)
+        .output()
+    {
+        let status_text = String::from_utf8_lossy(&status_out.stdout);
+        for line in status_text.lines() {
+            if line.starts_with("?? ") {
+                let rel_path = line[3..].trim().trim_matches('"');
+                if tracked_paths.contains(rel_path) {
+                    continue;
+                }
+                let full_path = root.join(rel_path);
+                if full_path.is_file() {
+                    // Check file size, skip if > 250KB to keep UI snappy
+                    if let Ok(meta) = fs::metadata(&full_path) {
+                        if meta.len() > 256 * 1024 {
+                            changes.push(WorkspaceFileChange {
+                                path: rel_path.to_string(),
+                                created: true,
+                                additions: 0,
+                                deletions: 0,
+                                hunks: vec![DiffHunk {
+                                    old_text: String::new(),
+                                    new_text: "(Large untracked file omitted from preview)"
+                                        .to_string(),
+                                }],
+                            });
+                            continue;
+                        }
+                    }
+
+                    if let Ok(content) = fs::read_to_string(&full_path) {
+                        let lines_count = content.lines().count();
+                        changes.push(WorkspaceFileChange {
+                            path: rel_path.to_string(),
+                            created: true,
+                            additions: lines_count,
+                            deletions: 0,
+                            hunks: vec![DiffHunk {
+                                old_text: String::new(),
+                                new_text: content,
+                            }],
+                        });
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(changes)
+}
+
+fn parse_unified_diff(diff: &str) -> Vec<WorkspaceFileChange> {
+    let mut files = Vec::new();
+    let mut current_file: Option<WorkspaceFileChange> = None;
+    let mut current_old_lines = Vec::new();
+    let mut current_new_lines = Vec::new();
+    let mut in_hunk = false;
+
+    let flush_hunk =
+        |f: &mut WorkspaceFileChange, old_lines: &mut Vec<String>, new_lines: &mut Vec<String>| {
+            if !old_lines.is_empty() || !new_lines.is_empty() {
+                f.hunks.push(DiffHunk {
+                    old_text: old_lines.join("\n"),
+                    new_text: new_lines.join("\n"),
+                });
+                old_lines.clear();
+                new_lines.clear();
+            }
+        };
+
+    for line in diff.lines() {
+        if line.starts_with("diff --git ") {
+            if let Some(mut f) = current_file.take() {
+                flush_hunk(&mut f, &mut current_old_lines, &mut current_new_lines);
+                files.push(f);
+            }
+            in_hunk = false;
+
+            // Extract file path from "diff --git a/path b/path"
+            let path = line
+                .split(" b/")
+                .nth(1)
+                .unwrap_or_else(|| line.split_whitespace().last().unwrap_or(""))
+                .to_string();
+
+            current_file = Some(WorkspaceFileChange {
+                path,
+                created: false,
+                additions: 0,
+                deletions: 0,
+                hunks: Vec::new(),
+            });
+            continue;
+        }
+
+        let Some(ref mut f) = current_file else {
+            continue;
+        };
+
+        if line.starts_with("new file mode") {
+            f.created = true;
+            continue;
+        }
+
+        if line.starts_with("--- ") || line.starts_with("+++ ") {
+            if line.starts_with("--- /dev/null") {
+                f.created = true;
+            }
+            continue;
+        }
+
+        if line.starts_with("@@ ") {
+            if in_hunk {
+                flush_hunk(f, &mut current_old_lines, &mut current_new_lines);
+            }
+            in_hunk = true;
+            continue;
+        }
+
+        if in_hunk {
+            if let Some(rest) = line.strip_prefix('+') {
+                f.additions += 1;
+                current_new_lines.push(rest.to_string());
+            } else if let Some(rest) = line.strip_prefix('-') {
+                f.deletions += 1;
+                current_old_lines.push(rest.to_string());
+            } else if let Some(rest) = line.strip_prefix(' ') {
+                current_old_lines.push(rest.to_string());
+                current_new_lines.push(rest.to_string());
+            } else if line == "\" {
+                // Ignore newline warning marker
+            }
+        }
+    }
+
+    if let Some(mut f) = current_file.take() {
+        flush_hunk(&mut f, &mut current_old_lines, &mut current_new_lines);
+        files.push(f);
+    }
+
+    files
+}

package/crates/mint-core/src/git/mod.rs

@@ -1,7 +1,15 @@
+pub mod branches;
 pub mod checkpoint;
+pub mod diff;
 
+pub use branches::{
+    BranchChange, BranchChangeOutcome, BranchInfo, change_branch, checkout_remote_branch,
+    create_branch, read_branch_info, read_graph, switch_branch,
+};
 pub use checkpoint::{
     Checkpoint, commit_task_changes, create_checkpoint, create_task_branch,
-    generate_commit_message, get_head_hash, is_git_repo, list_checkpoints, record_checkpoint,
-    restore_file, rollback_checkpoint, rollback_task_changes, rollback_to_step, undo_rollback,
+    detect_project_language, generate_commit_message, get_current_branch, get_head_hash,
+    is_git_repo, list_checkpoints, record_checkpoint, restore_file, rollback_checkpoint,
+    rollback_task_changes, rollback_to_step, undo_rollback,
 };
+pub use diff::{DiffHunk, WorkspaceFileChange, read_workspace_git_diff};