kardo_core/analysis/

agent_setup.rs

//! Agent setup infrastructure analysis.
//!
//! Evaluates the AI agent configuration quality of a project:
//! CLAUDE.md, .claude/ directory, MCP config, .cursorrules, other AI configs.

use serde::Serialize;
use std::fs;
use std::path::Path;

/// Weight constants for each signal group.
const W_CLAUDE_MD: f64 = 0.30;
const W_CLAUDE_DIR: f64 = 0.25;
const W_MCP: f64 = 0.20;
const W_CURSOR: f64 = 0.10;
const W_OTHER_AI: f64 = 0.15;

/// Result of agent setup infrastructure analysis.
#[derive(Debug, Clone, Serialize)]
pub struct AgentSetupResult {
    /// Weighted composite agent setup score (0.0-1.0).
    pub score: f64,
    /// CLAUDE.md presence and quality score.
    pub claude_md_score: f64,
    /// .claude/ directory structure completeness score.
    pub claude_dir_score: f64,
    /// MCP configuration (.mcp.json) quality score.
    pub mcp_score: f64,
    /// Cursor rules (.cursorrules / .cursor/rules) presence score.
    pub cursor_score: f64,
    /// Other AI tool config files (Copilot, Windsurf, Aider, etc.) score.
    pub other_ai_score: f64,
    /// Individual check results with pass/fail details.
    pub details: Vec<AgentSetupDetail>,
}

/// Individual check detail.
#[derive(Debug, Clone, Serialize)]
pub struct AgentSetupDetail {
    /// Human-readable description of what was checked.
    pub check: String,
    /// Whether this check passed (file/directory found and valid).
    pub found: bool,
    /// Relative path of the detected file or directory, if found.
    pub path: Option<String>,
}

pub struct AgentSetupAnalyzer;

impl AgentSetupAnalyzer {
    /// Analyze agent setup infrastructure in the project directory.
    pub fn analyze(project_root: &Path) -> AgentSetupResult {
        let mut details = Vec::new();

        let claude_md_score = Self::check_claude_md(project_root, &mut details);
        let claude_dir_score = Self::check_claude_dir(project_root, &mut details);
        let mcp_score = Self::check_mcp(project_root, &mut details);
        let cursor_score = Self::check_cursor(project_root, &mut details, claude_md_score > 0.0);
        let other_ai_score = Self::check_other_ai(project_root, &mut details);

        let score = W_CLAUDE_MD * claude_md_score
            + W_CLAUDE_DIR * claude_dir_score
            + W_MCP * mcp_score
            + W_CURSOR * cursor_score
            + W_OTHER_AI * other_ai_score;

        AgentSetupResult {
            score,
            claude_md_score,
            claude_dir_score,
            mcp_score,
            cursor_score,
            other_ai_score,
            details,
        }
    }

    /// Check CLAUDE.md presence and quality (weight 0.30).
    fn check_claude_md(root: &Path, details: &mut Vec<AgentSetupDetail>) -> f64 {
        let path = root.join("CLAUDE.md");
        let exists = path.exists();
        details.push(AgentSetupDetail {
            check: "CLAUDE.md exists".to_string(),
            found: exists,
            path: if exists { Some("CLAUDE.md".to_string()) } else { None },
        });

        if !exists {
            return 0.0;
        }

        let content = fs::read_to_string(&path).unwrap_or_default();
        let len = content.len();

        let mut score: f64 = 0.5; // base for existence

        if len > 2000 {
            score += 0.3; // total 0.8 for >2000
        } else if len > 500 {
            score += 0.2; // total 0.7 for >500
        }

        // Structured: has markdown headings
        let has_headings = content.lines().any(|l| l.starts_with('#'));
        if has_headings {
            score = (score + 0.1).min(1.0);
        }

        details.push(AgentSetupDetail {
            check: format!("CLAUDE.md length: {} chars", len),
            found: len > 500,
            path: Some("CLAUDE.md".to_string()),
        });

        score
    }

