tokf 0.2.33

Config-driven CLI tool that compresses command output before it reaches an 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
153
154
155
156

#![allow(clippy::unwrap_used, clippy::expect_used)]

use std::fs;
use std::process::Command;

use tempfile::TempDir;

fn tokf() -> Command {
    Command::new(env!("CARGO_BIN_EXE_tokf"))
}

/// Create a temp dir with a project-scoped filter and test suite.
fn setup_project_filter(tmp: &TempDir) {
    let filter_dir = tmp.path().join(".tokf/filters/test");
    fs::create_dir_all(&filter_dir).unwrap();
    fs::write(filter_dir.join("hello.toml"), "command = \"test-hello\"\n").unwrap();

    let suite_dir = filter_dir.join("hello_test");
    fs::create_dir_all(&suite_dir).unwrap();
    fs::write(
        suite_dir.join("basic.toml"),
        r#"name = "basic"
inline = "hello world"

[[expect]]
contains = "hello"
"#,
    )
    .unwrap();
}

/// Create a temp dir with a stdlib-style filter and test suite (filters/ in CWD).
fn setup_stdlib_filter(tmp: &TempDir) {
    let filter_dir = tmp.path().join("filters/test");
    fs::create_dir_all(&filter_dir).unwrap();
    fs::write(filter_dir.join("world.toml"), "command = \"test-world\"\n").unwrap();

    let suite_dir = filter_dir.join("world_test");
    fs::create_dir_all(&suite_dir).unwrap();
    fs::write(
        suite_dir.join("basic.toml"),
        r#"name = "basic"
inline = "hello world"

[[expect]]
contains = "world"
"#,
    )
    .unwrap();
}

#[test]
fn verify_scope_project_finds_project_filters() {
    let tmp = TempDir::new().unwrap();
    setup_project_filter(&tmp);

    let output = tokf()
        .current_dir(tmp.path())
        .args(["verify", "--scope", "project", "--list"])
        .output()
        .unwrap();
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        output.status.success(),
        "stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    assert!(
        stdout.contains("test/hello"),
        "expected project filter in list:\n{stdout}"
    );
}

#[test]
fn verify_scope_project_ignores_stdlib() {
    let tmp = TempDir::new().unwrap();
    // Only create stdlib-style filters, no project filters
    setup_stdlib_filter(&tmp);

    let output = tokf()
        .current_dir(tmp.path())
        .args(["verify", "--scope", "project", "--list"])
        .output()
        .unwrap();
    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);
    // Should not find the stdlib filter
    assert!(
        !stdout.contains("test/world"),
        "project scope should not include stdlib filters:\n{stdout}"
    );
    // Project scope with no .tokf/filters/ → empty discovery → stderr message
    assert!(
        stdout.is_empty(),
        "expected empty stdout for empty scope:\n{stdout}"
    );
    assert!(
        stderr.contains("no test suites discovered"),
        "expected 'no test suites discovered' on stderr:\n{stderr}"
    );
}

// Note: --scope global is not integration-tested because the global config dir
// (e.g. ~/.config/tokf/filters/) is OS-specific and shared across the user's
// session. The unit tests in verify_cmd.rs::tests cover the path logic.

#[test]
fn verify_scope_stdlib_finds_stdlib_filters() {
    let tmp = TempDir::new().unwrap();
    setup_stdlib_filter(&tmp);

    let output = tokf()
        .current_dir(tmp.path())
        .args(["verify", "--scope", "stdlib", "--list"])
        .output()
        .unwrap();
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        output.status.success(),
        "stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    assert!(
        stdout.contains("test/world"),
        "expected stdlib filter in list:\n{stdout}"
    );
}

#[test]
fn verify_no_scope_unchanged() {
    // Default behavior (no --scope) should still work.
    let tmp = TempDir::new().unwrap();
    setup_project_filter(&tmp);
    setup_stdlib_filter(&tmp);

    let output = tokf()
        .current_dir(tmp.path())
        .args(["verify", "--list"])
        .output()
        .unwrap();
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(
        output.status.success(),
        "stderr: {}",
        String::from_utf8_lossy(&output.stderr)
    );
    // Should find both
    assert!(
        stdout.contains("test/hello"),
        "expected project filter:\n{stdout}"
    );
    assert!(
        stdout.contains("test/world"),
        "expected stdlib filter:\n{stdout}"
    );
}