double-o 0.5.0

Context-efficient command runner for AI coding agents
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280

// Tests for built-in patterns

use double_o::pattern::{extract_failure, extract_summary, find_matching};

#[test]
fn test_builtin_pytest_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("pytest tests/ -x", patterns).unwrap();
    let output = "collected 47 items\n\
                   .................\n\
                   47 passed in 3.2s\n";
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "47 passed, 3.2s");
}

#[test]
fn test_builtin_pytest_failure_tail() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("pytest -x", patterns).unwrap();
    let fail_pat = pat.failure.as_ref().unwrap();
    let lines: String = (0..50).map(|i| format!("line {i}\n")).collect();
    let result = extract_failure(fail_pat, &lines);
    // tail 30 lines from 50 → lines 20..49
    assert!(result.contains("line 20"));
    assert!(result.contains("line 49"));
    assert!(!result.contains("line 0\n"));
}

#[test]
fn test_builtin_cargo_test_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("cargo test --release", patterns).unwrap();
    let output = "running 15 tests\n\
                   test result: ok. 15 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 3.45s\n";
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "15 passed, 3.45s");
}

#[test]
fn test_command_matching() {
    let patterns = double_o::pattern::builtins();
    assert!(find_matching("pytest tests/", patterns).is_some());
    assert!(find_matching("cargo test", patterns).is_some());
    assert!(find_matching("cargo build", patterns).is_some());
    assert!(find_matching("go test ./...", patterns).is_some());
    assert!(find_matching("ruff check src/", patterns).is_some());
    assert!(find_matching("eslint .", patterns).is_some());
    assert!(find_matching("tsc --noEmit", patterns).is_some());
    assert!(find_matching("cargo clippy", patterns).is_some());
}

#[test]
fn test_no_match_unknown_command() {
    let patterns = double_o::pattern::builtins();
    assert!(find_matching("curl https://example.com", patterns).is_none());
}

// -----------------------------------------------------------------------
// New built-in pattern tests (issue #58)
// -----------------------------------------------------------------------

#[test]
fn test_builtin_npm_test_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("npm test", patterns).unwrap();
    let output =
        "Test Suites: 1 passed, 1 total\nTests:       10 passed, 10 total\nTime:        2.345 s";
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "10 passed, 2.345s");
}

#[test]
fn test_builtin_yarn_test_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("yarn test", patterns).unwrap();
    let output =
        "Test Suites: 1 passed, 1 total\nTests:       15 passed, 15 total\nTime:        1.234 s";
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "15 passed, 1.234s");
}

#[test]
fn test_builtin_pnpm_test_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("pnpm test", patterns).unwrap();
    let output =
        "Test Suites: 2 passed, 2 total\nTests:       20 passed, 20 total\nTime:        3.456 s";
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "20 passed, 3.456s");
}

#[test]
fn test_builtin_bun_test_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("bun test", patterns).unwrap();
    let output =
        "Test Suites: 1 passed, 1 total\nTests:       5 passed, 5 total\nTime:        0.456 s";
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "5 passed, 0.456s");
}

#[test]
fn test_builtin_npx_jest_success() {
    let patterns = double_o::pattern::builtins();
    // The existing jest/vitest pattern should match npx jest
    // Note: existing pattern doesn't have (?s) so it won't match multi-line output
    // For now, just verify the pattern exists and matches the command
    let pat = find_matching("npx jest", patterns).unwrap();
    assert!(pat.command_match.is_match("npx jest"));
}

#[test]
fn test_builtin_cargo_tarpaulin_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("cargo tarpaulin", patterns).unwrap();
    let output = "|| Tested/Total Lines:\n|| src/main.rs: 100%\n|| Overall coverage: 85.2%";
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "85.2% coverage");
}

#[test]
fn test_builtin_cargo_fmt_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("cargo fmt", patterns).unwrap();
    let output = ""; // silent success
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "");
}

#[test]
fn test_builtin_cargo_fmt_failure() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("cargo fmt", patterns).unwrap();
    let fail_pat = pat.failure.as_ref().unwrap();
    let output = "Diff in src/main.rs at line 10:\n---\n+++\n-let x=1\n+let x = 1\n";
    let result = extract_failure(fail_pat, output);
    assert!(result.contains("Diff in"));
}

