kardo_core/rules/

plugin.rs

//! Plugin API for loading rules from YAML configuration files.
//!
//! Users can define custom rules via YAML files in:
//! - `~/.kardo/plugins/*.yaml` (global plugins)
//! - `.kardo/rules/*.yaml` (project-local rules)
//! - Standard rule packages (shipped with Kardo)
//!
//! YAML schema:
//! ```yaml
//! id: "custom-my-rule"
//! name: "My Custom Rule"
//! category: freshness | integrity | configuration | agent_setup | structure | custom
//! severity: high | medium | low
//! pattern:
//!   type: file_missing | file_stale | content_match | regex
//!   target: "CLAUDE.md"          # file path or pattern
//!   threshold: 30                 # for file_stale: days
//! message: "Description of what's wrong"
//! suggestion: "How to fix it"
//! ```

use std::path::{Path, PathBuf};

use serde::{Deserialize, Serialize};

use super::{Rule, RuleCategory, RuleConfig, RuleContext, RuleViolation, Severity};

// ── YAML Schema Types ──

/// The pattern type that determines how a YAML rule matches.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum YamlPattern {
    /// Check if a specific file is missing from the project.
    FileMissing {
        target: String,
    },
    /// Check if a file is stale (not updated in `threshold` days).
    FileStale {
        target: String,
        #[serde(default = "default_stale_threshold")]
        threshold: i64,
    },
    /// Check if a file's content matches (or doesn't match) a substring.
    ContentMatch {
        target: String,
        #[serde(default)]
        contains: Option<String>,
        #[serde(default)]
        not_contains: Option<String>,
    },
    /// Check if a file's content matches a regex pattern.
    Regex {
        target: String,
        pattern: String,
        #[serde(default)]
        negate: bool,
    },
}

fn default_stale_threshold() -> i64 {
    90
}

/// A rule definition loaded from YAML.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct YamlRuleDef {
    pub id: String,
    pub name: String,
    pub category: RuleCategory,
    pub severity: Severity,
    pub pattern: YamlPattern,
    pub message: String,
    #[serde(default)]
    pub suggestion: Option<String>,
}

/// Validation errors for YAML rule definitions.
#[derive(Debug, Clone)]
pub enum YamlRuleError {
    /// The rule ID is empty or invalid.
    InvalidId(String),
    /// The rule name is empty.
    EmptyName,
    /// The pattern target is empty.
    EmptyTarget,
    /// The regex pattern is invalid.
    InvalidRegex { pattern: String, error: String },
    /// YAML parsing failed.
    ParseError(String),
}

impl std::fmt::Display for YamlRuleError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            YamlRuleError::InvalidId(id) => write!(f, "Invalid rule ID: '{}'", id),
            YamlRuleError::EmptyName => write!(f, "Rule name cannot be empty"),
            YamlRuleError::EmptyTarget => write!(f, "Pattern target cannot be empty"),
            YamlRuleError::InvalidRegex { pattern, error } => {
                write!(f, "Invalid regex '{}': {}", pattern, error)
            }
            YamlRuleError::ParseError(msg) => write!(f, "YAML parse error: {}", msg),
        }
    }
}

impl std::error::Error for YamlRuleError {}

/// Validate a YAML rule definition.
fn validate_yaml_rule(def: &YamlRuleDef) -> Result<(), YamlRuleError> {
    if def.id.is_empty() || def.id.contains(' ') {
        return Err(YamlRuleError::InvalidId(def.id.clone()));
    }
    if def.name.is_empty() {
        return Err(YamlRuleError::EmptyName);
    }

    match &def.pattern {
        YamlPattern::FileMissing { target } => {
            if target.is_empty() {
                return Err(YamlRuleError::EmptyTarget);
            }
        }
        YamlPattern::FileStale { target, .. } => {
            if target.is_empty() {
                return Err(YamlRuleError::EmptyTarget);
            }
        }
        YamlPattern::ContentMatch { target, .. } => {
            if target.is_empty() {
                return Err(YamlRuleError::EmptyTarget);
            }
        }
        YamlPattern::Regex {
            target, pattern, ..
        } => {
            if target.is_empty() {
                return Err(YamlRuleError::EmptyTarget);
            }
            // Validate the regex compiles
            if let Err(e) = regex::Regex::new(pattern) {
                return Err(YamlRuleError::InvalidRegex {
                    pattern: pattern.clone(),
                    error: e.to_string(),
                });
            }
        }
    }

    Ok(())
}

