bctx-weave 0.1.6

use super::node::{FallbackPolicy, MeshNode};
use crate::domains;
use crate::lenses::clarity::ClarityLens;
use crate::lenses::focus::FocusLens;
use crate::lenses::narrow::NarrowLens;
use crate::lenses::{LensContext, LensOutput};

/// Commands that produce streaming / interactive output and must never be compressed.
static PASSTHROUGH_PREFIXES: &[&str] = &[
    // JS/TS dev servers
    "next dev",
    "next start",
    "vite dev",
    "vite preview",
    "vite ",
    "nuxt dev",
    "astro dev",
    "webpack serve",
    "webpack-dev-server",
    "gatsby develop",
    "remix dev",
    "wrangler dev",
    "hugo server",
    "jekyll serve",
    "ember serve",
    // Package script runners (dev servers)
    "npm run dev",
    "npm run start",
    "npm run serve",
    "npm run watch",
    "npm run preview",
    "npm start",
    "pnpm run dev",
    "pnpm run start",
    "pnpm dev",
    "pnpm start",
    "yarn dev",
    "yarn start",
    "yarn serve",
    "yarn watch",
    "bun run dev",
    "bun run start",
    "bun start",
    "deno task dev",
    "deno task start",
    "deno run --watch",
    // Node watchers
    "nodemon",
    "ts-node-dev",
    "concurrently",
    "pm2 logs",
    "pm2 start",
    // Test watchers
    "vitest watch",
    "jest --watch",
    "jest --watchAll",
    "npm run test:watch",
    "pnpm run test:watch",
    // Docker streaming
    "docker compose up",
    "docker-compose up",
    "docker compose logs",
    "docker-compose logs",
    "docker logs -f",
    "docker attach",
    "docker exec -it",
    "docker stats",
    // Kubernetes streaming
    "kubectl logs -f",
    "kubectl port-forward",
    "kubectl exec -it",
    "kubectl attach",
    "kubectl proxy",
    // System monitors
    "top",
    "htop",
    "btop",
    "bpytop",
    "glances",
    "watch ",
    "tail -f",
    "journalctl -f",
    "journalctl -fu",
    // Build watchers
    "cargo watch",
    "watchexec",
    "entr",
    // Misc interactive
    "ssh ",
    "sftp ",
    "ftp ",
    "telnet ",
];

pub struct FilterMesh {
    nodes: Vec<MeshNode>,
}

impl FilterMesh {
    pub fn new() -> Self {
        Self { nodes: Vec::new() }
    }

    pub fn register(&mut self, node: MeshNode) {
        self.nodes.push(node);
    }

    pub fn find(&self, program: &str, args: &[String]) -> Option<&MeshNode> {
        self.nodes.iter().find(|n| (n.matcher)(program, args))
    }

    pub fn apply(
        &self,
        program: &str,
        args: &[String],
        input: &str,
        ctx: &LensContext,
    ) -> LensOutput {
        // Check passthrough list first (streaming commands → no compression)
        let full_cmd = format!("{} {}", program, args.join(" ")).trim().to_string();
        if is_passthrough(&full_cmd) {
            return LensOutput::passthrough(input);
        }

        match self.find(program, args) {
            Some(node) => {
                let enriched = if ctx.subcmd.is_empty() {
                    let mut c = ctx.clone();
                    c.subcmd = args.first().cloned().unwrap_or_default();
                    std::borrow::Cow::Owned(c)
                } else {
                    std::borrow::Cow::Borrowed(ctx)
                };
                node.apply(input, &enriched)
            }
            None => LensOutput::passthrough(input),
        }
    }

