foundry_mcp/core/

validation.rs

//! Content validation logic

use crate::utils::validation::{
    conditional_error, conditional_suggestion, conditional_suggestions,
};

/// Content types that can be validated
#[derive(Debug, Clone, Copy)]
pub enum ContentType {
    Vision,
    TechStack,
    Summary,
    Spec,
    Notes,
    Tasks,
}

/// Validation result
pub struct ValidationResult {
    pub is_valid: bool,
    pub errors: Vec<String>,
    pub suggestions: Vec<String>,
}

/// Validate content based on type
pub fn validate_content(content_type: ContentType, content: &str) -> ValidationResult {
    match content_type {
        ContentType::Vision => validate_vision_content(content),
        ContentType::TechStack => validate_tech_stack_content(content),
        ContentType::Summary => validate_summary_content(content),
        ContentType::Spec => validate_spec_content(content),
        ContentType::Notes => validate_notes_content(content),
        ContentType::Tasks => validate_tasks_content(content),
    }
}

/// Validate vision content (2-4 paragraphs, 200+ characters)
fn validate_vision_content(content: &str) -> ValidationResult {
    let errors = conditional_error(
        content.len() < 200,
        "Vision content must be at least 200 characters",
    );

    let paragraphs_count = content
        .split("\n\n")
        .filter(|p| !p.trim().is_empty())
        .count();

    let lower_content = content.to_lowercase();

    // Context completeness scoring for future implementation
    let context_keywords = [
        "architecture",
        "integration",
        "dependencies",
        "business",
        "rationale",
        "context",
        "implementation",
        "approach",
    ];
    let context_score = context_keywords
        .iter()
        .filter(|&k| lower_content.contains(k))
        .count();

    let mut suggestions = conditional_suggestions(&[
        (
            paragraphs_count < 2,
            "Consider adding more paragraphs to provide comprehensive vision coverage",
        ),
        (
            !lower_content.contains("problem") && !lower_content.contains("solve"),
            "Consider including what problem this solves",
        ),
        (
            !lower_content.contains("target") && !lower_content.contains("user"),
            "Consider specifying target users or audience",
        ),
    ]);

    // Add context completeness suggestions
    if context_score < 3 {
        suggestions.push("Consider adding more context for future implementers (architectural decisions, business rationale, implementation approach)".to_string());
    }

    ValidationResult {
        is_valid: errors.is_empty(),
        errors,
        suggestions,
    }
}

/// Validate tech stack content (150+ characters)
fn validate_tech_stack_content(content: &str) -> ValidationResult {
    let errors = conditional_error(
        content.len() < 150,
        "Tech stack content must be at least 150 characters",
    );

    let lower_content = content.to_lowercase();
    let tech_keywords = [
        "language",
        "framework",
        "database",
        "deployment",
        "infrastructure",
    ];
    let has_tech = tech_keywords
        .iter()
        .any(|&keyword| lower_content.contains(keyword));

    let suggestions = conditional_suggestion(
        !has_tech,
        "Consider including specific technologies, frameworks, or deployment platforms",
    );

    ValidationResult {
        is_valid: errors.is_empty(),
        errors,
        suggestions,
    }
}

/// Validate summary content (100+ characters, concise)
fn validate_summary_content(content: &str) -> ValidationResult {
    let errors = conditional_error(
        content.len() < 100,
        "Summary content must be at least 100 characters",
    );

    let suggestions = conditional_suggestion(
        content.len() > 500,
        "Consider making the summary more concise (under 500 characters)",
    );

    ValidationResult {
        is_valid: errors.is_empty(),
        errors,
        suggestions,
    }
}

/// Validate spec content
fn validate_spec_content(content: &str) -> ValidationResult {
    let errors = conditional_error(
        content.len() < 100,
        "Spec content must be at least 100 characters",
    );

    let lower_content = content.to_lowercase();
    let structure_keywords = ["requirements", "functionality", "behavior", "interface"];
    let has_structure = structure_keywords
        .iter()
        .any(|&keyword| lower_content.contains(keyword));

    // Context completeness scoring for future implementation
    let context_keywords = [
        "architecture",
        "integration",
        "dependencies",
        "business",
        "rationale",
        "implementation",
        "approach",
        "constraints",
        "edge",
        "validation",
    ];
    let context_score = context_keywords
        .iter()
        .filter(|&k| lower_content.contains(k))
        .count();

    let mut suggestions = conditional_suggestion(
        !has_structure,
        "Consider adding requirements, functionality, or behavioral specifications",
    );

    // Add context completeness suggestions
    if context_score < 4 {
        suggestions.push("Consider adding more implementation context (architecture, dependencies, business rationale, constraints, edge cases)".to_string());
    }

    ValidationResult {
        is_valid: errors.is_empty(),
        errors,
        suggestions,
    }
}