// ── YamlRule: implements the Rule trait ──

/// A rule loaded from a YAML definition file.
/// Implements the `Rule` trait so it can be added to a `RuleSet`.
#[derive(Debug, Clone)]
pub struct YamlRule {
    def: YamlRuleDef,
}

impl YamlRule {
    /// Create a YamlRule from a validated definition.
    pub fn new(def: YamlRuleDef) -> Result<Self, YamlRuleError> {
        validate_yaml_rule(&def)?;
        Ok(Self { def })
    }

    /// Parse a YAML string into a YamlRule.
    pub fn from_yaml(yaml: &str) -> Result<Self, YamlRuleError> {
        let def: YamlRuleDef =
            serde_yaml::from_str(yaml).map_err(|e| YamlRuleError::ParseError(e.to_string()))?;
        Self::new(def)
    }

    /// Parse a YAML file containing multiple rule definitions.
    /// Returns all valid rules and any errors encountered.
    pub fn from_yaml_multi(yaml: &str) -> (Vec<Self>, Vec<YamlRuleError>) {
        let mut rules = Vec::new();
        let mut errors = Vec::new();

        // Try parsing as a single rule first
        if let Ok(rule) = Self::from_yaml(yaml) {
            return (vec![rule], vec![]);
        }

        // Try parsing as a list of rules
        match serde_yaml::from_str::<Vec<YamlRuleDef>>(yaml) {
            Ok(defs) => {
                for def in defs {
                    match Self::new(def) {
                        Ok(rule) => rules.push(rule),
                        Err(e) => errors.push(e),
                    }
                }
            }
            Err(e) => {
                errors.push(YamlRuleError::ParseError(e.to_string()));
            }
        }

        (rules, errors)
    }

    /// Get the underlying definition.
    pub fn definition(&self) -> &YamlRuleDef {
        &self.def
    }
}

impl Rule for YamlRule {
    fn id(&self) -> &str {
        &self.def.id
    }

    fn name(&self) -> &str {
        &self.def.name
    }

    fn description(&self) -> &str {
        &self.def.message
    }

    fn category(&self) -> RuleCategory {
        self.def.category
    }

    fn default_severity(&self) -> Severity {
        self.def.severity
    }

    fn evaluate(&self, ctx: &RuleContext, _config: &RuleConfig) -> Vec<RuleViolation> {
        match &self.def.pattern {
            YamlPattern::FileMissing { target } => {
                self.check_file_missing(ctx, target)
            }
            YamlPattern::FileStale { target, threshold } => {
                self.check_file_stale(ctx, target, *threshold)
            }
            YamlPattern::ContentMatch {
                target,
                contains,
                not_contains,
            } => self.check_content_match(ctx, target, contains.as_deref(), not_contains.as_deref()),
            YamlPattern::Regex {
                target,
                pattern,
                negate,
            } => self.check_regex(ctx, target, pattern, *negate),
        }
    }
}

impl YamlRule {
    fn check_file_missing(&self, ctx: &RuleContext, target: &str) -> Vec<RuleViolation> {
        // Check if target file exists in known paths or discovered files
        let exists = ctx.known_paths.contains(target)
            || ctx.files.iter().any(|f| f.relative_path == target);

        if exists {
            return vec![];
        }

        vec![RuleViolation {
            rule_id: self.def.id.clone(),
            category: self.def.category,
            severity: self.def.severity,
            file_path: None,
            title: self.def.message.clone(),
            attribution: format!("Required file '{}' is missing from the project", target),
            suggestion: self.def.suggestion.clone(),
        }]
    }

