enact_runner/

commands.rs

//! Slash commands — user-invokable commands from ~/.enact/commands/, .enact/commands/, and plugins.
//!
//! Command files are Markdown with optional YAML frontmatter. Invoked as `/command-name` or
//! `/plugin:command-name`. Supports $ARGUMENTS, $1, $2, ... substitution.

use enact_config::enact_home;
use enact_plugins::load_plugins;
use serde::{Deserialize, Serialize};
use std::path::Path;

/// Single command definition (from a Markdown file + frontmatter).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CommandDef {
    /// Command name (from filename or frontmatter); may be namespaced e.g. plugin:cmd.
    pub name: String,
    #[serde(default)]
    pub description: Option<String>,
    /// Body content (Markdown) after frontmatter; may contain $ARGUMENTS, $1, $2.
    pub content: String,
    /// Allowed tools for this command (optional restriction).
    #[serde(default)]
    pub allowed_tools: Vec<String>,
    /// Model override (optional).
    #[serde(default)]
    pub model: Option<String>,
}

/// Loads commands from enact_home/commands/ and optionally project .enact/commands/.
/// Project commands take precedence (same name = project wins).
pub fn load_commands(project_dir: Option<&Path>) -> Vec<CommandDef> {
    let home = enact_home();
    let global_dir = home.join("commands");
    let mut commands = load_commands_from_dir(&global_dir, None);
    if let Some(proj) = project_dir {
        let project_commands_dir = proj.join(".enact").join("commands");
        let project_commands = load_commands_from_dir(&project_commands_dir, None);
        // Merge: project commands override global by name
        for pc in project_commands {
            if let Some(pos) = commands.iter().position(|c| c.name == pc.name) {
                commands[pos] = pc;
            } else {
                commands.push(pc);
            }
        }
    }
    commands
}

/// Load commands for the run path: global + project + plugin namespaced commands.
pub fn load_commands_for_run(project_dir: Option<&Path>) -> Vec<CommandDef> {
    let mut commands = load_commands(project_dir);
    for plugin in load_plugins(project_dir) {
        let dir = plugin.commands_dir();
        let prefix = format!("{}:", plugin.manifest.name);
        let plugin_cmds = load_commands_from_dir(dir.as_path(), Some(prefix.as_str()));
        commands.extend(plugin_cmds);
    }
    commands
}

/// Load command definitions from a directory (each .md file = one command).
/// If name_prefix is Some(e.g. "plugin:"), each command name becomes prefix + stem.
fn load_commands_from_dir(dir: &Path, name_prefix: Option<&str>) -> Vec<CommandDef> {
    let mut out = Vec::new();
    if !dir.is_dir() {
        return out;
    }
    let entries = match std::fs::read_dir(dir) {
        Ok(e) => e,
        Err(_) => return out,
    };
    for entry in entries.flatten() {
        let path = entry.path();
        if path.extension().is_some_and(|e| e == "md") {
            if let Some(name) = path.file_stem().and_then(|s| s.to_str()) {
                if let Ok(mut def) = parse_command_file(&path, name) {
                    if let Some(prefix) = name_prefix {
                        def.name = format!("{}{}", prefix, def.name);
                    }
                    out.push(def);
                }
            }
        }
    }
    out
}

/// Parse a single command file: optional YAML frontmatter between ---, then content.
fn parse_command_file(path: &Path, default_name: &str) -> anyhow::Result<CommandDef> {
    let s = std::fs::read_to_string(path)?;
    let (frontmatter, content) = split_frontmatter(&s);
    let name = default_name.to_string();
    let mut description = None;
    let mut allowed_tools = Vec::new();
    let mut model = None;
    if let Some(fm) = frontmatter {
        if let Ok(parsed) = serde_yaml::from_str::<serde_yaml::Value>(&fm) {
            if let Some(desc) = parsed.get("description").and_then(|v| v.as_str()) {
                description = Some(desc.to_string());
            }
            if let Some(tools) = parsed.get("allowed_tools").and_then(|v| v.as_sequence()) {
                allowed_tools = tools
                    .iter()
                    .filter_map(|v| v.as_str().map(String::from))
                    .collect();
            }
            if let Some(m) = parsed.get("model").and_then(|v| v.as_str()) {
                model = Some(m.to_string());
            }
        }
    }
    Ok(CommandDef {
        name,
        description,
        content: content.trim().to_string(),
        allowed_tools,
        model,
    })
}

