pi-squeeze 0.0.0-stage → 0.2.0

package/extensions/core/pytest.ts

@@ -0,0 +1,37 @@
+/**
+ * pytest: the session header, progress dots and PASSED lines go; failures, errors, the
+ * warnings summary, the short test summary and the result line stay.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { stripAnsi } from "./generic.ts";
+
+const RESULT = /^=+ .*\b(passed|failed|errors?|skipped|deselected|no tests ran)\b.* in [\d.]+s.* =+$/;
+const DROP = [
+	/^=+ test session starts =+$/,
+	/^platform \S+ -- Python /,
+	/^(rootdir|cachedir|plugins|configfile|testpaths|cov|hypothesis profile|benchmark|asyncio|django|metadata): /,
+	/^collect(ing|ed) \d+ items?/,
+	/^collecting \.\.\./,
+	/^-- Docs: https:\/\/docs\.pytest\.org/,
+	// `test_a.py ..F.s   [ 50%]`: the failures are listed again below.
+	/^\S+\.py [.sSxXfFE]+\s*(\[\s*\d+%\])?$/,
+	/ PASSED\s*(\[\s*\d+%\])?$/,
+];
+
+export function compactPytest(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = stripAnsi(output).split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const result = lines.findLast((l) => RESULT.test(l));
+	if (!result) return undefined;
+	const kept: string[] = [];
+	for (const l of lines) {
+		if (RESULT.test(l) || DROP.some((d) => d.test(l))) continue;
+		if (l === "" && (kept.length === 0 || kept.at(-1) === "")) continue;
+		// `-v`: `test_a.py::test_x FAILED [ 50%]` keeps its verdict, loses the percentage;
+		// a full-width `==== FAILURES ====` / `____ test_x ____` banner keeps two of each.
+		const line = l.replace(/\s+\[\s*\d+%\]$/, "").replace(/^([=_])\1{2,} (.*?) \1{3,}$/, "$1$1 $2 $1$1");
+		kept.push(cutLine(line, limits.lineChars));
+	}
+	while (kept.at(-1) === "") kept.pop();
+	return capLines([`pytest: ${result.replace(/^=+ | =+$/g, "")}`, ...kept], limits.total);
+}

package/extensions/core/rg.ts

@@ -0,0 +1,126 @@
+/**
+ * `rg -n` / `grep -n` output (`path:line:text`, context lines `path-line-text`) grouped by
+ * file, so each path is written once instead of on every match:
+ *
+ *   src/a.ts (3)
+ *     12: const x = 1;
+ *     13- context
+ *
+ * Without line numbers (`rg pattern dir`, `path:text`) the path cannot be told from text that
+ * has a colon, so `compactRgPlain` only groups when every path is a file that exists.
+ *
+ * Strict: when any line is not in that format (`--heading`, `-c`, `-l`, `--json`) it returns
+ * undefined and the output passes through unchanged.
+ */
+import { cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+type Row = { path: string; line: number; sep: ":" | "-"; text: string };
+
+const MATCH = /^(.+?):(\d+):(.*)$/;
+
+export function parseRows(output: string): Row[] | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.length) return undefined;
+	const rows: Row[] = [];
+	const files = new Set<string>();
+	const pending: { index: number; raw: string }[] = [];
+	for (const raw of lines) {
+		if (raw === "--") continue;
+		const m = MATCH.exec(raw);
+		if (m) {
+			if (m[1]!.includes(":")) return undefined; // `12:foo:3:bar` is single-file output, not a path
+			files.add(m[1]!);
+			rows.push({ path: m[1]!, line: Number(m[2]), sep: ":", text: m[3]! });
+		} else {
+			pending.push({ index: rows.length, raw });
+			rows.push(undefined as unknown as Row);
+		}
+	}
+	if (!files.size) return undefined;
+	// Context lines (`path-line-text`) only count for files that also had a real match.
+	for (const { index, raw } of pending) {
+		let row: Row | undefined;
+		for (const path of files) {
+			if (!raw.startsWith(`${path}-`)) continue;
+			const m = /^(\d+)-(.*)$/.exec(raw.slice(path.length + 1));
+			if (m) {
+				row = { path, line: Number(m[1]), sep: "-", text: m[2]! };
+				break;
+			}
+		}
+		if (!row) return undefined;
+		rows[index] = row;
+	}
+	return rows;
+}
+
+/** At most this many distinct paths are looked up on disk. */
+const MAX_LOOKUPS = 500;
+
+/** `path:text` rows (no line numbers), or undefined unless every path is an existing file. */
+export function parsePlainRows(output: string, isFile: (path: string) => boolean): Row[] | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.length) return undefined;
+	const known = new Map<string, boolean>();
+	const rows: Row[] = [];
+	for (const raw of lines) {
+		const at = raw.indexOf(":");
+		if (at <= 0) return undefined;
+		const path = raw.slice(0, at);
+		let ok = known.get(path);
+		if (ok === undefined) {
+			if (known.size >= MAX_LOOKUPS) return undefined;
+			ok = isFile(path);
+			known.set(path, ok);
+		}
+		if (!ok) return undefined;
+		rows.push({ path, line: 0, sep: ":", text: raw.slice(at + 1) });
+	}
+	return rows;
+}
+
+export function compactRg(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const rows = parseRows(output);
+	return rows && render(rows, limits);
+}
+
+export function compactRgPlain(output: string, limits: Limits, isFile: (path: string) => boolean): Squeezed | undefined {
+	const rows = parsePlainRows(output, isFile);
+	return rows && render(rows, limits);
+}
+
+function render(rows: Row[], limits: Limits): Squeezed {
+	const groups = new Map<string, Row[]>();
+	for (const r of rows) {
+		const g = groups.get(r.path);
+		if (g) g.push(r);
+		else groups.set(r.path, [r]);
+	}
+	const matchCount = rows.filter((r) => r.sep === ":").length;
+	const out: string[] = [`${matchCount} matches in ${groups.size} file${groups.size === 1 ? "" : "s"}`];
+	let truncated = false;
+	let hiddenFiles = 0;
+	for (const [path, list] of groups) {
+		if (out.length >= limits.total) {
+			hiddenFiles++;
+			truncated = true;
+			continue;
+		}
+		const matches = list.filter((r) => r.sep === ":").length;
+		out.push(`${path} (${matches})`);
+		let shown = 0;
+		for (const r of list) {
+			if (shown >= limits.perGroup) break;
+			out.push(`  ${r.line ? `${r.line}${r.sep} ` : ""}${cutLine(r.text.trim(), limits.lineChars)}`);
+			shown++;
+		}
+		if (list.length > shown) {
+			out.push(`  … [+${list.length - shown} more in this file]`);
+			truncated = true;
+		}
+	}
+	if (hiddenFiles) out.push(`… [+${hiddenFiles} more files]`);
+	return { text: out.join("\n"), truncated };
+}