    pub fn default_mesh() -> Self {
        let mut mesh = Self::new();

        // ── VCS: git ─────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "git".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "git"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::vcs::git::compress_git(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── VCS: gh (GitHub CLI) ──────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "gh".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "gh"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::vcs::gh::compress_gh(&ctx.subcmd, raw)
            })),
        });

        // ── cargo build / check / clippy ──────────────────────────────────────
        mesh.register(MeshNode {
            name: "cargo-build".into(),
            matcher: Box::new(|prog, args| {
                prog_name(prog) == "cargo"
                    && args
                        .first()
                        .map(|s| matches!(s.as_str(), "build" | "b" | "check" | "c" | "clippy"))
                        .unwrap_or(false)
            }),
            lens_stack: vec![
                Box::new(ClarityLens),
                Box::new(FocusLens),
                Box::new(NarrowLens),
            ],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::cargo::compress_cargo(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── cargo test ────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "cargo-test".into(),
            matcher: Box::new(|prog, args| {
                prog_name(prog) == "cargo"
                    && args
                        .first()
                        .map(|s| matches!(s.as_str(), "test" | "t" | "nextest"))
                        .unwrap_or(false)
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::cargo::compress_test(raw, ctx.exit_code)
            })),
        });

        // ── cargo misc (tree/add/update/fmt/bench/doc/publish/run) ───────────
        mesh.register(MeshNode {
            name: "cargo-misc".into(),
            matcher: Box::new(|prog, args| {
                prog_name(prog) == "cargo"
                    && args
                        .first()
                        .map(|s| {
                            matches!(
                                s.as_str(),
                                "tree"
                                    | "add"
                                    | "remove"
                                    | "rm"
                                    | "update"
                                    | "fmt"
                                    | "bench"
                                    | "doc"
                                    | "publish"
                                    | "run"
                                    | "r"
                            )
                        })
                        .unwrap_or(false)
            }),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::cargo::compress_cargo(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── go build / test ───────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "go".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "go"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::go::compress_go(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── tsc / tsup / esbuild ──────────────────────────────────────────────
        // We default to `tsc` behaviour; tsup/esbuild get more specific handling
        // via their own output shapes in compress_typescript.
        mesh.register(MeshNode {
            name: "tsc".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "tsc"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::typescript::compress_tsc(raw, ctx.exit_code)
            })),
        });

        mesh.register(MeshNode {
            name: "tsup".into(),
            matcher: Box::new(|prog, _| {
                matches!(prog_name(prog), "tsup" | "unbuild" | "esbuild" | "swc")
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::build::typescript::compress_tsup(raw)
            })),
        });

        // ── gradle ────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "gradle".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "gradle" | "gradlew")),
            lens_stack: vec![
                Box::new(ClarityLens),
                Box::new(FocusLens),
                Box::new(NarrowLens),
            ],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::gradle::compress_gradle(raw, ctx.exit_code)
            })),
        });

        // ── maven ─────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "maven".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "mvn" | "mvnw")),
            lens_stack: vec![
                Box::new(ClarityLens),
                Box::new(FocusLens),
                Box::new(NarrowLens),
            ],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::gradle::compress_maven(raw, ctx.exit_code)
            })),
        });

        // ── make / cmake ──────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "make".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "make" | "gmake")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::make::compress_make(raw, ctx.exit_code)
            })),
        });

        mesh.register(MeshNode {
            name: "cmake".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "cmake" | "ctest")),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::build::make::compress_cmake(raw)
            })),
        });

        // ── docker ────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "docker".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "docker" | "docker-compose")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::infra::docker::compress_docker(&ctx.subcmd, raw)
            })),
        });

        // ── kubectl ───────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "kubectl".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "kubectl" | "k")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::infra::kubectl::compress_kubectl(&ctx.subcmd, raw)
            })),
        });

        // ── terraform ─────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "terraform".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "terraform"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::infra::terraform::compress_terraform(&ctx.subcmd, raw)
            })),
        });

        // ── aws ───────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "aws".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "aws"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::infra::aws::compress_aws(&ctx.subcmd, raw)
            })),
        });

        // ── npm / yarn ────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "npm".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "npm" | "yarn")),
            lens_stack: vec![
                Box::new(ClarityLens),
                Box::new(FocusLens),
                Box::new(NarrowLens),
            ],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::pkg::npm::compress_npm(&ctx.subcmd, raw)
            })),
        });

        // ── pnpm ──────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "pnpm".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "pnpm"),
            lens_stack: vec![
                Box::new(ClarityLens),
                Box::new(FocusLens),
                Box::new(NarrowLens),
            ],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::pkg::pnpm::compress_pnpm(&ctx.subcmd, raw)
            })),
        });

        // ── bun ───────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "bun".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "bun" | "bunx")),
            lens_stack: vec![
                Box::new(ClarityLens),
                Box::new(FocusLens),
                Box::new(NarrowLens),
            ],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::pkg::bun::compress_bun(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── pip / pip3 ────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "pip".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "pip" | "pip3")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::pkg::pip::compress_pip(&ctx.subcmd, raw)
            })),
        });

        // ── poetry / uv / conda ───────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "poetry".into(),
            matcher: Box::new(|prog, _| {
                matches!(
                    prog_name(prog),
                    "poetry" | "uv" | "conda" | "mamba" | "pipx"
                )
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::pkg::poetry::compress_poetry(raw)
            })),
        });

        // ── pytest ────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "pytest".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "pytest" | "py.test")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::test::pytest::compress_pytest(raw, ctx.exit_code)
            })),
        });

        // ── jest / mocha ──────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "jest".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "jest" | "mocha")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::test::jest::compress_jest(raw, ctx.exit_code)
            })),
        });

        // ── playwright ────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "playwright".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "playwright"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::test::playwright::compress_playwright(raw, ctx.exit_code)
            })),
        });

        // ── rspec / rake ──────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "rspec".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "rspec" | "rake" | "ruby")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::test::ruby::compress_ruby_test(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── ruff ──────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "ruff".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "ruff"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::lint::ruff::compress_ruff_check(raw)
            })),
        });

        // ── mypy / dmypy ──────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "mypy".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "mypy" | "dmypy")),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::lint::mypy::compress_mypy(raw)
            })),
        });

        // ── eslint / biome / stylelint ────────────────────────────────────────
        mesh.register(MeshNode {
            name: "eslint".into(),
            matcher: Box::new(|prog, _| {
                matches!(prog_name(prog), "eslint" | "biome" | "stylelint")
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::lint::eslint::compress_eslint(raw)
            })),
        });

        // ── rubocop / bundle-audit ────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "rubocop".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "rubocop"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::lint::rubocop::compress_rubocop(raw, ctx.exit_code)
            })),
        });

        mesh.register(MeshNode {
            name: "bundle-audit".into(),
            matcher: Box::new(|prog, _| {
                matches!(prog_name(prog), "bundle-audit" | "bundler-audit")
            }),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::lint::rubocop::compress_bundle_audit(raw)
            })),
        });

        // ── golangci-lint ─────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "golangci-lint".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "golangci-lint" | "golangci")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::lint::golangci::compress_golangci(raw, ctx.exit_code)
            })),
        });

        // ── generic lint (flake8, pylint, swiftlint) ─────────────────────────
        mesh.register(MeshNode {
            name: "lint-generic".into(),
            matcher: Box::new(|prog, _| {
                matches!(prog_name(prog), "flake8" | "pylint" | "swiftlint")
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::lint::compress_lint_grouped(raw)
            })),
        });

        // ── curl ──────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "curl".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "curl"),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::sys::curl::compress_curl(&ctx.subcmd, raw)
            })),
        });

        // ── psql / sqlite3 ────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "psql".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "psql" | "sqlite3" | "mongosh")),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| domains::db::compress_psql(raw))),
        });

        // ── mysql / mariadb ───────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "mysql".into(),
            matcher: Box::new(|prog, _| {
                matches!(prog_name(prog), "mysql" | "mariadb" | "mycli" | "mysqldump")
            }),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                if ctx.subcmd == "mysqldump" {
                    domains::db::mysql::compress_mysqldump(raw)
                } else {
                    domains::db::mysql::compress_mysql(raw)
                }
            })),
        });

        // ── prisma ────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "prisma".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "prisma"),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::db::prisma::compress_prisma(&ctx.subcmd, raw)
            })),
        });

        // ── ls / find / grep / rg ────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "ls".into(),
            matcher: Box::new(|prog, _| {
                matches!(prog_name(prog), "ls" | "ll" | "la" | "exa" | "lsd")
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| domains::sys::compress_ls(raw, 200))),
        });

        mesh.register(MeshNode {
            name: "find".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "find" | "fd")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| domains::sys::compress_find(raw))),
        });

        mesh.register(MeshNode {
            name: "grep".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "grep" | "rg" | "ag" | "ack")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| domains::sys::compress_grep(raw))),
        });

        // ── env / printenv ────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "env".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "env" | "printenv" | "export")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| domains::sys::compress_env(raw))),
        });

        // ── jq ────────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "jq".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "jq" | "yq" | "fx")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| domains::sys::compress_jq_output(raw))),
        });

        // ── systemctl / journalctl ────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "systemd".into(),
            matcher: Box::new(|prog, _| {
                matches!(prog_name(prog), "systemctl" | "journalctl" | "service")
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                if ctx.subcmd.is_empty() || ctx.subcmd == "journalctl" {
                    domains::sys::systemd::compress_journalctl(raw)
                } else {
                    domains::sys::systemd::compress_systemctl(&ctx.subcmd, raw)
                }
            })),
        });

        // ── helm ──────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "helm".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "helm"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::infra::helm::compress_helm(&ctx.subcmd, raw)
            })),
        });

        // ── ansible ───────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "ansible".into(),
            matcher: Box::new(|prog, _| {
                matches!(
                    prog_name(prog),
                    "ansible" | "ansible-playbook" | "ansible-galaxy" | "ansible-vault"
                )
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::infra::ansible::compress_ansible(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── dotnet ────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "dotnet".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "dotnet"),
            lens_stack: vec![
                Box::new(ClarityLens),
                Box::new(FocusLens),
                Box::new(NarrowLens),
            ],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::dotnet::compress_dotnet(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── swift ─────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "swift".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "swift"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::swift::compress_swift(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── zig ───────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "zig".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "zig"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::zig::compress_zig(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── flutter / dart ────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "flutter".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "flutter" | "dart")),
            lens_stack: vec![
                Box::new(ClarityLens),
                Box::new(FocusLens),
                Box::new(NarrowLens),
            ],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::flutter::compress_flutter(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── bazel ─────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "bazel".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "bazel" | "bazelisk" | "bb")),
            lens_stack: vec![
                Box::new(ClarityLens),
                Box::new(FocusLens),
                Box::new(NarrowLens),
            ],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::bazel::compress_bazel(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── composer / artisan ────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "composer".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "composer" | "artisan")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::pkg::composer::compress_composer(&ctx.subcmd, raw)
            })),
        });

        // ── mix (Elixir) ──────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "mix".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "mix"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::pkg::mix::compress_mix(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── deno ──────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "deno".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "deno"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::pkg::deno::compress_deno(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        // ── prettier ──────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "prettier".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "prettier"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::lint::prettier::compress_prettier(raw, ctx.exit_code)
            })),
        });

        // ── wget ──────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "wget".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "wget"),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| domains::sys::wget::compress_wget(raw))),
        });

        // ── ps / df / du / lsof / netstat / ss ───────────────────────────────
        mesh.register(MeshNode {
            name: "ps".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "ps"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::sys::sysinfo::compress_ps(raw)
            })),
        });

        mesh.register(MeshNode {
            name: "df".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "df"),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::sys::sysinfo::compress_df(raw)
            })),
        });

        mesh.register(MeshNode {
            name: "du".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "du"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::sys::sysinfo::compress_du(raw)
            })),
        });

        mesh.register(MeshNode {
            name: "lsof".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "lsof"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::sys::sysinfo::compress_lsof(raw)
            })),
        });

        mesh.register(MeshNode {
            name: "netstat".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "netstat" | "ss")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::sys::sysinfo::compress_netstat(raw)
            })),
        });

        // ── jj (Jujutsu VCS) ──────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "jj".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "jj"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::vcs::jj::compress_jj(&ctx.subcmd, raw)
            })),
        });

        // ── gem / bundler ─────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "gem".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "gem"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::pkg::gem::compress_gem(&ctx.subcmd, raw)
            })),
        });

        mesh.register(MeshNode {
            name: "bundle".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "bundle" | "bundler")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::pkg::gem::compress_bundle(&ctx.subcmd, raw)
            })),
        });

        // ── vite / next / turbo ───────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "vite".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "vite"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::vite::compress_vite(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        mesh.register(MeshNode {
            name: "next".into(),
            matcher: Box::new(|prog, args| {
                prog_name(prog) == "next"
                    || (prog_name(prog) == "npx"
                        && args.first().map(|s| s == "next").unwrap_or(false))
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::vite::compress_next(&ctx.subcmd, raw, ctx.exit_code)
            })),
        });

        mesh.register(MeshNode {
            name: "turbo".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "turbo" | "turborepo")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::build::vite::compress_turbo(raw)
            })),
        });

        // ── vitest ────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "vitest".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "vitest"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::test::vitest::compress_vitest(raw, ctx.exit_code)
            })),
        });

        // ── npx / pnpm dlx ────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "npx".into(),
            matcher: Box::new(|prog, _| matches!(prog_name(prog), "npx" | "pnpm-dlx")),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| domains::pkg::npm::compress_npx(raw))),
        });

        // ── cargo nextest (higher priority than cargo-test) ───────────────────
        mesh.register(MeshNode {
            name: "cargo-nextest".into(),
            matcher: Box::new(|prog, args| {
                prog_name(prog) == "cargo" && args.first().map(|s| s.as_str()) == Some("nextest")
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::cargo::compress_nextest(raw, ctx.exit_code)
            })),
        });

        // ── cargo clippy (higher priority than cargo-misc) ────────────────────
        mesh.register(MeshNode {
            name: "cargo-clippy".into(),
            matcher: Box::new(|prog, args| {
                prog_name(prog) == "cargo" && args.first().map(|s| s.as_str()) == Some("clippy")
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::build::cargo::compress_clippy(raw)
            })),
        });

        // ── cargo fmt / rustfmt ───────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "cargo-fmt".into(),
            matcher: Box::new(|prog, args| {
                (prog_name(prog) == "cargo" && args.first().map(|s| s.as_str()) == Some("fmt"))
                    || prog_name(prog) == "rustfmt"
            }),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                let sub = if ctx.exit_code != 0 { "check" } else { "" };
                domains::build::rustfmt::compress_rustfmt(sub, raw)
            })),
        });

        // ── uv ────────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "uv".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "uv"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::pkg::uv::compress_uv(&ctx.subcmd, raw)
            })),
        });

        // ── docker compose (separate from docker build/pull/push) ─────────────
        mesh.register(MeshNode {
            name: "docker-compose".into(),
            matcher: Box::new(|prog, args| {
                prog_name(prog) == "docker-compose"
                    || (prog_name(prog) == "docker"
                        && args.first().map(|s| s.as_str()) == Some("compose"))
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                let sub = if ctx.subcmd.starts_with("compose ") {
                    ctx.subcmd.trim_start_matches("compose").trim()
                } else {
                    ctx.subcmd.as_str()
                };
                domains::infra::docker_compose::compress_compose(sub, raw)
            })),
        });

        // ── biome ─────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "biome".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "biome"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::lint::biome::compress_biome(&ctx.subcmd, raw)
            })),
        });

        // ── trivy ─────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "trivy".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "trivy"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::lint::trivy::compress_trivy(&ctx.subcmd, raw)
            })),
        });

        // ── buf ───────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "buf".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "buf"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::build::buf::compress_buf(&ctx.subcmd, raw)
            })),
        });

        // ── hadolint ──────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "hadolint".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "hadolint"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::lint::hadolint::compress_hadolint(raw)
            })),
        });

        // ── semgrep ───────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "semgrep".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "semgrep"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::lint::semgrep::compress_semgrep(&ctx.subcmd, raw)
            })),
        });

        // ── mise ──────────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "mise".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "mise"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::sys::mise::compress_mise(&ctx.subcmd, raw)
            })),
        });

        // ── swiftlint ─────────────────────────────────────────────────────────
        mesh.register(MeshNode {
            name: "swiftlint".into(),
            matcher: Box::new(|prog, _| prog_name(prog) == "swiftlint"),
            lens_stack: vec![Box::new(ClarityLens), Box::new(FocusLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::lint::swiftlint::compress_swiftlint(raw)
            })),
        });

        // ── gh-run (higher priority than gh) ──────────────────────────────────
        mesh.register(MeshNode {
            name: "gh-run".into(),
            matcher: Box::new(|prog, args| {
                prog_name(prog) == "gh" && args.first().map(|s| s.as_str()) == Some("run")
            }),
            lens_stack: vec![Box::new(ClarityLens), Box::new(NarrowLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, ctx| {
                domains::vcs::gh::compress_gh(&ctx.subcmd, raw)
            })),
        });

        // ── gh-pr-checks (higher priority than gh) ────────────────────────────
        mesh.register(MeshNode {
            name: "gh-pr-checks".into(),
            matcher: Box::new(|prog, args| {
                prog_name(prog) == "gh"
                    && args.first().map(|s| s.as_str()) == Some("pr")
                    && args.get(1).map(|s| s.as_str()) == Some("checks")
            }),
            lens_stack: vec![Box::new(ClarityLens)],
            fallback: FallbackPolicy::Passthrough,
            preprocessor: Some(Box::new(|raw, _ctx| {
                domains::vcs::gh::compress_pr_checks(raw)
            })),
        });

        mesh
    }
}

