mur_core/policy/

patterns.rs

//! Mur pattern injection — reads patterns from ~/.mur/patterns/*.yaml
//! and provides them as context for AI model steps.

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

/// A pattern loaded from a YAML file.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Pattern {
    /// Unique pattern identifier.
    pub id: String,
    /// Human-readable name.
    pub name: String,
    /// Detailed description / the pattern content.
    pub description: String,
    /// Tags for matching patterns to workflows.
    #[serde(default)]
    pub tags: Vec<String>,
    /// When to inject this pattern (e.g., "always", "on_match", "manual").
    #[serde(default = "default_inject")]
    pub inject: String,
    /// Glob patterns for action types that trigger injection.
    #[serde(default)]
    pub match_actions: Vec<String>,
}

fn default_inject() -> String {
    "on_match".to_string()
}

/// Store for managing mur patterns.
pub struct PatternStore {
    patterns_dir: PathBuf,
    cache: Mutex<Option<(Instant, Vec<Pattern>)>>,
}

impl PatternStore {
    /// Create a new pattern store.
    pub fn new(patterns_dir: &Path) -> Self {
        Self {
            patterns_dir: patterns_dir.to_path_buf(),
            cache: Mutex::new(None),
        }
    }

    /// Load patterns with caching (30-second staleness window).
    fn cached_load(&self) -> Result<Vec<Pattern>> {
        let mut cache = self.cache.lock().unwrap_or_else(|e| e.into_inner());
        if let Some((loaded_at, ref patterns)) = *cache {
            if loaded_at.elapsed() < std::time::Duration::from_secs(30) {
                return Ok(patterns.clone());
            }
        }
        let patterns = self.load_all()?;
        *cache = Some((Instant::now(), patterns.clone()));
        Ok(patterns)
    }

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

    /// Load all patterns from the patterns directory.
    pub fn load_all(&self) -> Result<Vec<Pattern>> {
        if !self.patterns_dir.exists() {
            return Ok(Vec::new());
        }

        let mut patterns = Vec::new();
        let glob_pattern = self
            .patterns_dir
            .join("*.yaml")
            .to_string_lossy()
            .to_string();

        for entry in glob::glob(&glob_pattern).context("Invalid glob pattern")? {
            match entry {
                Ok(path) => match self.load_pattern(&path) {
                    Ok(p) => patterns.push(p),
                    Err(e) => {
                        tracing::warn!("Failed to load pattern {:?}: {}", path, e);
                    }
                },
                Err(e) => {
                    tracing::warn!("Glob error: {}", e);
                }
            }
        }

        // Also try .yml extension
        let yml_pattern = self
            .patterns_dir
            .join("*.yml")
            .to_string_lossy()
            .to_string();

        for entry in glob::glob(&yml_pattern).context("Invalid glob pattern")? {
            match entry {
                Ok(path) => match self.load_pattern(&path) {
                    Ok(p) => {
                        if !patterns.iter().any(|existing| existing.id == p.id) {
                            patterns.push(p);
                        }
                    }
                    Err(e) => {
                        tracing::warn!("Failed to load pattern {:?}: {}", path, e);
                    }
                },
                Err(e) => {
                    tracing::warn!("Glob error: {}", e);
                }
            }
        }

        Ok(patterns)
    }

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

    /// Get patterns that should be injected for a given action.
    ///
    /// NOTE: Glob matching intentionally delegates to `super::rules::pattern_matches`
    /// rather than implementing its own glob logic. This keeps glob matching
    /// centralized in a single function (`rules::pattern_matches`) to avoid
    /// duplicated and potentially divergent matching behavior.
    pub fn get_matching_patterns(
        &self,
        action_type: &str,
        action_command: &str,
    ) -> Result<Vec<Pattern>> {
        let all = self.cached_load()?;
        let mut matching = Vec::new();

        for pattern in all {
            if pattern.inject == "always" {
                matching.push(pattern);
                continue;
            }

            if pattern.inject == "on_match" {
                // Delegates to rules::pattern_matches — see note on this method.
                let matches = pattern.match_actions.iter().any(|matcher| {
                    super::rules::pattern_matches(action_type, matcher) || super::rules::pattern_matches(action_command, matcher)
                });
                // If no matchers specified, match by tags
                if matches
                    || (pattern.match_actions.is_empty()
                        && pattern.tags.iter().any(|t| {
                            super::rules::pattern_matches(action_type, t) || super::rules::pattern_matches(action_command, t)
                        }))
                {
                    matching.push(pattern);
                }
            }
        }

        Ok(matching)
    }

    /// Format matching patterns as context text for AI model injection.
    pub fn format_context(
        &self,
        action_type: &str,
        action_command: &str,
    ) -> Result<Option<String>> {
        let patterns = self.get_matching_patterns(action_type, action_command)?;
        if patterns.is_empty() {
            return Ok(None);
        }

        let mut context = String::from("## Relevant Patterns\n\n");
        for pattern in &patterns {
            context.push_str(&format!("### {}\n", pattern.name));
            context.push_str(&pattern.description);
            context.push_str("\n\n");
        }

        Ok(Some(context))
    }

    /// Save a pattern to the patterns directory.
    pub fn save_pattern(&self, pattern: &Pattern) -> Result<()> {
        validate_pattern_id(&pattern.id)?;
        std::fs::create_dir_all(&self.patterns_dir)?;
        let path = self.patterns_dir.join(format!("{}.yaml", pattern.id));
        let yaml = serde_yaml::to_string(pattern)?;
        std::fs::write(path, yaml)?;
        Ok(())
    }

