claude_priority/validators/

frontmatter.rs

use crate::models::{CheckType, SkillFrontmatter, ValidationResult};
use std::fs;
use std::path::Path;
use walkdir::WalkDir;

const VALID_LICENSES: &[&str] = &[
    "MIT",
    "Apache-2.0",
    "GPL-3.0",
    "BSD-3-Clause",
    "CC-BY-SA",
    "Unlicense",
];

pub fn validate_frontmatter(plugin_path: &Path) -> ValidationResult {
    let mut result = ValidationResult::new(CheckType::Frontmatter);
    let skills_dir = plugin_path.join("skills");

    if !skills_dir.exists() || !skills_dir.is_dir() {
        // No skills directory is okay
        return result;
    }

    // Find all skill.md files
    for entry in WalkDir::new(&skills_dir)
        .min_depth(2)
        .max_depth(2)
        .into_iter()
        .filter_map(|e| e.ok())
    {
        if entry.file_type().is_file() && entry.file_name() == "skill.md" {
            let skill_name = entry
                .path()
                .parent()
                .and_then(|p| p.file_name())
                .and_then(|n| n.to_str())
                .unwrap_or("unknown");

            validate_skill_frontmatter(entry.path(), skill_name, &mut result);
        }
    }

    // Check commands if they exist
    let commands_dir = plugin_path.join("commands");
    if commands_dir.exists() && commands_dir.is_dir() {
        for entry in WalkDir::new(&commands_dir)
            .min_depth(2)
            .max_depth(2)
            .into_iter()
            .filter_map(|e| e.ok())
        {
            if entry.file_type().is_file() && entry.file_name() == "command.md" {
                let command_name = entry
                    .path()
                    .parent()
                    .and_then(|p| p.file_name())
                    .and_then(|n| n.to_str())
                    .unwrap_or("unknown");

                validate_command_frontmatter(entry.path(), command_name, &mut result);
            }
        }
    }

    result
}

fn validate_skill_frontmatter(
    skill_md: &Path,
    skill_name: &str,
    result: &mut ValidationResult,
) {
    let content = match fs::read_to_string(skill_md) {
        Ok(c) => c,
        Err(e) => {
            result.add_error(format!("Failed to read skill.md in '{}': {}", skill_name, e));
            return;
        }
    };

    // Check for frontmatter markers
    if !content.starts_with("---") {
        result.add_error(format!("Missing frontmatter in skill: {}", skill_name));
        return;
    }

    // Extract frontmatter
    let frontmatter_str = match extract_frontmatter(&content) {
        Some(fm) => fm,
        None => {
            result.add_error(format!("Empty frontmatter in skill: {}", skill_name));
            return;
        }
    };

    // Parse YAML frontmatter
    let frontmatter: SkillFrontmatter = match serde_yaml::from_str(&frontmatter_str) {
        Ok(fm) => fm,
        Err(e) => {
            result.add_error(format!(
                "Invalid YAML frontmatter in skill '{}': {}",
                skill_name, e
            ));
            return;
        }
    };

    // Check required fields
    if frontmatter.name.is_empty() {
        result.add_error(format!("Missing 'name' in frontmatter: {}", skill_name));
    }

    if frontmatter.description.is_empty() {
        result.add_error(format!(
            "Missing 'description' in frontmatter: {}",
            skill_name
        ));
    } else {
        // Validate description length (10-200 chars for skills)
        let desc_len = frontmatter.description.len();
        if desc_len < 10 {
            result.add_error(format!(
                "Description too short in skill '{}' ({} chars, minimum 10)",
                skill_name, desc_len
            ));
        } else if desc_len > 200 {
            result.add_warning(format!(
                "Description very long in skill '{}' ({} chars, recommended max 200)",
                skill_name, desc_len
            ));
        }
    }

    // Validate license if present
    if let Some(license) = &frontmatter.license {
        if !VALID_LICENSES.contains(&license.as_str()) {
            result.add_warning(format!(
                "License '{}' in skill '{}' is not in the approved list: {:?}",
                license, skill_name, VALID_LICENSES
            ));
        }
    }

    // Check that title heading matches skill name
    if let Some(title_line) = content.lines().skip_while(|l| l.starts_with("---") || l.trim().is_empty()).next() {
        if title_line.starts_with("# ") {
            let title = title_line.trim_start_matches("# ").trim();
            if title.to_lowercase().replace(' ', "-") != skill_name {
                result.add_warning(format!(
                    "Title heading '{}' doesn't match skill directory '{}'",
                    title, skill_name
                ));
            }
        }
    }
}

fn validate_command_frontmatter(
    command_md: &Path,
    command_name: &str,
    result: &mut ValidationResult,
) {
    let content = match fs::read_to_string(command_md) {
        Ok(c) => c,
        Err(_) => return, // Commands frontmatter is optional
    };

    // Check for frontmatter markers
    if !content.starts_with("---") {
        return; // Optional for commands
    }

    // Extract frontmatter
    let frontmatter_str = match extract_frontmatter(&content) {
        Some(fm) => fm,
        None => return,
    };

    // Parse YAML frontmatter
    let frontmatter: SkillFrontmatter = match serde_yaml::from_str(&frontmatter_str) {
        Ok(fm) => fm,
        Err(e) => {
            result.add_error(format!(
                "Invalid YAML frontmatter in command '{}': {}",
                command_name, e
            ));
            return;
        }
    };

    // For commands, validate description length (5-100 chars)
    if !frontmatter.description.is_empty() {
        let desc_len = frontmatter.description.len();
        if desc_len < 5 {
            result.add_warning(format!(
                "Description too short in command '{}' ({} chars, minimum 5)",
                command_name, desc_len
            ));
        } else if desc_len > 100 {
            result.add_warning(format!(
                "Description long in command '{}' ({} chars, recommended max 100)",
                command_name, desc_len
            ));
        }
    }
}

fn extract_frontmatter(content: &str) -> Option<String> {
    let lines: Vec<&str> = content.lines().collect();
    if lines.is_empty() || lines[0] != "---" {
        return None;
    }

    let mut frontmatter_lines = Vec::new();
    for line in lines.iter().skip(1) {
        if *line == "---" {
            break;
        }
        frontmatter_lines.push(*line);
    }

    if frontmatter_lines.is_empty() {
        return None;
    }

    Some(frontmatter_lines.join("\n"))
}

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

    #[test]
    fn test_extract_frontmatter() {
        let content = "---\nname: test\ndescription: Test\n---\nContent";
        let fm = extract_frontmatter(content).unwrap();
        assert!(fm.contains("name: test"));
    }

    #[test]
    fn test_extract_frontmatter_empty() {
        let content = "---\n---\nContent";
        assert!(extract_frontmatter(content).is_none());
    }

    #[test]
    fn test_extract_frontmatter_missing() {
        let content = "No frontmatter here";
        assert!(extract_frontmatter(content).is_none());
    }
}