    /// Check .claude/ directory structure (weight 0.25).
    fn check_claude_dir(root: &Path, details: &mut Vec<AgentSetupDetail>) -> f64 {
        let mut score = 0.0;

        let instructions = root.join(".claude/instructions");
        let has_instructions = instructions.exists();
        details.push(AgentSetupDetail {
            check: ".claude/instructions exists".to_string(),
            found: has_instructions,
            path: if has_instructions { Some(".claude/instructions".to_string()) } else { None },
        });
        if has_instructions {
            score += 0.3;
        }

        let subdirs = [
            ("commands", 0.2),
            ("agents", 0.2),
            ("skills", 0.15),
            ("hooks", 0.15),
        ];

        for (name, weight) in &subdirs {
            let dir = root.join(format!(".claude/{}", name));
            let has_files = dir.is_dir() && Self::dir_has_files(&dir);
            details.push(AgentSetupDetail {
                check: format!(".claude/{}/ with files", name),
                found: has_files,
                path: if has_files { Some(format!(".claude/{}/", name)) } else { None },
            });
            if has_files {
                score += weight;
            }
        }

        score
    }

    /// Check MCP configuration (weight 0.20).
    fn check_mcp(root: &Path, details: &mut Vec<AgentSetupDetail>) -> f64 {
        let mcp_path = root.join(".mcp.json");
        let mcp_example = root.join(".mcp.json.example");

        if mcp_path.exists() {
            details.push(AgentSetupDetail {
                check: ".mcp.json exists".to_string(),
                found: true,
                path: Some(".mcp.json".to_string()),
            });

            let mut score = 0.5;

            // Try to parse and count servers
            if let Ok(content) = fs::read_to_string(&mcp_path) {
                if let Ok(json) = serde_json::from_str::<serde_json::Value>(&content) {
                    let server_count = json
                        .get("mcpServers")
                        .and_then(|v| v.as_object())
                        .map(|obj| obj.len())
                        .unwrap_or(0);

                    details.push(AgentSetupDetail {
                        check: format!("MCP servers configured: {}", server_count),
                        found: server_count > 0,
                        path: Some(".mcp.json".to_string()),
                    });

                    if server_count >= 3 {
                        score += 0.5; // total 1.0
                    } else if server_count >= 1 {
                        score += 0.25; // total 0.75
                    }
                }
            }

            score
        } else if mcp_example.exists() {
            details.push(AgentSetupDetail {
                check: ".mcp.json.example exists".to_string(),
                found: true,
                path: Some(".mcp.json.example".to_string()),
            });
            0.3
        } else {
            details.push(AgentSetupDetail {
                check: ".mcp.json exists".to_string(),
                found: false,
                path: None,
            });
            0.0
        }
    }

    /// Check .cursorrules / .cursor/rules (weight 0.10).
    fn check_cursor(root: &Path, details: &mut Vec<AgentSetupDetail>, has_claude_md: bool) -> f64 {
        let cursorrules = root.join(".cursorrules");
        let cursor_rules = root.join(".cursor/rules");

        let found = cursorrules.exists() || cursor_rules.exists();
        let path_str = if cursorrules.exists() {
            Some(".cursorrules".to_string())
        } else if cursor_rules.exists() {
            Some(".cursor/rules".to_string())
        } else {
            None
        };

        details.push(AgentSetupDetail {
            check: ".cursorrules or .cursor/rules exists".to_string(),
            found,
            path: path_str,
        });

        if found {
            1.0
        } else if has_claude_md {
            0.5 // Partial: CLAUDE.md exists but no cursor config
        } else {
            0.0
        }
    }

