pi-squeeze 0.0.0-stage → 0.2.0

package/extensions/core/javac.ts

@@ -0,0 +1,44 @@
+/**
+ * `javac` output: each error keeps its source line, caret and `symbol:` / `location:` lines
+ * (what fixing it needs); warnings are grouped by kind and message, each location once
+ * (`warning [rawtypes]: found raw type: List (3)`), their source lines and "where E is a
+ * type-variable" explanations go, as does the advice to recompile with -Xlint. Anything
+ * that is not javac output passes the whole of it through.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { shortenPaths } from "./gradle.ts";
+import { type Diag, renderDiags } from "./lint.ts";
+
+const HEAD = /^(\S.*?\.java):(\d+): (error|warning): (?:\[([\w-]+)\] )?(.*)$/;
+const TOTAL = /^\d+ (?:errors?|warnings?)$/;
+const NOTE = /^Note: /;
+
+export function compactJavac(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const errors: string[] = [];
+	const warnings: Diag[] = [];
+	const totals: string[] = [];
+	let current: "error" | "warning" | undefined;
+	for (const l of lines) {
+		const m = HEAD.exec(l);
+		if (m) {
+			current = m[3] as "error" | "warning";
+			if (current === "error") errors.push(l);
+			else warnings.push({ file: m[1]!, line: m[2]!, severity: "warning", rule: m[4], message: m[5]! });
+		} else if (TOTAL.test(l)) totals.push(l);
+		else if (NOTE.test(l)) {
+			// "uses or overrides a deprecated API" says something; "Recompile with -Xlint" does not.
+			if (!/Recompile with -Xlint/.test(l)) totals.push(l);
+		} else if (!current) return undefined;
+		// Under an error: the source line, the caret and symbol/location stay; type-variable notes go.
+		else if (current === "error" && !/^\s+(?:where \w+ is a type-variable|\w+ extends \w+ declared in)/.test(l)) errors.push(l);
+	}
+	if (!errors.length && !warnings.length) return undefined;
+	shortenPaths(errors);
+	const out = errors.map((l) => cutLine(l, limits.lineChars));
+	if (warnings.length) out.push(...renderDiags({ tool: "javac", diags: warnings, notes: [] }, { ...limits, total: Number.MAX_SAFE_INTEGER }).text.split("\n"));
+	out.push(...totals);
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: warnings.length > 0 || capped.truncated };
+}

package/extensions/core/jest.ts

@@ -0,0 +1,38 @@
+/**
+ * jest and vitest: passing tests (`✓`) and passing files go, skipped tests are counted;
+ * failures with their diff and source frame, and the totals, stay.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { stripAnsi } from "./generic.ts";
+
+const TOTALS = /^\s*(Tests|Test Files|Test Suites):?\s+\d+ (passed|failed|skipped|todo|total)/;
+const PASS = [
+	/^\s*[✓√] /,
+	/^PASS /,
+	/^ RUN {2}v[\d.]+/,
+	/^\s+Start at {2}/,
+	/^Snapshots: {3}0 total$/,
+	/^Ran all test suites\.$/,
+];
+const SKIP = /^\s*[↓○] (skipped )?/;
+
+export function compactJest(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = stripAnsi(output).split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.some((l) => TOTALS.test(l))) return undefined;
+	const kept: string[] = [];
+	let skipped = 0;
+	for (const l of lines) {
+		if (PASS.some((p) => p.test(l))) continue;
+		if (SKIP.test(l)) {
+			skipped++;
+			continue;
+		}
+		if (l.trim() === "" && (kept.length === 0 || kept.at(-1) === "")) continue;
+		// vitest's full-width `⎯⎯⎯ Failed Tests 2 ⎯⎯⎯` rules keep two of their dashes.
+		kept.push(cutLine(l.trim() === "" ? "" : l.replace(/⎯{3,}/g, "⎯⎯"), limits.lineChars));
+	}
+	while (kept.at(-1) === "") kept.pop();
+	if (skipped) kept.push(`(${skipped} skipped not listed)`);
+	return capLines(kept, limits.total);
+}

package/extensions/core/jvm.ts

@@ -0,0 +1,18 @@
+/**
+ * What the JVM and its usual libraries print on every run of Gradle, Maven or a test JVM,
+ * and that says nothing about the build: class-data sharing, dynamic agents (Mockito,
+ * ByteBuddy), SLF4J without a binding.
+ */
+export const JVM_NOISE = [
+	/^OpenJDK 64-Bit Server VM warning: Sharing is only supported/,
+	/^WARNING: A Java agent has been loaded dynamically/,
+	/^WARNING: If a serviceability tool is (?:not )?in use/,
+	/^WARNING: Dynamic loading of agents will be disallowed/,
+	/^WARNING: A terminally deprecated method in sun\.misc\.Unsafe/,
+	/^WARNING: sun\.misc\.Unsafe::\w+ (?:has been called|will be removed)/,
+	/^WARNING: Please consider reporting this to the maintainers/,
+	/^Mockito is currently self-attaching to enable the inline-mock-maker/,
+	/^SLF4J(?:\(\w\))?: (?:No SLF4J providers|Defaulting to no-operation|See https?:\/\/www\.slf4j\.org|Failed to load class|Class path contains multiple)/,
+];
+
+export const isJvmNoise = (line: string): boolean => JVM_NOISE.some((n) => n.test(line));