package/extensions/core/rtk.ts

@@ -0,0 +1,50 @@
+/**
+ * The optional rtk layer: commands that have no native compactor here (git, cargo, docker, …) are
+ * rewritten to their `rtk` form, which prints a compact output itself.
+ *
+ * `rtk rewrite <command>` is the single source of truth for what rtk can take over. Exit 0 and 3
+ * mean "rewritten" (3: the host should ask for approval, pi has no such step); 1 means no rewrite
+ * and 2 a deny. Never rewritten: what a native compactor handles (its output format is ours to
+ * parse) and file reads (`rtk read` may drop lines, and a read must stay exact).
+ */
+import { spawnSync } from "node:child_process";
+import { handles } from "./compact.ts";
+
+export type Run = (command: string) => { status: number | null; stdout: string; missing?: boolean };
+
+const spawnRun: Run = (command) => {
+	const r = spawnSync("rtk", ["rewrite", command], { encoding: "utf8", timeout: 2000 });
+	return { status: r.status, stdout: r.stdout ?? "", missing: (r.error as NodeJS.ErrnoException | undefined)?.code === "ENOENT" };
+};
+
+let run: Run = spawnRun;
+/** For tests: replace the process runner (no argument restores it). */
+export const useRunner = (r: Run = spawnRun): void => {
+	run = r;
+};
+
+const cache = new Map<string, string | undefined>();
+const CACHE_MAX = 500;
+let missing = false;
+
+/** The command to run instead of `command`, or undefined to run it as written. */
+export function rewrite(command: string): string | undefined {
+	if (missing || command.trim() === "" || handles(command)) return undefined;
+	if (cache.has(command)) return cache.get(command);
+	const r = run(command);
+	if (r.missing) {
+		missing = true;
+		return undefined;
+	}
+	const out = r.stdout.trim();
+	const rewritten = (r.status === 0 || r.status === 3) && out !== "" && out !== command && !/^rtk read\b/.test(out) ? out : undefined;
+	if (cache.size >= CACHE_MAX) cache.clear();
+	cache.set(command, rewritten);
+	return rewritten;
+}
+
+/** For tests: forget what was learned (the cache and a missing binary). */
+export function resetRtk(): void {
+	cache.clear();
+	missing = false;
+}

