codepack 0.11.7

A *lightning-fast* tool that transforms a directory into a single, LLM-friendly text file, perfect for easy processing and analysis.
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

use anyhow::Result;
use clap::Parser;
use codepack::{DirectoryProcessor, Filter};
use prettytable::{Cell, Row, Table};
use std::path::Path;

#[derive(Parser, Debug)]
#[command(name = "codepack", version)]
#[command(
    about = "Convert local directory contents into a single text file, useful for processing by an LLM."
)]
struct Args {
    /// Path to the local directory (first argument)
    directory_path: String,

    /// Output file path (optional)author
    #[arg(short, long)]
    output: Option<String>,

    /// File extensions to include (e.g., -e rs -e toml)
    #[arg(short = 'e', long = "extension",  action = clap::ArgAction::Append)]
    extensions: Vec<String>,

    /// Files to exclude from the output, by name/pattern (e.g. -x *.lock -x LICENSE -x node_modules/)
    #[arg(short = 'x', long)]
    excluded_files: Vec<String>,

    /// Suppress the output prompt (description of file formatting)
    #[arg(long)]
    suppress_prompt: bool,

    /// Overwrite output file without confirmation
    #[arg(long)]
    force: bool,

    #[arg(short = 'f', long = "filter", action = clap::ArgAction::Append)]
    filters: Vec<String>,
}

fn main() -> Result<()> {
    log::set_max_level(log::LevelFilter::Info);
    let mut args = Args::parse();
    let directory_path = Path::new(&args.directory_path);

    if !args.output.is_some() {
        args.output = Some({
            let directory_name = directory_path
                .file_name()
                .and_then(|n| n.to_str())
                .unwrap_or("directory");

            // Use the number of files processed to build the description
            format!("{}_code_pack.txt", directory_name)
        });
    }
    let filters = args
        .filters
        .iter()
        .map(|filter| {
            if let Some(value) = filter.strip_prefix("file.name=") {
                Filter::FileName(value.to_string())
            } else if let Some(value) = filter.strip_prefix("path.contains=") {
                Filter::PathContains(value.to_string())
            } else if let Some(value) = filter.strip_prefix("content.contains=") {
                Filter::ContentContains(value.to_string())
            } else {
                panic!("Invalid filter: {}", filter);
            }
        })
        .collect();

    let processor = DirectoryProcessor::new(
        args.extensions,
        args.excluded_files,
        args.suppress_prompt,
        args.output.clone().unwrap(),
        args.force,
        filters,
    );

    // Start the timer
    let start_time = std::time::Instant::now();

    // Run the processing
    let files = processor.run(directory_path)?;

    // Calculate elapsed time
    let duration = start_time.elapsed();
    let formatted_time = format!("{:?}", duration);

    // Output the stats and details in a pretty table
    let mut table = Table::new();
    table.add_row(Row::new(vec![
        Cell::new("Total time taken"),
        Cell::new(&formatted_time),
    ]));
    table.add_row(Row::new(vec![
        Cell::new("Number of files processed"),
        Cell::new(&files.to_string()),
    ]));
    table.printstd();

    println!("\nOutput written to: {:?}", args.output.unwrap());

    Ok(())
}