mur_core/

emerge.rs

//! MUR Emerge bridge — convert emerge patterns into Commander workflows.

use anyhow::{Context, Result};
use serde::{Deserialize, Serialize};
use std::path::{Path, PathBuf};

/// A MUR emerge pattern loaded from `~/.mur/patterns/`.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EmergePattern {
    /// Pattern identifier (derived from filename).
    pub id: String,
    /// Human-readable name.
    pub name: String,
    /// Description of what the pattern does.
    pub description: String,
    /// The solution / steps to execute.
    pub solution: String,
    /// Verification command or check.
    pub verification: String,
    /// Tags for categorization.
    #[serde(default)]
    pub tags: Vec<String>,
}

/// Suggestion for creating a workflow from a detected pattern.
#[derive(Debug, Clone)]
pub struct WorkflowSuggestion {
    /// The source pattern.
    pub pattern: EmergePattern,
    /// Generated YAML content.
    pub yaml: String,
    /// Suggested workflow file path.
    pub target_path: PathBuf,
}

/// Get the patterns directory path.
fn patterns_dir() -> PathBuf {
    directories::BaseDirs::new()
        .map(|d| d.home_dir().join(".mur").join("patterns"))
        .unwrap_or_else(|| PathBuf::from(".mur/patterns"))
}

/// Get the workflows directory path.
fn workflows_dir() -> PathBuf {
    directories::BaseDirs::new()
        .map(|d| d.home_dir().join(".mur").join("workflows"))
        .unwrap_or_else(|| PathBuf::from(".mur/workflows"))
}

/// Load a single emerge pattern from a YAML file.
pub fn load_pattern(path: &Path) -> Result<EmergePattern> {
    let content = std::fs::read_to_string(path)
        .with_context(|| format!("Reading pattern file {:?}", path))?;
    let pattern: EmergePattern =
        serde_yaml::from_str(&content).with_context(|| format!("Parsing pattern {:?}", path))?;
    Ok(pattern)
}

/// Scan `~/.mur/patterns/` for all emerge pattern files.
pub fn scan_patterns() -> Result<Vec<EmergePattern>> {
    let dir = patterns_dir();
    if !dir.exists() {
        return Ok(vec![]);
    }

    let mut patterns = Vec::new();
    let pattern_glob = dir.join("*.yaml").to_string_lossy().to_string();

    for entry in glob::glob(&pattern_glob)
        .context("Invalid glob pattern")?
        .filter_map(|e| e.ok())
    {
        match load_pattern(&entry) {
            Ok(p) => patterns.push(p),
            Err(e) => tracing::warn!("Skipping pattern {:?}: {}", entry, e),
        }
    }

    // Also check .yml
    let yml_glob = dir.join("*.yml").to_string_lossy().to_string();
    for entry in glob::glob(&yml_glob)
        .context("Invalid glob pattern")?
        .filter_map(|e| e.ok())
    {
        match load_pattern(&entry) {
            Ok(p) => patterns.push(p),
            Err(e) => tracing::warn!("Skipping pattern {:?}: {}", entry, e),
        }
    }

    Ok(patterns)
}

/// Convert a MUR emerge pattern into a Commander workflow YAML string.
pub fn emerge_to_workflow(pattern: &EmergePattern) -> Result<String> {
    // Split the solution into steps by newline (each line becomes a step)
    let solution_lines: Vec<&str> = pattern
        .solution
        .lines()
        .map(|l| l.trim())
        .filter(|l| !l.is_empty())
        .collect();

    let mut steps = Vec::new();

    for (i, line) in solution_lines.iter().enumerate() {
        steps.push(format!(
            r#"  - name: "step-{}"
    step_type: execute
    action: "{}"
    on_failure: abort"#,
            i + 1,
            line.replace('"', "\\\"")
        ));
    }

    // Add verification step if present
    if !pattern.verification.is_empty() {
        steps.push(format!(
            r#"  - name: "verify"
    step_type: analyze
    action: "{}"
    on_failure: abort"#,
            pattern.verification.replace('"', "\\\"")
        ));
    }

    let yaml = format!(
        r#"id: "emerge-{id}"
name: "{name}"
description: "{desc}"
variables: {{}}
steps:
{steps}
"#,
        id = pattern.id,
        name = pattern.name.replace('"', "\\\""),
        desc = pattern.description.replace('"', "\\\""),
        steps = steps.join("\n"),
    );

    Ok(yaml)
}

