devcat 0.1.5

A micro-version control system for your AI development loop.
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

use crate::{utils, OutputArgs, Result, ExcludeArgs};
use clap::Parser;
use globset::{Glob, GlobSetBuilder};
use ignore::WalkBuilder;
use log::debug;
use std::path::PathBuf;

#[derive(Parser, Debug)]
#[command(about = "Concatenates all non-ignored text files in a specific module directory.")]
pub struct ModuleArgs {
    /// The directory of the module to concatenate.
    #[arg(required = true)]
    path: PathBuf,
    #[command(flatten)]
    pub exclude_args: ExcludeArgs,
    #[command(flatten)]
    output_args: OutputArgs,
}

pub fn run(args: ModuleArgs) -> Result<()> {
    let mut output = String::new();
    
    // Load config and merge excludes
    let config = crate::config::load_config(std::path::Path::new("."))?;
    let mut excludes = args.exclude_args.exclude.clone();
    excludes.extend(config.exclude);

    // Automatically exclude the output file itself to prevent self-inclusion
    if let Some(output_path) = &args.output_args.output {
        if let Some(file_name) = output_path.file_name() {
            excludes.push(file_name.to_string_lossy().to_string());
        }
    }

    let mut glob_builder = GlobSetBuilder::new();
    for pattern in &excludes {
        let glob = Glob::new(&format!("**/{}", pattern))?;
        glob_builder.add(glob);
    }
    let exclude_set = glob_builder.build()?;

    let walker = WalkBuilder::new(&args.path)
        .follow_links(false)
        .filter_entry(move |entry| {
            if entry.path().starts_with("./.devcat") {
                return false;
            }
            if exclude_set.is_match(entry.path()) {
                debug!("Excluding path via --exclude: {}", entry.path().display());
                return false;
            }
            true
        })
        .build();

    for result in walker {
        let entry = result?;
        let path = entry.path();
        if path.is_file() {
            if utils::check_file_signature(path)? {
                debug!("Skipping devcat output file: {}", path.display());
                continue;
            }
            utils::append_file_content(
                path,
                path.strip_prefix(&args.path).unwrap_or(path),
                &mut output,
            )?;
        }
    }

    utils::handle_output(output, &args.output_args, "Module content")
}