impl Default for FilterMesh {
    fn default() -> Self {
        Self::default_mesh()
    }
}

fn prog_name(prog: &str) -> &str {
    prog.split('/').next_back().unwrap_or(prog)
}

/// Passthrough check: command starts with any known streaming prefix.
fn is_passthrough(full_cmd: &str) -> bool {
    let lc = full_cmd.to_ascii_lowercase();
    PASSTHROUGH_PREFIXES.iter().any(|p| lc.starts_with(p))
}

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

    #[test]
    fn passthrough_dev_server() {
        assert!(is_passthrough("next dev --port 3000"));
        assert!(is_passthrough("npm run dev"));
        assert!(is_passthrough("docker compose up"));
        assert!(is_passthrough("kubectl logs -f my-pod"));
    }

    #[test]
    fn passthrough_does_not_match_build() {
        assert!(!is_passthrough("npm run build"));
        assert!(!is_passthrough("docker build ."));
        assert!(!is_passthrough("kubectl get pods"));
    }

    #[test]
    fn mesh_routes_git() {
        let mesh = FilterMesh::default_mesh();
        let ctx = LensContext::new(4000);
        let raw = "On branch main\nnothing to commit, working tree clean\n";
        let out = mesh.apply("git", &["status".to_string()], raw, &ctx);
        // Compressed output should be shorter or equal
        assert!(out.tokens_after <= out.tokens_before + 5);
    }

    #[test]
    fn mesh_routes_cargo() {
        let mesh = FilterMesh::default_mesh();
        let ctx = LensContext::new(4000);
        let raw =
            "   Compiling foo v0.1.0\n   Compiling bar v0.2.0\nerror[E0412]: type not found\n";
        let out = mesh.apply("cargo", &["build".to_string()], raw, &ctx);
        assert!(!out.content.contains("Compiling foo"), "{}", out.content);
        assert!(out.content.contains("error"));
    }

    #[test]
    fn mesh_routes_docker_pull() {
        let mesh = FilterMesh::default_mesh();
        let ctx = LensContext::new(4000);
        let raw = "abc123: Pull complete\ndef456: Pull complete\nStatus: Downloaded newer image for ubuntu:22.04\n";
        let out = mesh.apply(
            "docker",
            &["pull".to_string(), "ubuntu:22.04".to_string()],
            raw,
            &ctx,
        );
        assert!(!out.content.contains("Pull complete"), "{}", out.content);
        assert!(out.content.contains("Downloaded newer image") || out.content.contains("ubuntu"));
    }

    #[test]
    fn mesh_routes_npm_install() {
        let mesh = FilterMesh::default_mesh();
        let ctx = LensContext::new(4000);
        let raw = "npm verb cli /usr/bin/node\nnpm info timing npm Completed in 2000ms\nadded 42 packages in 3s\n";
        let out = mesh.apply("npm", &["install".to_string()], raw, &ctx);
        assert!(!out.content.contains("npm verb"), "{}", out.content);
        assert!(out.content.contains("added 42 packages"));
    }
}