package/extensions/core/lint.ts

@@ -0,0 +1,199 @@
+/**
+ * Linter findings grouped by rule and message, each location listed once:
+ *
+ *   eslint: 20 errors, 5 warnings in 5 files
+ *   error eqeqeq: Expected '===' and instead saw '==' (5)
+ *     src/m.js:2:46  src/m1.js:2:47  …
+ *
+ * Source frames, help text and fix suggestions go (the location leads back to them). Formats:
+ * ESLint stylish, Biome, Ruff (full and concise), `flutter analyze`, and the one-line
+ * `path:line:col: message` shape that flake8, mypy, pylint, ktlint, detekt, swiftlint and
+ * shellcheck share, and Android Lint's text report (its source lines and explanations go). Anything else in the output passes the whole of it through.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { stripAnsi } from "./generic.ts";
+
+export type Diag = { file: string; line: string; col?: string; severity: string; rule?: string; message: string };
+/** `lossy`: the format had more than the findings (frames, help, fixes), which the result leaves out. */
+export type Parsed = { tool: string; diags: Diag[]; notes: string[]; lossy?: boolean };
+
+/** ESLint's default `stylish` formatter. */
+export function parseEslint(lines: string[]): Parsed | undefined {
+	const diags: Diag[] = [];
+	const notes: string[] = [];
+	let file: string | undefined;
+	for (const l of lines) {
+		const m = /^\s+(\d+):(\d+)\s+(error|warning)\s+(.*?)(?:\s{2,}(\S+))?$/.exec(l);
+		if (m && file) diags.push({ file, line: m[1]!, col: m[2], severity: m[3]!, message: m[4]!, rule: m[5] });
+		else if (/^✖ \d+ problems?/.test(l) || /^\s+\d+ errors? and \d+ warnings? potentially fixable/.test(l)) notes.push(l.trim());
+		else if (/^\S/.test(l) && !/:\d+/.test(l)) file = l;
+		else if (l.trim() !== "") return undefined;
+	}
+	return diags.length && notes.length ? { tool: "eslint", diags, notes } : undefined;
+}
+
+/** Biome: `path:line:col rule  FIXABLE  ━━━` headers, the message on the first `×`/`!`/`i` line. */
+export function parseBiome(lines: string[]): Parsed | undefined {
+	const diags: Diag[] = [];
+	const notes: string[] = [];
+	let open: Diag | undefined;
+	let footer = false;
+	for (const l of lines) {
+		const h = /^(\S+?):(\d+):(\d+) (\S+)(?:\s+FIXABLE)?\s+━+$/.exec(l);
+		if (h && !footer) {
+			open = { file: h[1]!, line: h[2]!, col: h[3], rule: h[4], severity: "", message: "" };
+			diags.push(open);
+		} else if (/^(Checked \d+ files?|Found \d+ (errors?|warnings?|infos?)|The number of diagnostics exceeds|Skipped \d+ suggested)/.test(l)) {
+			footer = true;
+			notes.push(l);
+		} else if (footer && /^\s+× /.test(l)) notes.push(l.trim());
+		else if (open && !open.message) {
+			const m = /^\s+([×!i]) (.*)$/.exec(l);
+			if (m) {
+				open.severity = m[1] === "×" ? "error" : m[1] === "!" ? "warning" : "info";
+				open.message = m[2]!;
+			}
+		}
+	}
+	return diags.length && notes.length && diags.every((d) => d.message) ? { tool: "biome", diags, notes, lossy: true } : undefined;
+}
+
+/** Ruff's full format: `CODE [*] message` then ` --> path:line:col`, then a frame and help. */
+export function parseRuff(lines: string[]): Parsed | undefined {
+	const diags: Diag[] = [];
+	const notes: string[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		const l = lines[i]!;
+		const h = /^([A-Z]+\d+) (?:\[\*\] )?(.*)$/.exec(l);
+		const at = /^\s*--> (.+?):(\d+):(\d+)$/.exec(lines[i + 1] ?? "");
+		if (h && at) {
+			diags.push({ file: at[1]!, line: at[2]!, col: at[3], rule: h[1], severity: "", message: h[2]! });
+			i++;
+		} else if (/^(Found \d+ errors?|\[\*\] \d+ fixable|No fixes available|warning: )/.test(l)) notes.push(l);
+	}
+	return diags.length ? { tool: "ruff", diags, notes, lossy: true } : undefined;
+}
+
+/** `flutter analyze` / `dart analyze`: `  info • message • lib/a.dart:3:5 • rule`. */
+export function parseDart(lines: string[]): Parsed | undefined {
+	const diags: Diag[] = [];
+	const notes: string[] = [];
+	for (const l of lines) {
+		const m = /^\s*(error|warning|info) • (.*) • (\S+?):(\d+):(\d+) • (\S+)$/.exec(l);
+		if (m) diags.push({ severity: m[1]!, message: m[2]!, file: m[3]!, line: m[4]!, col: m[5], rule: m[6] });
+		else if (l.trim() !== "") notes.push(l.trim());
+	}
+	return diags.length && notes.length <= 4 ? { tool: "analyze", diags, notes } : undefined;
+}
+
+const LOCATED = /^(\S.*?):(\d+)(?::(\d+))?:? (?:(error|warning|note|info|fatal|convention|refactor|style)\s*:?\s+)?(.+)$/;
+/** Lines a one-line linter prints around its findings. */
+const BANNER = /^(Found \d+|\[\*\] \d+ fixable|No fixes available|warning: |Success: |All checks passed|Your code has been rated|-{10,}|\*{5,} Module |Summary: |Done linting|Summary error count|\s+[\w:./-]+: \d+$|\d+ (problems?|errors?|warnings?|violations?|issues?)\b)/;
+
+/** One finding per line: `path:line[:col]: [severity:] message [rule]`. */
+export function parseLocated(lines: string[]): Parsed | undefined {
+	const diags: Diag[] = [];
+	const notes: string[] = [];
+	for (const l of lines) {
+		const m = LOCATED.exec(l);
+		if (m && !/^\s/.test(l) && !BANNER.test(l)) {
+			let message = m[5]!;
+			let rule: string | undefined;
+			const code = /^([A-Z]+\d+):? (?:\[\*\] )?(.*)$/.exec(message);
+			const tail = /^(.*?)\s+[[(]([\w:./@-]+)[\])]$/.exec(message);
+			if (code) [rule, message] = [code[1], code[2]!];
+			else if (tail) [message, rule] = [tail[1]!, tail[2]];
+			diags.push({ file: m[1]!, line: m[2]!, col: m[3], severity: m[4] ?? "", rule, message });
+		} else if (BANNER.test(l)) notes.push(l);
+		else if (l.trim() !== "") return undefined;
+	}
+	return diags.length ? { tool: "lint", diags, notes } : undefined;
+}
+
+/** Android Lint's text report: `path:12: Warning: message [IssueId]`, the source line, `~~~~`, explanations. */
+const ANDROID_LINT = /^(\S.*?):(\d+): (Error|Warning|Information|Hint|Fatal): (.*) \[(\w+)\]$/;
+
+export function parseAndroidLint(lines: string[]): Parsed | undefined {
+	const diags: Diag[] = [];
+	const notes: string[] = [];
+	for (const l of lines) {
+		const m = ANDROID_LINT.exec(l);
+		if (m) diags.push({ file: m[1]!, line: m[2]!, severity: m[3]!.toLowerCase(), rule: m[5], message: m[4]! });
+		// Source lines, underlines and explanations are indented; the summary is `3 errors, 1 warning`.
+		else if (/^\d+ errors?(, \d+ warnings?)?$|^\d+ warnings?$|^No issues found/.test(l)) notes.push(l);
+		else if (l.trim() !== "" && !/^\s/.test(l)) return undefined;
+	}
+	return diags.length ? { tool: "android lint", diags, notes, lossy: true } : undefined;
+}
+
+/** The directory every absolute path shares, to be written once. */
+export function sharedDir(files: string[]): string {
+	if (!files.length || !files.every((f) => f.startsWith("/"))) return "";
+	let prefix = files[0]!.slice(0, files[0]!.lastIndexOf("/") + 1);
+	for (const f of files) while (!f.startsWith(prefix)) prefix = prefix.slice(0, prefix.lastIndexOf("/", prefix.length - 2) + 1);
+	return prefix.length > 1 ? prefix : "";
+}
+
+const count = (n: number, word: string) => `${n} ${word}${n === 1 ? "" : "s"}`;
+
+/** Renders findings grouped by severity, rule and message. */
+export function renderDiags({ tool, diags, notes, lossy = false }: Parsed, limits: Limits): Squeezed {
+	const dir = sharedDir([...new Set(diags.map((d) => d.file))]);
+	const groups = new Map<string, string[]>();
+	for (const d of diags) {
+		// A message that names its own file (detekt's license rule) groups with the others once the name goes.
+		const message = d.message.replaceAll(d.file, "<file>");
+		const key = `${d.severity ? `${d.severity} ` : ""}${d.rule ? `${d.rule}: ` : ""}${message}`;
+		const at = `${d.file.slice(dir.length)}:${d.line}${d.col ? `:${d.col}` : ""}`;
+		groups.set(key, [...(groups.get(key) ?? []), at]);
+	}
+	const by = (s: string) => diags.filter((d) => d.severity === s).length;
+	const parts = [by("error") && count(by("error"), "error"), by("warning") && count(by("warning"), "warning")].filter(Boolean);
+	const files = new Set(diags.map((d) => d.file)).size;
+	const out = [`${tool}: ${parts.length ? parts.join(", ") : count(diags.length, "finding")} in ${count(files, "file")}${dir ? ` (under ${dir})` : ""}`];
+	let cut = false;
+	const sorted = [...groups].sort((a, b) => b[1].length - a[1].length);
+	for (const [key, at] of sorted) {
+		// A finding of its own is one line: message, then where.
+		if (at.length === 1) {
+			out.push(cutLine(`${key}  ${at[0]}`, limits.lineChars));
+			continue;
+		}
+		out.push(cutLine(`${key} (${at.length})`, limits.lineChars));
+		const shown = at.slice(0, limits.perGroup * 2);
+		// Locations share lines, as many as fit.
+		let line = " ";
+		for (const a of shown) {
+			if (line.length + a.length + 2 > limits.lineChars && line.trim()) (out.push(line), (line = " "));
+			line += ` ${a}`;
+		}
+		if (at.length > shown.length) {
+			line += `  … +${at.length - shown.length}`;
+			cut = true;
+		}
+		out.push(line);
+	}
+	if (notes.length) out.push("", ...notes.map((n) => cutLine(n, limits.lineChars)));
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: lossy || cut || capped.truncated };
+}
+
+const PARSERS = [parseEslint, parseBiome, parseRuff, parseDart, parseAndroidLint, parseLocated];
+
+export function compactLint(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = stripAnsi(output).split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	for (const parse of PARSERS) {
+		const p = parse(lines);
+		if (p) return renderDiags(p, limits);
+	}
+	return undefined;
+}
+
+/** For sniffing: only formats with an unmistakable shape (a `path:line` line alone could be anything). */
+export function compactLintSniffed(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = stripAnsi(output).split("\n");
+	const android = lines.some((l) => /^\s+~+$/.test(l)) ? parseAndroidLint(lines) : undefined;
+	const p = parseEslint(lines) ?? parseBiome(lines) ?? parseRuff(lines) ?? android;
+	return p ? renderDiags(p, limits) : undefined;
+}

