mur_core/

skill.rs

//! Skill system — load, install, list, and manage workflow skills.
//!
//! Skills are packaged workflow templates with metadata that can be
//! installed from local directories or a community repository.

use anyhow::{Context, Result};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::{Path, PathBuf};

/// Skill manifest (skill.yaml) — metadata for a skill package.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SkillManifest {
    /// Unique skill identifier (e.g., "deploy-docker").
    pub id: String,
    /// Human-readable name.
    pub name: String,
    /// Description of what the skill does.
    pub description: String,
    /// Skill version (semver).
    pub version: String,
    /// Author name or handle.
    pub author: String,
    /// Tags for discovery.
    #[serde(default)]
    pub tags: Vec<String>,
    /// Workflow files included in this skill.
    #[serde(default)]
    pub workflows: Vec<String>,
    /// Required environment variables.
    #[serde(default)]
    pub requires_env: Vec<String>,
    /// Minimum Commander version required.
    #[serde(default)]
    pub min_commander_version: Option<String>,
}

/// An installed skill with metadata.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct InstalledSkill {
    pub manifest: SkillManifest,
    pub install_path: PathBuf,
    pub installed_at: DateTime<Utc>,
    pub enabled: bool,
    pub source: SkillSource,
}

/// Where a skill was installed from.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SkillSource {
    /// Installed from a local directory.
    Local { path: String },
    /// Installed from the community repository.
    Community { url: String },
}

/// Registry of installed skills.
pub struct SkillRegistry {
    skills_dir: PathBuf,
}

impl SkillRegistry {
    /// Create a new skill registry.
    pub fn new(skills_dir: &Path) -> Self {
        Self {
            skills_dir: skills_dir.to_path_buf(),
        }
    }

    /// Get the default skills directory (~/.mur/skills/).
    pub fn default_dir() -> PathBuf {
        directories::BaseDirs::new()
            .map(|d| d.home_dir().join(".mur").join("skills"))
            .unwrap_or_else(|| PathBuf::from(".mur/skills"))
    }

    /// List all installed skills.
    pub fn list(&self) -> Result<Vec<InstalledSkill>> {
        if !self.skills_dir.exists() {
            return Ok(Vec::new());
        }

        let registry_path = self.skills_dir.join("registry.json");
        if !registry_path.exists() {
            return Ok(Vec::new());
        }

        let content = std::fs::read_to_string(&registry_path)
            .context("Reading skill registry")?;
        let skills: Vec<InstalledSkill> = serde_json::from_str(&content)
            .context("Parsing skill registry")?;
        Ok(skills)
    }

    /// Install a skill from a local directory.
    pub fn install_local(&self, source_dir: &Path) -> Result<InstalledSkill> {
        let manifest_path = source_dir.join("skill.yaml");
        if !manifest_path.exists() {
            anyhow::bail!("No skill.yaml found in {:?}", source_dir);
        }

        let manifest_content = std::fs::read_to_string(&manifest_path)
            .context("Reading skill.yaml")?;
        let manifest: SkillManifest = serde_yaml::from_str(&manifest_content)
            .context("Parsing skill.yaml")?;

        // Create skill directory
        let skill_dir = self.skills_dir.join(&manifest.id);
        std::fs::create_dir_all(&skill_dir)?;

        // Copy workflow files
        for wf_file in &manifest.workflows {
            let src = source_dir.join(wf_file);
            if src.exists() {
                let dst = skill_dir.join(wf_file);
                std::fs::copy(&src, &dst)?;
            }
        }

        // Copy manifest
        std::fs::copy(&manifest_path, skill_dir.join("skill.yaml"))?;

        let installed = InstalledSkill {
            manifest,
            install_path: skill_dir,
            installed_at: Utc::now(),
            enabled: true,
            source: SkillSource::Local {
                path: source_dir.to_string_lossy().to_string(),
            },
        };

        // Update registry
        self.add_to_registry(&installed)?;

        // Link workflows to ~/.mur/workflows/
        self.link_workflows(&installed)?;

        Ok(installed)
    }

