mur_chat/

command.rs

//! Command parser — parse chat messages into Commander commands.

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Parsed command from a chat message.
///
/// NOTE: This enum is nearly identical to `DiscordCommand` and `TelegramCommand`.
/// A shared command enum should be considered to reduce duplication.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "command", rename_all = "snake_case")]
pub enum ChatCommand {
    /// Run a workflow: `/run <name> [--shadow] [--var key=value]`
    Run {
        workflow: String,
        shadow: bool,
        variables: HashMap<String, String>,
    },
    /// Workflow command: `/workflow run <name>`, `/workflow list`, `/workflow status <id>`
    Workflow {
        action: WorkflowAction,
    },
    /// List workflows: `/workflows`
    Workflows,
    /// Show status: `/status`
    Status,
    /// Show audit log: `/audit [workflow_id]`
    Audit { workflow_id: Option<String> },
    /// Show help: `/help`
    Help,
    /// Stop a running workflow: `/stop <execution_id>`
    Stop { execution_id: String },
    /// Approve a breakpoint: `/approve <execution_id>`
    Approve { execution_id: String },
    /// Deny a breakpoint: `/deny <execution_id>`
    Deny { execution_id: String },
    /// List scheduled jobs: `/schedule`
    Schedule,
    /// Show skills: `/skills`
    Skills,
    /// Unknown command
    Unknown { text: String },
}

/// Sub-actions for the `/workflow` command.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "action", rename_all = "snake_case")]
pub enum WorkflowAction {
    /// `/workflow run <name> [--shadow]`
    Run {
        workflow: String,
        shadow: bool,
        variables: HashMap<String, String>,
    },
    /// `/workflow list`
    List,
    /// `/workflow status <execution_id>`
    Status { execution_id: String },
    /// `/workflow cancel <execution_id>`
    Cancel { execution_id: String },
}

/// Parse a chat message into a command.
pub fn parse_command(text: &str) -> ChatCommand {
    let text = text.trim();

    // Must start with /
    if !text.starts_with('/') {
        return ChatCommand::Unknown {
            text: text.to_string(),
        };
    }

    let parts: Vec<&str> = text.split_whitespace().collect();
    let cmd = parts.first().map(|s| s.to_lowercase()).unwrap_or_default();

    match cmd.as_str() {
        "/run" => parse_run_args(&parts),
        "/workflow" | "/wf" => parse_workflow_command(&parts),
        "/workflows" => ChatCommand::Workflows,
        "/status" => ChatCommand::Status,
        "/audit" => ChatCommand::Audit {
            workflow_id: parts.get(1).map(|s| s.to_string()),
        },
        "/help" => ChatCommand::Help,
        "/stop" => {
            let execution_id = parts.get(1).unwrap_or(&"").to_string();
            if execution_id.is_empty() {
                return ChatCommand::Unknown {
                    text: "Usage: /stop <execution_id>".to_string(),
                };
            }
            ChatCommand::Stop { execution_id }
        }
        "/approve" => {
            let execution_id = parts.get(1).unwrap_or(&"").to_string();
            if execution_id.is_empty() {
                return ChatCommand::Unknown {
                    text: "Usage: /approve <execution_id>".to_string(),
                };
            }
            ChatCommand::Approve { execution_id }
        }
        "/deny" => {
            let execution_id = parts.get(1).unwrap_or(&"").to_string();
            if execution_id.is_empty() {
                return ChatCommand::Unknown {
                    text: "Usage: /deny <execution_id>".to_string(),
                };
            }
            ChatCommand::Deny { execution_id }
        }
        "/schedule" | "/schedules" => ChatCommand::Schedule,
        "/skills" => ChatCommand::Skills,
        _ => ChatCommand::Unknown {
            text: text.to_string(),
        },
    }
}

/// Parse `/run <workflow> [--shadow] [--var key=value]`
fn parse_run_args(parts: &[&str]) -> ChatCommand {
    let workflow = parts.get(1).unwrap_or(&"").to_string();
    if workflow.is_empty() {
        return ChatCommand::Help;
    }
    let shadow = parts.contains(&"--shadow");
    let variables = extract_variables(parts);
    ChatCommand::Run {
        workflow,
        shadow,
        variables,
    }
}

/// Parse `/workflow <subcommand> [args]`
fn parse_workflow_command(parts: &[&str]) -> ChatCommand {
    let sub = parts
        .get(1)
        .map(|s| s.to_lowercase())
        .unwrap_or_default();

    match sub.as_str() {
        "run" => {
            let workflow = parts.get(2).unwrap_or(&"").to_string();
            if workflow.is_empty() {
                return ChatCommand::Help;
            }
            let shadow = parts.contains(&"--shadow");
            let variables = extract_variables(parts);
            ChatCommand::Workflow {
                action: WorkflowAction::Run {
                    workflow,
                    shadow,
                    variables,
                },
            }
        }
        "list" | "ls" => ChatCommand::Workflow {
            action: WorkflowAction::List,
        },
        "status" => {
            let execution_id = parts.get(2).unwrap_or(&"").to_string();
            ChatCommand::Workflow {
                action: WorkflowAction::Status { execution_id },
            }
        }
        "cancel" | "stop" => {
            let execution_id = parts.get(2).unwrap_or(&"").to_string();
            ChatCommand::Workflow {
                action: WorkflowAction::Cancel { execution_id },
            }
        }
        // `/workflow <name>` — shorthand for `/workflow run <name>`
        name if !name.is_empty() => {
            let shadow = parts.contains(&"--shadow");
            let variables = extract_variables(parts);
            ChatCommand::Workflow {
                action: WorkflowAction::Run {
                    workflow: name.to_string(),
                    shadow,
                    variables,
                },
            }
        }
        _ => ChatCommand::Workflows,
    }
}