package/extensions/core/logs.ts

@@ -0,0 +1,106 @@
+/**
+ * Logs (`docker logs`, `docker compose logs`, `kubectl logs`, `journalctl`, `adb logcat`):
+ *
+ * * a run of 3+ lines that differ only in timestamps and numbers keeps its first and last
+ *   line, with `… [N similar]` between;
+ * * stack frames of the runtime itself (java., android., kotlinx.coroutines., …) fold into
+ *   `… N framework frames`;
+ * * logcat's `MM-DD` date (when it is the same throughout), thread id and padding go
+ *   (`threadtime`, `time` and `brief` formats);
+ * * the end of a log is what matters: past the line limit the start goes, not the end.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { stripAnsi } from "./generic.ts";
+
+/** Leading timestamps in the common log formats (ISO 8601, syslog, logcat, bracketed clock). */
+const STAMP = /^(?:\S+\s+\|\s+)?(?:\[?\d{4}-\d\d-\d\dT?\s?[\d:.,]+(?:Z|[+-]\d\d:?\d\d)?\]?|[A-Z][a-z]{2} [ \d]\d [\d:]{8}|\d\d-\d\d [\d:.]{12}|\[?[\d:]{8}(?:[.,]\d+)?\]?)\s*/;
+
+/** Frames of runtimes and frameworks: never the code being debugged. */
+const FRAMEWORK = /(?:^|:\s)\s*at (?:java\.|javax\.|jdk\.|sun\.|kotlin\.|kotlinx\.coroutines\.|android\.|androidx\.|com\.android\.|dalvik\.|libcore\.|org\.junit\.|junit\.|org\.gradle\.|worker\.org\.gradle\.|org\.robolectric\.|com\.intellij\.|io\.mockk\.|org\.mockito\.|org\.assertj\.|org\.hamcrest\.|org\.springframework\.|org\.apache\.(?:maven|catalina|tomcat|coyote)\.|io\.netty\.|reactor\.core\.|okhttp3\.internal\.|retrofit2\.|io\.ktor\.|org\.koin\.|node:internal|process\.processTicksAndRejections|new Promise \(<anonymous>\))/;
+
+/** The shape of a line once what changes from one occurrence to the next is gone. */
+export const shape = (line: string): string => line.replace(STAMP, "").replace(/0x[\da-f]+|\d+/gi, "#");
+
+/** Folds runs of framework stack frames. */
+export function foldFrames(lines: string[]): { lines: string[]; folded: boolean } {
+	const out: string[] = [];
+	let folded = false;
+	for (let i = 0; i < lines.length; ) {
+		let j = i;
+		while (j < lines.length && FRAMEWORK.test(lines[j]!)) j++;
+		if (j - i >= 2) {
+			// Whatever stood before `at ` (indent, a logcat prefix) stays.
+			const m = FRAMEWORK.exec(lines[i]!)!;
+			out.push(`${lines[i]!.slice(0, m.index + m[0].indexOf("at "))}… ${j - i} framework frames`);
+			folded = true;
+			i = j;
+		} else out.push(lines[i++]!);
+	}
+	return { lines: out, folded };
+}
+
+/** logcat `threadtime` (the default): `11-02 01:36:28.503  1947  2690 D Tag: message`. */
+const LOGCAT = /^(\d\d-\d\d) ([\d:.]{12}) +(\d+) +\d+ ([VDIWEFA]) (.*)$/;
+/** logcat `-v time` and `-v brief`: `[11-02 01:36:28.503 ]D/Tag( 1947): message`. */
+const LOGCAT_TIME = /^(?:(\d\d-\d\d) ([\d:.]{12}) )?([VDIWEFA])\/(.*?)\(\s*(\d+)\): (.*)$/;
+
+/** The same logcat line in `threadtime`'s order, without the thread id and padding. */
+function logcatParts(l: string): [string | undefined, string | undefined, string, string, string] | undefined {
+	const t = LOGCAT.exec(l);
+	if (t) return [t[1], t[2], t[3]!, t[4]!, t[5]!];
+	const b = LOGCAT_TIME.exec(l);
+	return b ? [b[1], b[2], b[5]!, b[3]!, `${b[4]!.trimEnd()}: ${b[6]}`] : undefined;
+}
+
+function shortenLogcat(lines: string[]): string[] {
+	const dates = new Set(lines.map((l) => logcatParts(l)?.[0]).filter(Boolean));
+	const keepDate = dates.size > 1;
+	return lines.map((l) => {
+		const m = logcatParts(l);
+		return m ? [keepDate && m[0], m[1], m[2], m[3], m[4]].filter(Boolean).join(" ") : l;
+	});
+}
+
+export function compactLogs(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const raw = stripAnsi(output).split("\n");
+	while (raw.length && raw.at(-1) === "") raw.pop();
+	if (raw.length < 4) return undefined;
+	const logcat = raw.some((l) => logcatParts(l) !== undefined);
+	const lines = logcat ? shortenLogcat(raw) : raw;
+
+	const runs: string[] = [];
+	let similar = false;
+	for (let i = 0; i < lines.length; ) {
+		const s = shape(lines[i]!);
+		let j = i + 1;
+		while (j < lines.length && shape(lines[j]!) === s) j++;
+		if (j - i >= 3) {
+			runs.push(lines[i]!, `  … [${j - i - 2} similar]`, lines[j - 1]!);
+			similar = true;
+		} else runs.push(...lines.slice(i, j));
+		i = j;
+	}
+	const { lines: folded, folded: didFold } = foldFrames(runs);
+	const cut = folded.map((l) => cutLine(l, limits.lineChars));
+	const dropped = Math.max(0, cut.length - limits.total);
+	const text = [...(dropped ? [`… [first ${dropped} lines left out]`] : []), ...cut.slice(dropped)].join("\n");
+	return { text, truncated: logcat || similar || didFold || dropped > 0 || cut.some((l, i) => l !== folded[i]) };
+}
+
+/** A JVM stack trace: `\tat pkg.Class.method(File.java:12)` frames under an exception. */
+const FRAME = /^\s*at [\w$.<>/-]+\(.*\)$/;
+
+/**
+ * Stack traces in any output (`java -jar`, a crashed test JVM, `adb logcat`, a pasted log):
+ * runs of framework frames fold to `… N framework frames`; the exception, each `Caused by:`,
+ * the code's own frames and `... N more` stay. Nothing else is touched.
+ */
+export function compactTrace(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	if (lines.filter((l) => FRAME.test(l)).length < 3 || !lines.some((l) => /(?:Exception|Error|Throwable)\b/.test(l))) return undefined;
+	const { lines: folded, folded: didFold } = foldFrames(lines);
+	if (!didFold) return undefined;
+	const cut = folded.map((l) => cutLine(l, limits.lineChars));
+	const capped = capLines(cut, limits.total);
+	return { text: capped.text, truncated: true };
+}

