vallum 0.8.8

Security boundary between AI coding agents and your shell — redacts secrets, neutralizes prompt injection, sanitizes untrusted terminal output, audits every command.
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

use super::CommandOptimizer;

/// Collapses Ninja's `[N/M] …` build-progress lines while keeping compiler
/// warnings, errors, and any other non-progress output verbatim.
pub struct NinjaOptimizer;

impl CommandOptimizer for NinjaOptimizer {
    fn name(&self) -> &'static str {
        "ninja"
    }

    fn matches(&self, cmd: &str, _args: &[String]) -> bool {
        cmd == "ninja"
    }

    fn optimize(&self, input: &str) -> Option<String> {
        super::collapse_noise_runs(input, 10, is_progress_line, "build steps")
    }
}

/// True for a `[<digits>/<digits>] …` Ninja progress line.
fn is_progress_line(line: &str) -> bool {
    let t = line.trim_start();
    let Some(rest) = t.strip_prefix('[') else {
        return false;
    };
    let Some((counter, _)) = rest.split_once(']') else {
        return false;
    };
    let Some((num, den)) = counter.split_once('/') else {
        return false;
    };
    !num.is_empty()
        && !den.is_empty()
        && num.bytes().all(|b| b.is_ascii_digit())
        && den.bytes().all(|b| b.is_ascii_digit())
}

#[cfg(test)]
mod tests {
    use super::*;

    fn args(items: &[&str]) -> Vec<String> {
        items.iter().map(|s| s.to_string()).collect()
    }

    #[test]
    fn matches_ninja_only() {
        let opt = NinjaOptimizer;
        assert!(opt.matches("ninja", &args(&[])));
        assert!(!opt.matches("make", &args(&[])));
    }

    #[test]
    fn collapses_progress_keeps_warnings() {
        let opt = NinjaOptimizer;
        let mut input = String::new();
        for i in 1..=12 {
            input.push_str(&format!(
                "[{i}/12] Building CXX object src/CMakeFiles/foo.dir/f{i}.cpp.o\n"
            ));
        }
        input.push_str("../src/f3.cpp:10:5: warning: unused variable 'x'\n");
        input.push_str("[12/12] Linking CXX executable foo\n");

        let out = opt.optimize(&input).unwrap();
        assert!(out.contains("build steps hidden"), "got: {out}");
        assert!(out.contains("warning: unused variable 'x'"));
        assert!(out.contains("[summarized by vallum]"));
        assert!(!out.contains("f1.cpp.o"));
    }

    #[test]
    fn passes_through_short_output() {
        let opt = NinjaOptimizer;
        assert!(opt.optimize("[1/1] Linking foo\n").is_none());
    }

    #[test]
    fn non_progress_bracket_line_is_not_noise() {
        assert!(!is_progress_line("[info] building"));
        assert!(!is_progress_line("[1/] partial"));
        assert!(is_progress_line("[7/512] Building"));
    }
}