/// Extract `--var key=value` pairs from command parts.
fn extract_variables(parts: &[&str]) -> HashMap<String, String> {
    let mut variables = HashMap::new();
    for (i, part) in parts.iter().enumerate() {
        if *part == "--var" {
            if let Some(kv) = parts.get(i + 1) {
                if let Some((k, v)) = kv.split_once('=') {
                    variables.insert(k.to_string(), v.to_string());
                }
            }
        }
    }
    variables
}

/// Format help text.
pub fn help_text() -> String {
    r#"⚡ *MUR Commander* — Available Commands:

`/run <workflow> [--shadow]` — Execute a workflow
`/workflow run <name>` — Execute a workflow (alias)
`/workflow list` — List available workflows
`/workflow status <id>` — Check execution status
`/workflow cancel <id>` — Cancel a running workflow
`/workflows` — List available workflows
`/status` — Show daemon status
`/audit [workflow_id]` — View audit log
`/stop <execution_id>` — Stop running workflow
`/approve <execution_id>` — Approve a breakpoint
`/deny <execution_id>` — Deny a breakpoint
`/schedule` — List scheduled jobs
`/skills` — List installed skills
`/help` — Show this help"#
        .to_string()
}

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

    #[test]
    fn test_parse_run() {
        let cmd = parse_command("/run deploy --shadow --var env=staging");
        match cmd {
            ChatCommand::Run {
                workflow,
                shadow,
                variables,
            } => {
                assert_eq!(workflow, "deploy");
                assert!(shadow);
                assert_eq!(variables.get("env").unwrap(), "staging");
            }
            _ => panic!("Expected Run command"),
        }
    }

    #[test]
    fn test_parse_workflows() {
        assert!(matches!(
            parse_command("/workflows"),
            ChatCommand::Workflows
        ));
    }

    #[test]
    fn test_parse_unknown() {
        let cmd = parse_command("hello");
        assert!(matches!(cmd, ChatCommand::Unknown { .. }));
    }

    #[test]
    fn test_parse_help() {
        assert!(matches!(parse_command("/help"), ChatCommand::Help));
    }

    #[test]
    fn test_parse_audit_with_filter() {
        let cmd = parse_command("/audit deploy-wf");
        match cmd {
            ChatCommand::Audit { workflow_id } => {
                assert_eq!(workflow_id.unwrap(), "deploy-wf");
            }
            _ => panic!("Expected Audit command"),
        }
    }

    #[test]
    fn test_parse_approve() {
        let cmd = parse_command("/approve exec-123");
        match cmd {
            ChatCommand::Approve { execution_id } => {
                assert_eq!(execution_id, "exec-123");
            }
            _ => panic!("Expected Approve command"),
        }
    }

    #[test]
    fn test_parse_deny() {
        let cmd = parse_command("/deny exec-456");
        match cmd {
            ChatCommand::Deny { execution_id } => {
                assert_eq!(execution_id, "exec-456");
            }
            _ => panic!("Expected Deny command"),
        }
    }

    #[test]
    fn test_parse_schedule() {
        assert!(matches!(
            parse_command("/schedule"),
            ChatCommand::Schedule
        ));
        assert!(matches!(
            parse_command("/schedules"),
            ChatCommand::Schedule
        ));
    }

    #[test]
    fn test_parse_skills() {
        assert!(matches!(parse_command("/skills"), ChatCommand::Skills));
    }

    #[test]
    fn test_parse_workflow_run() {
        let cmd = parse_command("/workflow run deploy --shadow");
        match cmd {
            ChatCommand::Workflow {
                action: WorkflowAction::Run { workflow, shadow, .. },
            } => {
                assert_eq!(workflow, "deploy");
                assert!(shadow);
            }
            _ => panic!("Expected Workflow Run command"),
        }
    }

    #[test]
    fn test_parse_workflow_list() {
        let cmd = parse_command("/workflow list");
        match cmd {
            ChatCommand::Workflow {
                action: WorkflowAction::List,
            } => {}
            _ => panic!("Expected Workflow List command"),
        }
    }

    #[test]
    fn test_parse_workflow_status() {
        let cmd = parse_command("/workflow status exec-789");
        match cmd {
            ChatCommand::Workflow {
                action: WorkflowAction::Status { execution_id },
            } => {
                assert_eq!(execution_id, "exec-789");
            }
            _ => panic!("Expected Workflow Status command"),
        }
    }

    #[test]
    fn test_parse_workflow_cancel() {
        let cmd = parse_command("/workflow cancel exec-789");
        match cmd {
            ChatCommand::Workflow {
                action: WorkflowAction::Cancel { execution_id },
            } => {
                assert_eq!(execution_id, "exec-789");
            }
            _ => panic!("Expected Workflow Cancel command"),
        }
    }

    #[test]
    fn test_parse_workflow_shorthand() {
        // `/workflow deploy` should be treated as `/workflow run deploy`
        let cmd = parse_command("/workflow deploy");
        match cmd {
            ChatCommand::Workflow {
                action: WorkflowAction::Run { workflow, shadow, .. },
            } => {
                assert_eq!(workflow, "deploy");
                assert!(!shadow);
            }
            _ => panic!("Expected Workflow Run shorthand, got {:?}", cmd),
        }
    }

    #[test]
    fn test_parse_wf_alias() {
        // `/wf list` should work same as `/workflow list`
        let cmd = parse_command("/wf list");
        match cmd {
            ChatCommand::Workflow {
                action: WorkflowAction::List,
            } => {}
            _ => panic!("Expected Workflow List from /wf alias"),
        }
    }
}