code-graph-cli 3.0.3

Code intelligence engine for TypeScript/JavaScript/Rust/Python/Go — query the dependency graph instead of reading source files.
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use serde::Serialize;

/// Aggregate statistics produced by an indexing run.
#[derive(Debug, Serialize)]
pub struct IndexStats {
    pub file_count: usize,
    pub functions: usize,
    pub classes: usize,
    pub interfaces: usize,
    pub type_aliases: usize,
    pub enums: usize,
    pub variables: usize,
    pub components: usize,
    pub methods: usize,
    pub properties: usize,
    pub imports: usize,
    /// Number of ESM static imports (`import ... from`).
    pub esm_imports: usize,
    /// Number of CommonJS require imports (`require(...)`).
    pub cjs_imports: usize,
    /// Number of dynamic imports (`import(...)`).
    pub dynamic_imports: usize,
    pub exports: usize,
    /// Files skipped due to read or parse errors.
    pub skipped: usize,
    /// Wall-clock time for the indexing run in seconds.
    pub elapsed_secs: f64,
    // Resolution metrics (Phase 2)
    /// Number of imports successfully resolved to a local indexed file.
    pub resolved_imports: usize,
    /// Number of imports that could not be resolved to any target.
    pub unresolved_imports: usize,
    /// Number of imports resolved to external packages (node_modules).
    pub external_packages: usize,
    /// Number of imports classified as Node.js built-in modules.
    pub builtin_modules: usize,
    /// Number of symbol-level relationship edges added (Calls, Extends, Implements, TypeRef).
    pub relationship_edges: usize,
    /// Number of TypeScript (.ts/.tsx) files discovered.
    pub ts_file_count: usize,
    /// Number of JavaScript (.js/.jsx) files discovered.
    pub js_file_count: usize,
    /// Number of Rust (.rs) files discovered and parsed.
    pub rust_file_count: usize,
    /// Number of Python (.py) files discovered and parsed.
    pub python_file_count: usize,
    // Rust symbol counts (Phase 8)
    pub rust_fns: usize,
    pub rust_structs: usize,
    pub rust_enums: usize,
    pub rust_traits: usize,
    pub rust_impl_methods: usize,
    pub rust_type_aliases: usize,
    pub rust_consts: usize,
    pub rust_statics: usize,
    pub rust_macros: usize,
    pub rust_use_statements: usize,
    pub rust_pub_use_reexports: usize,
}

/// Print a summary of the indexing run.
///
/// - `json = true`: emit a pretty-printed JSON object to stdout.
/// - `json = false`: emit a cargo-style human-readable summary to stdout.
///
/// If `stats.skipped > 0`, a warning line is written to **stderr** so that
/// the stdout stream remains clean for downstream JSON consumers.
pub fn print_summary(stats: &IndexStats, json: bool) {
    if json {
        match serde_json::to_string_pretty(stats) {
            Ok(s) => println!("{}", s),
            Err(e) => eprintln!("error serialising stats: {}", e),
        }
        return;
    }

    // Human-readable cargo-style summary.
    println!(
        "Indexed {} files in {:.2}s",
        stats.file_count, stats.elapsed_secs
    );

    // Per-language file counts — only show languages with files present.
    if stats.ts_file_count > 0 {
        println!("  TypeScript: {} files", stats.ts_file_count);
    }
    if stats.js_file_count > 0 {
        println!("  JavaScript: {} files", stats.js_file_count);
    }
    if stats.rust_file_count > 0 {
        println!("  Rust: {} files", stats.rust_file_count);
        println!(
            "    {} fn, {} struct, {} enum, {} trait, {} impl method, {} type, {} const, {} static, {} macro",
            stats.rust_fns,
            stats.rust_structs,
            stats.rust_enums,
            stats.rust_traits,
            stats.rust_impl_methods,
            stats.rust_type_aliases,
            stats.rust_consts,
            stats.rust_statics,
            stats.rust_macros,
        );
        println!(
            "    {} use statements (unresolved), {} pub use re-exports",
            stats.rust_use_statements, stats.rust_pub_use_reexports,
        );
    }
    if stats.python_file_count > 0 {
        println!("  Python: {} files", stats.python_file_count);
    }

    println!(
        "  {} functions, {} classes, {} interfaces, {} types, {} enums, {} variables",
        stats.functions,
        stats.classes,
        stats.interfaces,
        stats.type_aliases,
        stats.enums,
        stats.variables,
    );
    println!(
        "  {} components, {} methods, {} properties",
        stats.components, stats.methods, stats.properties,
    );
    println!("  {} imports, {} exports", stats.imports, stats.exports);
    println!(
        "  {} ESM, {} CJS, {} dynamic imports",
        stats.esm_imports, stats.cjs_imports, stats.dynamic_imports,
    );

    // Resolution section.
    println!(
        "  Resolved {} imports ({} external, {} unresolved, {} builtins)",
        stats.resolved_imports,
        stats.external_packages,
        stats.unresolved_imports,
        stats.builtin_modules,
    );
    println!("  Added {} relationship edges", stats.relationship_edges);

    if stats.skipped > 0 {
        eprintln!("  {} files skipped (parse errors)", stats.skipped);
    }
}