fn split_frontmatter(s: &str) -> (Option<String>, &str) {
    let s = s.trim_start();
    if !s.starts_with("---") {
        return (None, s);
    }
    let rest = &s[3..];
    let end = rest.find("\n---").unwrap_or(0);
    let (fm, content) = if end > 0 {
        let fm = rest[..end].trim();
        let content_start = rest[end + 4..].trim_start();
        (fm, content_start)
    } else {
        ("", rest)
    };
    (
        if fm.is_empty() {
            None
        } else {
            Some(fm.to_string())
        },
        content,
    )
}

/// Dispatch: if input starts with /name or /project:name, expand command and return new content; else None.
pub fn dispatch(input: &str, commands: &[CommandDef]) -> Option<String> {
    let (raw_name, args) = parse_slash_invocation(input)?;
    // Support /scope:command-name (e.g. plugin:skill); lookup by command name (part after last colon).
    let lookup_name = raw_name.rsplit(':').next().unwrap_or(&raw_name).to_string();
    let cmd = commands
        .iter()
        .find(|c| c.name == lookup_name || c.name == raw_name)?;
    let expanded = substitute_args(&cmd.content, &args);
    Some(expanded)
}

/// Parse `/name args...` input into `(name, args)`.
pub fn parse_slash_invocation(input: &str) -> Option<(String, String)> {
    let input = input.trim();
    if !input.starts_with('/') {
        return None;
    }
    let rest = input[1..].trim_start();
    let (raw_name, args) = split_first_word(rest);
    if raw_name.is_empty() {
        return None;
    }
    Some((raw_name, args.to_string()))
}

fn split_first_word(s: &str) -> (String, &str) {
    let s = s.trim_start();
    if s.is_empty() {
        return (String::new(), s);
    }
    let first = s
        .split_whitespace()
        .next()
        .map(String::from)
        .unwrap_or_default();
    let args = s.get(first.len()..).unwrap_or("").trim_start();
    (first, args)
}

/// Replace $ARGUMENTS and $1, $2, ... in content.
fn substitute_args(content: &str, arguments: &str) -> String {
    let parts: Vec<&str> = arguments.split_whitespace().collect();
    let mut out = content.to_string();
    out = out.replace("$ARGUMENTS", arguments);
    for (i, part) in parts.iter().enumerate() {
        let placeholder = format!("${}", i + 1);
        out = out.replace(&placeholder, part);
    }
    out
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_substitute_args() {
        let s = substitute_args("Run $1 with $2 and rest: $ARGUMENTS", "foo bar baz");
        assert!(s.contains("foo"));
        assert!(s.contains("bar"));
        assert!(s.contains("baz"));
        assert!(s.contains("foo bar baz"));
    }

    #[test]
    fn split_frontmatter_empty() {
        let (fm, content) = split_frontmatter("hello");
        assert!(fm.is_none());
        assert_eq!(content, "hello");
    }

    #[test]
    fn split_frontmatter_with_fm() {
        let (fm, _) = split_frontmatter("---\ndescription: x\n---\nbody");
        assert!(fm.is_some());
        assert!(fm.unwrap().contains("description"));
    }

    #[test]
    fn parse_slash_invocation_parses_name_and_args() {
        let parsed = parse_slash_invocation("/my-plugin:skill do this now").unwrap();
        assert_eq!(parsed.0, "my-plugin:skill");
        assert_eq!(parsed.1, "do this now");
    }

    #[test]
    fn parse_slash_invocation_returns_none_for_non_slash() {
        assert!(parse_slash_invocation("hello").is_none());
    }
}