context-creator 1.5.0

High-performance CLI tool to convert codebases to Markdown for LLM context
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Tests for search command respecting .gitignore and hidden files

use assert_cmd::Command;
use predicates::prelude::*;
use std::fs;
use tempfile::TempDir;

/// Helper to create a test project with gitignore
fn create_project_with_gitignore() -> TempDir {
    let temp_dir = TempDir::new().unwrap();
    let base = temp_dir.path();

    // Create directory structure
    fs::create_dir_all(base.join("src")).unwrap();
    fs::create_dir_all(base.join("build")).unwrap();
    fs::create_dir_all(base.join("node_modules")).unwrap();
    fs::create_dir_all(base.join(".git")).unwrap();
    fs::create_dir_all(base.join(".hidden")).unwrap();

    // Create .gitignore
    fs::write(
        base.join(".gitignore"),
        "build/
node_modules/
*.log
temp_*
",
    )
    .unwrap();

    // Create files that should be found
    fs::write(
        base.join("src/main.rs"),
        "fn main() { println!(\"test_pattern\"); }",
    )
    .unwrap();

    fs::write(
        base.join("src/lib.rs"),
        "pub fn test_pattern() -> String { \"test\".to_string() }",
    )
    .unwrap();

    // Create files that should be ignored
    fs::write(
        base.join("build/output.txt"),
        "test_pattern in build directory",
    )
    .unwrap();

    fs::write(
        base.join("node_modules/package.js"),
        "console.log('test_pattern in node_modules');",
    )
    .unwrap();

    fs::write(base.join("debug.log"), "test_pattern in log file").unwrap();

    fs::write(base.join("temp_file.txt"), "test_pattern in temp file").unwrap();

    // Create files in hidden directories
    fs::write(base.join(".git/config"), "[core] test_pattern = true").unwrap();

    fs::write(
        base.join(".hidden/secret.txt"),
        "test_pattern in hidden directory",
    )
    .unwrap();

    temp_dir
}

#[test]
fn test_search_respects_gitignore() {
    let project = create_project_with_gitignore();

    Command::cargo_bin("context-creator")
        .unwrap()
        .arg("search")
        .arg("test_pattern")
        .arg(project.path())
        .assert()
        .success()
        .stdout(predicate::str::contains("main.rs"))
        .stdout(predicate::str::contains("lib.rs"))
        // Should NOT contain ignored files
        .stdout(predicate::str::contains("build").not())
        .stdout(predicate::str::contains("node_modules").not())
        .stdout(predicate::str::contains(".log").not())
        .stdout(predicate::str::contains("temp_").not());
}

#[test]
fn test_search_excludes_hidden_directories() {
    let project = create_project_with_gitignore();

    Command::cargo_bin("context-creator")
        .unwrap()
        .arg("search")
        .arg("test_pattern")
        .arg(project.path())
        .assert()
        .success()
        // Should NOT contain hidden directories
        .stdout(predicate::str::contains(".git").not())
        .stdout(predicate::str::contains(".hidden").not());
}

#[test]
fn test_search_with_paths_style_respects_gitignore() {
    let project = create_project_with_gitignore();

    Command::cargo_bin("context-creator")
        .unwrap()
        .arg("--style")
        .arg("paths")
        .arg("search")
        .arg("test_pattern")
        .arg(project.path())
        .assert()
        .success()
        .stdout(predicate::str::is_match(r"src[/\\]main\.rs").unwrap())
        .stdout(predicate::str::is_match(r"src[/\\]lib\.rs").unwrap())
        // Ensure paths output doesn't contain ignored paths
        .stdout(predicate::str::contains("build").not())
        .stdout(predicate::str::contains("node_modules").not())
        .stdout(predicate::str::contains(".git").not())
        .stdout(predicate::str::contains(".log").not());
}

#[test]
fn test_search_respects_ignore_file() {
    let project = create_project_with_gitignore();

    // Create a .ignore file (which is respected by the ignore crate)
    fs::write(project.path().join(".ignore"), "src/test.rs").unwrap();

    // Also create a file that would normally be included
    fs::write(project.path().join("src/test.rs"), "fn test_pattern() {}").unwrap();

    Command::cargo_bin("context-creator")
        .unwrap()
        .arg("search")
        .arg("test_pattern")
        .arg(project.path())
        .assert()
        .success()
        .stdout(predicate::str::contains("main.rs"))
        .stdout(predicate::str::contains("lib.rs"))
        // Should not contain the file excluded by .ignore
        .stdout(predicate::str::contains("test.rs").not());
}