mirage-analyzer 1.5.1

Path-Aware Code Intelligence Engine for Rust
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

use crate::cli::{resolve_db_path, Cli, OutputFormat, StatsArgs};
use crate::output;
use anyhow::Result;

pub fn stats(_args: &StatsArgs, cli: &Cli) -> Result<()> {
    use crate::analysis::stats;
    use crate::storage::MirageDb;

    let db_path = resolve_db_path(cli.db.clone())?;
    let db = match MirageDb::open(&db_path) {
        Ok(db) => db,
        Err(e) => {
            if matches!(cli.output, OutputFormat::Json | OutputFormat::Pretty) {
                let error = output::JsonError::database_not_found(&db_path);
                let wrapper = output::JsonResponse::new(error);
                println!("{}", wrapper.to_json());
                std::process::exit(output::EXIT_DATABASE);
            } else {
                output::error(&format!("Failed to open database: {}", e));
                std::process::exit(output::EXIT_DATABASE);
            }
        }
    };

    let report = stats::gather_stats(&db)?;

    match cli.output {
        OutputFormat::Human => {
            println!("Code Statistics:");
            println!(
                "  Functions: {} total, {} with CFG, {} without",
                report.total_functions, report.functions_with_cfg, report.functions_without_cfg
            );
            println!(
                "  Blocks: {} total, avg {:.1} per function, max {} ({})",
                report.total_blocks,
                report.avg_blocks_per_function,
                report.max_blocks,
                report.max_blocks_function.as_deref().unwrap_or("N/A")
            );
            println!("  Paths: {} cached", report.total_paths);
            println!("  Dead code blocks: {}", report.dead_code_count);
            println!("  Coverage gaps: {}", report.coverage_gap_count);
            println!(
                "  Complexity: {} low, {} medium, {} high, {} critical",
                report.complexity_distribution.low,
                report.complexity_distribution.medium,
                report.complexity_distribution.high,
                report.complexity_distribution.critical
            );
        }
        OutputFormat::Json => {
            let response = output::JsonResponse::new(&report);
            println!("{}", response.to_json());
        }
        OutputFormat::Pretty => {
            let response = output::JsonResponse::new(&report);
            println!("{}", response.to_pretty_json());
        }
    }

    Ok(())
}