package/extensions/core/lsd.ts

@@ -0,0 +1,64 @@
+/**
+ * `lsd -l`, `eza -l` and `ls -l` listings reduced to what a model uses: type, size, modified
+ * time (no year or seconds) and name. Owner, group and permission bits are dropped.
+ *
+ *   d  Oct 24 16:40  command
+ *   -  6.0KB  Oct 24 16:40  tokenburn.ts
+ *
+ * Strict: a single line that does not parse makes it return undefined.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+type Row = { type: string; size: string; when: string; name: string };
+type Parser = (line: string) => Row | undefined;
+
+const kindOf = (k: string) => (k === "d" ? "d" : k === "l" ? "l" : "-");
+
+/** lsd: `.rw-r--r-- user group 1.9 KB Sun Nov  1 23:14:32 2026 name` */
+const LSD = /^([dl.\-bcps])[rwxsStT\-.+@]{9}\S*\s+\S+\s+\S+\s+([\d.,]+ ?[A-Za-z]*)\s+\w{3} (\w{3})\s+(\d+) (\d\d:\d\d):\d\d \d{4}\s+(.+)$/;
+/** eza: `.rw-r--r--@ 1.9k user [group]  1 Nov 23:14 name` (a year instead of the time when old) */
+const EZA = /^([dl.\-bcps])[rwxsStT\-.+@]{9}\S*\s+(-|[\d.,]+[kMGTPE]?)\s+\S+(?:\s+\S+)?\s+(\d{1,2}) (\w{3})\s+(\d\d:\d\d|\d{4})\s+(.+)$/;
+/** ls: `-rw-r--r--@ 1 user group 1934 Nov  1 23:14 name` */
+const LS = /^([dl\-bcps])[rwxsStT\-]{9}[@+.]?\s+\d+\s+\S+\s+\S+\s+(\d+)\s+(\w{3})\s+(\d{1,2})\s+(\d\d:\d\d|\d{4})\s+(.+)$/;
+
+/** Bytes as ls -lh would say them. */
+export function human(bytes: number): string {
+	const units = ["B", "K", "M", "G", "T"];
+	let n = bytes;
+	let u = 0;
+	while (n >= 1024 && u < units.length - 1) (n /= 1024), u++;
+	return u === 0 ? `${n}B` : `${n < 10 ? n.toFixed(1) : Math.round(n)}${units[u]}`;
+}
+
+const PARSERS: Parser[] = [
+	(l: string) => {
+		const m = LSD.exec(l);
+		return m ? { type: kindOf(m[1]!), size: m[2]!.replace(/\s+/g, ""), when: `${m[3]} ${m[4]} ${m[5]}`, name: m[6]! } : undefined;
+	},
+	(l: string) => {
+		const m = EZA.exec(l);
+		return m ? { type: kindOf(m[1]!), size: m[2]!, when: `${m[4]} ${m[3]} ${m[5]}`, name: m[6]! } : undefined;
+	},
+	(l: string) => {
+		const m = LS.exec(l);
+		return m ? { type: kindOf(m[1]!), size: human(Number(m[2])), when: `${m[3]} ${m[4]} ${m[5]}`, name: m[6]! } : undefined;
+	},
+];
+
+export function compactLsd(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (/^total \d+/.test(lines[0] ?? "")) lines.shift(); // ls -l
+	if (lines.length < 3) return undefined;
+	const parse = PARSERS.find((p) => p(lines[0]!));
+	if (!parse) return undefined;
+	const out: string[] = [];
+	for (const l of lines) {
+		const row = parse(l);
+		if (!row) return undefined;
+		if (row.name === "." || row.name === "..") continue;
+		const meta = row.type === "d" ? "" : `${row.size}  `;
+		out.push(`${row.type}  ${meta}${row.when}  ${row.name}`);
+	}
+	return capLines(out, limits.total);
+}