    /// Remove a pattern by ID.
    pub fn remove_pattern(&self, id: &str) -> Result<bool> {
        validate_pattern_id(id)?;
        let path = self.patterns_dir.join(format!("{}.yaml", id));
        if path.exists() {
            std::fs::remove_file(&path)?;
            return Ok(true);
        }
        let path_yml = self.patterns_dir.join(format!("{}.yml", id));
        if path_yml.exists() {
            std::fs::remove_file(&path_yml)?;
            return Ok(true);
        }
        Ok(false)
    }
}

/// Validate that a pattern ID is safe for use in file paths.
fn validate_pattern_id(id: &str) -> Result<()> {
    if id.is_empty() {
        anyhow::bail!("Pattern ID cannot be empty");
    }
    if !id
        .chars()
        .all(|c| c.is_alphanumeric() || c == '_' || c == '-')
    {
        anyhow::bail!(
            "Pattern ID must only contain alphanumeric characters, underscores, and hyphens"
        );
    }
    Ok(())
}

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

    #[test]
    fn test_pattern_parse() {
        let yaml = r#"
id: error-handling
name: Error Handling Pattern
description: |
  Always use Result<T> for fallible operations.
  Log errors with tracing before propagating.
tags: [rust, error-handling]
inject: on_match
match_actions: ["code", "fix", "refactor"]
"#;
        let pattern: Pattern = serde_yaml::from_str(yaml).unwrap();
        assert_eq!(pattern.id, "error-handling");
        assert_eq!(pattern.tags.len(), 2);
        assert_eq!(pattern.match_actions.len(), 3);
    }

    #[test]
    fn test_load_all_empty() {
        let dir = tempfile::TempDir::new().unwrap();
        let store = PatternStore::new(dir.path());
        let patterns = store.load_all().unwrap();
        assert!(patterns.is_empty());
    }

    #[test]
    fn test_load_all_from_files() {
        let dir = tempfile::TempDir::new().unwrap();

        // Write a test pattern
        let yaml = r#"
id: test-pattern
name: Test Pattern
description: A test pattern for unit tests
tags: [test]
inject: always
"#;
        std::fs::write(dir.path().join("test-pattern.yaml"), yaml).unwrap();

        let store = PatternStore::new(dir.path());
        let patterns = store.load_all().unwrap();
        assert_eq!(patterns.len(), 1);
        assert_eq!(patterns[0].id, "test-pattern");
    }

    #[test]
    fn test_get_matching_always() {
        let dir = tempfile::TempDir::new().unwrap();
        let yaml = r#"
id: always-inject
name: Always Inject
description: This always injects
tags: []
inject: always
"#;
        std::fs::write(dir.path().join("always-inject.yaml"), yaml).unwrap();

        let store = PatternStore::new(dir.path());
        let matching = store.get_matching_patterns("execute", "cargo build").unwrap();
        assert_eq!(matching.len(), 1);
    }

    #[test]
    fn test_get_matching_on_match() {
        let dir = tempfile::TempDir::new().unwrap();
        let yaml = r#"
id: deploy-pattern
name: Deploy Safety
description: Check all services before deploying
tags: [deploy]
inject: on_match
match_actions: ["deploy*"]
"#;
        std::fs::write(dir.path().join("deploy-pattern.yaml"), yaml).unwrap();

        let store = PatternStore::new(dir.path());

        let matching = store.get_matching_patterns("execute", "deploy production").unwrap();
        assert_eq!(matching.len(), 1);

        let no_match = store.get_matching_patterns("read", "git log").unwrap();
        assert!(no_match.is_empty());
    }

    #[test]
    fn test_format_context() {
        let dir = tempfile::TempDir::new().unwrap();
        let yaml = r#"
id: ctx-pattern
name: Context Pattern
description: Use this context when coding
inject: always
"#;
        std::fs::write(dir.path().join("ctx-pattern.yaml"), yaml).unwrap();

        let store = PatternStore::new(dir.path());
        let ctx = store.format_context("code", "write code").unwrap();
        assert!(ctx.is_some());
        let text = ctx.unwrap();
        assert!(text.contains("Context Pattern"));
        assert!(text.contains("Use this context when coding"));
    }

    #[test]
    fn test_save_and_remove_pattern() {
        let dir = tempfile::TempDir::new().unwrap();
        let store = PatternStore::new(dir.path());

        let pattern = Pattern {
            id: "saveable".into(),
            name: "Saveable".into(),
            description: "test".into(),
            tags: vec![],
            inject: "always".into(),
            match_actions: vec![],
        };

        store.save_pattern(&pattern).unwrap();
        let loaded = store.load_all().unwrap();
        assert_eq!(loaded.len(), 1);

        assert!(store.remove_pattern("saveable").unwrap());
        let loaded = store.load_all().unwrap();
        assert!(loaded.is_empty());
    }

    #[test]
    fn test_remove_nonexistent() {
        let dir = tempfile::TempDir::new().unwrap();
        let store = PatternStore::new(dir.path());
        assert!(!store.remove_pattern("nope").unwrap());
    }

    #[test]
    fn test_pattern_matches() {
        use crate::policy::rules::pattern_matches;
        assert!(pattern_matches("deploy production", "deploy*"));
        assert!(pattern_matches("run tests", "test"));
        assert!(!pattern_matches("read files", "deploy"));
    }

    #[test]
    fn test_nonexistent_dir() {
        let store = PatternStore::new(Path::new("/nonexistent/path"));
        let patterns = store.load_all().unwrap();
        assert!(patterns.is_empty());
    }
}