bctx-weave 0.1.16

bctx-weave — FilterMesh lens pipeline, CLI interception, domain compression
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

pub mod biome;
pub mod cargo_deny;
pub mod cosign;
pub mod eslint;
pub mod flake8;
pub mod golangci;
pub mod grype;
pub mod hadolint;
pub mod mypy;
pub mod prettier;
pub mod pylint;
pub mod rubocop;
pub mod ruff;
pub mod semgrep;
pub mod stylelint;
pub mod swiftlint;
pub mod syft;
pub mod trivy;

use forge::signal::compactor;
use std::collections::HashMap;

/// Route linter output to the right compressor by program name.
pub fn compress_linter(prog: &str, subcmd: &str, raw: &str, exit_code: i32) -> String {
    match prog {
        "ruff" => ruff::compress_ruff_check(raw),
        "mypy" | "dmypy" => mypy::compress_mypy(raw),
        "flake8" => flake8::compress_flake8(raw),
        "pylint" => pylint::compress_pylint(raw),
        "eslint" => eslint::compress_eslint(raw),
        "stylelint" => stylelint::compress_stylelint(raw),
        "cargo-deny" => cargo_deny::compress_deny(raw),
        "prettier" => prettier::compress_prettier(raw, exit_code),
        "rubocop" => rubocop::compress_rubocop(raw, exit_code),
        "bundle-audit" => rubocop::compress_bundle_audit(raw),
        "golangci-lint" | "golangci" => golangci::compress_golangci(raw, exit_code),
        "biome" => biome::compress_biome(subcmd, raw),
        "hadolint" => hadolint::compress_hadolint(raw),
        "semgrep" => semgrep::compress_semgrep(subcmd, raw),
        "swiftlint" => swiftlint::compress_swiftlint(raw),
        "trivy" => trivy::compress_trivy(subcmd, raw),
        "grype" => grype::compress_grype(raw),
        "syft" => syft::compress_syft(raw),
        "cosign" => cosign::compress_cosign(subcmd, raw),
        _ => {
            let _ = subcmd;
            compress_lint_grouped(raw)
        }
    }
}

/// Compress linter output by grouping identical rule violations.
/// Used for cargo clippy and generic linters.
pub fn compress_lint_grouped(raw: &str) -> String {
    let cleaned = compactor::normalise(raw);
    let mut counts: HashMap<String, usize> = HashMap::new();
    let mut errors_and_misc = Vec::new();

    for line in cleaned.lines() {
        if line.contains("warning:") || line.contains("note:") {
            let key = line.split("-->").next().unwrap_or(line).trim().to_string();
            *counts.entry(key).or_insert(0) += 1;
        } else {
            errors_and_misc.push(line.to_string());
        }
    }

    let mut result = errors_and_misc;
    for (rule, count) in &counts {
        if *count > 1 {
            result.push(format!("{rule} (×{count})"));
        } else {
            result.push(rule.clone());
        }
    }
    result.join("\n")
}

/// Legacy 3-arg signature kept for existing callers.
#[allow(dead_code)]
pub fn compress_linter_compat(prog: &str, subcmd: &str, raw: &str) -> String {
    compress_linter(prog, subcmd, raw, 0)
}