repotoire 0.3.47

Graph-powered code analysis CLI. 81 detectors for security, architecture, and code quality.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Status command - show analysis status and info

use anyhow::{Context, Result};
use console::style;
use std::path::Path;

/// Run the status command
pub fn run(path: &Path) -> Result<()> {
    let repo_path = path
        .canonicalize()
        .with_context(|| format!("Path does not exist: {}", path.display()))?;

    println!("\nRepotoire Status\n");

    // Check cache directory
    let cache_dir = crate::cache::get_cache_dir(&repo_path);
    let db_path = crate::cache::get_graph_db_path(&repo_path);
    let findings_path = crate::cache::get_findings_cache_path(&repo_path);

    println!("  Repository: {}", style(repo_path.display()).cyan());
    println!("  Cache: {}", style(cache_dir.display()).dim());
    println!();

    // Check for database
    if db_path.exists() {
        println!("  {} Graph database exists", style("[OK]").green());
        
        // Try to get stats from cached JSON (faster than loading graph)
        let stats_path = crate::cache::get_graph_stats_path(&repo_path);
        if let Ok(stats_json) = std::fs::read_to_string(&stats_path) {
            if let Ok(stats) = serde_json::from_str::<serde_json::Value>(&stats_json) {
                let file_count = stats.get("total_files").and_then(|v| v.as_i64()).unwrap_or(0);
                let func_count = stats.get("total_functions").and_then(|v| v.as_i64()).unwrap_or(0);
                let class_count = stats.get("total_classes").and_then(|v| v.as_i64()).unwrap_or(0);
            
                println!("      {} files, {} functions, {} classes", 
                    style(file_count).cyan(),
                    style(func_count).cyan(),
                    style(class_count).cyan()
                );
            }
        }
    } else {
        println!(
            "  {} No analysis yet. Run {}",
            style("[--]").dim(),
            style("repotoire analyze").cyan()
        );
    }

    // Check for cached findings
    if findings_path.exists() {
        println!("  {} Findings cached", style("[OK]").green());
        
        if let Ok(content) = std::fs::read_to_string(&findings_path) {
            if let Ok(report) = serde_json::from_str::<serde_json::Value>(&content) {
                if let Some(findings) = report.get("findings").and_then(|f| f.as_array()) {
                    let total = findings.len();
                    let critical = findings.iter()
                        .filter(|f| f.get("severity").and_then(|s| s.as_str()) == Some("critical"))
                        .count();
                    let high = findings.iter()
                        .filter(|f| f.get("severity").and_then(|s| s.as_str()) == Some("high"))
                        .count();
                    
                    println!(
                        "      {} findings ({} critical, {} high)",
                        style(total).cyan(),
                        style(critical).red(),
                        style(high).yellow()
                    );
                }
            }
        }
    }

    // Check for API keys
    println!();
    println!("  API Keys:");
    
    let has_openai = std::env::var("OPENAI_API_KEY").is_ok();
    let has_anthropic = std::env::var("ANTHROPIC_API_KEY").is_ok();
    
    if has_openai {
        println!("    {} OPENAI_API_KEY", style("[OK]").green());
    } else {
        println!("    {} OPENAI_API_KEY", style("[--]").dim());
    }
    
    if has_anthropic {
        println!("    {} ANTHROPIC_API_KEY", style("[OK]").green());
    } else {
        println!("    {} ANTHROPIC_API_KEY", style("[--]").dim());
    }

    if !has_openai && !has_anthropic {
        println!(
            "\n  Set an API key to enable AI fixes (BYOK)"
        );
    }

    println!();
    Ok(())
}