pi-squeeze 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sorin Albu-Irimies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,97 @@
-# Temporary Holding Version
+# pi-squeeze
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm](https://img.shields.io/npm/v/pi-squeeze.svg)](https://www.npmjs.com/package/pi-squeeze)
+[![CI](https://github.com/sorinirimies/pi-squeeze/actions/workflows/ci.yml/badge.svg)](https://github.com/sorinirimies/pi-squeeze/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Audit](https://github.com/sorinirimies/pi-squeeze/actions/workflows/security.yml/badge.svg)](https://github.com/sorinirimies/pi-squeeze/actions/workflows/security.yml)
+[![Fuzz](https://github.com/sorinirimies/pi-squeeze/actions/workflows/fuzz.yml/badge.svg)](https://github.com/sorinirimies/pi-squeeze/actions/workflows/fuzz.yml)
+
+Shrinks bash output before it reaches the agent's context: native compactors for git, cargo, rg, ls, test and build output, plus rtk when installed. Full output stays one temp file away.
+
+A [pi](https://github.com/earendil-works/pi-coding-agent) extension.
+
+## Install
+
+```bash
+pi install npm:pi-squeeze
+```
+
+## What it does
+
+After a `bash` command, pi-squeeze replaces its output with a shorter form with the same facts.
+It only touches output it fully understands, and otherwise passes it through unchanged:
+
+| Command | Becomes |
+|---|---|
+| `rg -n` / `grep -rn` | totals line, then matches grouped by file (path written once, indent trimmed, long lines and busy files cut) |
+| `rg pattern dir` / `grep -r` (no `-n`) | the same, but only when every `path:` prefix is a file that exists in the session's directory (a colon in the text is never taken for a path) |
+| `fd`, `find` | paths grouped by directory |
+| `lsd -l`, `eza -l`, `ls -l` | type, size, short date and name (owner, group, permissions and the `total` line dropped) |
+| `git diff` | one header line per file (`path (new, +12 −0)`), `index`/mode/`---`/`+++` lines dropped, every changed line kept, context trimmed to 1 line, long files cut |
+| `cargo test` | totals line, then only warnings, failures, panics and result lines (build progress and passing tests dropped); also when the run failed |
+| `rg -l` / `rg --files` / `grep -l` / `git ls-files` / `git diff --name-only` | paths grouped by directory |
+| `git status` | `## main...origin/main [ahead 2]`, then `staged:` / `unstaged:` / `untracked:` with `M`/`A`/`D`/`R` codes; the hints go |
+| `git log` | one line per commit (short hash, date, author, subject); the body stays, capped at 8 lines; one author is said once |
+| `git show` | that commit line, then the compacted diff |
+| `git blame` | one header per run of lines from the same commit |
+| `dust` | size, tree and share; the bar chart goes |
+| `cargo build` / `check` / `clippy` / `doc` | errors keep their whole block; warnings become one line each, grouped by lint (`clippy::needless_return (2)`); `Compiling`/`Finished` lines go |
+| `cargo audit` | one line per advisory (id, crate, version, kind, title, fix) |
+| `cargo tree`, `tree`, `eza --tree` | cut below 3 levels, `… [+15 lines deeper]` under each cut |
+| `tsc` | errors grouped by file (`a.ts (8)`, `1:7 TS2322 …`) |
+| `gradle`, `./gradlew` | task lines counted (`11 tasks (5 executed, 4 no-source, 2 up-to-date)`); failures, compiler errors, test failures and the `BUILD` line stay; daemon and `--scan` hints go; Kotlin `w:`/`e:` paths lose their shared directory |
+| `bun test`, `go test` | passing tests counted, not listed; failures and totals stay |
+| anything else | colour codes dropped, progress bars (`\r`) keep their last frame, 4+ identical lines become `line  [×N]`, 3+ blank lines become one. Never for `cat`, `head`, `jq`, `curl`… (content commands) |
+| `git`, `cargo`, `docker`… | rewritten through [rtk](https://github.com/rtk-ai/rtk) when it is installed (switch: `/squeeze rtk off`) |
+
+Output with a marker of its own (a `tsc` error list, a gradle build, a `bun test` run, rustc diagnostics) is recognised whatever ran it: `just check`, `npm run build`, `make test`, `… 2>&1`.
+A **failed** command is compacted too, but only for test and build output, where the errors are the point.
+`git -C dir …`, `git --no-pager …`, `--color=never` and `cargo +nightly …` are read as the plain command.
+
+Safety rules:
+
+* Pipes, redirects, chains and `--json`/`-c`/`-l`/`-x` style flags are never touched: the output is no longer the tool's own format.
+* A line that does not parse makes the whole output pass through.
+* The result must be clearly smaller (under 90%) and the output at least 400 characters.
+* Every cut leaves a marker (`… [+12 more in this file]`), and the full original goes to a temp file whose path is in the output.
+* `read`, `edit` and `write` are never changed.
+
+## Commands
+
+| Command | |
+|---|---|
+| `/squeeze` or `/squeeze status` | the settings and the tokens saved so far |
+| `/squeeze [on\|off]` | switch everything |
+| `/squeeze [search\|paths\|listing\|diff\|tests\|git\|build\|tree\|generic] [on\|off]` | switch one compactor |
+| `/squeeze rtk [on\|off]` | rewrite git, cargo, docker… through [rtk](https://github.com/rtk-ai/rtk), when installed |
+| `/squeeze min <chars>` | smallest output worth compacting (default 400) |
+
+Settings are remembered in `<pi agent dir>/squeeze.json` (`PI_CODING_AGENT_DIR`, else `~/.pi/agent`); it also holds
+`lineChars`, `perGroup` and `total`, the limits of a compacted result. `PI_SQUEEZE=off` disables it at start.
+The status line shows the tokens saved.
+
+## Development
+
+```bash
+bun install
+just check   # typecheck + tests (95% coverage gate) + pack check + nu script tests
+just --list  # everything else: fuzz, audit, release, remotes
+```
+
+Layout:
+
+| Path | What |
+|---|---|
+| `extensions/squeeze.ts` | the extension: pure functions plus a thin default export |
+| `tests/` | `bun test`: `core` (pure logic), `extension` (hooks), `fuzz` (randomised properties) |
+| `scripts/` | Nushell only, each with a test in `scripts/tests/` |
+| `.github/`, `.gitea/` | CI, release, nightlies on both hosts |
+
+Releases run in CI: **Actions → Release → Run workflow** with a bump (`patch`, `minor`, `major`, or
+`current` for the version already in `package.json`), or `just release-ci patch`. The workflow runs the
+quality gate, bumps `package.json`, regenerates `CHANGELOG.md` with git-cliff, commits, tags, pushes and
+publishes to npm (secret `NPM_TOKEN`). Locally, `just release patch` does the same up to the tag push.
+
+## License
+
+MIT

package/extensions/command/parse.ts

@@ -0,0 +1,82 @@
+/** `/squeeze ...`: parsing and argument completion. Pure: the handler in squeeze.ts acts on the result. */
+import { KINDS, type Kind } from "../core/compact.ts";
+
+export type Command =
+	| { kind: "status" }
+	| { kind: "on" }
+	| { kind: "off" }
+	| { kind: "compactor"; compactor: Kind; on: boolean }
+	| { kind: "rtk"; on: boolean }
+	| { kind: "min"; chars: number }
+	| { kind: "invalid"; message: string };
+
+
+export const USAGE = `Usage: /squeeze [status] · on · off · ${KINDS.join("|")}|rtk <on|off> · min <chars>`;
+
+export function parseCommand(args: string | undefined): Command {
+	const [cmd, p1] = (args ?? "").trim().toLowerCase().split(/\s+/).filter(Boolean);
+	switch (cmd) {
+		case undefined:
+		case "status":
+			return { kind: "status" };
+		case "on":
+		case "enable":
+			return { kind: "on" };
+		case "off":
+		case "disable":
+			return { kind: "off" };
+		case "min": {
+			const n = Number(p1);
+			return Number.isInteger(n) && n >= 100 && n <= 1_000_000
+				? { kind: "min", chars: n }
+				: { kind: "invalid", message: "Usage: /squeeze min <chars> (100 to 1000000)" };
+		}
+		case "rtk":
+			return p1 === "on" || p1 === "off" ? { kind: "rtk", on: p1 === "on" } : { kind: "invalid", message: "Usage: /squeeze rtk <on|off>" };
+		default:
+			if ((KINDS as readonly string[]).includes(cmd)) {
+				return p1 === "on" || p1 === "off"
+					? { kind: "compactor", compactor: cmd as Kind, on: p1 === "on" }
+					: { kind: "invalid", message: `Usage: /squeeze ${cmd} <on|off>` };
+			}
+			return { kind: "invalid", message: `Unknown option "${cmd}". ${USAGE}` };
+	}
+}
+
+export interface CompletionItem {
+	value: string;
+	/** Required by pi: it calls `label.endsWith(...)` when applying a completion. */
+	label: string;
+	description?: string;
+}
+
+const TOP_LEVEL: CompletionItem[] = [
+	{ value: "status", label: "status", description: "Show the settings and the savings" },
+	{ value: "on", label: "on", description: "Turn pi-squeeze on" },
+	{ value: "off", label: "off", description: "Turn it off (nothing is compacted)" },
+	{ value: "search ", label: "search", description: "rg / grep results grouped by file (on or off)" },
+	{ value: "paths ", label: "paths", description: "fd / find results grouped by directory (on or off)" },
+	{ value: "listing ", label: "listing", description: "lsd / eza -l listings (on or off)" },
+	{ value: "diff ", label: "diff", description: "git diff with trimmed context (on or off)" },
+	{ value: "tests ", label: "tests", description: "cargo test without build noise and passing tests (on or off)" },
+	{ value: "git ", label: "git", description: "git status, log, show and blame, shorter (on or off)" },
+	{ value: "build ", label: "build", description: "cargo build/clippy/audit, tsc and gradle, errors kept and warnings grouped (on or off)" },
+	{ value: "tree ", label: "tree", description: "cargo tree, tree and eza --tree cut below a depth (on or off)" },
+	{ value: "generic ", label: "generic", description: "ANSI codes, progress frames and repeated lines in any output (on or off)" },
+	{ value: "rtk ", label: "rtk", description: "Rewrite git, cargo, docker… through rtk, when installed (on or off)" },
+	{ value: "min ", label: "min", description: "Smallest output to compact, in characters" },
+];
+
+/** `prefix` is the whole argument text typed so far (pi replaces it with `value`). */
+export function completions(prefix: string): CompletionItem[] | null {
+	const text = (prefix ?? "").toLowerCase().replace(/^\s+/, "");
+	const kind = [...KINDS, "rtk"].find((k) => text.startsWith(`${k} `));
+	const pool: CompletionItem[] = kind
+		? [
+				{ value: `${kind} on`, label: "on", description: kind === "rtk" ? "Rewrite commands through rtk" : `Compact ${kind} output` },
+				{ value: `${kind} off`, label: "off", description: kind === "rtk" ? "Run commands as written" : `Leave ${kind} output alone` },
+			]
+		: TOP_LEVEL;
+	const out = pool.filter((i) => i.value.startsWith(text));
+	return out.length > 0 ? out : null;
+}

package/extensions/core/audit.ts

@@ -0,0 +1,53 @@
+/**
+ * `cargo audit` advisories, one line each:
+ *
+ *   RUSTSEC-2025-0141 bincode 1.3.3 unmaintained: Bincode is unmaintained  (fix: upgrade to >=1.3.4)
+ *
+ * The dependency-tree dump under a vulnerability, the date and the URL go. Strict: a block
+ * without an `ID:` line makes it return undefined.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const FIELD = /^([A-Z][A-Za-z ]*?):\s+(.*)$/;
+
+export function compactAudit(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	const head: string[] = [];
+	const rows: string[] = [];
+	const tail: string[] = [];
+	let fields: Record<string, string> | undefined;
+	let inTree = false;
+	const finish = () => {
+		if (!fields) return true;
+		const f = fields;
+		fields = undefined;
+		if (!f.ID || !f.Crate) return false;
+		const kind = f.Warning ?? (f.Severity ? `vulnerability (${f.Severity})` : "vulnerability");
+		rows.push(cutLine(`${f.ID} ${f.Crate} ${f.Version ?? ""} ${kind}: ${f.Title ?? ""}${f.Solution ? `  (fix: ${f.Solution})` : ""}`, limits.lineChars));
+		return true;
+	};
+	for (const l of lines) {
+		if (l === "") {
+			inTree = false;
+			if (!finish()) return undefined;
+			continue;
+		}
+		if (fields && l.startsWith("Dependency tree:")) {
+			inTree = true;
+			continue;
+		}
+		const m = FIELD.exec(l);
+		if (m && m[1] === "Crate") {
+			if (!finish()) return undefined;
+			fields = { Crate: m[2]! };
+		} else if (fields && m && !inTree) {
+			fields[m[1]!] = m[2]!;
+		} else if (fields) {
+			if (!inTree) return undefined;
+		} else if (rows.length || /^(warning|error): \d+ /.test(l)) tail.push(l);
+		else head.push(l);
+	}
+	if (!finish() || !rows.length) return undefined;
+	const scanned = head.find((l) => /^\s+Scanning /.test(l));
+	return capLines([...(scanned ? [scanned.trim()] : []), `${rows.length} advisories`, ...rows, ...tail], limits.total);
+}

package/extensions/core/blame.ts

@@ -0,0 +1,32 @@
+/**
+ * `git blame` with one header per run of lines from the same commit:
+ *
+ *   bd6a3dd4 Sorin Albu-Irimies 2026-10-16
+ *     1: # Dodai UI
+ *     2:
+ *
+ * Strict: a line that is not in the default blame format returns undefined.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const ROW = /^(\^?[0-9a-f]{6,40}) (?:\S+ +)?\((.+?) +(\d{4}-\d\d-\d\d) \d\d:\d\d:\d\d [+-]\d{4} +(\d+)\) ?(.*)$/;
+
+export function compactBlame(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.length) return undefined;
+	const out: string[] = [];
+	let last = "";
+	for (const l of lines) {
+		const m = ROW.exec(l);
+		if (!m) return undefined;
+		const [, hash, author, date, no, text] = m;
+		const key = `${hash} ${author} ${date}`;
+		if (key !== last) {
+			out.push(key);
+			last = key;
+		}
+		out.push(cutLine(`  ${no}: ${text}`, limits.lineChars));
+	}
+	return capLines(out, limits.total);
+}

package/extensions/core/command.ts

@@ -0,0 +1,86 @@
+/**
+ * Reads a bash command line just far enough to know which program ran and with which
+ * arguments. Anything that reshapes the output (pipes, redirects, chains, substitution)
+ * makes it return undefined: the output is then not in the program's own format and
+ * must pass through untouched.
+ */
+
+export type Invocation = { program: string; args: string[] };
+
+const OPERATOR = /[|;&<>`]|\$\(/;
+
+/** Split on whitespace, honouring single/double quotes and backslash escapes. */
+export function tokenize(line: string): string[] | undefined {
+	const out: string[] = [];
+	let cur = "";
+	let has = false;
+	let quote: "'" | '"' | undefined;
+	for (let i = 0; i < line.length; i++) {
+		const c = line[i]!;
+		if (quote) {
+			if (c === quote) quote = undefined;
+			else if (c === "\\" && quote === '"' && i + 1 < line.length) cur += line[++i];
+			else cur += c;
+		} else if (c === "'" || c === '"') {
+			quote = c;
+			has = true;
+		} else if (c === "\\" && i + 1 < line.length) {
+			cur += line[++i];
+			has = true;
+		} else if (/\s/.test(c)) {
+			if (has || cur) out.push(cur);
+			cur = "";
+			has = false;
+		} else {
+			cur += c;
+			has = true;
+		}
+	}
+	if (quote) return undefined;
+	if (has || cur) out.push(cur);
+	return out;
+}
+
+/** True when `text` contains a shell operator outside quotes. */
+export function hasOperator(text: string): boolean {
+	let quote: "'" | '"' | undefined;
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i]!;
+		if (quote) {
+			if (c === quote) quote = undefined;
+			else if (c === "\\" && quote === '"') i++;
+			else if (quote === '"' && (c === "`" || (c === "$" && text[i + 1] === "("))) return true;
+		} else if (c === "'" || c === '"') quote = c;
+		else if (c === "\\") i++;
+		else if (OPERATOR.test(c === "$" ? text.slice(i, i + 2) : c)) return true;
+	}
+	return false;
+}
+
+/** Drop a leading `cd <dir> &&`, which only sets the working directory. */
+export function stripCd(command: string): string {
+	return command.replace(/^\s*cd\s+(?:"[^"]*"|'[^']*'|[^\s;&|]+)\s*&&\s*/, "");
+}
+
+/** The single simple command a line runs, or undefined when it is anything more. */
+export function parse(command: string): Invocation | undefined {
+	// `2>&1` only merges the streams, which is how pi shows them anyway.
+	const line = stripCd(command).replace(/\s+2>&1\s*$/, "").trim();
+	if (!line || hasOperator(line)) return undefined;
+	const words = tokenize(line);
+	if (!words) return undefined;
+	while (words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0]!)) words.shift();
+	const first = words.shift();
+	if (!first) return undefined;
+	return { program: first.split("/").pop()!, args: words };
+}
+
+/** Does a short or long flag appear in `args` (also inside combined short flags like -rn)? */
+export function hasFlag(args: string[], long: string[], short: string[] = []): boolean {
+	for (const a of args) {
+		if (a === "--") return false;
+		if (long.includes(a) || long.some((l) => a.startsWith(`${l}=`))) return true;
+		if (/^-[A-Za-z]+$/.test(a) && short.some((s) => a.includes(s))) return true;
+	}
+	return false;
+}

package/extensions/core/compact.ts

@@ -0,0 +1,207 @@
+/** Chooses the compactor for a bash command and applies the safety rules. */
+import { hasFlag, parse } from "./command.ts";
+import { DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { compactAudit } from "./audit.ts";
+import { compactBlame } from "./blame.ts";
+import { compactDiff } from "./diff.ts";
+import { compactDust } from "./dust.ts";
+import { compactGradle } from "./gradle.ts";
+import { compactGeneric, isContent } from "./generic.ts";
+import { compactLog, compactShow } from "./gitlog.ts";
+import { compactStatus } from "./gitstatus.ts";
+import { compactLsd } from "./lsd.ts";
+import { compactPaths } from "./paths.ts";
+import { compactRg, compactRgPlain } from "./rg.ts";
+import { compactRustc } from "./rustc.ts";
+import { compactBunTest, compactGoTest } from "./runners.ts";
+import { compactTests } from "./tests.ts";
+import { compactTree } from "./tree.ts";
+import { compactTsc } from "./tsc.ts";
+
+export const KINDS = ["search", "paths", "listing", "diff", "tests", "git", "build", "tree", "generic"] as const;
+export type Kind = (typeof KINDS)[number];
+
+export type Result = { text: string; kind: Kind; truncated: boolean; before: number; after: number };
+
+export type Options = {
+	limits?: Limits;
+	/** Output shorter than this is never touched. */
+	minChars?: number;
+	/** The result must be at most this share of the original, or the original is kept. */
+	maxRatio?: number;
+	/** Compactors that may run; a missing entry means on. */
+	kinds?: Partial<Record<Kind, boolean>>;
+	/** The command failed: only test and build output is worth compacting then (the errors are the point). */
+	failed?: boolean;
+	/** Is `path` (relative to the command's directory) an existing file? Lets search output without line numbers be grouped. */
+	isFile?: (path: string) => boolean;
+};
+
+
+const SEARCH = new Set(["rg", "grep", "egrep", "ugrep"]);
+const PATHS = new Set(["fd", "fdfind", "find"]);
+const LISTING = new Set(["lsd", "eza", "exa", "ls"]);
+const LIST_ONLY = { long: ["--files", "--files-with-matches", "--files-without-match"], short: ["l"] };
+const NOT_A_LIST = { long: ["--json", "--count", "--null", "--print0", "--stats", "--vimgrep"], short: ["c", "0", "z"] };
+
+/** Flags after which the output is no longer plain `path:line:text` / one path per line. */
+const NOT_PLAIN_SEARCH = { long: ["--json", "--count", "--files-with-matches", "--files-without-match", "--files", "--heading", "--stats", "--vimgrep", "--only-matching", "--null", "--passthru"], short: ["c", "l", "L", "o", "z"] };
+const NOT_PLAIN_PATHS = { long: ["--exec", "--exec-batch", "--list-details", "--print0", "--format"], short: ["x", "X", "l", "0"] };
+
+/** Flags of `git log`, `show`, `blame` and `status` that leave the default format. */
+const GIT_FORMAT = ["--oneline", "--pretty", "--stat", "--shortstat", "--numstat", "--name-only", "--name-status", "--raw", "--graph", "--patch", "--color-words", "--word-diff", "--porcelain", "--line-porcelain", "--incremental", "--short", "--branch", "--stage", "--eol", "--debug", "--format", "--null", "--color"];
+const GIT_FORMAT_SHORT = ["p", "s", "z", "b", "e", "t", "v"];
+
+/** `git diff` flags that change the output format away from a unified diff. */
+const NOT_PLAIN_DIFF = {
+	long: ["--stat", "--numstat", "--shortstat", "--dirstat", "--summary", "--name-only", "--name-status", "--raw", "--check", "--patch-with-stat", "--patch-with-raw", "--word-diff", "--color-words", "--color", "--compact-summary", "--submodule", "--no-index", "--output"],
+	short: ["s", "z"],
+};
+
+function plainFind(args: string[]): boolean {
+	return !args.some((a) => ["-exec", "-execdir", "-ls", "-print0", "-printf", "-fprint", "-delete", "-ok"].includes(a));
+}
+
+function pickCargo(all: string[]): ReturnType<typeof pick> {
+	// `cargo +nightly build`: the toolchain does not change the output.
+	const [sub, ...rest] = all[0]?.startsWith("+") ? all.slice(1) : all;
+	if (hasFlag(rest, ["--format", "--message-format", "--prefix", "--charset", "--timings"])) return undefined;
+	switch (sub) {
+		case "test":
+			return { kind: "tests", run: compactTests };
+		case "build":
+		case "check":
+		case "clippy":
+		case "doc":
+		case "bench":
+			return { kind: "build", run: compactRustc };
+		case "audit":
+			return { kind: "build", run: compactAudit };
+		case "tree":
+			return { kind: "tree", run: compactTree };
+		default:
+			return undefined;
+	}
+}
+
+/** Output with a strong marker of its own is recognised whatever command produced it (`just check`, `npm run build`, pipes). */
+const SNIFFERS: { kind: Kind; run: (out: string, l: Limits) => Squeezed | undefined }[] = [
+	{ kind: "tests", run: compactBunTest },
+	{ kind: "tests", run: compactGoTest },
+	{ kind: "build", run: compactGradle },
+	{ kind: "build", run: compactTsc },
+	{ kind: "build", run: compactRustc },
+	{ kind: "build", run: compactAudit },
+];
+
+/** `git` options before the subcommand that do not change its output: `-C dir`, `-c k=v`, `--no-pager`, ... */
+function gitSubcommand(args: string[]): string[] {
+	let i = 0;
+	while (i < args.length) {
+		const a = args[i]!;
+		if (a === "-C" || a === "-c") i += 2;
+		else if (["--no-pager", "-P", "--no-optional-locks", "--literal-pathspecs"].includes(a) || /^--(git-dir|work-tree)=/.test(a)) i++;
+		else break;
+	}
+	return args.slice(i);
+}
+
+/** `--color=never` and `--no-color` leave the output as it is without them. */
+const noColor = (args: string[]) => args.filter((a) => a !== "--color=never" && a !== "--no-color");
+
+function pickGit(all: string[]): ReturnType<typeof pick> {
+	const [sub, ...rest] = noColor(gitSubcommand(all));
+	switch (sub) {
+		case "diff":
+			if (hasFlag(rest, ["--name-only"]) && !hasFlag(rest, ["--null"], ["z"])) return { kind: "paths", run: compactPaths };
+			return hasFlag(rest, NOT_PLAIN_DIFF.long, NOT_PLAIN_DIFF.short) ? undefined : { kind: "diff", run: compactDiff };
+		case "ls-files":
+			return hasFlag(rest, ["--stage", "--eol", "--debug", "--format", "--deleted", "--others"], ["s", "z", "t", "v"]) ? undefined : { kind: "paths", run: compactPaths };
+		case "status":
+			return hasFlag(rest, GIT_FORMAT, GIT_FORMAT_SHORT) ? undefined : { kind: "git", run: compactStatus };
+		case "log":
+			return hasFlag(rest, GIT_FORMAT, GIT_FORMAT_SHORT) ? undefined : { kind: "git", run: compactLog };
+		case "show":
+			return hasFlag(rest, GIT_FORMAT, GIT_FORMAT_SHORT) ? undefined : { kind: "git", run: compactShow };
+		case "blame":
+			return hasFlag(rest, GIT_FORMAT, GIT_FORMAT_SHORT) ? undefined : { kind: "git", run: compactBlame };
+		default:
+			return undefined;
+	}
+}
+
+/** Flags that print context lines (`path-text`, which cannot be told apart from a path with a dash). */
+const CONTEXT = { long: ["--context", "--after-context", "--before-context"], short: /^-[A-Za-z]*[ABC]/ };
+
+/**
+ * `rg pattern dir` without -n: grouped only when the paths can be checked on disk, and not when the
+ * only path searched is itself a file (then there is no path prefix, and a colon in the text would pass for one).
+ */
+function plainSearch(args: string[], isFile: ((path: string) => boolean) | undefined): ReturnType<typeof pick> {
+	if (hasFlag(args, ["--line-number"], ["n"]) || hasFlag(args, CONTEXT.long) || args.some((a) => CONTEXT.short.test(a)) || !isFile) return undefined;
+	const operands = args.filter((a) => !a.startsWith("-")).slice(1);
+	if (operands.length === 1 && isFile(operands[0]!)) return undefined;
+	return { kind: "search", run: (out, l) => compactRgPlain(out, l, isFile) };
+}
+
+function pick(command: string, isFile?: (path: string) => boolean): { kind: Kind; run: (out: string, l: Limits) => Squeezed | undefined } | undefined {
+	const inv = parse(command);
+	if (!inv) return undefined;
+	// Relative paths in the output are relative to the `cd`, which the file check does not know.
+	const local = /^\s*cd\s/.test(command) ? undefined : isFile;
+	const { program, args } = inv;
+	if (SEARCH.has(program)) {
+		const files = hasFlag(args, LIST_ONLY.long, program === "rg" ? LIST_ONLY.short : [...LIST_ONLY.short, "L"]);
+		if (files) return hasFlag(args, NOT_A_LIST.long, NOT_A_LIST.short) ? undefined : { kind: "paths", run: compactPaths };
+		if (hasFlag(args, NOT_PLAIN_SEARCH.long, NOT_PLAIN_SEARCH.short)) return undefined;
+		const plain = plainSearch(args, local);
+		return plain ?? { kind: "search", run: compactRg };
+	}
+	if (PATHS.has(program)) {
+		if (program === "find" ? !plainFind(args) : hasFlag(args, NOT_PLAIN_PATHS.long, NOT_PLAIN_PATHS.short)) return undefined;
+		return { kind: "paths", run: compactPaths };
+	}
+	if (program === "git") return pickGit(args);
+	if (program === "cargo") return pickCargo(args);
+	if (program === "tsc" || ((program === "npx" || program === "bunx") && args[0] === "tsc")) return { kind: "build", run: compactTsc };
+	if (program === "gradle" || program === "gradlew") return { kind: "build", run: compactGradle };
+	if (program === "go" && args[0] === "test") return hasFlag(args, ["-json", "--json"]) ? undefined : { kind: "tests", run: compactGoTest };
+	if (program === "bun" && args[0] === "test") return { kind: "tests", run: compactBunTest };
+	if (program === "tree" || ((program === "eza" || program === "exa" || program === "lsd") && hasFlag(args, ["--tree"], ["T"]))) return hasFlag(args, ["-J", "--json", "-H", "--html"]) ? undefined : { kind: "tree", run: compactTree };
+	if (program === "dust") return hasFlag(args, ["--output-json"], ["j"]) ? undefined : { kind: "listing", run: compactDust };
+	if (LISTING.has(program)) {
+		if (!hasFlag(args, ["--long"], ["l"])) return undefined;
+		// Other column sets (inode, blocks, group only, full time, numeric ids, octal) do not parse.
+		if (hasFlag(args, ["--inode", "--blocks", "--size", "--full-time", "--time-style", "--numeric-uid-gid", "--git", "--header", "--octal-permissions", "--total-size", "--context"], ["i", "s", "n", "g", "o", "H", "Z"])) return undefined;
+		return { kind: "listing", run: compactLsd };
+	}
+	return undefined;
+}
+
+/** True when a native compactor takes care of `command`'s output (whatever the switches say). */
+export const handles = (command: string): boolean => pick(command) !== undefined;
+
+/** Compacts the output of `command`, or returns undefined to leave it exactly as it is. */
+export function compact(command: string, output: string, opts: Options = {}): Result | undefined {
+	const { limits = DEFAULT_LIMITS, minChars = 400, maxRatio = 0.9, kinds = {}, failed = false, isFile } = opts;
+	if (output.length < minChars) return undefined;
+	const small = (sq: Squeezed | undefined): sq is Squeezed => sq !== undefined && sq.text.length <= output.length * maxRatio;
+	const allowed = (kind: Kind) => kinds[kind] !== false && (!failed || kind === "tests" || kind === "build");
+	const done = (sq: Squeezed, kind: Kind): Result => ({ text: sq.text, kind, truncated: sq.truncated, before: output.length, after: sq.text.length });
+
+	const chosen = pick(command, isFile);
+	if (chosen && allowed(chosen.kind)) {
+		const sq = chosen.run(output, limits);
+		if (small(sq)) return done(sq, chosen.kind);
+	}
+	if (isContent(command)) return undefined;
+	for (const s of SNIFFERS) {
+		if (!allowed(s.kind)) continue;
+		const sq = s.run(output, limits);
+		if (small(sq)) return done(sq, s.kind);
+	}
+	// Nothing specific fits: still drop colour codes, progress frames and repeated lines.
+	if (failed || kinds.generic === false) return undefined;
+	const sq = compactGeneric(output);
+	return small(sq) ? done(sq, "generic") : undefined;
+}