/// Generate a workflow suggestion from an emerge pattern.
pub fn suggest_workflow(pattern: &EmergePattern) -> Result<WorkflowSuggestion> {
    let yaml = emerge_to_workflow(pattern)?;
    let target_path = workflows_dir().join(format!("emerge-{}.yaml", pattern.id));

    Ok(WorkflowSuggestion {
        pattern: pattern.clone(),
        yaml,
        target_path,
    })
}

/// Save a generated workflow YAML to the workflows directory.
pub fn save_workflow(suggestion: &WorkflowSuggestion) -> Result<PathBuf> {
    let dir = workflows_dir();
    if !dir.exists() {
        std::fs::create_dir_all(&dir)
            .with_context(|| format!("Creating workflows directory {:?}", dir))?;
    }

    std::fs::write(&suggestion.target_path, &suggestion.yaml)
        .with_context(|| format!("Writing workflow {:?}", suggestion.target_path))?;

    Ok(suggestion.target_path.clone())
}

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

    fn sample_pattern() -> EmergePattern {
        EmergePattern {
            id: "fix-build".into(),
            name: "Fix Build Errors".into(),
            description: "Automatically fix common build errors".into(),
            solution: "cargo check 2>&1\ncargo fix --allow-dirty".into(),
            verification: "cargo build".into(),
            tags: vec!["rust".into(), "build".into()],
        }
    }

    #[test]
    fn test_emerge_to_workflow() {
        let pattern = sample_pattern();
        let yaml = emerge_to_workflow(&pattern).unwrap();

        assert!(yaml.contains("emerge-fix-build"));
        assert!(yaml.contains("Fix Build Errors"));
        assert!(yaml.contains("cargo check"));
        assert!(yaml.contains("cargo fix --allow-dirty"));
        assert!(yaml.contains("verify"));
        assert!(yaml.contains("cargo build"));
    }

    #[test]
    fn test_suggest_workflow() {
        let pattern = sample_pattern();
        let suggestion = suggest_workflow(&pattern).unwrap();

        assert!(suggestion.target_path.to_string_lossy().contains("emerge-fix-build"));
        assert!(!suggestion.yaml.is_empty());
    }

    #[test]
    fn test_load_pattern_from_yaml() {
        let yaml = r#"
id: test-pattern
name: Test Pattern
description: A test pattern
solution: "echo hello"
verification: "echo done"
tags:
  - test
"#;
        let pattern: EmergePattern = serde_yaml::from_str(yaml).unwrap();
        assert_eq!(pattern.id, "test-pattern");
        assert_eq!(pattern.name, "Test Pattern");
        assert_eq!(pattern.tags, vec!["test"]);
    }

    #[test]
    fn test_scan_patterns_empty_dir() {
        // When the patterns dir doesn't exist, should return empty
        let result = scan_patterns();
        // This test depends on the environment; if ~/.mur/patterns exists it may find patterns.
        // We just verify it doesn't error out.
        assert!(result.is_ok());
    }

    #[test]
    fn test_emerge_to_workflow_empty_solution() {
        let pattern = EmergePattern {
            id: "empty".into(),
            name: "Empty".into(),
            description: "No solution".into(),
            solution: String::new(),
            verification: String::new(),
            tags: vec![],
        };
        let yaml = emerge_to_workflow(&pattern).unwrap();
        assert!(yaml.contains("emerge-empty"));
        // No steps except possibly an empty verification
        assert!(yaml.contains("steps:"));
    }
}