    fn check_file_stale(
        &self,
        ctx: &RuleContext,
        target: &str,
        threshold: i64,
    ) -> Vec<RuleViolation> {
        let mut violations = Vec::new();

        // Check via freshness analysis results
        if let Some(freshness) = ctx.freshness {
            for file in &freshness.file_scores {
                if !Self::path_matches(&file.relative_path, target) {
                    continue;
                }
                if let Some(days) = file.days_since_modified {
                    if days > threshold {
                        violations.push(RuleViolation {
                            rule_id: self.def.id.clone(),
                            category: self.def.category,
                            severity: self.def.severity,
                            file_path: Some(file.relative_path.clone()),
                            title: format!("{}: {}", file.relative_path, self.def.message),
                            attribution: format!(
                                "{} hasn't been updated in {} days (threshold: {})",
                                file.relative_path, days, threshold
                            ),
                            suggestion: self.def.suggestion.clone(),
                        });
                    }
                }
            }
        }

        // Fallback: check via git_infos
        if violations.is_empty() {
            for gi in ctx.git_infos {
                if !Self::path_matches(&gi.relative_path, target) {
                    continue;
                }
                if let Some(days) = gi.days_since_modified {
                    if days > threshold {
                        violations.push(RuleViolation {
                            rule_id: self.def.id.clone(),
                            category: self.def.category,
                            severity: self.def.severity,
                            file_path: Some(gi.relative_path.clone()),
                            title: format!("{}: {}", gi.relative_path, self.def.message),
                            attribution: format!(
                                "{} hasn't been updated in {} days (threshold: {})",
                                gi.relative_path, days, threshold
                            ),
                            suggestion: self.def.suggestion.clone(),
                        });
                    }
                }
            }
        }

        violations
    }

    fn check_content_match(
        &self,
        ctx: &RuleContext,
        target: &str,
        contains: Option<&str>,
        not_contains: Option<&str>,
    ) -> Vec<RuleViolation> {
        let mut violations = Vec::new();

        for (path, doc) in ctx.parsed_docs.iter() {
            if !Self::path_matches(path, target) {
                continue;
            }

            // Reconstruct content from parsed doc (headings as proxy)
            // For a proper implementation, we'd need the raw content.
            // For now, check heading text as a simple heuristic.
            let heading_text: String = doc
                .headings
                .iter()
                .map(|h| h.text.as_str())
                .collect::<Vec<_>>()
                .join(" ");

            if let Some(must_contain) = contains {
                if !heading_text.contains(must_contain) {
                    violations.push(RuleViolation {
                        rule_id: self.def.id.clone(),
                        category: self.def.category,
                        severity: self.def.severity,
                        file_path: Some(path.clone()),
                        title: format!("{}: {}", path, self.def.message),
                        attribution: format!(
                            "{} does not contain required text '{}'",
                            path, must_contain
                        ),
                        suggestion: self.def.suggestion.clone(),
                    });
                }
            }

            if let Some(must_not_contain) = not_contains {
                if heading_text.contains(must_not_contain) {
                    violations.push(RuleViolation {
                        rule_id: self.def.id.clone(),
                        category: self.def.category,
                        severity: self.def.severity,
                        file_path: Some(path.clone()),
                        title: format!("{}: {}", path, self.def.message),
                        attribution: format!(
                            "{} contains prohibited text '{}'",
                            path, must_not_contain
                        ),
                        suggestion: self.def.suggestion.clone(),
                    });
                }
            }
        }

        violations
    }

