pi-squeeze 0.0.0-stage → 0.2.0

package/extensions/core/files.ts

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

package/extensions/core/generic.ts

@@ -0,0 +1,40 @@
+/**
+ * Clean-up for any command output, without leaving anything out that a reader would miss:
+ * ANSI colour codes go, progress bars redrawn with `\r` keep their last frame, a line
+ * repeated 4+ times in a row becomes `line  [×N]`, and 3+ blank lines become one.
+ *
+ * Never used on commands that print file content (cat, head, jq, curl…): there, every
+ * byte is the point.
+ */
+import type { Limits, Squeezed } from "./elide.ts";
+
+// CSI sequences (colours, cursor moves) and OSC sequences (titles, hyperlinks).
+const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g;
+
+/** Commands whose output is content, not a report. Checked anywhere in the command line. */
+const CONTENT = /(?:^|[\s|;&(])(cat|head|tail|sed|awk|jq|yq|bat|less|more|curl|wget|base64|xxd|od|hexdump|tee|printf|echo|diff|cmp|sort|uniq|cut|tr|wc)(?=\s|$)/;
+
+export const isContent = (command: string): boolean => CONTENT.test(command);
+
+/** Colour codes and terminal hyperlinks out; the text they wrapped stays. */
+export const stripAnsi = (text: string): string => text.replace(ANSI, "");
+
+export function compactGeneric(output: string, _limits?: Limits): Squeezed | undefined {
+	const lines = stripAnsi(output).split("\n").map((l) => {
+		const frame = l.replace(/\r+$/, "");
+		return (frame.includes("\r") ? frame.slice(frame.lastIndexOf("\r") + 1) : frame).trimEnd();
+	});
+	const out: string[] = [];
+	for (let i = 0; i < lines.length; ) {
+		let j = i;
+		while (j < lines.length && lines[j] === lines[i]) j++;
+		const run = j - i;
+		if (lines[i] === "") {
+			const keep = run >= 3 ? 1 : run;
+			for (let k = 0; k < keep; k++) out.push("");
+		} else if (run >= 4) out.push(`${lines[i]}  [×${run}]`);
+		else for (let k = 0; k < run; k++) out.push(lines[i]!);
+		i = j;
+	}
+	return { text: out.join("\n"), truncated: false };
+}

package/extensions/core/gitlog.ts

@@ -0,0 +1,75 @@
+/**
+ * `git log` and `git show` in their default format, one line per commit:
+ *
+ *   0a845ae 2026-11-01 Sorin Albu-Irimies  docs(readme): add the badges
+ *
+ * The message body stays (indented, at most 8 lines per commit). Strict: anything that is
+ * not the default format (`--stat`, `-p` and `--oneline` are handled elsewhere or skipped)
+ * returns undefined.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { compactDiff } from "./diff.ts";
+
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+const BODY_LINES = 8;
+
+type Commit = { hash: string; author: string; date: string; message: string[] };
+
+/** Parses the commit blocks in `lines`; returns the commits and the index of the first line after them. */
+function parseCommits(lines: string[]): { commits: Commit[]; next: number } | undefined {
+	const commits: Commit[] = [];
+	let i = 0;
+	while (i < lines.length) {
+		const m = /^commit ([0-9a-f]{7,64})(?: \(.*\))?$/.exec(lines[i]!);
+		if (!m) break;
+		i++;
+		if (lines[i]?.startsWith("Merge: ")) i++;
+		const a = /^Author: (.*?)(?: <[^>]*>)?$/.exec(lines[i++] ?? "");
+		const d = /^Date: +\w{3} (\w{3}) +(\d+) [\d:]+ (\d{4}) [+-]\d{4}$/.exec(lines[i++] ?? "");
+		if (!a || !d || lines[i++] !== "") return undefined;
+		const month = MONTHS.indexOf(d[1]!) + 1;
+		if (!month) return undefined;
+		const message: string[] = [];
+		for (; i < lines.length; i++) {
+			if (lines[i]!.startsWith("    ")) message.push(lines[i]!.slice(4));
+			else if (lines[i] === "" && lines.slice(i).find((l) => l !== "")?.startsWith("    ")) message.push("");
+			else break;
+		}
+		if (lines[i] === "") i++;
+		commits.push({ hash: m[1]!.slice(0, 7), author: a[1]!, date: `${d[3]}-${String(month).padStart(2, "0")}-${d[2]!.padStart(2, "0")}`, message });
+	}
+	return commits.length ? { commits, next: i } : undefined;
+}
+
+function render(commits: Commit[], limits: Limits): string[] {
+	// One author for the whole list: say so once instead of on every line.
+	const solo = commits.length > 1 && commits.every((c) => c.author === commits[0]!.author);
+	const out: string[] = solo ? [`by ${commits[0]!.author}`] : [];
+	for (const c of commits) {
+		const [subject = "", ...rest] = c.message;
+		out.push(cutLine(`${c.hash} ${c.date}${solo ? "" : ` ${c.author}`}  ${subject}`, limits.lineChars));
+		const body = rest.filter((l, i) => !(l === "" && (i === 0 || rest[i - 1] === "")));
+		for (const l of body.slice(0, BODY_LINES)) out.push(l ? cutLine(`  ${l}`, limits.lineChars) : "");
+		if (body.length > BODY_LINES) out.push(`  … [+${body.length - BODY_LINES} more lines]`);
+	}
+	return out;
+}
+
+export function compactLog(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const parsed = parseCommits(lines);
+	if (!parsed || parsed.next !== lines.length) return undefined;
+	return capLines(render(parsed.commits, limits), limits.total);
+}
+
+/** `git show` of a commit: the commit line above, then the (compacted) diff. */
+export function compactShow(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	const at = lines.findIndex((l) => l.startsWith("diff --git "));
+	if (at < 0) return compactLog(output, limits);
+	const parsed = parseCommits(lines.slice(0, at));
+	const diff = compactDiff(lines.slice(at).join("\n"), limits);
+	if (!parsed || parsed.next !== at || !diff) return undefined;
+	return { text: `${render(parsed.commits, limits).join("\n")}\n${diff.text}`, truncated: diff.truncated };
+}

package/extensions/core/gitstatus.ts

@@ -0,0 +1,52 @@
+/**
+ * `git status` (long form) without the hints:
+ *
+ *   ## main...origin/main [ahead 2]
+ *   staged:
+ *     M src/a.ts
+ *   untracked:
+ *     notes.txt
+ *
+ * Strict: a line it does not know makes it return undefined.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const SECTIONS: Record<string, string> = {
+	"Changes to be committed:": "staged",
+	"Changes not staged for commit:": "unstaged",
+	"Untracked files:": "untracked",
+	"Unmerged paths:": "unmerged",
+	"Ignored files:": "ignored",
+};
+const CODES: Record<string, string> = { modified: "M", "new file": "A", deleted: "D", renamed: "R", copied: "C", "both modified": "UU", "both added": "AA", "deleted by us": "DU", "deleted by them": "UD", "added by us": "AU", "added by them": "UA", "both deleted": "DD", "typechange": "T" };
+const FOOTER = /^(no changes added to commit|nothing added to commit|nothing to commit|nothing to commit, working tree clean)/;
+
+export function compactStatus(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	let head = "";
+	let track = "";
+	const out: string[] = [];
+	let section = "";
+	for (const l of lines) {
+		let m: RegExpExecArray | null;
+		if ((m = /^On branch (.+)$/.exec(l))) head = m[1]!;
+		else if ((m = /^HEAD detached (?:at|from) (.+)$/.exec(l))) head = `(detached ${m[1]})`;
+		else if ((m = /^Your branch is up to date with '(.+)'\.$/.exec(l))) track = `...${m[1]}`;
+		else if ((m = /^Your branch is (ahead of|behind) '(.+)' by (\d+) commits?(?:, and can be fast-forwarded)?\.$/.exec(l))) track = `...${m[2]} [${m[1]!.split(" ")[0]} ${m[3]}]`;
+		else if ((m = /^Your branch and '(.+)' have diverged,$/.exec(l))) track = `...${m[1]} [diverged]`;
+		else if ((m = /^and have (\d+) and (\d+) different commits each, respectively\.$/.exec(l))) track = track.replace("[diverged]", `[ahead ${m[1]}, behind ${m[2]}]`);
+		else if (SECTIONS[l]) {
+			section = SECTIONS[l]!;
+			out.push(`${section}:`);
+		} else if (/^\s+\(use "git .*\)$/.test(l) || l === "" || FOOTER.test(l) || /^\s*\(all conflicts fixed.*\)$/.test(l)) continue;
+		else if ((m = /^\t([a-z ]+?):\s+(.+)$/.exec(l)) && CODES[m[1]!]) out.push(`  ${CODES[m[1]!]} ${m[2]}`);
+		else if (section === "untracked" || section === "ignored") {
+			if (!l.startsWith("\t")) return undefined;
+			out.push(`  ${l.slice(1)}`);
+		} else return undefined;
+	}
+	if (!head) return undefined;
+	const clean = out.length === 0 ? [" clean"] : [];
+	return capLines([`## ${head}${track}${clean[0] ?? ""}`, ...out], limits.total);
+}

package/extensions/core/gradle.ts

@@ -0,0 +1,269 @@
+/**
+ * `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 = [
+	/^Starting a Gradle Daemon/,
+	/^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/,
+	/^> Run with --(stacktrace|info|debug|scan)/,
+	/^> Get more help at/,
+	/^> Configure project /,
+	/^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)/,
+];
+/** 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 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) {
+			s.tasks++;
+			if (t[2] === "FAILED") kept.push(l);
+			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 (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;
+
+		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);
+		}
+	}
+	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, "…/");
+}
+
+/** `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 };
+}