repotoire 0.5.3

Graph-powered code analysis CLI. 106 detectors for security, architecture, and code quality.
Documentation 
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::cache_dir(&repo_path);
    let db_path = crate::cache::graph_db_path(&repo_path);
    let findings_path = crate::cache::findings_cache_path(&repo_path);

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

    // Check analysis state — use findings cache as the primary indicator
    let has_findings = findings_path.exists();
    let has_db = db_path.exists();

    if has_findings || has_db {
        println!("  {} Analysis data found", style("[OK]").green());

        // Try to get stats from cached JSON
        let stats_path = crate::cache::graph_stats_path(&repo_path);
        if let Ok(stats) = std::fs::read_to_string(&stats_path)
            .ok()
            .and_then(|json| serde_json::from_str::<serde_json::Value>(&json).ok())
            .ok_or(())
        {
            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()
            );
        }

        if let Some(findings) = super::analyze::output::load_cached_findings_from(&findings_path) {
            use crate::models::Severity;
            let total = findings.len();
            let critical = findings.iter().filter(|f| f.severity == Severity::Critical).count();
            let high = findings.iter().filter(|f| f.severity == Severity::High).count();
            println!(
                "      {} findings ({} critical, {} high)",
                style(total).cyan(),
                style(critical).red(),
                style(high).yellow()
            );
        }
    } else {
        println!(
            "  {} No analysis yet. Run {}",
            style("[--]").dim(),
            style("repotoire analyze").cyan()
        );
    }

    // 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(())
}