pi-squeeze 0.1.0 → 0.2.0

package/README.md

@@ -6,7 +6,7 @@
 [![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.
+Shrinks bash output before it reaches the agent's context: native compactors for git, search, listings, tests, builds (cargo, gradle, Maven, javac, Xcode, tsc, docker), Android (adb, lint, detekt), linters, package installs and logs, plus rtk when installed. Full output stays one temp file away.
 
 A [pi](https://github.com/earendil-works/pi-coding-agent) extension.
 
@@ -23,7 +23,7 @@ It only touches output it fully understands, and otherwise passes it through unc
 
 | 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 -n` / `grep -rn` / `ack` | 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) |
@@ -39,12 +39,31 @@ It only touches output it fully understands, and otherwise passes it through unc
 | `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 |
+| `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, configuration-cache, JVM and `--scan` chatter goes; reported files lose their shared directory |
 | `bun test`, `go test` | passing tests counted, not listed; failures and totals stay |
+| `pytest` | session header, progress dots and `PASSED` lines go; failures, warnings and the short summary stay; full-width `====` banners shrink |
+| `jest`, `vitest` | passing tests and files go, skipped ones are counted; failures with their diff and frame, and the totals, stay |
+| `xcodebuild`, `swift build` / `test` | build steps (`CompileSwift`, `Ld`, `CodeSign` and their command lines) and progress counted, not listed; warnings grouped by message; errors keep frame and notes; passing XCTest / Swift Testing tests counted; the `** BUILD SUCCEEDED **` line stays |
+| `eslint`, `biome`, `ruff`, `flake8`, `mypy`, `pylint`, `ktlint`, `detekt`, `swiftlint`, `shellcheck`, `flutter analyze` | findings grouped by rule and message, each location once (`error eqeqeq: … (5)` then `m.js:2:46 m1.js:2:47 …`), the shared directory said once; frames and fix suggestions go |
+| `npm` / `pnpm` / `yarn` / `bun install`, `pip install`, `uv sync`, `pod install`, `bundle install`, `flutter pub get` | download and progress lines go; per-package lines become one line (`Collecting (9): requests, rich, …`); deprecation warnings become one list of names; errors and the summary stay |
+| `docker build` | `[internal]` steps, layer downloads, `CACHED` / `DONE` lines go; each step keeps its header and what it printed |
+| `docker logs`, `docker compose logs`, `kubectl logs`, `journalctl`, `adb logcat` (not `-f` / `--follow`) | 3+ lines that differ only in timestamps and numbers keep the first and last; framework stack frames fold; logcat drops the date and thread id; past the limit the start goes, not the end |
+| `gradle` on Android | also: Kotlin / KSP warnings, detekt / ktlint findings and Android Lint issues grouped by message with their locations (lint's source lines, explanations and baseline advice go); repeated warnings and `--warning-mode all` deprecations said once with a count, without the upgrade-guide links; R8 `Missing class` and `Duplicate class` lines become one list of classes; "Searched in the following locations" becomes a count; `A failure occurred while executing …` wrappers go and the failure summary does not repeat what was printed above it; framework frames fold |
+| `gradle tasks`, `gradle projects`, `dependencyInsight`, `dependencies` | tasks: names per group, descriptions go; projects: every path once, grouped by the first segment (`:api (261): …`); insight: the attribute tables go; dependencies: cut like a tree |
+| `mvn`, `./mvnw`, `mvnd` | `Downloading` / `Downloaded` lines and their progress counted; `[INFO]` lines go except the result, the test totals and modules that failed; a passing test class takes its output (Spring banners, logs) with it; errors said once, the `[Help 1]` footer goes; `dependency:tree` is cut like a tree |
+| `javac` | errors keep their source line, caret and `symbol:` / `location:`; warnings grouped by kind (`warning rawtypes: found raw type: List (2)`); `Recompile with -Xlint` notes go |
+| a JVM stack trace from anything (`java -jar`, a test JVM, a log) | framework frames (java., kotlin., android., org.junit., org.springframework.…) fold to `… N framework frames`; the exception, each `Caused by:`, your own frames and `... N more` stay; also when the command failed |
+| `adb exec-out uiautomator dump /dev/tty` | one line per node that says something, indented by nesting, with where to tap: `TextView "Network & internet" #title @375,608`; empty wrappers and off-screen nodes go |
+| `adb shell getprop`, `settings list …` | keys that share a prefix written once, every value kept: `aaudio: hw_burst_min_usec=2000 mmap_policy=2` |
+| `adb shell ps -A`, `top -n 1` | kernel threads and idle processes counted, not listed; column padding goes |
+| `adb shell dumpsys …` | lines deeper than an entry's own go with a count; 3+ lines of the same shape keep their ends |
+| `adb shell pm list packages [-f]` | grouped by the first two name segments; with `-f`, name then path, hashed install directories elided |
+| `adb logcat` (`threadtime`, `time`, `brief`) | as logs above; with `adb -s <serial>` too |
+| `… \| tail -50`, `… \| head -n 20` | the command before the pipe picks the compactor |
 | 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`.
+Output with a marker of its own (a `tsc` error list, a gradle or Maven build, `javac` errors, a JVM stack trace, a `uiautomator` dump, 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.
 
@@ -62,7 +81,7 @@ Safety rules:
 |---|---|
 | `/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 [search\|paths\|listing\|diff\|tests\|git\|build\|lint\|install\|logs\|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) |
 

package/extensions/core/adb.ts

@@ -0,0 +1,231 @@
+/**
+ * `adb shell pm list packages`: the `package:` prefix goes and names are grouped by their
+ * first two segments, each name still complete once its group is read:
+ *
+ *   com.google.android (3): apps.messaging gms gsf
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { shape } from "./logs.ts";
+
+export function compactPackages(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n").map((l) => l.trimEnd());
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.length || !lines.every((l) => /^package:[\w.]+$/.test(l))) return undefined;
+	const groups = new Map<string, string[]>();
+	for (const l of lines.map((l) => l.slice("package:".length)).sort()) {
+		const parts = l.split(".");
+		const key = parts.length > 2 ? parts.slice(0, 2).join(".") : "";
+		groups.set(key, [...(groups.get(key) ?? []), key ? parts.slice(2).join(".") : l]);
+	}
+	const out = [`${lines.length} packages`];
+	// A group line may run long: it is still one line of names, cut only far past the usual width.
+	const width = limits.lineChars * 8;
+	let cut = false;
+	for (const [key, names] of groups) {
+		const line = key ? `${key} (${names.length}): ${names.join(" ")}` : names.join(" ");
+		cut ||= line.length > width;
+		out.push(cutLine(line, width));
+	}
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: cut || capped.truncated };
+}
+
+/** `adb shell pm list packages -f`: `package:/path/base.apk=name` → `name  /path`, hashed install dirs elided. */
+export function compactPackagePaths(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n").map((l) => l.trimEnd());
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const rows = lines.map((l) => /^package:(\/\S+)=([\w.]+)$/.exec(l));
+	if (!rows.length || rows.some((r) => !r)) return undefined;
+	const out = rows
+		.map((r) => `${r![2]}  ${r![1]!.replace(/\/~~[^/]+==\/[\w.]+-[^/]+==\//, "/…/")}`)
+		.sort()
+		.map((l) => cutLine(l, limits.lineChars));
+	const capped = capLines([`${rows.length} packages`, ...out], limits.total);
+	return { text: capped.text, truncated: capped.truncated };
+}
+
+/** A value as `key=value` shows it: quoted when empty or holding spaces. */
+const shown = (v: string) => (v === "" || /\s/.test(v) ? JSON.stringify(v) : v);
+
+/**
+ * Properties and settings (`adb shell getprop`, `settings list global|secure|system`):
+ * keys that share a prefix are written once, values all kept:
+ *
+ *   ro.build: version.release=16 version.sdk=36 type=user
+ */
+export function compactProperties(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const raw = output.split("\n").map((l) => l.trimEnd());
+	while (raw.length && raw.at(-1) === "") raw.pop();
+	// A getprop value may span lines: they belong to the `[key]: [` line above.
+	const lines: string[] = [];
+	for (const l of raw) {
+		if (lines.length && /^\[[^\]]+\]: \[/.test(lines.at(-1)!) && !/\]$/.test(lines.at(-1)!)) lines[lines.length - 1] += `\\n${l}`;
+		else lines.push(l);
+	}
+	if (lines.length < 5) return undefined;
+	const getprop = lines.every((l) => /^\[[^\]]+\]: \[.*\]$/.test(l));
+	const pairs = lines.map((l) => (getprop ? /^\[([^\]]+)\]: \[(.*)\]$/.exec(l) : /^([\w.:-]+)=(.*)$/.exec(l)));
+	if (pairs.some((p) => !p)) return undefined;
+	const sep = getprop ? "." : "_";
+	const groups = new Map<string, string[]>();
+	for (const p of pairs) {
+		const key = p![1]!;
+		// getprop keys group by their first two segments (`ro.build`), settings by the first word.
+		const parts = key.split(sep);
+		const n = Math.min(getprop ? 2 : 1, parts.length - 1);
+		const [head, tail] = n > 0 && parts[0] ? [parts.slice(0, n).join(sep), parts.slice(n).join(sep)] : ["", key];
+		groups.set(head, [...(groups.get(head) ?? []), `${tail}=${shown(p![2]!)}`]);
+	}
+	let cut = false;
+	const out: string[] = [];
+	const item = (i: string) => {
+		cut ||= i.length > limits.lineChars;
+		return cutLine(i, limits.lineChars);
+	};
+	for (const [head, items] of groups) {
+		if (!head || items.length === 1) {
+			out.push(...items.map((i) => item(head ? `${head}${sep}${i}` : i)));
+			continue;
+		}
+		// Long groups wrap rather than lose values: a new line repeats the prefix.
+		let line = `${head}:`;
+		for (const i of items.map(item)) {
+			if (line.length + i.length + 1 > limits.lineChars * 2 && line !== `${head}:`) (out.push(line), (line = `${head}:`));
+			line += ` ${i}`;
+		}
+		out.push(line);
+	}
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: cut || capped.truncated };
+}
+
+/**
+ * Process lists (`adb shell ps -A`, `adb shell top -n 1`): kernel threads (no memory of their
+ * own) and idle rows of `top` are counted, not listed; column padding goes.
+ */
+export function compactProcesses(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n").map((l) => l.trimEnd());
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const header = lines.findIndex((l) => /^\s*(?:USER\s+PID\s+PPID|PID\s+USER\s+PR\s+NI)\b/.test(l));
+	if (header < 0 || lines.length - header < 5) return undefined;
+	const cols = lines[header]!.trim().split(/\s+/);
+	const ps = cols[0] === "USER";
+	const vsz = cols.indexOf("VSZ");
+	const cpu = cols.findIndex((c) => /%CPU/.test(c));
+	let hidden = 0;
+	const rows: string[] = [];
+	for (const l of lines.slice(header + 1)) {
+		const f = l.trim().split(/\s+/);
+		// ps: kernel threads have no virtual memory; top: rows that used no CPU.
+		const idle = ps ? f[vsz] === "0" : Number(f[cpu + (cols[cpu] === "S[%CPU]" ? 1 : 0)]) === 0;
+		if (idle) hidden++;
+		else rows.push(cutLine(f.join(" "), limits.lineChars));
+	}
+	const squeeze = (l: string) => l.trim().replace(/\s{2,}/g, " ");
+	const out = [...lines.slice(0, header).map(squeeze), squeeze(lines[header]!), ...rows];
+	if (hidden) out.push(`… ${hidden} ${ps ? "kernel threads" : "idle processes"} not listed`);
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: hidden > 0 || capped.truncated };
+}
+
+/** Indent deeper than this goes in a dumpsys report (sections, then their entries, stay). */
+const DUMPSYS_DEPTH = 8;
+
+/**
+ * `adb shell dumpsys …`: lines indented deeper than an entry's own line go (with a count),
+ * runs of 3+ lines of the same shape keep their ends, and long reports are capped.
+ */
+export function compactDumpsys(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n").map((l) => l.trimEnd());
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (lines.length < 20) return undefined;
+	const out: string[] = [];
+	let deeper = 0;
+	const flush = () => {
+		if (deeper) out.push(`${" ".repeat(DUMPSYS_DEPTH + 2)}… [+${deeper} deeper lines]`);
+		deeper = 0;
+	};
+	for (const l of lines) {
+		if (l.length - l.trimStart().length > DUMPSYS_DEPTH) {
+			deeper++;
+			continue;
+		}
+		flush();
+		out.push(l);
+	}
+	flush();
+	const runs: string[] = [];
+	for (let i = 0; i < out.length; ) {
+		const s = shape(out[i]!);
+		let j = i + 1;
+		while (j < out.length && shape(out[j]!) === s) j++;
+		runs.push(...(j - i >= 3 ? [out[i]!, `${out[i]!.match(/^\s*/)![0]}… [${j - i - 2} similar]`, out[j - 1]!] : out.slice(i, j)));
+		i = j;
+	}
+	const capped = capLines(
+		runs.map((l) => cutLine(l, limits.lineChars)),
+		limits.total,
+	);
+	return { text: capped.text, truncated: true };
+}
+
+const ENTITY: Record<string, string> = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+const unescape = (s: string) => s.replace(/&(amp|lt|gt|quot|apos|#(\d+));/g, (_, e: string, n?: string) => (n ? String.fromCodePoint(Number(n)) : ENTITY[e]!));
+
+/**
+ * `uiautomator dump` XML (`adb exec-out uiautomator dump /dev/tty`): one line per node that
+ * says something (text, description, id, or something to tap), indented by nesting, with its
+ * centre to tap at; empty wrappers and off-screen nodes go.
+ *
+ *   Button "OK" #ok click @540,1820
+ */
+export function compactUiDump(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	if (!/<hierarchy\b/.test(output)) return undefined;
+	const out: string[] = [];
+	/** For every open node: did it print (and so indent its children)? */
+	const open: boolean[] = [];
+	let nodes = 0;
+	for (const m of output.matchAll(/<node\b([^>]*?)(\/?)>|<\/node>/g)) {
+		if (!m[1] && !m[2] && m[0] === "</node>") {
+			open.pop();
+			continue;
+		}
+		nodes++;
+		const a: Record<string, string> = {};
+		for (const [, k, v] of m[1]!.matchAll(/([\w-]+)="([^"]*)"/g)) a[k!] = unescape(v!);
+		const b = /^\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]$/.exec(a.bounds ?? "");
+		const [x1, y1, x2, y2] = (b ?? []).slice(1).map(Number) as number[];
+		const visible = !!b && x2! > x1! && y2! > y1!;
+		const id = (a["resource-id"] ?? "").replace(/^.*:id\//, "");
+		const flags = [
+			a.clickable === "true" && "click",
+			a["long-clickable"] === "true" && "long-click",
+			a.scrollable === "true" && "scroll",
+			a.checkable === "true" && (a.checked === "true" ? "checked" : "unchecked"),
+			a.selected === "true" && "selected",
+			a.focused === "true" && "focused",
+			a.enabled === "false" && "disabled",
+			a.password === "true" && "password",
+		].filter(Boolean);
+		// An id alone names a leaf worth finding (an icon, an input); on a container it is layout.
+		const says = visible && (a.text || a["content-desc"] || a.hint || flags.length || (id && m[2]));
+		if (says) {
+			const depth = open.filter(Boolean).length;
+			const parts = [
+				(a.class ?? "").split(".").pop(),
+				a.text && JSON.stringify(a.text),
+				a["content-desc"] && `desc=${JSON.stringify(a["content-desc"])}`,
+				a.hint && `hint=${JSON.stringify(a.hint)}`,
+				id && `#${id}`,
+				...flags,
+				`@${Math.round((x1! + x2!) / 2)},${Math.round((y1! + y2!) / 2)}`,
+			].filter(Boolean);
+			out.push(cutLine(`${"  ".repeat(depth)}${parts.join(" ")}`, limits.lineChars));
+		}
+		if (!m[2]) open.push(!!says);
+	}
+	if (!nodes) return undefined;
+	const pkg = /package="([^"]+)"/.exec(output)?.[1];
+	const capped = capLines([`ui: ${out.length} of ${nodes} nodes${pkg ? ` (${pkg})` : ""}`, ...out], limits.total);
+	return { text: capped.text, truncated: true };
+}

