llmcc 0.2.50

llmcc: llm context compiler
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
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

use anyhow::anyhow;
use anyhow::Result;
use clap::ArgGroup;
use clap::Parser;

use llmcc::run_main;
use llmcc::LlmccOptions;
use llmcc_python::LangPython;
use llmcc_rust::LangRust;

#[derive(Parser, Debug)]
#[command(
    name = "llmcc",
    about = "llmcc: llm context compiler",
    version,
    group = ArgGroup::new("inputs").required(true).args(["files", "dirs"])
)]
pub struct Cli {
    /// Individual files to compile (repeatable)
    #[arg(
        short = 'f',
        long = "file",
        value_name = "FILE",
        num_args = 1..,
        action = clap::ArgAction::Append,
        conflicts_with = "dirs"
    )]
    files: Vec<String>,

    /// Directories to scan recursively (repeatable)
    #[arg(
        short = 'd',
        long = "dir",
        value_name = "DIR",
        num_args = 1..,
        action = clap::ArgAction::Append,
        conflicts_with = "files"
    )]
    dirs: Vec<String>,

    /// Language to use: 'rust' or 'python'
    #[arg(long, value_name = "LANG", default_value = "rust")]
    lang: String,

    /// Print intermediate representation (IR), internal debugging output
    #[arg(long, default_value_t = false)]
    print_ir: bool,

    /// Print basic block graph
    #[arg(long, default_value_t = false)]
    print_block: bool,

    /// Render a scoped design graph for the provided files or directories
    #[arg(
        long = "design-graph",
        default_value_t = false,
        conflicts_with_all = ["depends", "dependents", "query"]
    )]
    design_graph: bool,

    /// Summarize query output with file path and line range instead of full code blocks
    #[arg(long, default_value_t = false)]
    summary: bool,

    /// Use page rank algorithm to filter the most important nodes in the high graph
    #[arg(long, default_value_t = false)]
    pagerank: bool,

    /// Top k nodes to select using PageRank algorithm
    #[arg(long, value_name = "K", requires = "pagerank")]
    top_k: Option<usize>,

    /// Name of the symbol/function to query
    #[arg(long, value_name = "NAME")]
    query: Option<String>,

    /// Search recursively for transitive dependencies (default: direct dependencies only)
    #[arg(long, default_value_t = false)]
    recursive: bool,

    /// Return blocks that the queried symbol depends on
    #[arg(long, default_value_t = false, conflicts_with = "dependents")]
    depends: bool,

    /// Return blocks that depend on the queried symbol
    #[arg(long, default_value_t = false, conflicts_with = "depends")]
    dependents: bool,
}

pub fn run(args: Cli) -> Result<()> {
    // Initialize tracing subscriber for logging
    if std::env::var("RUST_LOG").is_ok() {
        tracing_subscriber::fmt()
            .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
            .with_writer(std::io::stderr)
            .init();
    }

    if args.query.is_none() && (args.depends || args.dependents) {
        eprintln!("Warning: --depends/--dependents flags are ignored without --query");
    }

    if args.pagerank && !args.design_graph {
        return Err(anyhow!("--pagerank requires --design-graph"));
    }

    let opts = LlmccOptions {
        files: args.files,
        dirs: args.dirs,
        print_ir: args.print_ir,
        print_block: args.print_block,
        design_graph: args.design_graph,
        pagerank: args.pagerank,
        top_k: args.top_k,
        query: args.query,
        depends: args.depends,
        dependents: args.dependents,
        recursive: args.recursive,
        summary: args.summary,
    };

    let result = match args.lang.as_str() {
        "rust" => run_main::<LangRust>(&opts),
        "python" => run_main::<LangPython>(&opts),
        _ => Err(format!("Unknown language: {}", args.lang).into()),
    };

    if let Ok(Some(output)) = result {
        println!("{output}");
    }
    Ok(())
}

pub fn main() -> Result<()> {
    let args = Cli::parse();
    run(args)
}