pi-squeeze 0.1.0 → 0.2.1

package/extensions/core/gradle.ts

@@ -1,10 +1,28 @@
 /**
- * `gradle` / `./gradlew` output: every `> Task :x UP-TO-DATE` line (and NO-SOURCE, FROM-CACHE,
- * SKIPPED, plain executed ones) becomes one counting line; failed tasks, compiler errors and
- * warnings, test failures and the `BUILD` result stay. The daemon, configuration-cache and
- * "Run with --scan" hints go. Kotlin `w:` / `e:` lines lose their shared directory prefix.
+ * `gradle` / `./gradlew` output:
+ *
+ * * every `> Task :x UP-TO-DATE` line (and NO-SOURCE, FROM-CACHE, SKIPPED, plain executed
+ *   ones) becomes one counting line; failed tasks, errors, test failures and the `BUILD`
+ *   result stay;
+ * * daemon, configuration-cache, AGP-option, JVM and "Run with --scan" chatter goes, as do
+ *   the wrappers around a failure (`A failure occurred while executing …`), the lint
+ *   baseline advice and dependencyInsight's attribute tables;
+ * * repeated warnings and `--warning-mode all` deprecations are said once, with a count,
+ *   without the upgrade-guide links; the failure summary does not repeat what was printed
+ *   above it;
+ * * Kotlin / KSP warnings, detekt and ktlint findings and Android Lint issues are grouped by
+ *   message, each location listed once (see `renderDiags`); errors stay one per line;
+ * * R8 "Missing class" lines become one list of class names, "Duplicate class" lines one
+ *   list per pair of modules; "Searched in the following locations" lists become a count;
+ * * `tasks` and `projects` reports become names per group (see gradlereports.ts);
+ * * reported files lose the directory they share; framework stack frames fold.
  */
 import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { squeezeProjects, squeezeTaskReport } from "./gradlereports.ts";