    /// Install a skill by name from the community repository.
    pub fn install_community(&self, name: &str) -> Result<InstalledSkill> {
        // Community repository integration is a future feature.
        // For now, check if there's a local skill directory.
        let local_path = self.skills_dir.join("community").join(name);
        if local_path.exists() {
            return self.install_local(&local_path);
        }
        anyhow::bail!(
            "Community skill '{}' not found. Community repository coming soon.\n\
             Install from local: murc skills install /path/to/skill",
            name
        );
    }

    /// Uninstall a skill by ID.
    pub fn uninstall(&self, skill_id: &str) -> Result<()> {
        let mut skills = self.list()?;
        let idx = skills
            .iter()
            .position(|s| s.manifest.id == skill_id)
            .context(format!("Skill '{}' not found", skill_id))?;

        let skill = skills.remove(idx);

        // Remove linked workflows
        self.unlink_workflows(&skill)?;

        // Remove skill directory
        if skill.install_path.exists() {
            std::fs::remove_dir_all(&skill.install_path)?;
        }

        // Update registry
        self.save_registry(&skills)?;

        Ok(())
    }

    /// Enable or disable a skill.
    pub fn set_enabled(&self, skill_id: &str, enabled: bool) -> Result<()> {
        let mut skills = self.list()?;
        if let Some(skill) = skills.iter_mut().find(|s| s.manifest.id == skill_id) {
            skill.enabled = enabled;
            if enabled {
                self.link_workflows(skill)?;
            } else {
                self.unlink_workflows(skill)?;
            }
        } else {
            anyhow::bail!("Skill '{}' not found", skill_id);
        }
        self.save_registry(&skills)?;
        Ok(())
    }

    /// Get skill details by ID.
    pub fn get(&self, skill_id: &str) -> Result<Option<InstalledSkill>> {
        let skills = self.list()?;
        Ok(skills.into_iter().find(|s| s.manifest.id == skill_id))
    }

    /// Link a skill's workflows to the workflows directory.
    fn link_workflows(&self, skill: &InstalledSkill) -> Result<()> {
        let workflows_dir = crate::workflow::parser::workflows_dir();
        std::fs::create_dir_all(&workflows_dir)?;

        for wf_file in &skill.manifest.workflows {
            let src = skill.install_path.join(wf_file);
            let dst = workflows_dir.join(wf_file);
            if src.exists() && !dst.exists() {
                std::fs::copy(&src, &dst)?;
            }
        }
        Ok(())
    }

    /// Unlink a skill's workflows from the workflows directory.
    fn unlink_workflows(&self, skill: &InstalledSkill) -> Result<()> {
        let workflows_dir = crate::workflow::parser::workflows_dir();
        for wf_file in &skill.manifest.workflows {
            let dst = workflows_dir.join(wf_file);
            if dst.exists() {
                let _ = std::fs::remove_file(&dst);
            }
        }
        Ok(())
    }

    /// Add a skill to the registry file.
    fn add_to_registry(&self, skill: &InstalledSkill) -> Result<()> {
        let mut skills = self.list()?;
        // Remove existing version if any
        skills.retain(|s| s.manifest.id != skill.manifest.id);
        skills.push(skill.clone());
        self.save_registry(&skills)?;
        Ok(())
    }

    /// Save the registry file.
    fn save_registry(&self, skills: &[InstalledSkill]) -> Result<()> {
        std::fs::create_dir_all(&self.skills_dir)?;
        let registry_path = self.skills_dir.join("registry.json");
        let json = serde_json::to_string_pretty(skills)?;
        std::fs::write(&registry_path, json)?;
        Ok(())
    }
}