    fn check_regex(
        &self,
        ctx: &RuleContext,
        target: &str,
        pattern: &str,
        negate: bool,
    ) -> Vec<RuleViolation> {
        let re = match regex::Regex::new(pattern) {
            Ok(r) => r,
            Err(_) => return vec![], // Already validated at load time
        };

        let mut violations = Vec::new();

        for (path, doc) in ctx.parsed_docs.iter() {
            if !Self::path_matches(path, target) {
                continue;
            }

            let heading_text: String = doc
                .headings
                .iter()
                .map(|h| h.text.as_str())
                .collect::<Vec<_>>()
                .join("\n");

            let matches = re.is_match(&heading_text);

            if negate && matches {
                // Pattern should NOT match, but does
                violations.push(RuleViolation {
                    rule_id: self.def.id.clone(),
                    category: self.def.category,
                    severity: self.def.severity,
                    file_path: Some(path.clone()),
                    title: format!("{}: {}", path, self.def.message),
                    attribution: format!(
                        "{} matches prohibited pattern '{}'",
                        path, pattern
                    ),
                    suggestion: self.def.suggestion.clone(),
                });
            } else if !negate && !matches {
                // Pattern should match, but doesn't
                violations.push(RuleViolation {
                    rule_id: self.def.id.clone(),
                    category: self.def.category,
                    severity: self.def.severity,
                    file_path: Some(path.clone()),
                    title: format!("{}: {}", path, self.def.message),
                    attribution: format!(
                        "{} does not match required pattern '{}'",
                        path, pattern
                    ),
                    suggestion: self.def.suggestion.clone(),
                });
            }
        }

        violations
    }

    /// Check if a file path matches a target pattern.
    /// Supports exact match and glob-like patterns with `*`.
    fn path_matches(path: &str, target: &str) -> bool {
        if target == "*" {
            return true;
        }
        if target.contains('*') {
            // Simple glob: *.md, docs/*.md, etc.
            let parts: Vec<&str> = target.split('*').collect();
            if parts.len() == 2 {
                let (prefix, suffix) = (parts[0], parts[1]);
                return path.starts_with(prefix) && path.ends_with(suffix);
            }
        }
        path == target
    }
}

// ── Plugin Loader ──

/// A collection of YAML rules loaded from a directory.
#[derive(Debug)]
pub struct RulePlugin {
    /// Source directory path.
    pub source: PathBuf,
    /// Successfully loaded rules.
    pub rules: Vec<YamlRule>,
    /// Errors encountered during loading.
    pub errors: Vec<(PathBuf, YamlRuleError)>,
}

/// Discovers and loads YAML rule plugins from multiple directories.
pub struct PluginLoader;

impl PluginLoader {
    /// Load rules from a single YAML file.
    pub fn load_file(path: &Path) -> Result<Vec<YamlRule>, YamlRuleError> {
        let content = std::fs::read_to_string(path)
            .map_err(|e| YamlRuleError::ParseError(format!("Cannot read {}: {}", path.display(), e)))?;

        let (rules, errors) = YamlRule::from_yaml_multi(&content);
        if !errors.is_empty() && rules.is_empty() {
            return Err(errors.into_iter().next().unwrap());
        }

        Ok(rules)
    }

    /// Load all .yaml and .yml files from a directory.
    pub fn load_directory(dir: &Path) -> RulePlugin {
        let mut plugin = RulePlugin {
            source: dir.to_path_buf(),
            rules: Vec::new(),
            errors: Vec::new(),
        };

        if !dir.exists() || !dir.is_dir() {
            return plugin;
        }

        let entries = match std::fs::read_dir(dir) {
            Ok(e) => e,
            Err(_) => return plugin,
        };

        for entry in entries.flatten() {
            let path = entry.path();
            if !path.is_file() {
                continue;
            }

            let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
            if ext != "yaml" && ext != "yml" {
                continue;
            }

            match Self::load_file(&path) {
                Ok(rules) => plugin.rules.extend(rules),
                Err(e) => plugin.errors.push((path, e)),
            }
        }

        plugin
    }