+import { isJvmNoise } from "./jvm.ts";
+import { type Diag, renderDiags } from "./lint.ts";
+import { foldFrames } from "./logs.ts";
+import { compactTree } from "./tree.ts";
 
 const TASK = /^> Task (\S+)(?: ([A-Z-]+))?$/;
 const NOISE = [
@@ -12,6 +30,7 @@ const NOISE = [
 	/^Daemon will be stopped/,
 	/^Calculating task graph/,
 	/^(Reusing|Configuration) cache/,
+	/^Reusing configuration cache\.$/,
 	/^Configuration cache entry/,
 	/^Isolated Projects is an incubating/,
 	/^Consider enabling configuration cache/,
@@ -21,53 +40,230 @@ const NOISE = [
 	/^Deprecated Gradle features were used/,
 	/^You can use '--warning-mode all'/,
 	/^For more on this, please refer to/,
+	/^\[Incubating\] Problems report is available/,
+	/^Type-safe project accessors is an incubating/,
+	// AGP's explanation under each `WARNING: The option setting …` line.
+	/^The current default is '/,
+	/^It will be removed in version [\d.]+ of the Android Gradle plugin/,
+	/^Add android\.sync\.suppress\w+=/,
+	/^Download https?:\/\//,
+	/^={20,}$/,
+	/^-{5,}$/,
+	// `gradle dependencyUpdates`: the URL under each dependency.
+	/^\s+https?:\/\/\S+$/,
+	// Wrappers around the actual failure.
+	/^\s*> A failure occurred while executing [\w.$]+$/,
+	/^\s*> There was a failure while executing work items$/,
+	/^\s*Go to the documentation to learn how to <a href=/,
+	// dependencyInsight: attribute tables and the legend.
+	/^\s+\|.*\|\s*$/,
+	/^\(\*\) - Indicates repeated occurrences/,
+	/^\([cn]\) - (?:A dependency constraint|A dependency or dependency configuration)/,
+	/^A web-based, searchable dependency report is available/,
+	// `gradle projects`.
+	/^To see a list of the tasks of a project, run/,
+	/^For example, try running gradlew/,
+	/^Project locations:$/,
+	// javac's advice to rerun with -Xlint.
+	/^Note: (?:Recompile with -Xlint|Some input files use)/,
 ];
-const KOTLIN = /^([we]): (?:file:\/\/)?(\/\S+?):(\d+):(\d+)(.*)$/;
+/** Blocks of advice, dropped from the first line to the last. */
+const ADVICE = [{ start: /^\s*Fix the issues identified by lint, or create a baseline/, end: /^\s*For more details, see https:\/\/developer\.android\.com\/studio\/write\/lint/ }];
+/** Lines said once are enough (their indented continuation goes with a repeat too). */
+const ONCE = /^(w: |e: |WARNING: |Lint found \d+|The full lint text report is located at:)/;
+/** `--warning-mode all` deprecations, said once and without the guide link. */
+const DEPRECATION = /scheduled to be removed in Gradle \d+|will fail with an error in Gradle \d+|has been deprecated\./;
+const GUIDE = /\s*(?:Consult the upgrading guide for further information|For more information, please refer to|Please refer to|See)\s*:?\s*https?:\/\/\S+.*$/;
+
+/** Findings that group by message: Kotlin / KSP warnings, detekt / ktlint, Android Lint. */
+const KOTLIN_W = /^w: (?:\[ksp\] )?(?:file:\/\/)?(\/\S+?):(\d+)(?::(\d+))?:? (.*)$/;
+const LINT_ISSUE = /^(\/\S+?):(\d+): (Error|Warning|Information|Hint|Fatal): (.*) \[(\w+)\]$/;
+const CHECKER = /^(\/\S+?):(\d+):(\d+): (.*?)(?: \[([\w:-]+)\])?$/;
+/** R8 and AGP's duplicate-class check. */
+const R8_MISSING = /^(?:ERROR: )?(?:R8: )?Missing class (\S+)(?: \(referenced from: .*\))?$/;
+const DUPLICATE = /^\s*(?:> )?Duplicate class (\S+) found in modules? (.+)$/;
+
+/** Every absolute file path followed by a line number, `:12` or Maven's `:[12,5]` (not a URL's host and port). */
+const PATH_AT = /(?<![\w/:.])(?:file:\/\/)?(\/[^\s:'"()[\]]+\.[A-Za-z]\w*):(?:\d|\[\d)/g;
+
+type Group = { tool: string; diags: Diag[] };
+type Listed = { label: string; names: string[] };
 
 export function compactGradle(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) => TASK.test(l)) || !lines.some((l) => /^BUILD (SUCCESSFUL|FAILED)/.test(l))) return undefined;
 
-	const states = new Map<string, number>();
-	const ran: string[] = [];
-	const kept: string[] = [];
-	let tasks = 0;
-	for (const l of lines) {
+	const s = scan(lines);
+	shortenPaths(s.kept, s.slots);
+	const width = limits.lineChars * 8;
+	let cut = s.cut;
+	const expanded = s.kept.flatMap((l, i) => {
+		const key = s.slots.get(i);
+		if (key === undefined) return [l];
+		const g = s.groups.get(key);
+		if (g) {
+			const r = renderDiags({ tool: g.tool, diags: g.diags, notes: [] }, { ...limits, total: Number.MAX_SAFE_INTEGER });
+			cut ||= r.truncated;
+			return r.text.split("\n");
+		}
+		const { label, names } = s.listed.get(key)!;
+		return [cutLine(`${label} (${names.length}): ${names.join(" ")}`, width)];
+	});
+	const tasksReport = squeezeTaskReport(expanded, width);
+	const projects = squeezeProjects(tasksReport.lines, width);
+	const { lines: folded, folded: didFold } = foldFrames(projects.lines);
+
+	// Blank lines only separate: never two in a row, never first. Lists may run to `width`.
+	const body: string[] = [];
+	for (const l of folded) {
+		const blank = l.trim() === "";
+		if (blank && (body.length === 0 || body.at(-1) === "")) continue;
+		body.push(blank ? "" : cutLine(l, LIST_LINE.test(l) ? width : limits.lineChars));
+	}
+	while (body.at(-1) === "") body.pop();
+
+	const parts = [...s.states].map(([k, v]) => `${v} ${k.toLowerCase()}`);
+	const head = `gradle: ${s.tasks} tasks (${parts.join(", ")})${s.ran.length ? ` ran: ${s.ran.slice(0, 12).join(" ")}${s.ran.length > 12 ? ` … +${s.ran.length - 12}` : ""}` : ""}`;
+	const capped = capLines([head, ...body], limits.total);
+	return { text: capped.text, truncated: capped.truncated || didFold || cut || tasksReport.cut || projects.cut };
+}
+
+/** `label (N): name name …`: one line of names, which may run long. */
+const LIST_LINE = /^\S.* \(\d+\): /;
+
+type Scan = {
+	kept: string[];
+	states: Map<string, number>;
+	ran: string[];
+	tasks: number;
+	groups: Map<string, Group>;
+	listed: Map<string, Listed>;
+	/** Lines where a group of findings or a list of names goes once all of it is known. */
+	slots: Map<number, string>;
+	/** Something was left out that the text does not show: R8 / duplicate-class references. */
+	cut: boolean;
+};
+
+/** Goes through the lines once: counts tasks, drops noise and repeats, collects findings. */
+function scan(lines: string[]): Scan {
+	const s: Scan = { kept: [], states: new Map(), ran: [], tasks: 0, groups: new Map(), listed: new Map(), slots: new Map(), cut: false };
+	const { kept } = s;
+	/** Where each said-once line went, and how often it came. */
+	const said = new Map<string, { at: number; n: number }>();
+	/** Trimmed lines printed before the failure summary, which repeats them. */
+	const printed = new Set<string>();
+	let skip: "try" | "repeat" | "issue" | RegExp | undefined;
+	let summary = false;
+	let searched: { at: number; n: number; indent: string } | undefined;
+
+	const slot = (key: string) => s.slots.set(kept.push("") - 1, key);
+	const group = (tool: string, d: Diag) => {
+		const g = s.groups.get(tool) ?? { tool, diags: [] };
+		if (!s.groups.has(tool)) slot(tool);
+		if (!g.diags.some((x) => x.file === d.file && x.line === d.line && x.message === d.message)) g.diags.push(d);
+		s.groups.set(tool, g);
+	};
+	const list = (key: string, label: string, name: string) => {
+		const g = s.listed.get(key) ?? { label, names: [] };
+		if (!s.listed.has(key)) slot(key);
+		if (!g.names.includes(name)) g.names.push(name);
+		s.listed.set(key, g);
+		s.cut = true;
+	};
+	const endSearch = () => {
+		kept[searched!.at] = `${searched!.indent}Searched in ${searched!.n} locations`;
+		searched = undefined;
+	};
+
+	for (const raw of lines) {
+		const l = DEPRECATION.test(raw) ? raw.replace(GUIDE, "") : raw;
+		s.cut ||= l !== raw;
+		if (/^(?:\* What went wrong:|FAILURE: )/.test(l)) summary = true;
+		if (!summary) printed.add(l.trim());
 		const t = TASK.exec(l);
 		if (t) {
-			tasks++;
+			s.tasks++;
 			if (t[2] === "FAILED") kept.push(l);
-			else if (t[2]) states.set(t[2], (states.get(t[2]) ?? 0) + 1);
-			else (states.set("executed", (states.get("executed") ?? 0) + 1), ran.push(t[1]!));
+			else if (t[2]) s.states.set(t[2], (s.states.get(t[2]) ?? 0) + 1);
+			else (s.states.set("executed", (s.states.get("executed") ?? 0) + 1), s.ran.push(t[1]!));
+			skip = undefined;
 			continue;
 		}
-		if (NOISE.some((n) => n.test(l))) continue;
-		kept.push(l);
-	}
-
-	// Kotlin diagnostics: strip the directory every file shares.
-	const paths = kept.map((l) => KOTLIN.exec(l)?.[2]).filter((p): p is string => !!p);
-	if (paths.length > 1) {
-		const dirs = paths.map((p) => p.slice(0, p.lastIndexOf("/") + 1));
-		let prefix = dirs[0]!;
-		for (const d of dirs) while (!d.startsWith(prefix)) prefix = prefix.slice(0, prefix.lastIndexOf("/", prefix.length - 2) + 1);
-		if (prefix.length > 1)
-			for (let i = 0; i < kept.length; i++) {
-				const m = KOTLIN.exec(kept[i]!);
-				if (m) kept[i] = `${m[1]}: …/${m[2]!.slice(prefix.length)}:${m[3]}:${m[4]}${m[5]}`;
+		if (searched) {
+			if (/^\s+- \S+$/.test(l)) {
+				searched.n++;
+				s.cut = true;
+				continue;
 			}
-	}
+			endSearch();
+		}
+		if (skip instanceof RegExp) {
+			if (skip.test(l)) skip = undefined;
+			continue;
+		}
+		if (skip) {
+			// `* Try:` runs to a blank line; a repeat's and an issue's continuation is indented.
+			const more = skip === "try" ? l.trim() !== "" : l === "" || /^\s/.test(l);
+			if (more) continue;
+			skip = undefined;
+		}
+		if (l === "* Try:") {
+			skip = "try";
+			continue;
+		}
+		const advice = ADVICE.find((a) => a.start.test(l));
+		if (advice) {
+			skip = advice.end;
+			continue;
+		}
+		if (NOISE.some((n) => n.test(l)) || isJvmNoise(l)) continue;
+		// The failure summary repeats lint's first issue, Kotlin's error and the like: once is enough.
+		const trimmed = l.trim();
+		if (summary && trimmed.length >= 4 && !trimmed.startsWith("* ") && printed.has(trimmed)) continue;
 
-	// Blank lines only separate: never two in a row, never first.
-	const body: string[] = [];
-	for (const l of kept) {
-		if (l === "" && (body.length === 0 || body.at(-1) === "")) continue;
-		body.push(cutLine(l, limits.lineChars));
+		const kw = KOTLIN_W.exec(l);
+		const li = LINT_ISSUE.exec(l);
+		const ck = CHECKER.exec(l);
+		const r8 = R8_MISSING.exec(l);
+		const dup = DUPLICATE.exec(l);
+		if (kw) group("kotlin", { file: kw[1]!, line: kw[2]!, col: kw[3], severity: "warning", message: kw[4]! });
+		else if (li) {
+			group("android lint", { file: li[1]!, line: li[2]!, severity: li[3]!.toLowerCase(), rule: li[5], message: li[4]! });
+			skip = "issue";
+			s.cut = true;
+		} else if (ck) group("detekt / ktlint", { file: ck[1]!, line: ck[2]!, col: ck[3], severity: "", rule: ck[5], message: ck[4]! });
+		else if (r8) list("r8", "R8: missing classes", r8[1]!);
+		else if (dup) list(`dup ${dup[2]}`, `Duplicate classes in ${dup[2]}`, dup[1]!);
+		else if (ONCE.test(l) || DEPRECATION.test(l)) {
+			const seen = said.get(l);
+			if (seen) {
+				seen.n++;
+				skip = "repeat";
+			} else said.set(l, { at: kept.push(l) - 1, n: 1 });
+		} else {
+			const sl = /^(\s*)Searched in the following locations:$/.exec(l);
+			if (sl) searched = { at: kept.length, n: 0, indent: sl[1]! };
+			kept.push(l);
+		}
 	}
-	while (body.at(-1) === "") body.pop();
+	if (searched) endSearch();
+	for (const { at, n } of said.values()) if (n > 1) kept[at] += ` (×${n})`;
+	return s;
+}
+
+/** Writes the directory every reported file shares once (grouped findings do their own). */
+export function shortenPaths(kept: string[], slots: Map<number, string> = new Map()) {
+	const paths = kept.flatMap((l, i) => (slots.has(i) ? [] : [...l.matchAll(PATH_AT)].map((m) => m[1]!)));
+	if (paths.length < 2) return;
+	let prefix = paths[0]!.slice(0, paths[0]!.lastIndexOf("/") + 1);
+	for (const p of paths) while (!p.startsWith(prefix)) prefix = prefix.slice(0, prefix.lastIndexOf("/", prefix.length - 2) + 1);
+	if (prefix.length > 1) for (let i = 0; i < kept.length; i++) kept[i] = kept[i]!.replaceAll(`file://${prefix}`, "…/").replaceAll(prefix, "…/");
+}
 
-	const parts = [...states].map(([k, v]) => `${v} ${k.toLowerCase()}`);
-	const head = `gradle: ${tasks} tasks (${parts.join(", ")})${ran.length ? ` ran: ${ran.slice(0, 12).join(" ")}${ran.length > 12 ? ` … +${ran.length - 12}` : ""}` : ""}`;
-	return capLines([head, ...body], limits.total);
+/** `gradle dependencies`: the gradle clean-up, then the tree cut below its depth. */
+export function compactGradleDeps(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const cleaned = compactGradle(output, limits);
+	const tree = compactTree(cleaned?.text ?? output, limits);
+	return tree ?? cleaned;
 }

package/extensions/core/gradlereports.ts

@@ -0,0 +1,78 @@
+/**
+ * Gradle's own reports, which list far more than anyone reads:
+ *
+ * * `gradle tasks [--all]`: per group, the task names on one line; the descriptions go.
+ * * `gradle projects`: every project path (Gradle prints them twice, flat and as a tree)
+ *   once, grouped by the first segment: `:api (60): analytics analytics:core …`.
+ */
+import { cutLine } from "./elide.ts";
+
+type Rewritten = { lines: string[]; cut: boolean };
+
+const TASKS_HEAD = /^Tasks runnable from (?:root )?project\b/;
+
+export function squeezeTaskReport(lines: string[], width: number): Rewritten {
+	const start = lines.findIndex((l) => TASKS_HEAD.test(l));
+	if (start < 0) return { lines, cut: false };
+	const out = lines.slice(0, start + 1);
+	let cut = false;
+	let i = start + 1;
+	while (i < lines.length) {
+		const l = lines[i]!;
+		if (/^To see (?:all tasks|more detail about a task)/.test(l)) {
+			i++;
+			continue;
+		}
+		// A group: its title, then one task per line up to a blank line.
+		const body: string[] = [];
+		let j = i + 1;
+		while (j < lines.length && lines[j] !== "") body.push(lines[j++]!);
+		if (l === "" || !body.length || !/tasks$/i.test(l)) {
+			out.push(l);
+			i++;
+			continue;
+		}
+		const line = `${l} (${body.length}): ${body.map((b) => b.split(" - ")[0]).join(" ")}`;
+		// The descriptions go: the full output keeps them.
+		cut = true;
+		out.push(cutLine(line, width));
+		i = j;
+	}
+	return { lines: out, cut };
+}
+
+const PROJECT = /^[|+\\ -]*[Pp]roject '(:[^']+)'/;
+
+export function squeezeProjects(lines: string[], width: number): Rewritten {
+	const paths = new Set<string>();
+	let at = -1;
+	const rest: string[] = [];
+	const roots = new Set<string>();
+	for (const l of lines) {
+		const m = PROJECT.exec(l);
+		if (m) {
+			if (at < 0) at = rest.length;
+			paths.add(m[1]!);
+		} else if (/^Root project '/.test(l)) {
+			if (!roots.has(l)) rest.push(l);
+			roots.add(l);
+		} else rest.push(l);
+	}
+	if (paths.size < 5) return { lines, cut: false };
+	const groups = new Map<string, string[]>();
+	for (const p of [...paths].sort()) {
+		const [top, ...sub] = p.slice(1).split(":");
+		const names = groups.get(top!) ?? [];
+		if (sub.length) names.push(sub.join(":"));
+		groups.set(top!, names);
+	}
+	let cut = false;
+	const listed = [`${paths.size} projects`];
+	for (const [top, names] of groups) {
+		const line = names.length ? `:${top} (${names.length}): ${names.join(" ")}` : `:${top}`;
+		cut ||= line.length > width;
+		listed.push(cutLine(line, width));
+	}
+	rest.splice(at, 0, ...listed);
+	return { lines: rest, cut };
+}

package/extensions/core/install.ts

@@ -0,0 +1,122 @@
+/**
+ * Package installs (npm, pnpm, yarn, bun, pip, uv, CocoaPods, Bundler, pub): download and progress lines
+ * go, per-package lines collapse into one line each (`Collecting (9): requests, rich, …`),
+ * deprecation warnings become one list of names. Errors, the summary and anything not
+ * recognised stay where they were.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { stripAnsi } from "./generic.ts";
+
+type Rule = { re: RegExp; label: string; item: (m: RegExpExecArray) => string };
+
+/** Lines that say nothing once the install is over. */
+const DROP: RegExp[] = [
+	// npm
+	/^\d+ packages? (are|is) looking for funding$/,
+	/^ {2}run `npm fund` for details$/,
+	/^To address (all|issues that do not require attention|all issues possible)/,
+	/^ {2}npm audit fix/,
+	/^Some issues need review, and may require choosing$/,
+	/^a different dependency\.$/,
+	/^npm notice/,
+	/^(up to date|changed \d+ packages?), audited/,
+	// pip
+	/^ {2}Downloading \S+/,
+	/^ {2}Using cached \S+/,
+	/^ {2}Preparing metadata/,
+	/^ {2}(Installing|Getting requirements to) build/,
+	/^ {2}(Building|Created|Stored in directory)/,
+	/^Building wheels? for /,
+	/^Installing collected packages: /,
+	/^ {2}Attempting uninstall: /,
+	/^ {4}(Found existing installation|Uninstalling) /,
+	/^ {6}Successfully uninstalled /,
+	/^WARNING: You are using pip version/,
+	/^You should consider upgrading via/,
+	/^\[notice\] /,
+	/^\s*[━╸╺\-]+ [\d.]+\/[\d.]+ [kMG]?B /,
+	// bun, uv, pnpm, yarn
+	/^bun (add|install|update|remove) v[\d.]+/,
+	/^Resolving dependencies$/,
+	/^Resolved, downloaded and extracted/,
+	/^Saved lockfile$/,
+	/^(Resolved|Prepared|Audited|Uninstalled) \d+ packages? in /,
+	/^Progress: resolved \d+/,
+	/^Packages: [+-]\d+/,
+	/^[+-]+$/,
+	/^\[\d\/\d\] /,
+	/^(yarn (install|add) v|info (No lockfile|Lockfile|fsevents)|success Saved lockfile|Done in [\d.]+s)/,
+	// CocoaPods, pub
+	/^(Analyzing|Downloading) dependencies$/,
+	/^Fetching gem metadata from /,
+	/^(Generating Pods project|Integrating client project|Resolving dependencies\.\.\.|Downloading packages\.\.\.|Got dependencies!?)$/,
+];
+
+/** Lines that become one counted line, at the place of the first one. */
+const COLLECT: Rule[] = [
+	{ re: /^npm warn deprecated (\S+): /, label: "npm warn deprecated", item: (m) => m[1]! },
+	{ re: /^\s*WARN\s+deprecated (\S+): /, label: "pnpm WARN deprecated", item: (m) => m[1]! },
+	{ re: /^warning (\S+(?: > \S+)*): .*deprecated/, label: "yarn warning deprecated", item: (m) => m[1]! },
+	{ re: /^Collecting (\S+)/, label: "Collecting", item: (m) => m[1]! },
+	{ re: /^Requirement already satisfied: (\S+)/, label: "Requirement already satisfied", item: (m) => m[1]! },
+	{ re: /^installed (\S+)/, label: "installed", item: (m) => m[1]! },
+	{ re: /^ ?\+ (\S+)(?: (\S+))?$/, label: "+", item: (m) => (m[2] ? `${m[1]} ${m[2]}` : m[1]!) },
+	{ re: /^ - (\S+)(?: (\S+))?$/, label: "-", item: (m) => (m[2] ? `${m[1]} ${m[2]}` : m[1]!) },
+	{ re: /^Installing (\S+) \(([^)]+)\)$/, label: "Installing", item: (m) => `${m[1]} ${m[2]}` },
+	{ re: /^Using (\S+) \(([^)]+)\)$/, label: "Using", item: (m) => `${m[1]} ${m[2]}` },
+	// Bundler: `Using rake 13.0.6`, `Installing nokogiri 1.16.0 with native extensions`.
+	{ re: /^Using (\S+) ([\w.]+)$/, label: "Using", item: (m) => `${m[1]} ${m[2]}` },
+	{ re: /^Installing (\S+) ([\w.]+)(?: with native extensions)?$/, label: "Installing", item: (m) => `${m[1]} ${m[2]}` },
+	{ re: /^Fetching (\S+) ([\w.]+)$/, label: "Fetching", item: (m) => `${m[1]} ${m[2]}` },
+	{ re: /^ {2}(\S+) ([\w.+-]+) \(([\w.+-]+) available\)$/, label: "newer versions available", item: (m) => `${m[1]} ${m[2]}→${m[3]}` },
+];
+
+/** Names shown per collected line before `… +N`. */
+const SHOWN = 12;
+
+export function compactInstall(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = stripAnsi(output)
+		.split("\n")
+		.map((l) => {
+			// A progress bar redrawn with `\r`: only its last frame counts.
+			const frame = l.replace(/\r+$/, "");
+			return frame.slice(frame.lastIndexOf("\r") + 1);
+		});
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const out: (string | { label: string; items: string[] })[] = [];
+	const groups = new Map<string, { label: string; items: string[] }>();
+	let touched = 0;
+	for (const l of lines) {
+		if (DROP.some((d) => d.test(l))) {
+			touched++;
+			continue;
+		}
+		const rule = COLLECT.find((r) => r.re.test(l));
+		if (rule) {
+			touched++;
+			const label = rule.label;
+			let g = groups.get(label);
+			if (!g) {
+				g = { label, items: [] };
+				groups.set(label, g);
+				out.push(g);
+			}
+			g.items.push(rule.item(rule.re.exec(l)!));
+			continue;
+		}
+		if (l === "" && (out.length === 0 || out.at(-1) === "")) continue;
+		out.push(l);
+	}
+	if (!touched) return undefined;
+	// A collected line keeps the names, not the rest of each line (paths, deprecation notes).
+	let cut = false;
+	const text = out.map((o) => {
+		if (typeof o === "string") return cutLine(o, limits.lineChars);
+		const shown = o.items.slice(0, SHOWN).join(", ");
+		if (o.items.length > SHOWN) cut = true;
+		return `${o.label} (${o.items.length}): ${shown}${o.items.length > SHOWN ? `, … +${o.items.length - SHOWN}` : ""}`;
+	});
+	while (text.at(-1) === "") text.pop();
+	const capped = capLines(text, limits.total);
+	return { text: capped.text, truncated: cut || capped.truncated || groups.size > 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));