#[test]
fn test_builtin_mypy_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("mypy src/", patterns).unwrap();
    let output = "Success: no issues found";
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "Success: no issues found");
}

#[test]
fn test_builtin_mypy_failure() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("mypy src/", patterns).unwrap();
    let fail_pat = pat.failure.as_ref().unwrap();
    let output = "src/main.py:10: error: Incompatible return value type\nsrc/main.py:15: error: Name 'x' not defined\nFound 2 errors in 1 file";
    let result = extract_failure(fail_pat, output);
    assert!(result.contains("Found 2 errors"));
}

#[test]
fn test_builtin_rubocop_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("rubocop", patterns).unwrap();
    let output = "5 files inspected, 0 offenses detected";
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "0 offenses");
}

#[test]
fn test_builtin_rubocop_failure() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("rubocop", patterns).unwrap();
    let fail_pat = pat.failure.as_ref().unwrap();
    let output = "Inspecting 5 files\n.offenses detected\nC\nRuboCop: 5 files inspected, 12 offenses detected";
    let result = extract_failure(fail_pat, output);
    assert!(result.contains("12 offenses"));
}

#[test]
fn test_builtin_ruff_format_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("ruff format", patterns).unwrap();
    let output = "3 files reformatted";
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "3 files reformatted");
}

#[test]
fn test_builtin_ruff_format_failure() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("ruff format", patterns).unwrap();
    let fail_pat = pat.failure.as_ref().unwrap();
    let output = "error: file not found foo.py\n";
    let result = extract_failure(fail_pat, output);
    assert!(result.contains("error:"));
}

#[test]
fn test_builtin_prettier_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("prettier --check", patterns).unwrap();
    let output = ""; // quiet on success
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "");
}

#[test]
fn test_builtin_prettier_failure() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("prettier --check", patterns).unwrap();
    let fail_pat = pat.failure.as_ref().unwrap();
    let output = "file1.js\nfile2.js\nCode style issues found in the above file";
    let result = extract_failure(fail_pat, output);
    assert!(result.contains("Code style issues"));
}

#[test]
fn test_builtin_npm_build_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("npm run build", patterns).unwrap();
    let output = ""; // quiet success
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "");
}

#[test]
fn test_builtin_npm_build_failure() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("npm run build", patterns).unwrap();
    let fail_pat = pat.failure.as_ref().unwrap();
    let output = "error TS2307: Cannot find module 'react'\n    at main.ts:3:1\n";
    let result = extract_failure(fail_pat, output);
    assert!(result.contains("error"));
}

#[test]
fn test_builtin_yarn_build_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("yarn build", patterns).unwrap();
    let output = "Done in 2.3s";
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "Done in 2.3s");
}

#[test]
fn test_builtin_pnpm_build_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("pnpm build", patterns).unwrap();
    let output = ""; // quiet success
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "");
}

#[test]
fn test_builtin_bun_build_success() {
    let patterns = double_o::pattern::builtins();
    let pat = find_matching("bun build", patterns).unwrap();
    let output = ""; // quiet success
    let summary = extract_summary(pat.success.as_ref().unwrap(), output).unwrap();
    assert_eq!(summary, "");
}

#[test]
fn test_all_new_patterns_match_commands() {
    let patterns = double_o::pattern::builtins();
    assert!(find_matching("npm test", patterns).is_some());
    assert!(find_matching("yarn test", patterns).is_some());
    assert!(find_matching("pnpm test", patterns).is_some());
    assert!(find_matching("bun test", patterns).is_some());
    assert!(find_matching("npx jest", patterns).is_some());
    assert!(find_matching("cargo tarpaulin", patterns).is_some());
    assert!(find_matching("cargo fmt", patterns).is_some());
    assert!(find_matching("mypy src/", patterns).is_some());
    assert!(find_matching("rubocop", patterns).is_some());
    assert!(find_matching("ruff format", patterns).is_some());
    assert!(find_matching("prettier", patterns).is_some());
    assert!(find_matching("npm run build", patterns).is_some());
    assert!(find_matching("yarn build", patterns).is_some());
    assert!(find_matching("pnpm build", patterns).is_some());
    assert!(find_matching("bun build", patterns).is_some());
}