package/extensions/core/compact.ts

@@ -1,11 +1,20 @@
 /** Chooses the compactor for a bash command and applies the safety rules. */
-import { hasFlag, parse } from "./command.ts";
+import { hasFlag, type Invocation, parse } from "./command.ts";
 import { DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { compactDumpsys, compactPackagePaths, compactPackages, compactProcesses, compactProperties, compactUiDump } from "./adb.ts";
 import { compactAudit } from "./audit.ts";
 import { compactBlame } from "./blame.ts";
 import { compactDiff } from "./diff.ts";
+import { compactDockerBuild } from "./docker.ts";
 import { compactDust } from "./dust.ts";
-import { compactGradle } from "./gradle.ts";
+import { compactGradle, compactGradleDeps } from "./gradle.ts";
+import { compactInstall } from "./install.ts";
+import { compactJavac } from "./javac.ts";
+import { compactJest } from "./jest.ts";
+import { compactLint, compactLintSniffed } from "./lint.ts";
+import { compactLogs, compactTrace } from "./logs.ts";
+import { compactMaven, compactMavenTree } from "./maven.ts";
+import { compactPytest } from "./pytest.ts";
 import { compactGeneric, isContent } from "./generic.ts";
 import { compactLog, compactShow } from "./gitlog.ts";
 import { compactStatus } from "./gitstatus.ts";
@@ -17,8 +26,9 @@ import { compactBunTest, compactGoTest } from "./runners.ts";
 import { compactTests } from "./tests.ts";
 import { compactTree } from "./tree.ts";
 import { compactTsc } from "./tsc.ts";
+import { compactXcode, compactXcodeSniffed } from "./xcode.ts";
 
-export const KINDS = ["search", "paths", "listing", "diff", "tests", "git", "build", "tree", "generic"] as const;
+export const KINDS = ["search", "paths", "listing", "diff", "tests", "git", "build", "lint", "install", "logs", "tree", "generic"] as const;
 export type Kind = (typeof KINDS)[number];
 
 export type Result = { text: string; kind: Kind; truncated: boolean; before: number; after: number };
@@ -31,14 +41,14 @@ export type Options = {
 	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). */
+	/** The command failed: only test, build, lint, install and log output is worth compacting then (the errors, or the stack trace, 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 SEARCH = new Set(["rg", "grep", "egrep", "ugrep", "ack"]);
 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"] };
@@ -88,10 +98,18 @@ function pickCargo(all: string[]): ReturnType<typeof pick> {
 const SNIFFERS: { kind: Kind; run: (out: string, l: Limits) => Squeezed | undefined }[] = [
 	{ kind: "tests", run: compactBunTest },
 	{ kind: "tests", run: compactGoTest },
+	{ kind: "tests", run: compactPytest },
+	{ kind: "tests", run: compactJest },
 	{ kind: "build", run: compactGradle },
+	{ kind: "build", run: compactXcodeSniffed },
 	{ kind: "build", run: compactTsc },
 	{ kind: "build", run: compactRustc },
 	{ kind: "build", run: compactAudit },
+	{ kind: "lint", run: compactLintSniffed },
+	{ kind: "build", run: compactMaven },
+	{ kind: "build", run: compactJavac },
+	{ kind: "tree", run: compactUiDump },
+	{ kind: "logs", run: compactTrace },
 ];
 
 /** `git` options before the subcommand that do not change its output: `-C dir`, `-c k=v`, `--no-pager`, ... */
@@ -144,9 +162,110 @@ function plainSearch(args: string[], isFile: ((path: string) => boolean) | undef
 	return { kind: "search", run: (out, l) => compactRgPlain(out, l, isFile) };
 }
 
+/** `npx tool`, `uv run tool`, `python -m tool`, `xcrun tool`…: the tool is what prints. */
+function unwrap({ program, args }: Invocation): Invocation {
+	const next = (rest: string[]): Invocation | undefined => {
+		const i = rest.findIndex((a) => !a.startsWith("-"));
+		return i < 0 ? undefined : { program: rest[i]!.split("/").pop()!, args: rest.slice(i + 1) };
+	};
+	let inner: Invocation | undefined;
+	if (["npx", "bunx", "pnpx", "uvx"].includes(program)) inner = next(args);
+	else if (["uv", "poetry", "pipenv", "pdm", "hatch"].includes(program) && args[0] === "run") inner = next(args.slice(1));
+	else if ((program === "pnpm" || program === "yarn") && (args[0] === "exec" || args[0] === "dlx")) inner = next(args.slice(1));
+	else if (/^python[\d.]*$/.test(program) && args[0] === "-m" && args[1]) inner = { program: args[1], args: args.slice(2) };
+	else if (program === "xcrun" && args[0] && !args[0].startsWith("-")) inner = { program: args[0], args: args.slice(1) };
+	return inner ? unwrap(inner) : { program, args };
+}
+
+/** `cmd | tail -50` / `cmd | head -n 20`: still `cmd`'s format, only fewer lines of it. */
+export function unpipe(command: string): string {
+	return command.replace(/\s*\|\s*(?:tail|head)(?:\s+(?:-n\s*\d+|-\d+|--lines=\d+))?\s*$/, "");
+}
+
+const INSTALL: Record<string, string[]> = {
+	npm: ["install", "i", "ci", "add", "update", "up"],
+	pnpm: ["install", "i", "add", "update", "up"],
+	yarn: ["install", "add", "upgrade"],
+	bun: ["install", "i", "add", "update"],
+	pip: ["install", "download"],
+	pip3: ["install", "download"],
+	pod: ["install", "update"],
+	bundle: ["install", "update"],
+	gem: ["install", "update"],
+};
+
+/** Linters whose output `compactLint` reads (with their subcommand where they have one). */
+const LINTERS: Record<string, string[] | undefined> = {
+	eslint: undefined,
+	biome: ["lint", "check", "ci"],
+	ruff: ["check"],
+	flake8: undefined,
+	mypy: undefined,
+	pylint: undefined,
+	ktlint: undefined,
+	detekt: undefined,
+	"detekt-cli": undefined,
+	swiftlint: ["lint"],
+	shellcheck: undefined,
+	flutter: ["analyze"],
+	dart: ["analyze"],
+};
+
+const LOG_COMMANDS = (program: string, args: string[]): boolean =>
+	((program === "docker" || program === "podman") && (args[0] === "logs" || (args[0] === "compose" && args[1] === "logs"))) ||
+	(program === "docker-compose" && args[0] === "logs") ||
+	(program === "kubectl" && args[0] === "logs") ||
+	["journalctl", "stern", "pidcat"].includes(program);
+
+/** `adb [-s serial|-d|-e|-t id] <command>`: logcat, and what `adb shell` prints for packages, properties, processes, dumpsys and UI dumps. */
+function pickAdb(all: string[]): ReturnType<typeof pick> {
+	let i = 0;
+	while (i < all.length && /^-[sHPLt]$|^-[de]$/.test(all[i]!)) i += /^-[de]$/.test(all[i]!) ? 1 : 2;
+	const [sub, ...rest] = all.slice(i);
+	// `adb shell "dumpsys battery"` is `adb shell dumpsys battery`.
+	const cmd = rest.join(" ").trim().split(/\s+/);
+	const line = cmd.join(" ");
+	if (sub === "logcat") return { kind: "logs", run: compactLogs };
+	if ((sub === "shell" || sub === "exec-out") && /^uiautomator dump \/dev\/(?:tty|stdout)\b/.test(line)) return { kind: "tree", run: compactUiDump };
+	if (sub !== "shell") return undefined;
+	if (/^(?:pm|cmd package) list packages\b/.test(line)) return cmd.includes("-f") ? { kind: "listing", run: compactPackagePaths } : { kind: "listing", run: compactPackages };
+	if (line === "getprop" || /^settings list (?:global|secure|system)$/.test(line)) return { kind: "listing", run: compactProperties };
+	if (/^ps(?: -A| -e)*$/.test(line) || /^top\b/.test(line)) return { kind: "listing", run: compactProcesses };
+	if (cmd[0] === "dumpsys" && cmd.length > 1) return { kind: "tree", run: compactDumpsys };
+	return undefined;
+}
+
+/** Package managers, linters, test runners, logs, docker and Xcode. */
+function pickTool({ program, args }: Invocation): ReturnType<typeof pick> {
+	const sub = args[0] ?? "";
+	const machine = args.some((a) => /json|sarif|junit|checkstyle|xml|github|gitlab|codeclimate|teamcity|tap\b/i.test(a));
+	if (machine) return undefined;
+	if (INSTALL[program]?.includes(sub) || (program === "yarn" && !sub) || (program === "uv" && (["add", "sync"].includes(sub) || (sub === "pip" && ["install", "sync"].includes(args[1] ?? "")))) || ((program === "flutter" || program === "dart") && sub === "pub" && args[1] === "get"))
+		return { kind: "install", run: compactInstall };
+	if (program in LINTERS) {
+		const subs = LINTERS[program];
+		// `ruff .` is `ruff check .` in older versions.
+		if (!subs || subs.includes(sub) || (program === "ruff" && sub.startsWith("-"))) return { kind: "lint", run: compactLint };
+		return undefined;
+	}
+	if (program === "pytest" || program === "py.test") return { kind: "tests", run: compactPytest };
+	if (program === "jest" || program === "vitest") return { kind: "tests", run: compactJest };
+	if (program === "mvn" || program === "mvnw" || program === "mvnd")
+		return args.some((a) => /dependency:tree$/.test(a)) ? { kind: "tree", run: compactMavenTree } : { kind: args.includes("test") ? "tests" : "build", run: compactMaven };
+	if (program === "javac") return { kind: "build", run: compactJavac };
+	if (LOG_COMMANDS(program, args)) return hasFlag(args, ["--follow"], ["f"]) ? undefined : { kind: "logs", run: compactLogs };
+	if (program === "adb") return pickAdb(args);
+	if (((program === "docker" || program === "podman") && (sub === "build" || (sub === "buildx" && args[1] === "build") || (sub === "compose" && args[1] === "build"))) || (program === "docker-compose" && sub === "build"))
+		return { kind: "build", run: compactDockerBuild };
+	if (program === "xcodebuild") return { kind: args.includes("test") ? "tests" : "build", run: compactXcode };
+	if (program === "swift" && (sub === "build" || sub === "test")) return { kind: sub === "test" ? "tests" : "build", run: compactXcode };
+	return undefined;
+}
+
 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;
+	const parsed = parse(command);
+	if (!parsed) return undefined;
+	const inv = unwrap(parsed);
 	// 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;
@@ -154,6 +273,8 @@ function pick(command: string, isFile?: (path: string) => boolean): { kind: Kind
 		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;
+		// ack: `-f` / `-g` list files; `-h` drops the path.
+		if (program === "ack" && hasFlag(args, ["--no-filename"], ["f", "g", "h"])) return hasFlag(args, [], ["f", "g"]) ? { kind: "paths", run: compactPaths } : undefined;
 		const plain = plainSearch(args, local);
 		return plain ?? { kind: "search", run: compactRg };
 	}
@@ -163,8 +284,8 @@ function pick(command: string, isFile?: (path: string) => boolean): { kind: Kind
 	}
 	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 === "tsc") return { kind: "build", run: compactTsc };