/// Search skills by tag or name.
pub fn search_skills<'a>(
    skills: &'a [InstalledSkill],
    query: &str,
) -> Vec<&'a InstalledSkill> {
    let query_lower = query.to_lowercase();
    skills
        .iter()
        .filter(|s| {
            s.manifest.id.to_lowercase().contains(&query_lower)
                || s.manifest.name.to_lowercase().contains(&query_lower)
                || s.manifest.description.to_lowercase().contains(&query_lower)
                || s.manifest.tags.iter().any(|t| t.to_lowercase().contains(&query_lower))
        })
        .collect()
}

/// Skill info summary for display.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SkillSummary {
    pub id: String,
    pub name: String,
    pub description: String,
    pub version: String,
    pub author: String,
    pub enabled: bool,
    pub workflows: usize,
    pub tags: Vec<String>,
}

impl From<&InstalledSkill> for SkillSummary {
    fn from(skill: &InstalledSkill) -> Self {
        Self {
            id: skill.manifest.id.clone(),
            name: skill.manifest.name.clone(),
            description: skill.manifest.description.clone(),
            version: skill.manifest.version.clone(),
            author: skill.manifest.author.clone(),
            enabled: skill.enabled,
            workflows: skill.manifest.workflows.len(),
            tags: skill.manifest.tags.clone(),
        }
    }
}

/// Scheduled job definition used by both skill system and scheduler.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScheduleConfig {
    /// Workflow ID to run.
    pub workflow_id: String,
    /// Cron expression (e.g., "0 9 * * 1-5").
    pub cron: String,
    /// Variables to pass.
    #[serde(default)]
    pub variables: HashMap<String, String>,
    /// Whether to run in shadow mode.
    #[serde(default)]
    pub shadow: bool,
    /// Whether the schedule is enabled.
    #[serde(default = "default_true")]
    pub enabled: bool,
}

fn default_true() -> bool {
    true
}

/// Trigger configuration used by skill system and trigger engine.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TriggerConfig {
    /// Trigger name.
    pub name: String,
    /// Trigger type.
    pub trigger_type: TriggerType,
    /// Workflow to execute when triggered.
    pub workflow_id: String,
    /// Variables to pass.
    #[serde(default)]
    pub variables: HashMap<String, String>,
    /// Whether the trigger is enabled.
    #[serde(default = "default_true")]
    pub enabled: bool,
}