    /// Check other AI config files (weight 0.15).
    fn check_other_ai(root: &Path, details: &mut Vec<AgentSetupDetail>) -> f64 {
        let mut score = 0.0;

        let checks: &[(&str, f64)] = &[
            (".github/copilot-instructions.md", 0.3),
            ("coderabbit.yaml", 0.2),
            (".windsurfrules", 0.2),
            (".clinerules", 0.2),
            ("AGENTS.md", 0.3),
        ];

        for (path, weight) in checks {
            let full = root.join(path);
            let found = full.exists();
            details.push(AgentSetupDetail {
                check: format!("{} exists", path),
                found,
                path: if found { Some(path.to_string()) } else { None },
            });
            if found {
                score += weight;
            }
        }

        // Check aider: .aider.conf.yml or .aider/ directory
        let aider_conf = root.join(".aider.conf.yml");
        let aider_dir = root.join(".aider");
        let has_aider = aider_conf.exists() || aider_dir.is_dir();
        details.push(AgentSetupDetail {
            check: ".aider config exists".to_string(),
            found: has_aider,
            path: if aider_conf.exists() {
                Some(".aider.conf.yml".to_string())
            } else if aider_dir.is_dir() {
                Some(".aider/".to_string())
            } else {
                None
            },
        });
        if has_aider {
            score += 0.3;
        }

        // Check any .ai/ or .ai-* config
        let ai_dir = root.join(".ai");
        let has_ai_dir = ai_dir.is_dir();
        if !has_ai_dir {
            // Check for .ai-* files
            if let Ok(entries) = fs::read_dir(root) {
                for entry in entries.flatten() {
                    let name = entry.file_name();
                    let name = name.to_string_lossy();
                    if name.starts_with(".ai-") || name.starts_with(".ai/") {
                        details.push(AgentSetupDetail {
                            check: "AI config directory/file exists".to_string(),
                            found: true,
                            path: Some(name.to_string()),
                        });
                        score += 0.2;
                        return score.min(1.0);
                    }
                }
            }
        } else {
            details.push(AgentSetupDetail {
                check: ".ai/ directory exists".to_string(),
                found: true,
                path: Some(".ai/".to_string()),
            });
            score += 0.2;
        }

        score.min(1.0)
    }

