@pheem49/mint 1.5.5 → 1.6.1

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

@@ -0,0 +1,317 @@
+use std::{
+    path::{Path, PathBuf},
+    process::{Command, Output},
+};
+
+use serde::Serialize;
+use thiserror::Error;
+
+use crate::{
+    Capability, MintConfig, SafetyError, SafetyTier, assert_path_capability,
+    classify_shell_command, shell_mode_allowed,
+};
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct ShellOutput {
+    pub command: String,
+    pub cwd: PathBuf,
+    pub mode: String,
+    pub status: Option<i32>,
+    pub success: bool,
+    pub sandboxed: bool,
+    pub stdout: String,
+    pub stderr: String,
+}
+
+#[derive(Debug, Error)]
+pub enum ShellError {
+    #[error("shell command requires explicit approval: {0}")]
+    ApprovalRequired(String),
+    #[error("blocked unsafe shell command ({reason}): {command}")]
+    Blocked { command: String, reason: String },
+    #[error("shell command mode '{mode}' is not allowed by policy: {command}")]
+    ModeDenied { command: String, mode: String },
+    #[error("shell working directory must be a directory: {0}")]
+    InvalidWorkingDirectory(PathBuf),
+    #[error(transparent)]
+    Safety(#[from] SafetyError),
+    #[error("sandbox mode is enforced but sandbox command '{0}' is unavailable")]
+    SandboxUnavailable(String),
+    #[error("unable to execute shell command: {0}")]
+    Execute(#[from] std::io::Error),
+}
+
+pub fn run_shell_command(
+    command: &str,
+    cwd: &Path,
+    approved: bool,
+    config: &MintConfig,
+) -> Result<ShellOutput, ShellError> {
+    let classification = classify_shell_command(command);
+    if classification.tier == SafetyTier::Blocked {
+        return Err(ShellError::Blocked {
+            command: command.into(),
+            reason: classification.reason,
+        });
+    }
+    if config.safety_enabled && !shell_mode_allowed(config, classification.mode) {
+        return Err(ShellError::ModeDenied {
+            command: command.into(),
+            mode: classification.mode.as_str().into(),
+        });
+    }
+    if !approved {
+        return Err(ShellError::ApprovalRequired(command.into()));
+    }
+
+    let cwd = assert_path_capability(cwd, Capability::Write, config)?;
+    if !cwd.is_dir() {
+        return Err(ShellError::InvalidWorkingDirectory(cwd));
+    }
+
+    let sandbox_mode = config.sandbox_mode.trim().to_ascii_lowercase();
+    if config.safety_enabled && sandbox_mode != "off" {
+        if let Some(output) = run_in_sandbox(command, &cwd, config)? {
+            return Ok(shell_output(
+                command,
+                cwd,
+                classification.mode.as_str(),
+                true,
+                output,
+            ));
+        }
+        if sandbox_mode == "enforce" {
+            return Err(ShellError::SandboxUnavailable(
+                config.sandbox_command.clone(),
+            ));
+        }
+    }
+
+    let output = shell_command(command).current_dir(&cwd).output()?;
+    Ok(shell_output(
+        command,
+        cwd,
+        classification.mode.as_str(),
+        false,
+        output,
+    ))
+}
+
+fn run_in_sandbox(
+    command: &str,
+    cwd: &Path,
+    config: &MintConfig,
+) -> Result<Option<Output>, ShellError> {
+    #[cfg(target_os = "linux")]
+    {
+        let sandbox = config.sandbox_command.trim();
+        if sandbox.is_empty() || !command_exists(sandbox) {
+            return Ok(None);
+        }
+        let mut process = Command::new(sandbox);
+        process
+            .args(["--die-with-parent", "--ro-bind", "/", "/", "--dev", "/dev"])
+            .args(["--proc", "/proc", "--tmpfs", "/tmp"]);
+        for root in writable_roots(config, cwd) {
+            process.arg("--bind").arg(&root).arg(&root);
+        }
+        let output = process
+            .arg("--chdir")
+            .arg(cwd)
+            .args(["bash", "-lc", command])
+            .output()?;
+        return Ok(Some(output));
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        let sandbox = config.sandbox_command.trim();
+        if sandbox.is_empty() || !command_exists(sandbox) {
+            return Ok(None);
+        }
+        let output = Command::new(sandbox)
+            .arg("-p")
+            .arg(mac_sandbox_profile(config, cwd))
+            .args(["bash", "-lc", command])
+            .current_dir(cwd)
+            .output()?;
+        return Ok(Some(output));
+    }
+
+    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
+    {
+        let _ = (command, cwd, config);
+        Ok(None)
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn mac_sandbox_profile(config: &MintConfig, cwd: &Path) -> String {
+    let mut read_roots = vec![
+        cwd.to_path_buf(),
+        PathBuf::from("/bin"),
+        PathBuf::from("/sbin"),
+        PathBuf::from("/usr"),
+        PathBuf::from("/System"),
+        PathBuf::from("/Library"),
+    ];
+    read_roots.extend(config.allowed_read_paths.iter().cloned());
+    read_roots.extend(config.allowed_write_paths.iter().cloned());
+
+    let mut write_roots = vec![cwd.to_path_buf(), std::env::temp_dir()];
+    write_roots.extend(config.allowed_write_paths.iter().cloned());
+
+    format!(
+        "(version 1)\n\
+         (deny default)\n\
+         (allow process*)\n\
+         (allow sysctl-read)\n\
+         (allow signal (target self))\n\
+         (allow file-read-metadata)\n\
+         (allow file-read*\n{})\n\
+         (allow file-write*\n{})",
+        sandbox_subpaths(read_roots),
+        sandbox_subpaths(write_roots),
+    )
+}
+
+#[cfg(target_os = "macos")]
+fn sandbox_subpaths(mut roots: Vec<PathBuf>) -> String {
+    roots.sort();
+    roots.dedup();
+    roots
+        .into_iter()
+        .filter(|root| root.exists())
+        .map(|root| {
+            format!(
+                "  (subpath \"{}\")",
+                root.to_string_lossy()
+                    .replace('\\', "\\\\")
+                    .replace('"', "\\\"")
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+#[cfg(target_os = "linux")]
+fn writable_roots(config: &MintConfig, cwd: &Path) -> Vec<PathBuf> {
+    let mut roots = config
+        .allowed_write_paths
+        .iter()
+        .filter(|root| root.exists())
+        .cloned()
+        .collect::<Vec<_>>();
+    if !roots.iter().any(|root| cwd.starts_with(root)) {
+        roots.push(cwd.to_path_buf());
+    }
+    roots.sort();
+    roots.dedup();
+    roots
+}
+
+#[cfg(any(target_os = "linux", target_os = "macos"))]
+fn command_exists(command: &str) -> bool {
+    Command::new("which")
+        .arg(command)
+        .output()
+        .is_ok_and(|output| output.status.success())
+}
+
+fn shell_command(command: &str) -> Command {
+    #[cfg(target_os = "windows")]
+    {
+        let mut process = Command::new("powershell.exe");
+        process.args([
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-Command",
+            command,
+        ]);
+        process
+    }
+    #[cfg(not(target_os = "windows"))]
+    {
+        let mut process = Command::new("bash");
+        process.args(["-lc", command]);
+        process
+    }
+}
+
+fn shell_output(
+    command: &str,
+    cwd: PathBuf,
+    mode: &str,
+    sandboxed: bool,
+    output: Output,
+) -> ShellOutput {
+    ShellOutput {
+        command: command.into(),
+        cwd,
+        mode: mode.into(),
+        status: output.status.code(),
+        success: output.status.success(),
+        sandboxed,
+        stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
+        stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn local_config() -> MintConfig {
+        MintConfig {
+            safety_enabled: false,
+            sandbox_mode: "off".into(),
+            ..MintConfig::default()
+        }
+    }
+
+    #[test]
+    fn requires_explicit_approval() {
+        let error =
+            run_shell_command("printf mint", Path::new("."), false, &local_config()).unwrap_err();
+        assert!(matches!(error, ShellError::ApprovalRequired(_)));
+    }
+
+    #[test]
+    fn blocks_destructive_commands_even_when_approved() {
+        let error = run_shell_command(
+            "git reset --hard HEAD",
+            Path::new("."),
+            true,
+            &local_config(),
+        )
+        .unwrap_err();
+        assert!(matches!(error, ShellError::Blocked { .. }));
+    }
+
+    #[test]
+    fn runs_an_approved_local_command() {
+        let output =
+            run_shell_command("printf mint", Path::new("."), true, &local_config()).unwrap();
+        assert!(output.success);
+        assert!(!output.sandboxed);
+        assert_eq!(output.stdout, "mint");
+    }
+
+    #[test]
+    fn reports_non_zero_exit_status() {
+        let output = run_shell_command(
+            "printf failure >&2; exit 7",
+            Path::new("."),
+            true,
+            &local_config(),
+        )
+        .unwrap();
+        assert!(!output.success);
+        assert_eq!(output.status, Some(7));
+        assert_eq!(output.stderr, "failure");
+    }
+}

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

@@ -0,0 +1,71 @@
+use std::{fs, path::Path};
+
+use thiserror::Error;
+
+use crate::{LearnedSkill, MemoryError, MemoryStore};
+
+const MAX_SKILL_BYTES: u64 = 256 * 1024;
+const MAX_CONTEXT_BYTES: usize = 16 * 1024;
+
+#[derive(Debug, Error)]
+pub enum SkillError {
+    #[error("unable to resolve skill file {path}: {source}")]
+    Resolve {
+        path: String,
+        source: std::io::Error,
+    },
+    #[error("skill path is not a file: {0}")]
+    NotFile(String),
+    #[error("skill file is too large ({0} bytes); limit is {MAX_SKILL_BYTES} bytes")]
+    TooLarge(u64),
+    #[error("Mint learn supports .md and .txt files only")]
+    UnsupportedExtension,
+    #[error(transparent)]
+    Io(#[from] std::io::Error),
+    #[error(transparent)]
+    Memory(#[from] MemoryError),
+}
+
+pub fn learn_skill(path: &Path) -> Result<LearnedSkill, SkillError> {
+    let path = path.canonicalize().map_err(|source| SkillError::Resolve {
+        path: path.display().to_string(),
+        source,
+    })?;
+    let metadata = fs::metadata(&path)?;
+    if !metadata.is_file() {
+        return Err(SkillError::NotFile(path.display().to_string()));
+    }
+    if metadata.len() > MAX_SKILL_BYTES {
+        return Err(SkillError::TooLarge(metadata.len()));
+    }
+    if !path
+        .extension()
+        .and_then(|value| value.to_str())
+        .is_some_and(|extension| matches!(extension.to_ascii_lowercase().as_str(), "md" | "txt"))
+    {
+        return Err(SkillError::UnsupportedExtension);
+    }
+    let content = fs::read_to_string(&path)?;
+    let name = path
+        .file_name()
+        .and_then(|value| value.to_str())
+        .unwrap_or("skill");
+    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()
+        .map(|skill| format!("Skill: {}\n{}", skill.name, skill.content))
+        .collect::<Vec<_>>()
+        .join("\n\n");
+    if value.len() <= MAX_CONTEXT_BYTES {
+        return Ok(value);
+    }
+    let mut end = MAX_CONTEXT_BYTES;
+    while !value.is_char_boundary(end) {
+        end -= 1;
+    }
+    Ok(format!("{}\n...<learned skills truncated>", &value[..end]))
+}

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

@@ -0,0 +1,157 @@
+use std::{
+    collections::BTreeMap,
+    fs,
+    path::{Path, PathBuf},
+    sync::LazyLock,
+};
+
+use regex::Regex;
+use serde::Serialize;
+use thiserror::Error;
+
+use crate::{CodeInspectionError, MintConfig, list_code_files};
+
+static PATTERNS: LazyLock<Vec<(&'static str, Regex)>> = LazyLock::new(|| {
+    [
+        (
+            "function",
+            r"^\s*(?:pub\s+)?(?:async\s+)?fn\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(",
+        ),
+        (
+            "function",
+            r"^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(",
+        ),
+        (
+            "function",
+            r"^\s*(?:async\s+)?def\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(",
+        ),
+        (
+            "class",
+            r"^\s*(?:export\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*)\b",
+        ),
+        (
+            "struct",
+            r"^\s*(?:pub\s+)?struct\s+([A-Za-z_][A-Za-z0-9_]*)\b",
+        ),
+        ("enum", r"^\s*(?:pub\s+)?enum\s+([A-Za-z_][A-Za-z0-9_]*)\b"),
+        (
+            "trait",
+            r"^\s*(?:pub\s+)?trait\s+([A-Za-z_][A-Za-z0-9_]*)\b",
+        ),
+        (
+            "interface",
+            r"^\s*(?:export\s+)?interface\s+([A-Za-z_$][A-Za-z0-9_$]*)\b",
+        ),
+        (
+            "type",
+            r"^\s*(?:export\s+)?type\s+([A-Za-z_$][A-Za-z0-9_$]*)\b",
+        ),
+    ]
+    .into_iter()
+    .map(|(kind, pattern)| (kind, Regex::new(pattern).unwrap()))
+    .collect()
+});
+
+#[derive(Debug, Error)]
+pub enum SymbolError {
+    #[error(transparent)]
+    Inspect(#[from] CodeInspectionError),
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct CodeSymbol {
+    pub name: String,
+    pub kind: String,
+    pub file: PathBuf,
+    pub line: usize,
+    pub signature: String,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct SymbolIndex {
+    pub root: PathBuf,
+    pub file_count: usize,
+    pub symbol_count: usize,
+    pub kind_counts: BTreeMap<String, usize>,
+    pub symbols: Vec<CodeSymbol>,
+}
+
+pub fn build_symbol_index(
+    root: &Path,
+    limit: usize,
+    config: &MintConfig,
+) -> Result<SymbolIndex, SymbolError> {
+    let files = list_code_files(root, usize::MAX, config)?;
+    let mut symbols = Vec::new();
+    for file in &files {
+        if symbols.len() >= limit {
+            break;
+        }
+        let Some(extension) = file.path.extension().and_then(|value| value.to_str()) else {
+            continue;
+        };
+        if !matches!(
+            extension,
+            "rs" | "js" | "jsx" | "ts" | "tsx" | "py" | "cjs" | "mjs"
+        ) {
+            continue;
+        }
+        let Ok(content) = fs::read_to_string(&file.path) else {
+            continue;
+        };
+        for (index, line) in content.lines().enumerate() {
+            for (kind, pattern) in PATTERNS.iter() {
+                let Some(found) = pattern.captures(line).and_then(|captures| captures.get(1))
+                else {
+                    continue;
+                };
+                symbols.push(CodeSymbol {
+                    name: found.as_str().into(),
+                    kind: (*kind).into(),
+                    file: file.path.clone(),
+                    line: index + 1,
+                    signature: line.trim().into(),
+                });
+                break;
+            }
+            if symbols.len() >= limit {
+                break;
+            }
+        }
+    }
+    let mut kind_counts = BTreeMap::new();
+    for symbol in &symbols {
+        *kind_counts.entry(symbol.kind.clone()).or_insert(0) += 1;
+    }
+    Ok(SymbolIndex {
+        root: root.to_path_buf(),
+        file_count: files.len(),
+        symbol_count: symbols.len(),
+        kind_counts,
+        symbols,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn indexes_rust_and_typescript_symbols() {
+        let root = std::env::temp_dir().join("mint-symbol-index");
+        let _ = fs::remove_dir_all(&root);
+        fs::create_dir_all(&root).unwrap();
+        fs::write(root.join("main.rs"), "pub struct Mint;\npub fn run() {}\n").unwrap();
+        fs::write(root.join("ui.ts"), "export interface Widget {}\n").unwrap();
+        let config = MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            blocked_paths: vec![],
+            ..MintConfig::default()
+        };
+        let index = build_symbol_index(&root, 20, &config).unwrap();
+        assert_eq!(index.symbol_count, 3);
+        let _ = fs::remove_dir_all(root);
+    }
+}