/// Validate notes content
fn validate_notes_content(content: &str) -> ValidationResult {
    let errors = conditional_error(
        content.len() < 50,
        "Notes content must be at least 50 characters",
    );

    let lower_content = content.to_lowercase();

    // Context completeness scoring for future implementation
    let context_keywords = [
        "rationale",
        "decision",
        "tradeoff",
        "constraint",
        "dependency",
        "business",
        "architecture",
        "integration",
        "why",
        "because",
    ];
    let context_score = context_keywords
        .iter()
        .filter(|&k| lower_content.contains(k))
        .count();

    let mut suggestions = Vec::new();

    // Add context completeness suggestions
    if context_score < 3 {
        suggestions.push("Consider adding more context for future implementers (decision rationale, tradeoffs, constraints, dependencies)".to_string());
    }

    ValidationResult {
        is_valid: errors.is_empty(),
        errors,
        suggestions,
    }
}

/// Validate tasks content
fn validate_tasks_content(content: &str) -> ValidationResult {
    let errors = conditional_error(
        content.len() < 30,
        "Tasks content must be at least 30 characters",
    );

    let lower_content = content.to_lowercase();
    let task_keywords = ["todo", "task", "implement", "create", "add", "-", "*"];
    let has_task_format = task_keywords
        .iter()
        .any(|&keyword| lower_content.contains(keyword));

    let suggestions = conditional_suggestion(
        !has_task_format,
        "Consider using task list format with - or * bullets or TODO items",
    );

    ValidationResult {
        is_valid: errors.is_empty(),
        errors,
        suggestions,
    }
}

/// Convert content type string to enum
pub fn parse_content_type(content_type: &str) -> anyhow::Result<ContentType> {
    match content_type.to_lowercase().as_str() {
        "vision" => Ok(ContentType::Vision),
        "tech-stack" => Ok(ContentType::TechStack),
        "summary" => Ok(ContentType::Summary),
        "spec" => Ok(ContentType::Spec),
        "notes" => Ok(ContentType::Notes),
        "tasks" => Ok(ContentType::Tasks),
        _ => Err(anyhow::anyhow!("Unknown content type: {}", content_type)),
    }
}

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

    #[test]
    fn test_validate_vision_content_too_short() {
        let content = "Too short";
        let result = validate_vision_content(content);

        assert!(!result.is_valid);
        assert_eq!(result.errors.len(), 1);
        assert!(result.errors[0].contains("200 characters"));
    }

    #[test]
    fn test_validate_tech_stack_content_too_short() {
        let content = "Too short";
        let result = validate_tech_stack_content(content);

        assert!(!result.is_valid);
        assert_eq!(result.errors.len(), 1);
        assert!(result.errors[0].contains("150 characters"));
    }

    #[test]
    fn test_validate_summary_content_too_short() {
        let content = "Too short";
        let result = validate_summary_content(content);

        assert!(!result.is_valid);
        assert_eq!(result.errors.len(), 1);
        assert!(result.errors[0].contains("100 characters"));
    }

    #[test]
    fn test_validate_spec_content_too_short() {
        let content = "Too short";
        let result = validate_spec_content(content);

        assert!(!result.is_valid);
        assert_eq!(result.errors.len(), 1);
        assert!(result.errors[0].contains("100 characters"));
    }

    #[test]
    fn test_validate_notes_content_too_short() {
        let content = "Too short";
        let result = validate_notes_content(content);

        assert!(!result.is_valid);
        assert_eq!(result.errors.len(), 1);
        assert!(result.errors[0].contains("50 characters"));
    }

    #[test]
    fn test_parse_content_type_valid() {
        assert!(matches!(
            parse_content_type("vision"),
            Ok(ContentType::Vision)
        ));
        assert!(matches!(
            parse_content_type("tech-stack"),
            Ok(ContentType::TechStack)
        ));
        assert!(matches!(
            parse_content_type("summary"),
            Ok(ContentType::Summary)
        ));
        assert!(matches!(parse_content_type("spec"), Ok(ContentType::Spec)));
        assert!(matches!(
            parse_content_type("notes"),
            Ok(ContentType::Notes)
        ));
    }

    #[test]
    fn test_parse_content_type_case_insensitive() {
        assert!(matches!(
            parse_content_type("VISION"),
            Ok(ContentType::Vision)
        ));
        assert!(matches!(
            parse_content_type("Tech-Stack"),
            Ok(ContentType::TechStack)
        ));
        assert!(matches!(
            parse_content_type("SUMMARY"),
            Ok(ContentType::Summary)
        ));
    }

    #[test]
    fn test_parse_content_type_invalid() {
        assert!(parse_content_type("invalid").is_err());
        assert!(parse_content_type("").is_err());
        assert!(parse_content_type("random").is_err());
    }
}