/// Types of event triggers.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum TriggerType {
    /// Watch a file or directory for changes.
    FileChange { path: String, pattern: Option<String> },
    /// Watch for git push events.
    GitPush { repo_path: String, branch: Option<String> },
    /// Watch log files for error patterns.
    ErrorPattern { file: String, pattern: String },
    /// HTTP webhook trigger.
    Webhook { secret: Option<String> },
}

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

    #[test]
    fn test_skill_manifest_parse() {
        let yaml = r#"
id: deploy-docker
name: Docker Deploy
description: Deploy services using Docker Compose
version: "1.0.0"
author: mur-team
tags: [docker, deploy, devops]
workflows:
  - docker-deploy.yaml
  - docker-rollback.yaml
requires_env:
  - DOCKER_HOST
"#;
        let manifest: SkillManifest = serde_yaml::from_str(yaml).unwrap();
        assert_eq!(manifest.id, "deploy-docker");
        assert_eq!(manifest.workflows.len(), 2);
        assert_eq!(manifest.tags.len(), 3);
        assert_eq!(manifest.requires_env.len(), 1);
    }

    #[test]
    fn test_skill_registry_empty() {
        let dir = tempfile::TempDir::new().unwrap();
        let registry = SkillRegistry::new(dir.path());
        let skills = registry.list().unwrap();
        assert!(skills.is_empty());
    }

    #[test]
    fn test_skill_install_local() {
        let skills_dir = tempfile::TempDir::new().unwrap();
        let source_dir = tempfile::TempDir::new().unwrap();

        // Create a skill source
        let manifest = r#"
id: test-skill
name: Test Skill
description: A test skill
version: "0.1.0"
author: test
tags: [test]
workflows:
  - test-workflow.yaml
"#;
        std::fs::write(source_dir.path().join("skill.yaml"), manifest).unwrap();
        std::fs::write(
            source_dir.path().join("test-workflow.yaml"),
            "id: test-wf\nname: Test\nsteps: []",
        ).unwrap();

        let registry = SkillRegistry::new(skills_dir.path());
        let installed = registry.install_local(source_dir.path()).unwrap();

        assert_eq!(installed.manifest.id, "test-skill");
        assert!(installed.enabled);

        let skills = registry.list().unwrap();
        assert_eq!(skills.len(), 1);
    }

    #[test]
    fn test_skill_uninstall() {
        let skills_dir = tempfile::TempDir::new().unwrap();
        let source_dir = tempfile::TempDir::new().unwrap();

        let manifest = r#"
id: removable-skill
name: Removable
description: Will be removed
version: "1.0.0"
author: test
workflows: []
"#;
        std::fs::write(source_dir.path().join("skill.yaml"), manifest).unwrap();

        let registry = SkillRegistry::new(skills_dir.path());
        registry.install_local(source_dir.path()).unwrap();

        assert_eq!(registry.list().unwrap().len(), 1);

        registry.uninstall("removable-skill").unwrap();
        assert_eq!(registry.list().unwrap().len(), 0);
    }

    #[test]
    fn test_search_skills() {
        let skill = InstalledSkill {
            manifest: SkillManifest {
                id: "deploy-docker".into(),
                name: "Docker Deploy".into(),
                description: "Deploy with Docker".into(),
                version: "1.0.0".into(),
                author: "test".into(),
                tags: vec!["docker".into(), "deploy".into()],
                workflows: vec![],
                requires_env: vec![],
                min_commander_version: None,
            },
            install_path: PathBuf::from("/tmp/test"),
            installed_at: Utc::now(),
            enabled: true,
            source: SkillSource::Local { path: "/tmp".into() },
        };

        let skills = vec![skill];
        assert_eq!(search_skills(&skills, "docker").len(), 1);
        assert_eq!(search_skills(&skills, "kubernetes").len(), 0);
        assert_eq!(search_skills(&skills, "deploy").len(), 1);
    }

    #[test]
    fn test_trigger_type_serialization() {
        let trigger = TriggerType::FileChange {
            path: "/var/log".into(),
            pattern: Some("*.log".into()),
        };
        let json = serde_json::to_string(&trigger).unwrap();
        assert!(json.contains("file_change"));

        let webhook = TriggerType::Webhook { secret: Some("s3cret".into()) };
        let json = serde_json::to_string(&webhook).unwrap();
        assert!(json.contains("webhook"));
    }

    #[test]
    fn test_schedule_config() {
        let config = ScheduleConfig {
            workflow_id: "deploy".into(),
            cron: "0 9 * * 1-5".into(),
            variables: HashMap::new(),
            shadow: false,
            enabled: true,
        };
        let json = serde_json::to_string(&config).unwrap();
        let parsed: ScheduleConfig = serde_json::from_str(&json).unwrap();
        assert_eq!(parsed.workflow_id, "deploy");
        assert!(parsed.enabled);
    }

    #[test]
    fn test_skill_summary() {
        let skill = InstalledSkill {
            manifest: SkillManifest {
                id: "test".into(),
                name: "Test".into(),
                description: "Desc".into(),
                version: "1.0.0".into(),
                author: "author".into(),
                tags: vec!["tag1".into()],
                workflows: vec!["w1.yaml".into(), "w2.yaml".into()],
                requires_env: vec![],
                min_commander_version: None,
            },
            install_path: PathBuf::from("/tmp"),
            installed_at: Utc::now(),
            enabled: true,
            source: SkillSource::Local { path: "/tmp".into() },
        };
        let summary = SkillSummary::from(&skill);
        assert_eq!(summary.workflows, 2);
        assert!(summary.enabled);
    }
}