    /// Discover and load rules from all standard locations:
    /// 1. `~/.kardo/plugins/` (global)
    /// 2. `<project>/.kardo/rules/` (project-local)
    pub fn discover(project_root: &Path) -> Vec<RulePlugin> {
        let mut plugins = Vec::new();

        // Global plugins
        if let Some(home) = dirs::home_dir() {
            let global_dir = home.join(".kardo").join("plugins");
            let plugin = Self::load_directory(&global_dir);
            if !plugin.rules.is_empty() || !plugin.errors.is_empty() {
                plugins.push(plugin);
            }
        }

        // Project-local rules
        let project_dir = project_root.join(".kardo").join("rules");
        let plugin = Self::load_directory(&project_dir);
        if !plugin.rules.is_empty() || !plugin.errors.is_empty() {
            plugins.push(plugin);
        }

        plugins
    }

    /// Load rules from a standard package directory (e.g., shipped rule packs).
    pub fn load_package(package_dir: &Path) -> RulePlugin {
        let mut combined = RulePlugin {
            source: package_dir.to_path_buf(),
            rules: Vec::new(),
            errors: Vec::new(),
        };

        if !package_dir.exists() || !package_dir.is_dir() {
            return combined;
        }

        // Load from standard/ subdirectory
        let standard_dir = package_dir.join("standard");
        if standard_dir.exists() {
            let plugin = Self::load_directory(&standard_dir);
            combined.rules.extend(plugin.rules);
            combined.errors.extend(plugin.errors);
        }

        // Load from presets/ subdirectory
        let presets_dir = package_dir.join("presets");
        if presets_dir.exists() {
            let plugin = Self::load_directory(&presets_dir);
            combined.rules.extend(plugin.rules);
            combined.errors.extend(plugin.errors);
        }

        // Load from root of package
        let root_plugin = Self::load_directory(package_dir);
        combined.rules.extend(root_plugin.rules);
        combined.errors.extend(root_plugin.errors);

        combined
    }
}

// ── Tests ──

#[cfg(test)]
mod tests {
    use super::*;
    use crate::analysis::staleness::{FileFreshness, FreshnessResult};
    use crate::parser::ParsedDocument;
    use crate::scanner::DiscoveredFile;
    use std::collections::{HashMap, HashSet};
    use std::path::PathBuf;

    fn make_file(relative_path: &str) -> DiscoveredFile {
        DiscoveredFile {
            path: PathBuf::from(relative_path),
            relative_path: relative_path.to_string(),
            size: 100,
            modified_at: None,
            extension: Some("md".to_string()),
            is_markdown: true,
            content_hash: "abc123".to_string(),
        }
    }