+	if (program === "gradle" || program === "gradlew") return args.some((a) => /(^|:)dependencies$/.test(a)) ? { kind: "tree", run: compactGradleDeps } : { 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 };
@@ -175,18 +296,22 @@ function pick(command: string, isFile?: (path: string) => boolean): { kind: Kind
 		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;
+	return pickTool(inv);
 }
 
 /** True when a native compactor takes care of `command`'s output (whatever the switches say). */
-export const handles = (command: string): boolean => pick(command) !== undefined;
+export const handles = (command: string): boolean => pick(unpipe(command)) !== undefined;
+
+/** Kinds whose output is worth compacting when the command failed: there the failures (or the crash's stack trace) are the point. */
+const FAILED_OK = new Set<Kind>(["tests", "build", "lint", "install", "logs"]);
 
 /** 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 {
+export function compact(full: string, output: string, opts: Options = {}): Result | undefined {
+	const command = unpipe(full);
 	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 allowed = (kind: Kind) => kinds[kind] !== false && (!failed || FAILED_OK.has(kind));
 	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);

package/extensions/core/docker.ts

@@ -0,0 +1,58 @@
+/**
+ * `docker build` (BuildKit plain progress and the classic builder): bookkeeping steps
+ * (`[internal]` loads, context transfer, CACHED, DONE, layer pushes, image export) go;
+ * each build step keeps its header and what its command printed, without the `#N 0.123`
+ * prefix. Errors stay whole.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { stripAnsi } from "./generic.ts";
+
+const STEP = /^#(\d+) (.*)$/;
+/** BuildKit lines with nothing to say once the build is over. */
+const QUIET = /^(building with |DONE [\d.]+s|CACHED|transferring |resolve |sha256:[\da-f]+ |extracting sha256:|exporting |writing image |naming to |unpacking to |preparing layers|load build definition|load \.dockerignore|load metadata for |\[auth\] )/;
+/** Classic builder bookkeeping. */
+const CLASSIC = /^( ---> |Removing intermediate container |Sending build context to Docker daemon|Successfully built [\da-f]+$)/;
+
+export function compactDockerBuild(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = stripAnsi(output).split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const buildkit = lines.some((l) => /^#\d+ \[/.test(l));
+	const classic = lines.some((l) => /^Step \d+\/\d+ : /.test(l));
+	if (!buildkit && !classic) return undefined;
+	const internal = new Set<string>();
+	const cached = new Set<string>();
+	/** Where each step's header went, to mark it CACHED. */
+	const steps = new Map<string, number>();
+	const out: string[] = [];
+	for (const l of lines) {
+		const m = STEP.exec(l);
+		if (!m) {
+			if (CLASSIC.test(l) || (l === "" && (out.length === 0 || out.at(-1) === ""))) continue;
+			out.push(cutLine(l, limits.lineChars));
+			continue;
+		}
+		const [, id, rest] = m as unknown as [string, string, string];
+		if (/^\[internal\]/.test(rest) || internal.has(id)) {
+			internal.add(id);
+			if (/^ERROR/.test(rest)) out.push(l);
+			continue;
+		}
+		if (rest === "CACHED" && steps.has(id)) {
+			cached.add(id);
+			out[steps.get(id)!] += " (cached)";
+		}
+		if (/^\[/.test(rest)) {
+			// BuildKit repeats a step's header when its output resumes after another step's.
+			if (!steps.has(id)) steps.set(id, out.push(cutLine(`#${id} ${rest}`, limits.lineChars)) - 1);
+		} else if (/^ERROR|^error/.test(rest)) out.push(cutLine(l, limits.lineChars));
+		else if (!QUIET.test(rest)) {
+			// `#7 0.512 npm warn …`: the command's own output.
+			const printed = /^[\d.]+(?: (.*))?$/.exec(rest);
+			if (printed && !printed[1]?.trim()) continue;
+			out.push(cutLine(printed ? `   ${printed[1]}` : `#${id} ${rest}`, limits.lineChars));
+		}
+	}
+	const head = buildkit ? [`docker build: ${steps.size} steps${cached.size ? `, ${cached.size} cached` : ""}`] : [];
+	const capped = capLines([...head, ...out], limits.total);
+	return { text: capped.text, truncated: capped.truncated };
+}

package/extensions/core/files.ts

@@ -1,5 +1,5 @@
 /** File checks for the compactors that need to know what is on disk. */
-import { statSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 
 /** A check whether `path`, relative to `cwd`, is an existing file. Without a cwd nothing is. */
@@ -13,3 +13,17 @@ export function fileIn(cwd: string | undefined): (path: string) => boolean {
 		}
 	};
 }
+
+/** Full outputs larger than this are not read back: compacting them would cost more than it saves. */
+export const FULL_OUTPUT_MAX_BYTES = 16 * 1024 * 1024;
+
+/** The full output pi saved for a bash run it truncated, or undefined when there is none to read. */
+export function readFullOutput(path: unknown, maxBytes = FULL_OUTPUT_MAX_BYTES): string | undefined {
+	if (typeof path !== "string") return undefined;
+	try {
+		if (statSync(path).size > maxBytes) return undefined;
+		return readFileSync(path, "utf8");
+	} catch {
+		return undefined; // gone already, unreadable
+	}
+}

package/extensions/core/generic.ts

@@ -16,8 +16,11 @@ const CONTENT = /(?:^|[\s|;&(])(cat|head|tail|sed|awk|jq|yq|bat|less|more|curl|w
 
 export const isContent = (command: string): boolean => CONTENT.test(command);
 
+/** Colour codes and terminal hyperlinks out; the text they wrapped stays. */
+export const stripAnsi = (text: string): string => text.replace(ANSI, "");
+
 export function compactGeneric(output: string, _limits?: Limits): Squeezed | undefined {
-	const lines = output.replace(ANSI, "").split("\n").map((l) => {
+	const lines = stripAnsi(output).split("\n").map((l) => {
 		const frame = l.replace(/\r+$/, "");
 		return (frame.includes("\r") ? frame.slice(frame.lastIndexOf("\r") + 1) : frame).trimEnd();
 	});