    /// Check if a directory contains at least one file.
    fn dir_has_files(dir: &Path) -> bool {
        fs::read_dir(dir)
            .map(|entries| entries.flatten().any(|e| e.file_type().map(|t| t.is_file()).unwrap_or(false)))
            .unwrap_or(false)
    }
}

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

    fn setup_project(setup: impl FnOnce(&Path)) -> (TempDir, AgentSetupResult) {
        let dir = TempDir::new().unwrap();
        setup(dir.path());
        let result = AgentSetupAnalyzer::analyze(dir.path());
        (dir, result)
    }

    #[test]
    fn test_empty_project_zero_score() {
        let (_dir, result) = setup_project(|_| {});
        assert!(
            result.score < 0.01,
            "Empty project should score ~0, got {}",
            result.score
        );
        assert_eq!(result.claude_md_score, 0.0);
        assert_eq!(result.claude_dir_score, 0.0);
        assert_eq!(result.mcp_score, 0.0);
    }

    #[test]
    fn test_project_with_claude_md_and_dir() {
        let (_dir, result) = setup_project(|root| {
            // Large CLAUDE.md with headings
            let content = format!(
                "# Project\n\n## Rules\n\nYou MUST follow these rules.\n\n{}\n",
                "x".repeat(3000)
            );
            fs::write(root.join("CLAUDE.md"), content).unwrap();

            // .claude/ directory with instructions and commands
            fs::create_dir_all(root.join(".claude/commands")).unwrap();
            fs::write(root.join(".claude/instructions"), "Instructions here").unwrap();
            fs::write(root.join(".claude/commands/build.md"), "Build command").unwrap();
        });

        assert!(
            result.claude_md_score >= 0.9,
            "Large structured CLAUDE.md should score >= 0.9, got {}",
            result.claude_md_score
        );
        assert!(
            result.claude_dir_score >= 0.5,
            "Dir with instructions + commands should score >= 0.5, got {}",
            result.claude_dir_score
        );
        assert!(
            result.score > 0.3,
            "Project with CLAUDE.md + .claude/ should score > 0.3, got {}",
            result.score
        );
    }

    #[test]
    fn test_project_with_no_ai_config_only_readme() {
        let (_dir, result) = setup_project(|root| {
            fs::write(root.join("README.md"), "# My Project\nDescription.").unwrap();
        });

        assert!(
            result.score < 0.15,
            "Project with only README should have low score, got {}",
            result.score
        );
        assert_eq!(result.claude_md_score, 0.0);
    }

    #[test]
    fn test_mcp_config_with_servers() {
        let (_dir, result) = setup_project(|root| {
            let mcp_json = r#"{
                "mcpServers": {
                    "context7": {"command": "npx", "args": ["context7"]},
                    "exa": {"command": "npx", "args": ["exa"]},
                    "memory": {"command": "npx", "args": ["memory"]}
                }
            }"#;
            fs::write(root.join(".mcp.json"), mcp_json).unwrap();
        });

        assert!(
            (result.mcp_score - 1.0).abs() < 0.01,
            "MCP with 3+ servers should score 1.0, got {}",
            result.mcp_score
        );
    }

    #[test]
    fn test_cursorrules_exists() {
        let (_dir, result) = setup_project(|root| {
            fs::write(root.join(".cursorrules"), "Cursor rules here").unwrap();
        });

        assert!(
            (result.cursor_score - 1.0).abs() < 0.01,
            ".cursorrules should give cursor_score = 1.0, got {}",
            result.cursor_score
        );
    }

    #[test]
    fn test_cursorrules_partial_when_claude_md_exists() {
        let (_dir, result) = setup_project(|root| {
            fs::write(root.join("CLAUDE.md"), "# Project\nRules.").unwrap();
            // No .cursorrules
        });

        assert!(
            (result.cursor_score - 0.5).abs() < 0.01,
            "No .cursorrules but CLAUDE.md → cursor_score = 0.5, got {}",
            result.cursor_score
        );
    }

    #[test]
    fn test_full_ai_setup_high_score() {
        let (_dir, result) = setup_project(|root| {
            // CLAUDE.md
            let content = format!("# Project\n\n## Rules\n\n{}\n", "y".repeat(3000));
            fs::write(root.join("CLAUDE.md"), content).unwrap();

            // .claude/ full setup
            fs::create_dir_all(root.join(".claude/commands")).unwrap();
            fs::create_dir_all(root.join(".claude/agents")).unwrap();
            fs::create_dir_all(root.join(".claude/skills")).unwrap();
            fs::create_dir_all(root.join(".claude/hooks")).unwrap();
            fs::write(root.join(".claude/instructions"), "Full instructions").unwrap();
            fs::write(root.join(".claude/commands/build.md"), "cmd").unwrap();
            fs::write(root.join(".claude/agents/reviewer.md"), "agent").unwrap();
            fs::write(root.join(".claude/skills/debug.md"), "skill").unwrap();
            fs::write(root.join(".claude/hooks/pre-commit.md"), "hook").unwrap();

            // MCP
            let mcp = r#"{"mcpServers":{"a":{},"b":{},"c":{}}}"#;
            fs::write(root.join(".mcp.json"), mcp).unwrap();

            // Cursor
            fs::write(root.join(".cursorrules"), "rules").unwrap();

            // Other AI
            fs::create_dir_all(root.join(".github")).unwrap();
            fs::write(root.join(".github/copilot-instructions.md"), "copilot").unwrap();
        });

        assert!(
            result.score > 0.85,
            "Full AI setup should score > 0.85, got {}",
            result.score
        );
    }

    #[test]
    fn test_windsurfrules_detected() {
        let (_dir, result) = setup_project(|root| {
            fs::write(root.join(".windsurfrules"), "Windsurf rules here").unwrap();
        });
        assert!(
            result.other_ai_score > 0.0,
            ".windsurfrules should contribute to other_ai_score, got {}",
            result.other_ai_score
        );
    }

    #[test]
    fn test_agents_md_standalone_detected() {
        let (_dir, result) = setup_project(|root| {
            fs::write(root.join("AGENTS.md"), "# Agents\n\n## Agent 1\nAgent config.").unwrap();
        });
        assert!(
            result.other_ai_score > 0.0,
            "Standalone AGENTS.md should contribute to other_ai_score, got {}",
            result.other_ai_score
        );
    }

    #[test]
    fn test_clinerules_detected() {
        let (_dir, result) = setup_project(|root| {
            fs::write(root.join(".clinerules"), "Cline rules").unwrap();
        });
        assert!(
            result.other_ai_score > 0.0,
            ".clinerules should contribute to other_ai_score, got {}",
            result.other_ai_score
        );
    }

    #[test]
    fn test_mcp_example_only() {
        let (_dir, result) = setup_project(|root| {
            fs::write(root.join(".mcp.json.example"), "{}").unwrap();
        });

        assert!(
            (result.mcp_score - 0.3).abs() < 0.01,
            ".mcp.json.example should score 0.3, got {}",
            result.mcp_score
        );
    }
}