package/extensions/core/maven.ts

@@ -0,0 +1,122 @@
+/**
+ * Maven (`mvn`, `./mvnw`, `mvnd`) output:
+ *
+ * * `Downloading from` / `Downloaded from` lines and their `Progress (1): …` frames become a
+ *   count in the header;
+ * * `[INFO]` lines go (banners, plugin headers, "Copying 1 resource", "Compiling 8 source
+ *   files", "Running x.FooTest" …) except the result: `BUILD SUCCESS|FAILURE`, `Total time`,
+ *   test totals, and the reactor summary lines of modules that did not succeed;
+ * * a test class that passes takes what it printed with it (Spring banners, logs); a class
+ *   that fails keeps it, with its failures;
+ * * `[ERROR]` lines that repeat an earlier line go (Maven prints compiler errors twice), and
+ *   so does the help footer (`-> [Help 1]`, "Re-run Maven using the -X switch" …);
+ * * `[WARNING]` lines are said once, with a count; JVM chatter goes; framework stack frames
+ *   fold; reported files lose the directory they share.
+ *
+ * `mvn dependency:tree` is the tree cut by depth (see tree.ts), once `[INFO] ` is gone.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { shortenPaths } from "./gradle.ts";
+import { isJvmNoise } from "./jvm.ts";
+import { foldFrames } from "./logs.ts";
+import { compactTree } from "./tree.ts";
+
+const RESULT = /^\[INFO\] BUILD (SUCCESS|FAILURE)$|^\[ERROR\] BUILD FAILURE$/;
+/** Without `-B` the lines stand alone; with it (batch mode) they are `[INFO]` lines. */
+const DOWNLOAD = /^(?:\[INFO\] )?(Downloading|Downloaded) from [\w.-]+: /;
+/** `[INFO]` lines that stay. */
+const INFO_KEPT = [
+	/^\[INFO\] BUILD /,
+	/^\[INFO\] Total time:/,
+	// The totals, not a class's own line (`-- in x.FooTest`).
+	/^\[INFO\] Tests run: (?!.* -- in ).*$/,
+	/^\[INFO\] Reactor Summary/,
+	/^\[INFO\] \S.* (?:FAILURE|SKIPPED)(?: \[|$)/,
+	/^\[INFO\] \d+ (?:errors?|warnings?) ?$/,
+];
+const HELP = /^\[ERROR\] (?:-> \[Help \d+\]|To see the full stack trace|Re-run Maven using the -X|For more information about the errors|\[Help \d+\] https?:|See dump files|After correcting the problems, you can resume|\s*mvn <args> -rf|See .*surefire-reports for the individual test results)/;
+/** The Spring Boot banner each `@SpringBootTest` prints. */
+const BANNER = /^ {0,2}(?:\.   ____|\/\\\\ \/ ___'|\( \( \)\\___|\\\\\/  ___\)|'  \|____\||=+\|_\|=+)| :: Spring Boot :: /;
+const CLASS_START = /^\[INFO\] Running (\S+)$/;
+const CLASS_END = /^\[(INFO|ERROR|WARNING)\] Tests run: \d+, Failures: (\d+), Errors: (\d+), .* -- in (\S+)$/;
+
+export function compactMaven(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	// Progress frames end in `\r`; what follows the last one is the line.
+	const lines = output.split("\n").map((l) => l.slice(l.lastIndexOf("\r") + 1).trimEnd());
+	if (!lines.some((l) => RESULT.test(l))) return undefined;
+
+	const kept: string[] = [];
+	const said = new Map<string, { at: number; n: number }>();
+	const before = new Set<string>();
+	let downloads = 0;
+	let passed = 0;
+	let dropped = false;
+	/** What a test class printed, kept only if it fails. */
+	let running: string[] | undefined;
+	const keep = (l: string) => (running ? running.push(l) : kept.push(l));
+
+	for (const l of lines) {
+		const content = l.replace(/^\[(?:ERROR|WARNING|INFO)\] ?/, "").trim();
+		const repeat = content.length >= 4 && before.has(content);
+		before.add(content);
+		const dl = DOWNLOAD.exec(l);
+		if (dl || /^Progress \(\d+\):/.test(l)) {
+			downloads += dl?.[1] === "Downloaded" ? 1 : 0;
+			continue;
+		}
+		if (CLASS_START.test(l)) {
+			running = [];
+			continue;
+		}
+		const end = CLASS_END.exec(l);
+		if (end) {
+			if (end[2] === "0" && end[3] === "0") passed++;
+			else kept.push(...running!, l);
+			running = undefined;
+			continue;
+		}
+		if (l.startsWith("[INFO]") && !INFO_KEPT.some((k) => k.test(l))) {
+			dropped = true;
+			continue;
+		}
+		// The indented paragraph of a dropped `[INFO]` line (annotation processing advice).
+		if (/^ {2}\S/.test(l) && dropped) continue;
+		dropped = false;
+		if (BANNER.test(l) || isJvmNoise(l) || HELP.test(l) || /^\[(?:ERROR|WARNING)\]\s*$/.test(l)) continue;
+		if (l.startsWith("[ERROR]") && repeat) continue;
+		if (l.startsWith("[WARNING]")) {
+			const seen = said.get(l);
+			if (seen) {
+				seen.n++;
+				continue;
+			}
+			said.set(l, { at: kept.length, n: 1 });
+		}
+		keep(l);
+	}
+	if (running) kept.push(...running);
+	for (const { at, n } of said.values()) if (n > 1) kept[at] += ` (×${n})`;
+	shortenPaths(kept);
+	const { lines: folded } = foldFrames(kept);
+
+	const body: string[] = [];
+	for (const l of folded) {
+		if (l === "" && (body.length === 0 || body.at(-1) === "")) continue;
+		body.push(cutLine(l, limits.lineChars));
+	}
+	while (body.at(-1) === "") body.pop();
+	const parts = [downloads && `${downloads} downloads`, passed && `${passed} test classes passed`].filter(Boolean);
+	const capped = capLines([...(parts.length ? [`maven: ${parts.join(", ")}`] : []), ...body], limits.total);
+	// `[INFO]` lines and passing classes' output always go: the full output keeps them.
+	return { text: capped.text, truncated: true };
+}
+
+/** `mvn dependency:tree`: the `[INFO] ` prefix goes, then the tree is cut by depth. */
+export function compactMavenTree(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n").map((l) => l.slice(l.lastIndexOf("\r") + 1));
+	if (!lines.some((l) => RESULT.test(l))) return undefined;
+	const tree = lines.filter((l) => /^\[INFO\] (?:[|+\\ ]*[+\\]- |[\w.-]+:[\w.-]+:)/.test(l)).map((l) => l.slice(7));
+	const cut = compactTree(tree.join("\n"), limits);
+	const result = lines.filter((l) => RESULT.test(l) || /^\[ERROR\] (?!\s*$)/.test(l) && !HELP.test(l));
+	return { text: [...(cut?.text ?? tree.join("\n")).split("\n"), ...result].join("\n"), truncated: true };
+}

package/extensions/core/paths.ts

@@ -0,0 +1,50 @@
+/**
+ * `fd` / `find` output (one path per line) grouped by directory:
+ *
+ *   src/core/
+ *     a.ts b.ts c.ts
+ *
+ * Names with spaces are quoted. A directory with a single entry keeps its full path.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+function split(path: string): [string, string] {
+	const dir = path.endsWith("/");
+	const body = dir ? path.slice(0, -1) : path;
+	const i = body.lastIndexOf("/");
+	if (i < 0) return ["", path];
+	return [body.slice(0, i + 1), body.slice(i + 1) + (dir ? "/" : "")];
+}
+
+export function compactPaths(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (lines.length < 2 || lines.some((l) => l === "" || l.includes("\t"))) return undefined;
+
+	const groups = new Map<string, string[]>();
+	for (const l of lines) {
+		const [dir, name] = split(l);
+		const g = groups.get(dir);
+		if (g) g.push(name);
+		else groups.set(dir, [name]);
+	}
+	const out: string[] = [];
+	for (const [dir, names] of groups) {
+		if (names.length === 1) {
+			out.push(`${dir}${names[0]}`);
+			continue;
+		}
+		out.push(dir || "./");
+		const quoted = names.map((n) => (/\s/.test(n) ? JSON.stringify(n) : n));
+		let row = "  ";
+		for (const n of quoted) {
+			if (row.length + n.length > 100 && row.trim()) {
+				out.push(row.trimEnd());
+				row = "  ";
+			}
+			row += `${n} `;
+		}
+		if (row.trim()) out.push(row.trimEnd());
+	}
+	return capLines(out, limits.total);
+}