roboticus_cli/cli/

defrag.rs

#![allow(non_snake_case, unused_variables)]

use std::collections::HashMap;
use std::fs;
use std::io::Write;
use std::path::{Path, PathBuf};

use regex::Regex;
use serde::{Deserialize, Serialize};

use super::{CRT_DRAW_MS, colors, icons, theme};

// ── Types ───────────────────────────────────────────────────────

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DefragFinding {
    pub file: PathBuf,
    pub line: Option<usize>,
    pub severity: Severity,
    pub message: String,
    pub fix_description: Option<String>,
    pub fixable: bool,
    pub pass_name: String,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Severity {
    Info,
    Warning,
    Error,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DefragSummary {
    pub total_findings: usize,
    pub fixable_count: usize,
    pub by_severity: SeverityCounts,
    pub by_pass: Vec<PassSummary>,
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct SeverityCounts {
    pub info: usize,
    pub warning: usize,
    pub error: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PassSummary {
    pub name: String,
    pub findings: usize,
    pub status: PassStatus,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum PassStatus {
    Clean,
    Findings,
    Error,
}

// ── Helpers ─────────────────────────────────────────────────────

fn migration_map() -> HashMap<&'static str, &'static str> {
    let mut m = HashMap::new();
    m.insert("legacy", "roboticus");
    m.insert("open_legacy", "roboticus");
    m.insert("Legacy", "Roboticus");
    m.insert("olegacy", "roboticus");
    m
}

fn walk_files(dir: &Path, extensions: &[&str]) -> Vec<PathBuf> {
    let mut result = Vec::new();
    walk_files_inner(dir, extensions, &mut result);
    result
}

fn walk_files_inner(dir: &Path, extensions: &[&str], out: &mut Vec<PathBuf>) {
    let entries = match fs::read_dir(dir) {
        Ok(e) => e,
        Err(_) => return,
    };
    for entry in entries.flatten() {
        let path = entry.path();
        if path.is_dir() {
            // Skip hidden directories and common build artifacts
            let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
            if name.starts_with('.') || name == "target" || name == "node_modules" {
                continue;
            }
            walk_files_inner(&path, extensions, out);
        } else if path.is_file() {
            if extensions.is_empty() {
                out.push(path);
            } else if let Some(ext) = path.extension().and_then(|e| e.to_str())
                && extensions.contains(&ext)
            {
                out.push(path);
            }
        }
    }
}

fn walk_all_entries(dir: &Path) -> Vec<PathBuf> {
    let mut result = Vec::new();
    walk_all_entries_inner(dir, &mut result);
    result
}

fn walk_all_entries_inner(dir: &Path, out: &mut Vec<PathBuf>) {
    let entries = match fs::read_dir(dir) {
        Ok(e) => e,
        Err(_) => return,
    };
    for entry in entries.flatten() {
        let path = entry.path();
        out.push(path.clone());
        if path.is_dir() {
            walk_all_entries_inner(&path, out);
        }
    }
}

fn is_dir_empty(path: &Path) -> bool {
    match fs::read_dir(path) {
        Ok(mut entries) => entries.next().is_none(),
        Err(_) => false,
    }
}

// ── Pass 1: Stale references ────────────────────────────────────

pub fn pass_refs(workspace: &Path) -> Vec<DefragFinding> {
    let mut findings = Vec::new();
    let map = migration_map();
    let extensions = &["md", "sh", "py", "js", "toml", "json"];
    let files = walk_files(workspace, extensions);

    // Build a single regex matching all old names (case-sensitive)
    let pattern = map.keys().copied().collect::<Vec<_>>().join("|");
    let re = match Regex::new(&pattern) {
        Ok(r) => r,
        Err(_) => return findings,
    };

    for file in files {
        let content = match fs::read_to_string(&file) {
            Ok(c) => c,
            Err(_) => continue,
        };
        for (line_num, line) in content.lines().enumerate() {
            for m in re.find_iter(line) {
                let old = m.as_str();
                let new = map.get(old).copied().unwrap_or("roboticus");
                findings.push(DefragFinding {
                    file: file.clone(),
                    line: Some(line_num + 1),
                    severity: Severity::Warning,
                    message: format!("stale reference '{old}' should be '{new}'"),
                    fix_description: Some(format!("replace '{old}' with '{new}'")),
                    fixable: true,
                    pass_name: "refs".to_string(),
                });
            }
        }
    }
    findings
}

// ── Pass 2: Config drift ────────────────────────────────────────

pub fn pass_drift(workspace: &Path) -> Vec<DefragFinding> {
    let mut findings = Vec::new();
    let config_path = workspace.join("roboticus.toml");
    let config_content = match fs::read_to_string(&config_path) {
        Ok(c) => c,
        Err(_) => return findings, // No config file, nothing to check
    };

    let config: toml::Value = match config_content.parse() {
        Ok(v) => v,
        Err(_) => return findings,
    };

    // Extract config values to check
    let port = config
        .get("server")
        .and_then(|s| s.get("port"))
        .and_then(|p| p.as_integer())
        .map(|p| p.to_string());
    let bind = config
        .get("server")
        .and_then(|s| s.get("bind"))
        .and_then(|b| b.as_str())
        .map(|s| s.to_string());
    let agent_name = config
        .get("agent")
        .and_then(|a| a.get("name"))
        .and_then(|n| n.as_str())
        .map(|s| s.to_string());

    let port_re = Regex::new(r"(?:port\s*[=:]\s*|localhost:)(\d{4,5})").ok();
    let bind_re = Regex::new(r"(?:bind\s*[=:]\s*)([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)").ok();
    let name_re = Regex::new(r#"(?:agent[_\s-]?name\s*[=:"]\s*)(\w+)"#).ok();

    let md_files = walk_files(workspace, &["md"]);
    for file in md_files {
        let content = match fs::read_to_string(&file) {
            Ok(c) => c,
            Err(_) => continue,
        };
        // Check for port references that differ from config
        if let Some(ref cfg_port) = port
            && let Some(ref port_re) = port_re
        {
            for (line_num, line) in content.lines().enumerate() {
                for cap in port_re.captures_iter(line) {
                    if let Some(found_port) = cap.get(1) {
                        let found = found_port.as_str();
                        if found != cfg_port.as_str() {
                            findings.push(DefragFinding {
                                file: file.clone(),
                                line: Some(line_num + 1),
                                severity: Severity::Info,
                                message: format!(
                                    "references port {found} but config uses {cfg_port}"
                                ),
                                fix_description: None,
                                fixable: false,
                                pass_name: "drift".to_string(),
                            });
                        }
                    }
                }
            }
        }
        // Check for bind address references that differ from config
        if let Some(ref cfg_bind) = bind
            && let Some(ref bind_re) = bind_re
        {
            for (line_num, line) in content.lines().enumerate() {
                for cap in bind_re.captures_iter(line) {
                    if let Some(found_bind) = cap.get(1) {
                        let found = found_bind.as_str();
                        if found != cfg_bind.as_str() {
                            findings.push(DefragFinding {
                                file: file.clone(),
                                line: Some(line_num + 1),
                                severity: Severity::Info,
                                message: format!(
                                    "references bind address {found} but config uses {cfg_bind}"
                                ),
                                fix_description: None,
                                fixable: false,
                                pass_name: "drift".to_string(),
                            });
                        }
                    }
                }
            }
        }
        // Check for agent name references that differ from config
        if let Some(ref cfg_name) = agent_name
            && let Some(ref name_re) = name_re
        {
            for (line_num, line) in content.lines().enumerate() {
                for cap in name_re.captures_iter(line) {
                    if let Some(found_name) = cap.get(1) {
                        let found = found_name.as_str();
                        if found != cfg_name.as_str() {
                            findings.push(DefragFinding {
                                file: file.clone(),
                                line: Some(line_num + 1),
                                severity: Severity::Info,
                                message: format!(
                                    "references agent name '{found}' but config uses '{cfg_name}'"
                                ),
                                fix_description: None,
                                fixable: false,
                                pass_name: "drift".to_string(),
                            });
                        }
                    }
                }
            }
        }
    }
    findings
}

// ── Pass 3: Build artifacts ─────────────────────────────────────

pub fn pass_artifacts(workspace: &Path) -> Vec<DefragFinding> {
    let mut findings = Vec::new();
    let skills_dir = workspace.join("skills");
    if !skills_dir.is_dir() {
        return findings;
    }

    let entries = walk_all_entries(&skills_dir);
    for path in entries {
        let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
        let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");

        if ext == "log" && path.is_file() {
            findings.push(DefragFinding {
                file: path,
                line: None,
                severity: Severity::Info,
                message: "stale log file in skills directory".to_string(),
                fix_description: Some("delete log file".to_string()),
                fixable: true,
                pass_name: "artifacts".to_string(),
            });
        } else if name == "__pycache__" && path.is_dir() {
            findings.push(DefragFinding {
                file: path,
                line: None,
                severity: Severity::Info,
                message: "__pycache__ directory in skills".to_string(),
                fix_description: Some("delete __pycache__ directory".to_string()),
                fixable: true,
                pass_name: "artifacts".to_string(),
            });
        } else if ext == "bak" && path.is_file() {
            findings.push(DefragFinding {
                file: path,
                line: None,
                severity: Severity::Warning,
                message: "backup file in skills directory".to_string(),
                fix_description: Some("delete backup file".to_string()),
                fixable: true,
                pass_name: "artifacts".to_string(),
            });
        } else if path.is_dir() && is_dir_empty(&path) {
            findings.push(DefragFinding {
                file: path,
                line: None,
                severity: Severity::Info,
                message: "empty directory in skills".to_string(),
                fix_description: Some("remove empty directory".to_string()),
                fixable: true,
                pass_name: "artifacts".to_string(),
            });
        }
    }
    findings
}

// ── Pass 4: Stale state entries ─────────────────────────────────

pub fn pass_stale(workspace: &Path) -> Vec<DefragFinding> {
    let mut findings = Vec::new();
    let state_path = workspace.join(".roboticus").join("update_state.json");
    let content = match fs::read_to_string(&state_path) {
        Ok(c) => c,
        Err(_) => return findings,
    };

    let state: serde_json::Value = match serde_json::from_str(&content) {
        Ok(v) => v,
        Err(_) => return findings,
    };

    // Check for entries that reference files which no longer exist
    if let Some(obj) = state.as_object() {
        for (key, value) in obj {
            if let Some(path_str) = value.as_str() {
                let target = workspace.join(path_str);
                if !target.exists() {
                    findings.push(DefragFinding {
                        file: state_path.clone(),
                        line: None,
                        severity: Severity::Warning,
                        message: format!("ghost entry '{key}' references missing file: {path_str}"),
                        fix_description: Some(format!(
                            "remove entry '{key}' from update_state.json"
                        )),
                        fixable: true,
                        pass_name: "stale".to_string(),
                    });
                }
            }
            // Also handle entries where the value is an object with a "path" field
            if let Some(inner_obj) = value.as_object()
                && let Some(path_str) = inner_obj.get("path").and_then(|p| p.as_str())
            {
                let target = workspace.join(path_str);
                if !target.exists() {
                    findings.push(DefragFinding {
                        file: state_path.clone(),
                        line: None,
                        severity: Severity::Warning,
                        message: format!("ghost entry '{key}' references missing file: {path_str}"),
                        fix_description: Some(format!(
                            "remove entry '{key}' from update_state.json"
                        )),
                        fixable: true,
                        pass_name: "stale".to_string(),
                    });
                }
            }
        }
    }
    findings
}

// ── Pass 5: Brand identity ──────────────────────────────────────

pub fn pass_identity(workspace: &Path) -> Vec<DefragFinding> {
    let mut findings = Vec::new();
    let map = migration_map();
    let files = walk_files(workspace, &["toml", "json"]);

    let old_brands: Vec<&str> = map.keys().copied().collect();
    let brand_pattern = old_brands.join("|");
    let re = match Regex::new(&format!(
        r#"(?:generated_by|brand)\s*[=:]\s*["']?({brand_pattern})"#
    )) {
        Ok(r) => r,
        Err(_) => return findings,
    };

    for file in files {
        let content = match fs::read_to_string(&file) {
            Ok(c) => c,
            Err(_) => continue,
        };
        for (line_num, line) in content.lines().enumerate() {
            for cap in re.captures_iter(line) {
                if let Some(m) = cap.get(1) {
                    let old = m.as_str();
                    let new = map.get(old).copied().unwrap_or("roboticus");
                    findings.push(DefragFinding {
                        file: file.clone(),
                        line: Some(line_num + 1),
                        severity: Severity::Warning,
                        message: format!("brand identity field references '{old}'"),
                        fix_description: Some(format!("replace '{old}' with '{new}'")),
                        fixable: true,
                        pass_name: "identity".to_string(),
                    });
                }
            }
        }
    }
    findings
}

// ── Pass 6: Script validation ───────────────────────────────────

pub fn pass_scripts(workspace: &Path) -> Vec<DefragFinding> {
    let mut findings = Vec::new();
    let skills_dir = workspace.join("skills");
    if !skills_dir.is_dir() {
        return findings;
    }

    let script_files = walk_files(&skills_dir, &["sh", "py", "rb", "pl"]);
    let shebang_re = Regex::new(r"^#!.+").unwrap();
    let hardcoded_re = Regex::new(r"/usr/local/bin/legacy").unwrap();

    for file in script_files {
        let content = match fs::read_to_string(&file) {
            Ok(c) => c,
            Err(_) => continue,
        };
        let lines: Vec<&str> = content.lines().collect();

        // Check for missing or invalid shebang
        if lines.is_empty() || !shebang_re.is_match(lines[0]) {
            findings.push(DefragFinding {
                file: file.clone(),
                line: Some(1),
                severity: Severity::Warning,
                message: "script missing valid shebang line".to_string(),
                fix_description: None,
                fixable: false,
                pass_name: "scripts".to_string(),
            });
        }

        // Check for hardcoded old paths
        for (line_num, line) in lines.iter().enumerate() {
            if hardcoded_re.is_match(line) {
                findings.push(DefragFinding {
                    file: file.clone(),
                    line: Some(line_num + 1),
                    severity: Severity::Error,
                    message: "hardcoded path '/usr/local/bin/legacy'".to_string(),
                    fix_description: None,
                    fixable: false,
                    pass_name: "scripts".to_string(),
                });
            }
        }
    }
    findings
}

// ── Fix application ─────────────────────────────────────────────

fn apply_fixes(workspace: &Path, findings: &[DefragFinding]) -> usize {
    let mut fixed = 0;

    // Group fixable findings by pass
    let refs_findings: Vec<&DefragFinding> = findings
        .iter()
        .filter(|f| f.fixable && f.pass_name == "refs")
        .collect();
    let artifact_findings: Vec<&DefragFinding> = findings
        .iter()
        .filter(|f| f.fixable && f.pass_name == "artifacts")
        .collect();
    let stale_findings: Vec<&DefragFinding> = findings
        .iter()
        .filter(|f| f.fixable && f.pass_name == "stale")
        .collect();
    let identity_findings: Vec<&DefragFinding> = findings
        .iter()
        .filter(|f| f.fixable && f.pass_name == "identity")
        .collect();

    // Fix refs: replace old names with new in files
    if !refs_findings.is_empty() {
        let map = migration_map();
        let mut patched_files: HashMap<PathBuf, String> = HashMap::new();
        for f in &refs_findings {
            patched_files.entry(f.file.clone()).or_insert_with(|| {
                match fs::read_to_string(&f.file) {
                    Ok(content) => content,
                    Err(e) => {
                        tracing::warn!(error = %e, path = %f.file.display(), "failed to read file for defrag, skipping");
                        String::new()
                    }
                }
            });
        }
        // Skip files that failed to read (empty content from error path above).
        patched_files.retain(|_, content| !content.is_empty());
        for (path, content) in &mut patched_files {
            let mut updated = content.clone();
            for (old, new) in &map {
                updated = updated.replace(old, new);
            }
            if updated != *content && fs::write(path, &updated).is_ok() {
                fixed += 1;
            }
        }
    }

    // Fix artifacts: delete files/dirs
    for f in &artifact_findings {
        let ok = if f.file.is_dir() {
            fs::remove_dir_all(&f.file).is_ok()
        } else {
            fs::remove_file(&f.file).is_ok()
        };
        if ok {
            fixed += 1;
        }
    }

    // Fix stale: remove ghost entries from update_state.json
    if !stale_findings.is_empty() {
        let state_path = workspace.join(".roboticus").join("update_state.json");
        if let Ok(content) = fs::read_to_string(&state_path)
            && let Ok(mut state) = serde_json::from_str::<serde_json::Value>(&content)
            && let Some(obj) = state.as_object_mut()
        {
            for f in &stale_findings {
                // Extract key name from the message
                if let Some(key) = f
                    .message
                    .strip_prefix("ghost entry '")
                    .and_then(|s| s.split('\'').next())
                {
                    obj.remove(key);
                }
            }
            if let Ok(json) = serde_json::to_string_pretty(&state)
                && fs::write(&state_path, json).is_ok()
            {
                fixed += stale_findings.len();
            }
        }
    }

    // Fix identity: replace old brand names in TOML/JSON files
    if !identity_findings.is_empty() {
        let map = migration_map();
        let mut patched_files: HashMap<PathBuf, String> = HashMap::new();
        for f in &identity_findings {
            patched_files
                .entry(f.file.clone())
                .or_insert_with(|| fs::read_to_string(&f.file).inspect_err(|e| tracing::warn!(error = %e, path = %f.file.display(), "failed to read file for defrag")).unwrap_or_default());
        }
        for (path, content) in &mut patched_files {
            let mut updated = content.clone();
            for (old, new) in &map {
                updated = updated.replace(old, new);
            }
            if updated != *content && fs::write(path, &updated).is_ok() {
                fixed += 1;
            }
        }
    }

    fixed
}

// ── Main entry point ────────────────────────────────────────────

pub fn cmd_defrag(
    workspace: &Path,
    fix: bool,
    yes: bool,
    json_output: bool,
) -> roboticus_core::Result<()> {
    let (DIM, BOLD, ACCENT, GREEN, YELLOW, RED, CYAN, RESET, MONO) = colors();
    let (OK, ACTION, WARN, DETAIL, ERR) = icons();

    // Run all 6 passes
    let pass_names = ["refs", "drift", "artifacts", "stale", "identity", "scripts"];
    let pass_results: Vec<(&str, Vec<DefragFinding>)> = vec![
        ("refs", pass_refs(workspace)),
        ("drift", pass_drift(workspace)),
        ("artifacts", pass_artifacts(workspace)),
        ("stale", pass_stale(workspace)),
        ("identity", pass_identity(workspace)),
        ("scripts", pass_scripts(workspace)),
    ];

    // Build summary
    let mut all_findings: Vec<DefragFinding> = Vec::new();
    let mut by_pass: Vec<PassSummary> = Vec::new();
    let mut severity_counts = SeverityCounts::default();

    for (name, findings) in &pass_results {
        let count = findings.len();
        let status = if count == 0 {
            PassStatus::Clean
        } else {
            PassStatus::Findings
        };
        by_pass.push(PassSummary {
            name: name.to_string(),
            findings: count,
            status,
        });
        for f in findings {
            match f.severity {
                Severity::Info => severity_counts.info += 1,
                Severity::Warning => severity_counts.warning += 1,
                Severity::Error => severity_counts.error += 1,
            }
        }
        all_findings.extend(findings.iter().cloned());
    }

    let fixable_count = all_findings.iter().filter(|f| f.fixable).count();
    let total_findings = all_findings.len();

    let summary = DefragSummary {
        total_findings,
        fixable_count,
        by_severity: severity_counts.clone(),
        by_pass: by_pass.clone(),
    };

    if json_output {
        let output = serde_json::json!({
            "findings": all_findings,
            "summary": summary,
        });
        let json_str = serde_json::to_string_pretty(&output).unwrap_or_else(|_| "{}".to_string());
        // Write JSON to stdout directly, bypassing CRT effect
        std::io::stdout()
            .write_all(json_str.as_bytes())
            .and_then(|_| std::io::stdout().write_all(b"\n"))
            .and_then(|_| std::io::stdout().flush())?;
        return Ok(());
    }

    // Human-readable output
    eprintln!();
    eprintln!("  {BOLD}Workspace Defrag{RESET}");
    eprintln!("  {DIM}{}{RESET}", "\u{2500}".repeat(40));
    eprintln!();

    for ps in &by_pass {
        let dots = ".".repeat(20usize.saturating_sub(ps.name.len()));
        let status_str = if ps.findings == 0 {
            format!("{GREEN}clean{RESET}")
        } else {
            let plural = if ps.findings == 1 {
                "finding"
            } else {
                "findings"
            };
            format!("{YELLOW}{} {plural}{RESET}", ps.findings)
        };
        eprintln!(
            "  {DIM}\u{25a0}{RESET} {BOLD}{}{RESET} {DIM}{dots}{RESET} {status_str}",
            ps.name
        );
    }

    eprintln!();
    let fixable_str = if fixable_count > 0 {
        format!(" ({fixable_count} fixable)")
    } else {
        String::new()
    };
    eprintln!("  {BOLD}Summary:{RESET} {total_findings} findings{fixable_str}");
    eprintln!(
        "    {CYAN}info:{RESET} {} {DIM}|{RESET} {YELLOW}warning:{RESET} {} {DIM}|{RESET} {RED}error:{RESET} {}",
        severity_counts.info, severity_counts.warning, severity_counts.error
    );

    // Show individual findings
    if !all_findings.is_empty() {
        eprintln!();
        for f in &all_findings {
            let sev_color = match f.severity {
                Severity::Info => CYAN,
                Severity::Warning => YELLOW,
                Severity::Error => RED,
            };
            let sev_label = match f.severity {
                Severity::Info => "info",
                Severity::Warning => "warn",
                Severity::Error => "error",
            };
            let loc = match f.line {
                Some(l) => format!("{}:{l}", f.file.display()),
                None => format!("{}", f.file.display()),
            };
            eprintln!(
                "  {sev_color}[{sev_label}]{RESET} {DIM}{}{RESET} {loc}",
                f.pass_name
            );
            eprintln!("         {}", f.message);
        }
    }

    // Fix mode
    if fix && fixable_count > 0 {
        let proceed = if yes {
            true
        } else {
            eprint!("\n  Apply {fixable_count} fixable findings? [y/N] ");
            std::io::stderr().flush().ok();
            let mut input = String::new();
            std::io::stdin().read_line(&mut input).unwrap_or(0);
            matches!(input.trim(), "y" | "Y" | "yes" | "Yes" | "YES")
        };

        if proceed {
            let fixed = apply_fixes(workspace, &all_findings);
            eprintln!();
            eprintln!("  {OK} {GREEN}Applied fixes ({fixed} items){RESET}");
        } else {
            eprintln!();
            eprintln!("  {DIM}No changes made.{RESET}");
        }
    } else if fix && fixable_count == 0 {
        eprintln!();
        eprintln!("  {OK} {GREEN}Nothing to fix{RESET}");
    }

    eprintln!();
    Ok(())
}

// ═══════════════════════════════════════════════════════════════
// Tests
// ═══════════════════════════════════════════════════════════════

#[cfg(test)]
mod tests {
    use std::fs;

    use tempfile::TempDir;

    use super::*;

    // ── migration_map ────────────────────────────────────────────

    #[test]
    fn migration_map_contains_expected_keys() {
        let m = migration_map();
        assert!(m.contains_key("legacy"));
        assert!(m.contains_key("Legacy"));
        assert!(m.contains_key("open_legacy"));
        assert!(m.contains_key("olegacy"));
    }

    #[test]
    fn migration_map_maps_to_roboticus() {
        let m = migration_map();
        assert_eq!(m["legacy"], "roboticus");
        assert_eq!(m["Legacy"], "Roboticus");
        assert_eq!(m["open_legacy"], "roboticus");
        assert_eq!(m["olegacy"], "roboticus");
    }

    // ── Severity / PassStatus ────────────────────────────────────

    #[test]
    fn severity_variants_are_distinct() {
        assert_ne!(Severity::Info, Severity::Warning);
        assert_ne!(Severity::Warning, Severity::Error);
        assert_ne!(Severity::Info, Severity::Error);
    }

    #[test]
    fn pass_status_variants_are_distinct() {
        assert_ne!(PassStatus::Clean, PassStatus::Findings);
        assert_ne!(PassStatus::Findings, PassStatus::Error);
        assert_ne!(PassStatus::Clean, PassStatus::Error);
    }

    #[test]
    fn severity_counts_default_is_zero() {
        let c = SeverityCounts::default();
        assert_eq!(c.info, 0);
        assert_eq!(c.warning, 0);
        assert_eq!(c.error, 0);
    }

    // ── DefragFinding construction ───────────────────────────────

    #[test]
    fn defrag_finding_roundtrips_via_serialize() {
        let finding = DefragFinding {
            file: std::path::PathBuf::from("/tmp/test.md"),
            line: Some(42),
            severity: Severity::Warning,
            message: "stale reference 'legacy'".to_string(),
            fix_description: Some("replace with 'roboticus'".to_string()),
            fixable: true,
            pass_name: "refs".to_string(),
        };
        let json = serde_json::to_string(&finding).unwrap();
        let parsed: DefragFinding = serde_json::from_str(&json).unwrap();
        assert_eq!(parsed.line, Some(42));
        assert_eq!(parsed.severity, Severity::Warning);
        assert_eq!(parsed.pass_name, "refs");
        assert!(parsed.fixable);
    }

    #[test]
    fn defrag_finding_no_line_serializes_as_null() {
        let finding = DefragFinding {
            file: std::path::PathBuf::from("/tmp/test.md"),
            line: None,
            severity: Severity::Info,
            message: "empty dir".to_string(),
            fix_description: None,
            fixable: false,
            pass_name: "artifacts".to_string(),
        };
        let json = serde_json::to_string(&finding).unwrap();
        assert!(json.contains("\"line\":null"));
    }

    // ── is_dir_empty ─────────────────────────────────────────────

    #[test]
    fn is_dir_empty_returns_true_for_empty_dir() {
        let tmp = TempDir::new().unwrap();
        assert!(is_dir_empty(tmp.path()));
    }

    #[test]
    fn is_dir_empty_returns_false_for_non_empty_dir() {
        let tmp = TempDir::new().unwrap();
        fs::write(tmp.path().join("file.txt"), "content").unwrap();
        assert!(!is_dir_empty(tmp.path()));
    }

    #[test]
    fn is_dir_empty_returns_false_for_nonexistent_path() {
        assert!(!is_dir_empty(std::path::Path::new("/nonexistent/path/xyz")));
    }

    // ── walk_files ───────────────────────────────────────────────

    #[test]
    fn walk_files_empty_extensions_returns_all_files() {
        let tmp = TempDir::new().unwrap();
        fs::write(tmp.path().join("a.md"), "").unwrap();
        fs::write(tmp.path().join("b.toml"), "").unwrap();
        let files = walk_files(tmp.path(), &[]);
        assert_eq!(files.len(), 2);
    }

    #[test]
    fn walk_files_filters_by_extension() {
        let tmp = TempDir::new().unwrap();
        fs::write(tmp.path().join("a.md"), "").unwrap();
        fs::write(tmp.path().join("b.toml"), "").unwrap();
        fs::write(tmp.path().join("c.json"), "").unwrap();
        let files = walk_files(tmp.path(), &["md"]);
        assert_eq!(files.len(), 1);
        assert!(files[0].ends_with("a.md"));
    }

    #[test]
    fn walk_files_skips_hidden_directories() {
        let tmp = TempDir::new().unwrap();
        let hidden = tmp.path().join(".hidden");
        fs::create_dir_all(&hidden).unwrap();
        fs::write(hidden.join("secret.md"), "hide me").unwrap();
        fs::write(tmp.path().join("visible.md"), "see me").unwrap();
        let files = walk_files(tmp.path(), &["md"]);
        assert_eq!(files.len(), 1);
        assert!(files[0].ends_with("visible.md"));
    }

    #[test]
    fn walk_files_skips_target_directory() {
        let tmp = TempDir::new().unwrap();
        let target = tmp.path().join("target");
        fs::create_dir_all(&target).unwrap();
        fs::write(target.join("build.toml"), "skip me").unwrap();
        fs::write(tmp.path().join("real.toml"), "find me").unwrap();
        let files = walk_files(tmp.path(), &["toml"]);
        assert_eq!(files.len(), 1);
        assert!(files[0].ends_with("real.toml"));
    }

    #[test]
    fn walk_files_skips_node_modules() {
        let tmp = TempDir::new().unwrap();
        let nm = tmp.path().join("node_modules");
        fs::create_dir_all(&nm).unwrap();
        fs::write(nm.join("pkg.json"), "skip me").unwrap();
        fs::write(tmp.path().join("project.json"), "find me").unwrap();
        let files = walk_files(tmp.path(), &["json"]);
        assert_eq!(files.len(), 1);
    }

    #[test]
    fn walk_files_recurses_into_subdirectories() {
        let tmp = TempDir::new().unwrap();
        let sub = tmp.path().join("subdir");
        fs::create_dir_all(&sub).unwrap();
        fs::write(sub.join("nested.md"), "nested").unwrap();
        fs::write(tmp.path().join("top.md"), "top").unwrap();
        let files = walk_files(tmp.path(), &["md"]);
        assert_eq!(files.len(), 2);
    }

    // ── walk_all_entries ─────────────────────────────────────────

    #[test]
    fn walk_all_entries_includes_dirs_and_files() {
        let tmp = TempDir::new().unwrap();
        let sub = tmp.path().join("subdir");
        fs::create_dir_all(&sub).unwrap();
        fs::write(sub.join("file.txt"), "").unwrap();
        let entries = walk_all_entries(tmp.path());
        // Should include 'subdir' itself and 'file.txt'
        assert!(entries.len() >= 2);
    }

    // ── pass_refs ────────────────────────────────────────────────

    #[test]
    fn pass_refs_detects_stale_references() {
        let tmp = TempDir::new().unwrap();
        fs::write(
            tmp.path().join("README.md"),
            "This is a legacy tool for testing.\n",
        )
        .unwrap();
        let findings = pass_refs(tmp.path());
        assert!(!findings.is_empty());
        assert!(findings.iter().all(|f| f.pass_name == "refs"));
        assert!(findings.iter().all(|f| f.fixable));
        assert!(findings.iter().all(|f| f.severity == Severity::Warning));
    }

    #[test]
    fn pass_refs_no_findings_for_clean_file() {
        let tmp = TempDir::new().unwrap();
        fs::write(tmp.path().join("README.md"), "This is a roboticus tool.\n").unwrap();
        let findings = pass_refs(tmp.path());
        assert!(findings.is_empty());
    }

    #[test]
    fn pass_refs_detects_all_stale_terms() {
        let tmp = TempDir::new().unwrap();
        // Each stale term on its own line
        fs::write(
            tmp.path().join("notes.md"),
            "legacy\nopen_legacy\nLegacy\nolegacy\n",
        )
        .unwrap();
        let findings = pass_refs(tmp.path());
        // Should find at least one finding per stale term
        assert!(findings.len() >= 4);
    }

    #[test]
    fn pass_refs_reports_correct_line_numbers() {
        let tmp = TempDir::new().unwrap();
        fs::write(
            tmp.path().join("notes.md"),
            "clean line\nlegacy here\nclean\n",
        )
        .unwrap();
        let findings = pass_refs(tmp.path());
        assert_eq!(findings.len(), 1);
        assert_eq!(findings[0].line, Some(2));
    }

    // ── pass_artifacts ───────────────────────────────────────────

    #[test]
    fn pass_artifacts_finds_log_files() {
        let tmp = TempDir::new().unwrap();
        let skills = tmp.path().join("skills");
        fs::create_dir_all(&skills).unwrap();
        fs::write(skills.join("output.log"), "log content").unwrap();
        let findings = pass_artifacts(tmp.path());
        assert_eq!(findings.len(), 1);
        assert_eq!(findings[0].severity, Severity::Info);
        assert!(findings[0].fixable);
    }

    #[test]
    fn pass_artifacts_finds_bak_files() {
        let tmp = TempDir::new().unwrap();
        let skills = tmp.path().join("skills");
        fs::create_dir_all(&skills).unwrap();
        fs::write(skills.join("skill.bak"), "backup").unwrap();
        let findings = pass_artifacts(tmp.path());
        assert_eq!(findings.len(), 1);
        assert_eq!(findings[0].severity, Severity::Warning);
        assert!(findings[0].fixable);
    }

    #[test]
    fn pass_artifacts_finds_pycache_dirs() {
        let tmp = TempDir::new().unwrap();
        let skills = tmp.path().join("skills");
        let pycache = skills.join("__pycache__");
        fs::create_dir_all(&pycache).unwrap();
        fs::write(pycache.join("cached.pyc"), "bytecode").unwrap();
        let findings = pass_artifacts(tmp.path());
        assert!(!findings.is_empty());
        assert!(findings.iter().any(|f| f.message.contains("__pycache__")));
    }

    #[test]
    fn pass_artifacts_finds_empty_directories() {
        let tmp = TempDir::new().unwrap();
        let skills = tmp.path().join("skills");
        let empty_sub = skills.join("empty_skill");
        fs::create_dir_all(&empty_sub).unwrap();
        let findings = pass_artifacts(tmp.path());
        assert!(!findings.is_empty());
        assert!(findings.iter().any(|f| f.message.contains("empty")));
    }

    #[test]
    fn pass_artifacts_returns_empty_when_no_skills_dir() {
        let tmp = TempDir::new().unwrap();
        let findings = pass_artifacts(tmp.path());
        assert!(findings.is_empty());
    }

    // ── pass_stale ───────────────────────────────────────────────

    #[test]
    fn pass_stale_detects_ghost_string_entries() {
        let tmp = TempDir::new().unwrap();
        let roboticus_dir = tmp.path().join(".roboticus");
        fs::create_dir_all(&roboticus_dir).unwrap();
        let state = serde_json::json!({
            "existing_file": "real_file.toml",
            "missing_file": "nonexistent/path/file.toml"
        });
        fs::write(
            roboticus_dir.join("update_state.json"),
            serde_json::to_string(&state).unwrap(),
        )
        .unwrap();
        // Create the "real" file so it doesn't appear as ghost
        fs::write(tmp.path().join("real_file.toml"), "content").unwrap();
        let findings = pass_stale(tmp.path());
        assert_eq!(findings.len(), 1);
        assert!(findings[0].message.contains("missing_file"));
        assert!(findings[0].fixable);
    }

    #[test]
    fn pass_stale_returns_empty_when_no_state_file() {
        let tmp = TempDir::new().unwrap();
        let findings = pass_stale(tmp.path());
        assert!(findings.is_empty());
    }

    #[test]
    fn pass_stale_returns_empty_when_all_entries_exist() {
        let tmp = TempDir::new().unwrap();
        let roboticus_dir = tmp.path().join(".roboticus");
        fs::create_dir_all(&roboticus_dir).unwrap();
        fs::write(tmp.path().join("roboticus.toml"), "content").unwrap();
        let state = serde_json::json!({
            "config": "roboticus.toml"
        });
        fs::write(
            roboticus_dir.join("update_state.json"),
            serde_json::to_string(&state).unwrap(),
        )
        .unwrap();
        let findings = pass_stale(tmp.path());
        assert!(findings.is_empty());
    }

    #[test]
    fn pass_stale_detects_ghost_object_entries() {
        let tmp = TempDir::new().unwrap();
        let roboticus_dir = tmp.path().join(".roboticus");
        fs::create_dir_all(&roboticus_dir).unwrap();
        let state = serde_json::json!({
            "component": { "path": "missing_component.toml" }
        });
        fs::write(
            roboticus_dir.join("update_state.json"),
            serde_json::to_string(&state).unwrap(),
        )
        .unwrap();
        let findings = pass_stale(tmp.path());
        assert_eq!(findings.len(), 1);
        assert!(findings[0].message.contains("component"));
        assert_eq!(findings[0].severity, Severity::Warning);
    }

    // ── pass_scripts ─────────────────────────────────────────────

    #[test]
    fn pass_scripts_returns_empty_when_no_skills_dir() {
        let tmp = TempDir::new().unwrap();
        let findings = pass_scripts(tmp.path());
        assert!(findings.is_empty());
    }

    #[test]
    fn pass_scripts_detects_missing_shebang() {
        let tmp = TempDir::new().unwrap();
        let skills = tmp.path().join("skills");
        fs::create_dir_all(&skills).unwrap();
        fs::write(skills.join("bad_script.sh"), "echo hello\n").unwrap();
        let findings = pass_scripts(tmp.path());
        assert_eq!(findings.len(), 1);
        assert!(findings[0].message.contains("shebang"));
        assert_eq!(findings[0].severity, Severity::Warning);
        assert!(!findings[0].fixable);
    }

    #[test]
    fn pass_scripts_accepts_valid_shebang() {
        let tmp = TempDir::new().unwrap();
        let skills = tmp.path().join("skills");
        fs::create_dir_all(&skills).unwrap();
        fs::write(skills.join("good_script.sh"), "#!/bin/bash\necho hello\n").unwrap();
        let findings = pass_scripts(tmp.path());
        assert!(findings.is_empty());
    }

    #[test]
    fn pass_scripts_detects_hardcoded_legacy_path() {
        let tmp = TempDir::new().unwrap();
        let skills = tmp.path().join("skills");
        fs::create_dir_all(&skills).unwrap();
        fs::write(
            skills.join("broken.sh"),
            "#!/bin/bash\n/usr/local/bin/legacy run\n",
        )
        .unwrap();
        let findings = pass_scripts(tmp.path());
        // Should find at least the hardcoded path finding (may also find shebang if valid)
        assert!(findings.iter().any(|f| f.severity == Severity::Error));
        assert!(
            findings
                .iter()
                .any(|f| f.message.contains("hardcoded path"))
        );
    }

    #[test]
    fn pass_scripts_handles_empty_script_file() {
        let tmp = TempDir::new().unwrap();
        let skills = tmp.path().join("skills");
        fs::create_dir_all(&skills).unwrap();
        fs::write(skills.join("empty.sh"), "").unwrap();
        let findings = pass_scripts(tmp.path());
        assert_eq!(findings.len(), 1);
        assert!(findings[0].message.contains("shebang"));
    }

    // ── pass_drift ───────────────────────────────────────────────

    #[test]
    fn pass_drift_returns_empty_when_no_config() {
        let tmp = TempDir::new().unwrap();
        let findings = pass_drift(tmp.path());
        assert!(findings.is_empty());
    }

    #[test]
    fn pass_drift_detects_port_mismatch() {
        let tmp = TempDir::new().unwrap();
        fs::write(
            tmp.path().join("roboticus.toml"),
            "[server]\nport = 18789\n",
        )
        .unwrap();
        fs::write(
            tmp.path().join("README.md"),
            "Connect to localhost:9000 for the API.\n",
        )
        .unwrap();
        let findings = pass_drift(tmp.path());
        assert!(!findings.is_empty());
        assert!(findings.iter().any(|f| f.message.contains("port")));
    }

    #[test]
    fn pass_drift_no_findings_when_port_matches() {
        let tmp = TempDir::new().unwrap();
        fs::write(
            tmp.path().join("roboticus.toml"),
            "[server]\nport = 18789\n",
        )
        .unwrap();
        fs::write(
            tmp.path().join("README.md"),
            "Connect to localhost:18789 for the API.\n",
        )
        .unwrap();
        let findings = pass_drift(tmp.path());
        assert!(findings.is_empty());
    }

    // ── pass_identity ────────────────────────────────────────────

    #[test]
    fn pass_identity_returns_empty_when_no_files() {
        let tmp = TempDir::new().unwrap();
        let findings = pass_identity(tmp.path());
        assert!(findings.is_empty());
    }

    #[test]
    fn pass_identity_detects_old_brand_in_toml() {
        let tmp = TempDir::new().unwrap();
        fs::write(
            tmp.path().join("config.toml"),
            "[meta]\ngenerated_by = \"legacy\"\n",
        )
        .unwrap();
        let findings = pass_identity(tmp.path());
        assert!(!findings.is_empty());
        assert!(findings.iter().all(|f| f.pass_name == "identity"));
        assert!(findings.iter().all(|f| f.fixable));
    }

    #[test]
    fn pass_identity_returns_empty_for_clean_brand() {
        let tmp = TempDir::new().unwrap();
        fs::write(
            tmp.path().join("config.toml"),
            "[meta]\ngenerated_by = \"roboticus\"\n",
        )
        .unwrap();
        let findings = pass_identity(tmp.path());
        assert!(findings.is_empty());
    }

    // ── DefragSummary construction ───────────────────────────────

    #[test]
    fn defrag_summary_serializes_correctly() {
        let summary = DefragSummary {
            total_findings: 5,
            fixable_count: 3,
            by_severity: SeverityCounts {
                info: 2,
                warning: 2,
                error: 1,
            },
            by_pass: vec![PassSummary {
                name: "refs".to_string(),
                findings: 5,
                status: PassStatus::Findings,
            }],
        };
        let json = serde_json::to_string(&summary).unwrap();
        let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
        assert_eq!(parsed["total_findings"], 5);
        assert_eq!(parsed["fixable_count"], 3);
    }

    // ── Integration: cmd_defrag on empty workspace ───────────────

    #[test]
    fn cmd_defrag_runs_on_empty_workspace() {
        let tmp = TempDir::new().unwrap();
        let result = cmd_defrag(tmp.path(), false, false, false);
        assert!(result.is_ok());
    }

    #[test]
    fn cmd_defrag_json_output_on_empty_workspace() {
        let tmp = TempDir::new().unwrap();
        let result = cmd_defrag(tmp.path(), false, false, true);
        assert!(result.is_ok());
    }

    #[test]
    fn cmd_defrag_no_fix_when_no_findings() {
        let tmp = TempDir::new().unwrap();
        // No stale references, no artifacts
        let result = cmd_defrag(tmp.path(), true, true, false);
        assert!(result.is_ok());
    }
}