package/extensions/core/runners.ts

@@ -0,0 +1,50 @@
+/**
+ * Test runners other than cargo: `bun test` and `go test`. Passing tests are counted, not
+ * listed; failures (with their source frame and message), skips and the totals stay.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+/** `(pass) name [1ms]` lines go, and a file header left with nothing under it goes too. */
+export function compactBunTest(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.some((l) => /^Ran \d+ tests? across \d+ files?\./.test(l))) return undefined;
+	const kept: string[] = [];
+	for (const l of lines) {
+		if (/^\(pass\) /.test(l)) continue;
+		// The file header (`path.test.ts:`) is only worth keeping when something stayed under it.
+		if (l === "" && (kept.length === 0 || kept.at(-1) === "")) continue;
+		kept.push(l);
+	}
+	const out: string[] = [];
+	for (let i = 0; i < kept.length; i++) {
+		const header = /^\S+\.(test|spec)\.\w+:$/.test(kept[i]!);
+		const empty = kept[i + 1] === undefined || kept[i + 1] === "" || /^\S+\.(test|spec)\.\w+:$/.test(kept[i + 1]!);
+		if (header && empty) continue;
+		out.push(kept[i]!);
+	}
+	const tidy = out.filter((l, i) => !(l === "" && (i === 0 || out[i - 1] === "")));
+	return capLines(tidy, limits.total);
+}
+
+/** `ok pkg 0.3s`, `? pkg [no test files]` and `PASS` collapse into one count line; `=== RUN` and `--- PASS` go. */
+export function compactGoTest(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	let ok = 0;
+	let failed = 0;
+	let none = 0;
+	const kept: string[] = [];
+	for (const l of lines) {
+		if (/^ok\s+\S+/.test(l)) ok++;
+		else if (/^\?\s+\S+\s+\[no test files\]$/.test(l)) none++;
+		else if (/^(FAIL)\s+\S+(\s|$)/.test(l) && /\s\d/.test(l)) {
+			failed++;
+			kept.push(l);
+		} else if (/^(=== (RUN|PAUSE|CONT|NAME)|\s*--- PASS:|PASS$)/.test(l)) continue;
+		else kept.push(l);
+	}
+	if (!ok && !failed && !none) return undefined;
+	const parts = [`${ok} ok`, `${failed} failed`, ...(none ? [`${none} without tests`] : [])];
+	return capLines([`go test: ${parts.join(", ")}`, ...kept], limits.total);
+}

package/extensions/core/rustc.ts

