pi-squeeze 0.1.0 → 0.2.0

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/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/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/tree.ts

@@ -1,5 +1,5 @@
 /**
- * Tree output (`cargo tree`, `tree`, `eza --tree`) cut below a depth, with a marker that says
+ * 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
@@ -11,8 +11,13 @@
  */
 import { cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
 
-const PREFIX = /^((?:│   |    )*)/;
-const BRANCH = /^(?:│   |    )*(?:├── |└── )/;
+/** 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;
@@ -20,17 +25,19 @@ 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();
-	if (lines.length < 5 || !lines.some((l) => BRANCH.test(l))) return undefined;
+	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)}… [+${hidden.length} lines deeper]`);
+		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 / 4;
-		const depth = BRANCH.test(l) || units > 0 ? units + 1 : 0;
+		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;

package/extensions/core/xcode.ts

@@ -0,0 +1,123 @@
+/**
+ * `xcodebuild` and `swift build` / `swift test`:
+ *
+ * * build steps (`CompileSwift …`, `Ld …`, `CodeSign …` with their indented command lines)
+ *   are counted, not listed; so are progress lines (`[12/40] Compiling …`);
+ * * warnings are grouped by message, one location each, without their source frame;
+ * * errors keep their frame and their notes;
+ * * passing tests (XCTest and Swift Testing) are counted; failures, issues and totals stay;
+ * * the `** BUILD SUCCEEDED **` / `** TEST FAILED **` result stays.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { stripAnsi } from "./generic.ts";
+import { renderDiags, type Diag } from "./lint.ts";
+
+const DIAG = /^(.+?):(\d+)(?::(\d+))?: (error|warning|note): (.*)$/;
+/** `CompileSwift normal arm64 …`, `WriteAuxiliaryFile …`: a CamelCase verb, or a one-word one. */
+const ACTION = /^(?:[A-Z][a-z]+[A-Z]\w*|Ld|Copy|Touch|Libtool|Strip|Lipo|Ditto|Validate)(?=[ \\]|$)/;
+const DROP = [
+	// `2026-11-02 01:38:45.358 xcodebuild[40118:44955631] …`: tool chatter.
+	/^\d{4}-\d\d-\d\d [\d:.]+ [\w.-]+\[\d+:\d+\] /,
+	/^(Details|Object|Method|Thread): {1,3}\S/,
+	/^Please file a bug at https:\/\/feedbackassistant/,
+	/^\{ platform:/,
+	/^(Command line invocation|Resolved source packages):$/,
+	/^(Resolve Package Graph|Prepare packages|Testing started)$/,
+	/^Build description (signature|path): /,
+	/^Building for (debugging|production)\.\.\.$/,
+	/^\[Planning deferred tasks\]$/,
+	// SwiftPM progress; the spaces are narrow no-break ones.
+	/^\[\d+\s?\/\s?\d+\]/,
+	/^(Fetching|Fetched|Computing version for|Computed|Creating working copy for|Working copy of|Updating|Updated) /,
+	/^note: (Building targets|Target dependency graph|Run script build phase|Using codesigning|Removed stale)/,
+	/^Test Case '.*' started\.$/,
+	/^Test Suite '.*' (started|passed|failed) at /,
+	/^◇ /,
+	/^↳ (Testing Library Version|Target Platform): /,
+	/^\[#[\w-]+\]: <https?:/,
+];
+/** A source frame line under a diagnostic. */
+const FRAME = /^\s*(\d+ )?\|/;
+
+export function compactXcode(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = stripAnsi(output).replace(/\u200b|XCTestOutputBarrier/g, "").split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.some((l) => /^\*\* \w+ (SUCCEEDED|FAILED) \*\*$|^Build complete!|^error: (Build failed|fatalError)|^Test Suite '|^✘ Test run|^✔ Test run/.test(l))) return undefined;
+
+	const actions = new Map<string, number>();
+	const warnings: Diag[] = [];
+	const seen = new Set<string>();
+	const out: string[] = [];
+	let executed: string | undefined;
+	let passed = 0;
+	let indented = false;
+	let last: "error" | "warning" | "other" = "other";
+	let skipNext = false;
+	for (const l of lines) {
+		if (skipNext) {
+			skipNext = false;
+			continue;
+		}
+		// Each suite repeats the totals; the last one (all tests) is the one that counts.
+		if (/^\s+Executed \d+ tests?/.test(l)) {
+			executed = l.trim();
+			continue;
+		}
+		if (indented && /^\s+\S/.test(l)) continue;
+		indented = false;
+		const action = ACTION.exec(l);
+		if (action) {
+			actions.set(action[0], (actions.get(action[0]) ?? 0) + 1);
+			indented = true;
+			continue;
+		}
+		if (/^(Command line invocation|Resolved source packages):$|^error: .* Command line:/.test(l)) indented = true;
+		if (DROP.some((d) => d.test(l))) {
+			indented = true;
+			continue;
+		}
+		if (/^Test Case '.*' passed \(/.test(l) || /^✔ Test /.test(l)) {
+			passed++;
+			continue;
+		}
+		const d = DIAG.exec(l);
+		if (d) {
+			const severity = d[4]!;
+			if (severity === "warning") {
+				const key = `${d[1]}:${d[2]}:${d[3]}:${d[5]}`;
+				if (!seen.has(key)) warnings.push({ file: d[1]!, line: d[2]!, col: d[3], severity, message: d[5]! });
+				seen.add(key);
+				last = "warning";
+				continue;
+			}
+			if (severity === "note" && last !== "error") continue;
+			if (severity === "error") last = "error";
+			out.push(cutLine(l, limits.lineChars));
+			continue;
+		}
+		if (FRAME.test(l) || /^\s+`- /.test(l)) {
+			if (last === "error") out.push(cutLine(l, limits.lineChars));
+			continue;
+		}
+		last = "other";
+		if (l === "Failed frontend command:") skipNext = true;
+		if (l.trim() === "" && (out.length === 0 || out.at(-1) === "")) continue;
+		out.push(cutLine(l.trim() === "" ? "" : l, limits.lineChars));
+	}
+	while (out.at(-1) === "") out.pop();
+	if (executed) out.push(executed);
+
+	const steps = [...actions].sort((a, b) => b[1] - a[1]);
+	const total = steps.reduce((n, [, c]) => n + c, 0);
+	const head: string[] = [];
+	if (total) head.push(`build: ${total} steps (${steps.slice(0, 4).map(([k, v]) => `${v} ${k}`).join(", ")}${steps.length > 4 ? ", …" : ""})`);
+	if (passed) head.push(`tests: ${passed} passed (not listed)`);
+	const warned = warnings.length ? ["", ...renderDiags({ tool: "swift", diags: warnings, notes: [] }, limits).text.split("\n")] : [];
+	const capped = capLines([...head, ...out, ...warned], limits.total);
+	return { text: capped.text, truncated: capped.truncated || warnings.length > 0 };
+}
+
+/** For sniffing: only with xcodebuild's own `** BUILD SUCCEEDED **`-style result line. */
+export function compactXcodeSniffed(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	return /^\*\* [A-Z ]+ (SUCCEEDED|FAILED) \*\*$/m.test(output) ? compactXcode(output, limits) : undefined;
+}