llmcc 0.2.65

llmcc brings multi-depth architecture graphs for code understanding and generation.
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
105
106
107
108

//! Shared CLI options for llmcc tools.
//!
//! This module defines common command-line options used across different llmcc binaries
//! (llmcc and llmcc-test) to ensure consistent behavior and reduce code duplication.

use clap::Args;
use llmcc_dot::ComponentDepth;

/// Common options for graph building and visualization.
#[derive(Args, Debug, Clone, Default)]
pub struct GraphOptions {
    /// Component grouping depth for graph visualization.
    /// - 0/flat: No grouping (flat graph, no clusters)
    /// - 1/crate: Crate level only
    /// - 2/module: Module level
    /// - 3/file: File level (default)
    #[arg(long = "component-depth", default_value = "3")]
    component_depth_num: usize,

    /// Number of top PageRank nodes to include (enables pagerank filtering).
    /// When set, only the top K most important nodes are shown.
    #[arg(long = "pagerank-top-k")]
    pub pagerank_top_k: Option<usize>,

    /// Generate architecture graph (data flow) instead of dependency graph.
    /// Architecture graph shows: param_type -> func -> return_type
    #[arg(long = "arch-graph")]
    pub architecture_graph: bool,

    /// Cluster modules by their parent crate (for module-level graphs).
    /// Creates visual subgraphs grouping related modules together.
    #[arg(long = "cluster-by-crate")]
    pub cluster_by_crate: bool,

    /// Use shortened labels (module name only, without crate prefix).
    /// Makes labels more compact for large graphs.
    #[arg(long = "short-labels")]
    pub short_labels: bool,
}

impl GraphOptions {
    /// Get the component depth as an enum
    pub fn component_depth(&self) -> ComponentDepth {
        ComponentDepth::from_number(self.component_depth_num)
    }
}

/// Common options for controlling processing behavior.
#[derive(Args, Debug, Clone, Default)]
pub struct ProcessingOptions {
    /// Process files in parallel (default: false for stable ordering).
    #[arg(long)]
    pub parallel: bool,

    /// Print IR during symbol resolution.
    #[arg(long = "print-ir", default_value = "false")]
    pub print_ir: bool,
}

/// Combined common options for test runners.
#[derive(Args, Debug, Clone, Default)]
pub struct CommonTestOptions {
    #[command(flatten)]
    pub graph: GraphOptions,

    #[command(flatten)]
    pub processing: ProcessingOptions,

    /// Keep the temporary project directory for inspection.
    #[arg(long = "keep-temps")]
    pub keep_temps: bool,

    /// Update expectation sections with current output (bless).
    #[arg(long)]
    pub update: bool,
}

impl GraphOptions {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_component_depth(mut self, depth: ComponentDepth) -> Self {
        self.component_depth_num = depth.as_number();
        self
    }

    pub fn with_pagerank_top_k(mut self, top_k: Option<usize>) -> Self {
        self.pagerank_top_k = top_k;
        self
    }
}

impl ProcessingOptions {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_parallel(mut self, parallel: bool) -> Self {
        self.parallel = parallel;
        self
    }

    pub fn with_print_ir(mut self, print_ir: bool) -> Self {
        self.print_ir = print_ir;
        self
    }
}