@@ -0,0 +1,99 @@
+/**
+ * `cargo build` / `check` / `clippy` output. Errors keep their full block (they are why you
+ * ran the command); warnings shrink to one line each, grouped by lint:
+ *
+ *   clippy::needless_return (2)
+ *     src/lib.rs:2:55 unneeded `return` statement
+ *
+ * Build progress (`Compiling`, `Checking`, `Finished`) goes, an identical warning reported
+ * for several targets is listed once, and the summary lines stay.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const PROGRESS = /^\s+(Compiling|Checking|Downloaded|Downloading|Updating|Locking|Fresh|Blocking|Adding|Building|Documenting|Finished|Fixed|Generated) /;
+const HEAD = /^(warning|error)(?:\[(E\d+)\])?: (.*)$/;
+const WHERE = /^\s*--> (.+?:\d+:\d+)$/;
+const ERROR_LINES = 40;
+
+type Diag = { level: "warning" | "error"; code: string; message: string; where: string; lint: string; help: string; block: string[] };
+
+function lintOf(block: string[]): string {
+	for (const l of block) {
+		const a = /#\[(?:warn|deny|forbid)\(([\w:]+)\)\]/.exec(l);
+		if (a) return a[1]!;
+		const b = /rust-clippy\/[^#]*#(\w+)$/.exec(l);
+		if (b) return `clippy::${b[1]}`;
+	}
+	return "other";
+}
+
+function parseBlock(block: string[]): Diag | undefined {
+	const h = HEAD.exec(block[0] ?? "");
+	const w = block.map((l) => WHERE.exec(l)).find(Boolean);
+	if (!h || !w) return undefined;
+	const help = block.map((l) => /\^+ help: (.*)$/.exec(l)).find(Boolean)?.[1] ?? "";
+	return { level: h[1] as Diag["level"], code: h[2] ?? "", message: h[3]!, where: w[1]!, lint: lintOf(block), help, block };
+}
+
+export function compactRustc(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const blocks: string[][] = [[]];
+	for (const l of lines) {
+		if (PROGRESS.test(l)) continue;
+		if (l === "") blocks.push([]);
+		else blocks.at(-1)!.push(l);
+	}
+	const diags: Diag[] = [];
+	const other: string[] = [];
+	let seen = false;
+	const order: (Diag | string)[] = [];
+	for (const b of blocks) {
+		if (!b.length) continue;
+		const d = parseBlock(b);
+		if (d) {
+			seen = true;
+			diags.push(d);
+			order.push(d);
+		} else {
+			other.push(...b);
+			order.push(b.join("\n"));
+		}
+	}
+	if (!seen) return undefined;
+
+	const errors = diags.filter((d) => d.level === "error");
+	const warnings = new Map<string, Map<string, string>>();
+	for (const d of diags) {
+		if (d.level !== "warning") continue;
+		const group = warnings.get(d.lint) ?? new Map<string, string>();
+		warnings.set(d.lint, group);
+		group.set(`${d.where} ${d.message}`, cutLine(`  ${d.where} ${d.message}${d.help ? ` → ${d.help}` : ""}`, limits.lineChars));
+	}
+	const out: string[] = [];
+	const count = [...warnings.values()].reduce((n, g) => n + g.size, 0);
+	out.push(`${errors.length} error${errors.length === 1 ? "" : "s"}, ${count} warning${count === 1 ? "" : "s"}`);
+	let cut = false;
+	for (const e of errors) {
+		out.push("", ...e.block.slice(0, ERROR_LINES).map((l) => cutLine(l, limits.lineChars)));
+		if (e.block.length > ERROR_LINES) {
+			out.push(`  … [+${e.block.length - ERROR_LINES} more lines]`);
+			cut = true;
+		}
+	}
+	if (errors.length && warnings.size) out.push("");
+	for (const [lint, group] of warnings) {
+		out.push(`${lint} (${group.size})`);
+		const entries = [...group.values()];
+		out.push(...entries.slice(0, limits.perGroup));
+		if (entries.length > limits.perGroup) {
+			out.push(`  … [+${entries.length - limits.perGroup} more]`);
+			cut = true;
+		}
+	}
+	// Whatever is not a diagnostic (summaries, `error: could not compile`, notes) stays as it was.
+	const rest = other.filter((l) => l !== "");
+	if (rest.length) out.push("", ...rest);
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: cut || capped.truncated };
+}

package/extensions/core/save.ts

@@ -0,0 +1,11 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/** Writes the untouched output to a temp file so a truncated result can be recovered. */
+export function saveFull(text: string, dir = join(tmpdir(), "pi-squeeze")): string {
+	mkdirSync(dir, { recursive: true });
+	const path = join(dir, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.txt`);
+	writeFileSync(path, text);
+	return path;
+}

package/extensions/core/stats.ts

@@ -0,0 +1,31 @@
+import { KINDS, type Kind, type Result } from "./compact.ts";
+
+export type Stats = { calls: number; before: number; after: number; byKind: Record<Kind, { calls: number; saved: number }> };
+
+export function emptyStats(): Stats {
+	return { calls: 0, before: 0, after: 0, byKind: Object.fromEntries(KINDS.map((k) => [k, { calls: 0, saved: 0 }])) as Stats["byKind"] };
+}
+
+export function record(stats: Stats, r: Result): void {
+	stats.calls++;
+	stats.before += r.before;
+	stats.after += r.after;
+	stats.byKind[r.kind].calls++;
+	stats.byKind[r.kind].saved += r.before - r.after;
+}
+
+/** Characters saved so far. */
+export const saved = (s: Stats): number => s.before - s.after;
+
+/** Rough token estimate: 4 characters per token. */
+export const tokens = (chars: number): number => Math.round(chars / 4);
+
+export function summary(stats: Stats): string {
+	if (!stats.calls) return "squeeze: nothing compacted yet in this session";
+	const pct = Math.round((saved(stats) / stats.before) * 100);
+	const kinds = (Object.entries(stats.byKind) as [Kind, { calls: number; saved: number }][])
+		.filter(([, v]) => v.calls)
+		.map(([k, v]) => `${k} ${v.calls}× (~${tokens(v.saved)} tokens)`)
+		.join(", ");
+	return `squeeze: ${stats.calls} outputs compacted, ~${tokens(saved(stats))} tokens saved (${pct}%): ${kinds}`;
+}

package/extensions/core/tests.ts

@@ -0,0 +1,46 @@
+/**
+ * `cargo test` output: the build progress, the `test … ok` lines and the `running N tests`
+ * headers go; warnings, failures, panics, `Running …` and `test result` lines stay. A one-line
+ * summary of the totals comes first.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const PROGRESS = /^\s+(Compiling|Downloaded|Downloading|Updating|Locking|Fresh|Blocking|Adding|Packaging|Checking|Building|Finished) /;
+const OK = /^test .* \.\.\. (ok|ignored)(, .*)?$/;
+const RUNNING_N = /^running \d+ tests?$/;
+const RESULT = /^test result: (ok|FAILED)\. (\d+) passed; (\d+) failed; (\d+) ignored;/;
+
+export function compactTests(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	let passed = 0;
+	let failed = 0;
+	let ignored = 0;
+	let binaries = 0;
+	let sawProgress = false;
+	let inFailures = false;
+	const kept: string[] = [];
+	for (const l of lines) {
+		const r = RESULT.exec(l);
+		if (r) {
+			binaries++;
+			passed += Number(r[2]);
+			failed += Number(r[3]);
+			ignored += Number(r[4]);
+		}
+		if (l === "failures:") inFailures = true;
+		if (r) inFailures = false;
+		if (PROGRESS.test(l)) {
+			sawProgress = true;
+			continue;
+		}
+		if (OK.test(l) || RUNNING_N.test(l)) continue;
+		const run = /^(\s+Running .*?) \(target\/.*\)$/.exec(l);
+		const text = run ? run[1]! : l;
+		// Blank lines only separate blocks: they stay only inside the failure report, where they separate panics.
+		if (text === "" && !inFailures) continue;
+		kept.push(text);
+	}
+	if (binaries === 0 && !sawProgress) return undefined;
+	const head = binaries ? [`cargo test: ${passed} passed, ${failed} failed, ${ignored} ignored (${binaries} test binar${binaries === 1 ? "y" : "ies"})`] : [];
+	return capLines([...head, ...kept], limits.total);
+}

package/extensions/core/tree.ts

@@ -0,0 +1,51 @@
+/**
+ * Tree output (`cargo tree`, `tree`, `eza --tree`, `gradle dependencies`) cut below a depth, with a marker that says
+ * how many lines were left out under each cut:
+ *
+ *   ├── ratatui v0.30.2
+ *   │   ├── instability v0.3.14 (proc-macro)
+ *   │   │   ├── darling v0.24.1
+ *               … [+15 lines deeper]
+ *
+ * A cut of a single line is not worth a marker and is left in.
+ */
+import { cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+/** Box-drawing trees indent by 4; gradle's ASCII one (`+--- `, `|    `) by 5, Maven's by 3. */
+const STYLES = [
+	{ prefix: /^((?:│   |    )*)/, branch: /^(?:│   |    )*(?:├── |└── )/, unit: 4 },
+	{ prefix: /^((?:\|    | {5})*)/, branch: /^(?:\|    | {5})*(?:\+--- |\\--- )/, unit: 5 },
+	// Maven's `dependency:tree`: `+- `, `\- `, `|  `.
+	{ prefix: /^((?:\|  | {3})*)/, branch: /^(?:\|  | {3})*(?:\+- |\\- )/, unit: 3 },
+];
+
+/** Levels kept below the root. */
+const DEPTH = 3;
+
+export function compactTree(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const style = STYLES.find((s) => lines.some((l) => s.branch.test(l)));
+	if (lines.length < 5 || !style) return undefined;
+	const { prefix, branch, unit } = style;
+	const out: string[] = [];
+	let hidden: string[] = [];
+	const flush = () => {
+		if (hidden.length === 1) out.push(cutLine(hidden[0]!, limits.lineChars));
+		else if (hidden.length) out.push(`${" ".repeat(DEPTH * unit)}… [+${hidden.length} lines deeper]`);
+		hidden = [];
+	};
+	for (const l of lines) {
+		const units = prefix.exec(l)![1]!.length / unit;
+		const depth = branch.test(l) || units > 0 ? units + 1 : 0;
+		if (depth > DEPTH) {
+			hidden.push(l);
+			continue;
+		}
+		flush();
+		out.push(cutLine(l, limits.lineChars));
+	}
+	flush();
+	if (out.length >= lines.length) return undefined;
+	return { text: out.join("\n"), truncated: true };
+}

package/extensions/core/tsc.ts

@@ -0,0 +1,49 @@
+/**
+ * `tsc` (plain, not `--pretty`) errors grouped by file:
+ *
+ *   a.ts (8)
+ *     1:7 TS2322 Type 'string' is not assignable to type 'number'.
+ *
+ * Continuation lines (indented) stay with their error. The `Found N errors` footer stays.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const ERROR = /^(.+?)\((\d+),(\d+)\): (error|warning) (TS\d+): (.*)$/;
+const FOOTER = /^Found \d+ errors?( in \d+ files?)?\.?$|^Errors +Files$|^ +\d+ +\S.*$/;
+
+export function compactTsc(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const files = new Map<string, string[]>();
+	const tail: string[] = [];
+	let current: string[] | undefined;
+	let errors = 0;
+	for (const l of lines) {
+		const m = ERROR.exec(l);
+		if (m) {
+			errors++;
+			current = files.get(m[1]!) ?? [];
+			files.set(m[1]!, current);
+			current.push(cutLine(`  ${m[2]}:${m[3]} ${m[4] === "warning" ? "warning " : ""}${m[5]} ${m[6]}`, limits.lineChars));
+		} else if (/^\s+\S/.test(l) && current && !tail.length) current.push(cutLine(`    ${l.trim()}`, limits.lineChars));
+		else if (l === "" || FOOTER.test(l)) {
+			tail.push(l);
+			current = undefined;
+		} else return undefined;
+	}
+	if (!errors) return undefined;
+	const out = [`tsc: ${errors} error${errors === 1 ? "" : "s"} in ${files.size} file${files.size === 1 ? "" : "s"}`];
+	let cut = false;
+	for (const [file, entries] of files) {
+		out.push(`${file} (${entries.filter((e) => !e.startsWith("    ")).length})`);
+		out.push(...entries.slice(0, limits.perGroup * 2));
+		if (entries.length > limits.perGroup * 2) {
+			out.push(`  … [+${entries.length - limits.perGroup * 2} more lines]`);
+			cut = true;
+		}
+	}
+	const footer = tail.filter((l) => l !== "");
+	if (footer.length) out.push("", ...footer);
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: cut || capped.truncated };
+}