    fn empty_ctx_with_files(files: &[DiscoveredFile]) -> RuleContext<'_> {
        let known: &HashSet<String> = Box::leak(Box::new(
            files.iter().map(|f| f.relative_path.clone()).collect(),
        ));
        let parsed = Box::leak(Box::new(HashMap::<String, ParsedDocument>::new()));
        RuleContext {
            files,
            known_paths: known,
            parsed_docs: parsed,
            git_infos: &[],
            project_root: std::path::Path::new("/tmp/test"),
            freshness: None,
            integrity: None,
            config_quality: None,
            agent_setup: None,
            structure: None,
        }
    }

    // ── YamlRule parsing tests ──

    #[test]
    fn test_parse_file_missing_rule() {
        let yaml = r#"
id: "custom-missing-changelog"
name: "Missing CHANGELOG"
category: configuration
severity: medium
pattern:
  type: file_missing
  target: "CHANGELOG.md"
message: "Project is missing a CHANGELOG.md"
suggestion: "Create a CHANGELOG.md to track version history"
"#;
        let rule = YamlRule::from_yaml(yaml).expect("Should parse");
        assert_eq!(rule.id(), "custom-missing-changelog");
        assert_eq!(rule.name(), "Missing CHANGELOG");
        assert_eq!(rule.category(), RuleCategory::Configuration);
        assert_eq!(rule.default_severity(), Severity::Warning); // "medium" in YAML maps to Warning
    }

    #[test]
    fn test_parse_file_stale_rule() {
        let yaml = r#"
id: "custom-stale-readme"
name: "Stale README"
category: freshness
severity: high
pattern:
  type: file_stale
  target: "README.md"
  threshold: 60
message: "README.md is stale"
suggestion: "Update README.md"
"#;
        let rule = YamlRule::from_yaml(yaml).expect("Should parse");
        assert_eq!(rule.id(), "custom-stale-readme");
        if let YamlPattern::FileStale { threshold, .. } = &rule.def.pattern {
            assert_eq!(*threshold, 60);
        } else {
            panic!("Expected FileStale pattern");
        }
    }

    #[test]
    fn test_parse_content_match_rule() {
        let yaml = r#"
id: "custom-content-check"
name: "Content Check"
category: configuration
severity: low
pattern:
  type: content_match
  target: "CLAUDE.md"
  contains: "MUST"
message: "CLAUDE.md should contain MUST directives"
"#;
        let rule = YamlRule::from_yaml(yaml).expect("Should parse");
        assert_eq!(rule.id(), "custom-content-check");
    }

    #[test]
    fn test_parse_regex_rule() {
        let yaml = r#"
id: "custom-regex-check"
name: "Regex Check"
category: structure
severity: medium
pattern:
  type: regex
  target: "*.md"
  pattern: "TODO|FIXME|HACK"
  negate: true
message: "Documentation should not contain TODO markers"
"#;
        let rule = YamlRule::from_yaml(yaml).expect("Should parse");
        assert_eq!(rule.id(), "custom-regex-check");
    }

    #[test]
    fn test_parse_multi_rules() {
        let yaml = r#"
- id: "rule-1"
  name: "Rule 1"
  category: freshness
  severity: high
  pattern:
    type: file_missing
    target: "README.md"
  message: "Missing README"

- id: "rule-2"
  name: "Rule 2"
  category: configuration
  severity: low
  pattern:
    type: file_missing
    target: "CLAUDE.md"
  message: "Missing CLAUDE.md"
"#;
        let (rules, errors) = YamlRule::from_yaml_multi(yaml);
        assert_eq!(rules.len(), 2);
        assert!(errors.is_empty());
    }

    // ── Validation tests ──

    #[test]
    fn test_invalid_empty_id() {
        let yaml = r#"
id: ""
name: "Test"
category: freshness
severity: high
pattern:
  type: file_missing
  target: "test.md"
message: "Test"
"#;
        let result = YamlRule::from_yaml(yaml);
        assert!(result.is_err());
    }

    #[test]
    fn test_invalid_id_with_spaces() {
        let yaml = r#"
id: "my rule"
name: "Test"
category: freshness
severity: high
pattern:
  type: file_missing
  target: "test.md"
message: "Test"
"#;
        let result = YamlRule::from_yaml(yaml);
        assert!(result.is_err());
    }

    #[test]
    fn test_invalid_empty_target() {
        let yaml = r#"
id: "test-rule"
name: "Test"
category: freshness
severity: high
pattern:
  type: file_missing
  target: ""
message: "Test"
"#;
        let result = YamlRule::from_yaml(yaml);
        assert!(result.is_err());
    }

    #[test]
    fn test_invalid_regex_pattern() {
        let yaml = r#"
id: "test-regex"
name: "Test"
category: freshness
severity: high
pattern:
  type: regex
  target: "test.md"
  pattern: "[invalid("
message: "Test"
"#;
        let result = YamlRule::from_yaml(yaml);
        assert!(result.is_err());
    }

    // ── Rule evaluation tests ──

    #[test]
    fn test_file_missing_rule_fires() {
        let yaml = r#"
id: "test-missing"
name: "Missing File"
category: configuration
severity: high
pattern:
  type: file_missing
  target: "CHANGELOG.md"
message: "CHANGELOG.md is missing"
suggestion: "Create CHANGELOG.md"
"#;
        let rule = YamlRule::from_yaml(yaml).unwrap();
        let files = vec![make_file("README.md")];
        let ctx = empty_ctx_with_files(&files);
        let violations = rule.evaluate(&ctx, &RuleConfig::default());
        assert_eq!(violations.len(), 1);
        assert_eq!(violations[0].rule_id, "test-missing");
    }

    #[test]
    fn test_file_missing_rule_passes() {
        let yaml = r#"
id: "test-missing"
name: "Missing File"
category: configuration
severity: high
pattern:
  type: file_missing
  target: "README.md"
message: "README.md is missing"
"#;
        let rule = YamlRule::from_yaml(yaml).unwrap();
        let files = vec![make_file("README.md")];
        let ctx = empty_ctx_with_files(&files);
        let violations = rule.evaluate(&ctx, &RuleConfig::default());
        assert!(violations.is_empty());
    }

    #[test]
    fn test_file_stale_rule_with_freshness_data() {
        let yaml = r#"
id: "test-stale"
name: "Stale File"
category: freshness
severity: medium
pattern:
  type: file_stale
  target: "README.md"
  threshold: 30
message: "README.md is stale"
"#;
        let rule = YamlRule::from_yaml(yaml).unwrap();

        let freshness = FreshnessResult {
            score: 0.5,
            file_scores: vec![FileFreshness {
                relative_path: "README.md".to_string(),
                score: 0.3,
                days_since_modified: Some(45),
                coupling_penalty: 0.0,
                importance_weight: 1.0,
            }],
        };

        let known = Box::leak(Box::new(HashSet::new()));
        let parsed = Box::leak(Box::new(HashMap::<String, ParsedDocument>::new()));
        let ctx = RuleContext {
            files: &[],
            known_paths: known,
            parsed_docs: parsed,
            git_infos: &[],
            project_root: std::path::Path::new("/tmp/test"),
            freshness: Some(&freshness),
            integrity: None,
            config_quality: None,
            agent_setup: None,
            structure: None,
        };

        let violations = rule.evaluate(&ctx, &RuleConfig::default());
        assert_eq!(violations.len(), 1);
        assert!(violations[0].attribution.contains("45 days"));
    }

    #[test]
    fn test_file_stale_rule_passes_when_fresh() {
        let yaml = r#"
id: "test-stale"
name: "Stale File"
category: freshness
severity: medium
pattern:
  type: file_stale
  target: "README.md"
  threshold: 30
message: "README.md is stale"
"#;
        let rule = YamlRule::from_yaml(yaml).unwrap();

        let freshness = FreshnessResult {
            score: 0.95,
            file_scores: vec![FileFreshness {
                relative_path: "README.md".to_string(),
                score: 0.95,
                days_since_modified: Some(5),
                coupling_penalty: 0.0,
                importance_weight: 1.0,
            }],
        };

        let known = Box::leak(Box::new(HashSet::new()));
        let parsed = Box::leak(Box::new(HashMap::<String, ParsedDocument>::new()));
        let ctx = RuleContext {
            files: &[],
            known_paths: known,
            parsed_docs: parsed,
            git_infos: &[],
            project_root: std::path::Path::new("/tmp/test"),
            freshness: Some(&freshness),
            integrity: None,
            config_quality: None,
            agent_setup: None,
            structure: None,
        };

        let violations = rule.evaluate(&ctx, &RuleConfig::default());
        assert!(violations.is_empty());
    }

    // ── Path matching tests ──

    #[test]
    fn test_path_matches_exact() {
        assert!(YamlRule::path_matches("README.md", "README.md"));
        assert!(!YamlRule::path_matches("README.md", "CHANGELOG.md"));
    }

    #[test]
    fn test_path_matches_wildcard() {
        assert!(YamlRule::path_matches("README.md", "*.md"));
        assert!(YamlRule::path_matches("docs/api.md", "docs/*.md"));
        assert!(!YamlRule::path_matches("README.txt", "*.md"));
    }

    #[test]
    fn test_path_matches_star_all() {
        assert!(YamlRule::path_matches("anything.md", "*"));
        assert!(YamlRule::path_matches("docs/nested/file.rs", "*"));
    }

    // ── Plugin loader tests ──

    #[test]
    fn test_load_nonexistent_directory() {
        let plugin = PluginLoader::load_directory(Path::new("/nonexistent/path"));
        assert!(plugin.rules.is_empty());
        assert!(plugin.errors.is_empty());
    }

    #[test]
    fn test_load_file_from_temp() {
        let dir = tempfile::tempdir().unwrap();
        let file_path = dir.path().join("test-rule.yaml");
        std::fs::write(
            &file_path,
            r#"
id: "test-temp"
name: "Temp Rule"
category: custom
severity: low
pattern:
  type: file_missing
  target: "test.md"
message: "Test file missing"
"#,
        )
        .unwrap();

        let rules = PluginLoader::load_file(&file_path).unwrap();
        assert_eq!(rules.len(), 1);
        assert_eq!(rules[0].id(), "test-temp");
    }

    #[test]
    fn test_load_directory_from_temp() {
        let dir = tempfile::tempdir().unwrap();

        // Create two YAML rule files
        std::fs::write(
            dir.path().join("rule1.yaml"),
            r#"
id: "dir-rule-1"
name: "Rule 1"
category: freshness
severity: high
pattern:
  type: file_missing
  target: "a.md"
message: "Missing a.md"
"#,
        )
        .unwrap();

        std::fs::write(
            dir.path().join("rule2.yml"),
            r#"
id: "dir-rule-2"
name: "Rule 2"
category: configuration
severity: medium
pattern:
  type: file_missing
  target: "b.md"
message: "Missing b.md"
"#,
        )
        .unwrap();

        // Also a non-yaml file that should be ignored
        std::fs::write(dir.path().join("notes.txt"), "not a rule").unwrap();

        let plugin = PluginLoader::load_directory(dir.path());
        assert_eq!(plugin.rules.len(), 2);
        assert!(plugin.errors.is_empty());
    }

    #[test]
    fn test_load_directory_with_invalid_file() {
        let dir = tempfile::tempdir().unwrap();

        std::fs::write(
            dir.path().join("bad.yaml"),
            "this is not valid yaml rule content: [[[",
        )
        .unwrap();

        let plugin = PluginLoader::load_directory(dir.path());
        assert!(plugin.rules.is_empty());
        assert_eq!(plugin.errors.len(), 1);
    }

    #[test]
    fn test_yaml_rule_error_display() {
        let e = YamlRuleError::InvalidId("bad id".to_string());
        assert!(e.to_string().contains("bad id"));

        let e = YamlRuleError::EmptyName;
        assert!(e.to_string().contains("empty"));

        let e = YamlRuleError::EmptyTarget;
        assert!(e.to_string().contains("empty"));

        let e = YamlRuleError::InvalidRegex {
            pattern: "[bad(".to_string(),
            error: "unclosed".to_string(),
        };
        assert!(e.to_string().contains("[bad("));

        let e = YamlRuleError::ParseError("oops".to_string());
        assert!(e.to_string().contains("oops"));
    }

    #[test]
    fn test_default_stale_threshold() {
        let yaml = r#"
id: "test-default-threshold"
name: "Default Threshold"
category: freshness
severity: medium
pattern:
  type: file_stale
  target: "README.md"
message: "Stale file"
"#;
        let rule = YamlRule::from_yaml(yaml).unwrap();
        if let YamlPattern::FileStale { threshold, .. } = &rule.def.pattern {
            assert_eq!(*threshold, 90); // default
        } else {
            panic!("Expected FileStale");
        }
    }
}