pi-squeeze 0.0.0-stage → 0.2.0

package/extensions/core/compact.ts

@@ -0,0 +1,332 @@
+/** Chooses the compactor for a bash command and applies the safety rules. */
+import { hasFlag, type Invocation, parse } from "./command.ts";
+import { DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { compactDumpsys, compactPackagePaths, compactPackages, compactProcesses, compactProperties, compactUiDump } from "./adb.ts";
+import { compactAudit } from "./audit.ts";
+import { compactBlame } from "./blame.ts";
+import { compactDiff } from "./diff.ts";
+import { compactDockerBuild } from "./docker.ts";
+import { compactDust } from "./dust.ts";
+import { compactGradle, compactGradleDeps } from "./gradle.ts";
+import { compactInstall } from "./install.ts";
+import { compactJavac } from "./javac.ts";
+import { compactJest } from "./jest.ts";
+import { compactLint, compactLintSniffed } from "./lint.ts";
+import { compactLogs, compactTrace } from "./logs.ts";
+import { compactMaven, compactMavenTree } from "./maven.ts";
+import { compactPytest } from "./pytest.ts";
+import { compactGeneric, isContent } from "./generic.ts";
+import { compactLog, compactShow } from "./gitlog.ts";
+import { compactStatus } from "./gitstatus.ts";
+import { compactLsd } from "./lsd.ts";
+import { compactPaths } from "./paths.ts";
+import { compactRg, compactRgPlain } from "./rg.ts";
+import { compactRustc } from "./rustc.ts";
+import { compactBunTest, compactGoTest } from "./runners.ts";
+import { compactTests } from "./tests.ts";
+import { compactTree } from "./tree.ts";
+import { compactTsc } from "./tsc.ts";
+import { compactXcode, compactXcodeSniffed } from "./xcode.ts";
+
+export const KINDS = ["search", "paths", "listing", "diff", "tests", "git", "build", "lint", "install", "logs", "tree", "generic"] as const;
+export type Kind = (typeof KINDS)[number];
+
+export type Result = { text: string; kind: Kind; truncated: boolean; before: number; after: number };
+
+export type Options = {
+	limits?: Limits;
+	/** Output shorter than this is never touched. */
+	minChars?: number;
+	/** The result must be at most this share of the original, or the original is kept. */
+	maxRatio?: number;
+	/** Compactors that may run; a missing entry means on. */
+	kinds?: Partial<Record<Kind, boolean>>;
+	/** The command failed: only test, build, lint, install and log output is worth compacting then (the errors, or the stack trace, are the point). */
+	failed?: boolean;
+	/** Is `path` (relative to the command's directory) an existing file? Lets search output without line numbers be grouped. */
+	isFile?: (path: string) => boolean;
+};
+
+
+const SEARCH = new Set(["rg", "grep", "egrep", "ugrep", "ack"]);
+const PATHS = new Set(["fd", "fdfind", "find"]);
+const LISTING = new Set(["lsd", "eza", "exa", "ls"]);
+const LIST_ONLY = { long: ["--files", "--files-with-matches", "--files-without-match"], short: ["l"] };
+const NOT_A_LIST = { long: ["--json", "--count", "--null", "--print0", "--stats", "--vimgrep"], short: ["c", "0", "z"] };
+
+/** Flags after which the output is no longer plain `path:line:text` / one path per line. */
+const NOT_PLAIN_SEARCH = { long: ["--json", "--count", "--files-with-matches", "--files-without-match", "--files", "--heading", "--stats", "--vimgrep", "--only-matching", "--null", "--passthru"], short: ["c", "l", "L", "o", "z"] };
+const NOT_PLAIN_PATHS = { long: ["--exec", "--exec-batch", "--list-details", "--print0", "--format"], short: ["x", "X", "l", "0"] };
+
+/** Flags of `git log`, `show`, `blame` and `status` that leave the default format. */
+const GIT_FORMAT = ["--oneline", "--pretty", "--stat", "--shortstat", "--numstat", "--name-only", "--name-status", "--raw", "--graph", "--patch", "--color-words", "--word-diff", "--porcelain", "--line-porcelain", "--incremental", "--short", "--branch", "--stage", "--eol", "--debug", "--format", "--null", "--color"];
+const GIT_FORMAT_SHORT = ["p", "s", "z", "b", "e", "t", "v"];
+
+/** `git diff` flags that change the output format away from a unified diff. */
+const NOT_PLAIN_DIFF = {
+	long: ["--stat", "--numstat", "--shortstat", "--dirstat", "--summary", "--name-only", "--name-status", "--raw", "--check", "--patch-with-stat", "--patch-with-raw", "--word-diff", "--color-words", "--color", "--compact-summary", "--submodule", "--no-index", "--output"],
+	short: ["s", "z"],
+};
+
+function plainFind(args: string[]): boolean {
+	return !args.some((a) => ["-exec", "-execdir", "-ls", "-print0", "-printf", "-fprint", "-delete", "-ok"].includes(a));
+}
+
+function pickCargo(all: string[]): ReturnType<typeof pick> {
+	// `cargo +nightly build`: the toolchain does not change the output.
+	const [sub, ...rest] = all[0]?.startsWith("+") ? all.slice(1) : all;
+	if (hasFlag(rest, ["--format", "--message-format", "--prefix", "--charset", "--timings"])) return undefined;
+	switch (sub) {
+		case "test":
+			return { kind: "tests", run: compactTests };
+		case "build":
+		case "check":
+		case "clippy":
+		case "doc":
+		case "bench":
+			return { kind: "build", run: compactRustc };
+		case "audit":
+			return { kind: "build", run: compactAudit };
+		case "tree":
+			return { kind: "tree", run: compactTree };
+		default:
+			return undefined;
+	}
+}
+
+/** Output with a strong marker of its own is recognised whatever command produced it (`just check`, `npm run build`, pipes). */
+const SNIFFERS: { kind: Kind; run: (out: string, l: Limits) => Squeezed | undefined }[] = [
+	{ kind: "tests", run: compactBunTest },
+	{ kind: "tests", run: compactGoTest },
+	{ kind: "tests", run: compactPytest },
+	{ kind: "tests", run: compactJest },
+	{ kind: "build", run: compactGradle },
+	{ kind: "build", run: compactXcodeSniffed },
+	{ kind: "build", run: compactTsc },
+	{ kind: "build", run: compactRustc },
+	{ kind: "build", run: compactAudit },
+	{ kind: "lint", run: compactLintSniffed },
+	{ kind: "build", run: compactMaven },
+	{ kind: "build", run: compactJavac },
+	{ kind: "tree", run: compactUiDump },
+	{ kind: "logs", run: compactTrace },
+];
+
+/** `git` options before the subcommand that do not change its output: `-C dir`, `-c k=v`, `--no-pager`, ... */
+function gitSubcommand(args: string[]): string[] {
+	let i = 0;
+	while (i < args.length) {
+		const a = args[i]!;
+		if (a === "-C" || a === "-c") i += 2;
+		else if (["--no-pager", "-P", "--no-optional-locks", "--literal-pathspecs"].includes(a) || /^--(git-dir|work-tree)=/.test(a)) i++;
+		else break;
+	}
+	return args.slice(i);
+}
+
+/** `--color=never` and `--no-color` leave the output as it is without them. */
+const noColor = (args: string[]) => args.filter((a) => a !== "--color=never" && a !== "--no-color");
+
+function pickGit(all: string[]): ReturnType<typeof pick> {
+	const [sub, ...rest] = noColor(gitSubcommand(all));
+	switch (sub) {
+		case "diff":
+			if (hasFlag(rest, ["--name-only"]) && !hasFlag(rest, ["--null"], ["z"])) return { kind: "paths", run: compactPaths };
+			return hasFlag(rest, NOT_PLAIN_DIFF.long, NOT_PLAIN_DIFF.short) ? undefined : { kind: "diff", run: compactDiff };
+		case "ls-files":
+			return hasFlag(rest, ["--stage", "--eol", "--debug", "--format", "--deleted", "--others"], ["s", "z", "t", "v"]) ? undefined : { kind: "paths", run: compactPaths };
+		case "status":
+			return hasFlag(rest, GIT_FORMAT, GIT_FORMAT_SHORT) ? undefined : { kind: "git", run: compactStatus };
+		case "log":
+			return hasFlag(rest, GIT_FORMAT, GIT_FORMAT_SHORT) ? undefined : { kind: "git", run: compactLog };
+		case "show":
+			return hasFlag(rest, GIT_FORMAT, GIT_FORMAT_SHORT) ? undefined : { kind: "git", run: compactShow };
+		case "blame":
+			return hasFlag(rest, GIT_FORMAT, GIT_FORMAT_SHORT) ? undefined : { kind: "git", run: compactBlame };
+		default:
+			return undefined;
+	}
+}
+
+/** Flags that print context lines (`path-text`, which cannot be told apart from a path with a dash). */
+const CONTEXT = { long: ["--context", "--after-context", "--before-context"], short: /^-[A-Za-z]*[ABC]/ };
+
+/**
+ * `rg pattern dir` without -n: grouped only when the paths can be checked on disk, and not when the
+ * only path searched is itself a file (then there is no path prefix, and a colon in the text would pass for one).
+ */
+function plainSearch(args: string[], isFile: ((path: string) => boolean) | undefined): ReturnType<typeof pick> {
+	if (hasFlag(args, ["--line-number"], ["n"]) || hasFlag(args, CONTEXT.long) || args.some((a) => CONTEXT.short.test(a)) || !isFile) return undefined;
+	const operands = args.filter((a) => !a.startsWith("-")).slice(1);
+	if (operands.length === 1 && isFile(operands[0]!)) return undefined;
+	return { kind: "search", run: (out, l) => compactRgPlain(out, l, isFile) };
+}
+
+/** `npx tool`, `uv run tool`, `python -m tool`, `xcrun tool`…: the tool is what prints. */
+function unwrap({ program, args }: Invocation): Invocation {
+	const next = (rest: string[]): Invocation | undefined => {
+		const i = rest.findIndex((a) => !a.startsWith("-"));
+		return i < 0 ? undefined : { program: rest[i]!.split("/").pop()!, args: rest.slice(i + 1) };
+	};
+	let inner: Invocation | undefined;
+	if (["npx", "bunx", "pnpx", "uvx"].includes(program)) inner = next(args);
+	else if (["uv", "poetry", "pipenv", "pdm", "hatch"].includes(program) && args[0] === "run") inner = next(args.slice(1));
+	else if ((program === "pnpm" || program === "yarn") && (args[0] === "exec" || args[0] === "dlx")) inner = next(args.slice(1));
+	else if (/^python[\d.]*$/.test(program) && args[0] === "-m" && args[1]) inner = { program: args[1], args: args.slice(2) };
+	else if (program === "xcrun" && args[0] && !args[0].startsWith("-")) inner = { program: args[0], args: args.slice(1) };
+	return inner ? unwrap(inner) : { program, args };
+}
+
+/** `cmd | tail -50` / `cmd | head -n 20`: still `cmd`'s format, only fewer lines of it. */
+export function unpipe(command: string): string {
+	return command.replace(/\s*\|\s*(?:tail|head)(?:\s+(?:-n\s*\d+|-\d+|--lines=\d+))?\s*$/, "");
+}
+
+const INSTALL: Record<string, string[]> = {
+	npm: ["install", "i", "ci", "add", "update", "up"],
+	pnpm: ["install", "i", "add", "update", "up"],
+	yarn: ["install", "add", "upgrade"],
+	bun: ["install", "i", "add", "update"],
+	pip: ["install", "download"],
+	pip3: ["install", "download"],
+	pod: ["install", "update"],
+	bundle: ["install", "update"],
+	gem: ["install", "update"],
+};
+
+/** Linters whose output `compactLint` reads (with their subcommand where they have one). */
+const LINTERS: Record<string, string[] | undefined> = {
+	eslint: undefined,
+	biome: ["lint", "check", "ci"],
+	ruff: ["check"],
+	flake8: undefined,
+	mypy: undefined,
+	pylint: undefined,
+	ktlint: undefined,
+	detekt: undefined,
+	"detekt-cli": undefined,
+	swiftlint: ["lint"],
+	shellcheck: undefined,
+	flutter: ["analyze"],
+	dart: ["analyze"],
+};
+
+const LOG_COMMANDS = (program: string, args: string[]): boolean =>
+	((program === "docker" || program === "podman") && (args[0] === "logs" || (args[0] === "compose" && args[1] === "logs"))) ||
+	(program === "docker-compose" && args[0] === "logs") ||
+	(program === "kubectl" && args[0] === "logs") ||
+	["journalctl", "stern", "pidcat"].includes(program);
+
+/** `adb [-s serial|-d|-e|-t id] <command>`: logcat, and what `adb shell` prints for packages, properties, processes, dumpsys and UI dumps. */
+function pickAdb(all: string[]): ReturnType<typeof pick> {
+	let i = 0;
+	while (i < all.length && /^-[sHPLt]$|^-[de]$/.test(all[i]!)) i += /^-[de]$/.test(all[i]!) ? 1 : 2;
+	const [sub, ...rest] = all.slice(i);
+	// `adb shell "dumpsys battery"` is `adb shell dumpsys battery`.
+	const cmd = rest.join(" ").trim().split(/\s+/);
+	const line = cmd.join(" ");
+	if (sub === "logcat") return { kind: "logs", run: compactLogs };
+	if ((sub === "shell" || sub === "exec-out") && /^uiautomator dump \/dev\/(?:tty|stdout)\b/.test(line)) return { kind: "tree", run: compactUiDump };
+	if (sub !== "shell") return undefined;
+	if (/^(?:pm|cmd package) list packages\b/.test(line)) return cmd.includes("-f") ? { kind: "listing", run: compactPackagePaths } : { kind: "listing", run: compactPackages };
+	if (line === "getprop" || /^settings list (?:global|secure|system)$/.test(line)) return { kind: "listing", run: compactProperties };
+	if (/^ps(?: -A| -e)*$/.test(line) || /^top\b/.test(line)) return { kind: "listing", run: compactProcesses };
+	if (cmd[0] === "dumpsys" && cmd.length > 1) return { kind: "tree", run: compactDumpsys };
+	return undefined;
+}
+
+/** Package managers, linters, test runners, logs, docker and Xcode. */
+function pickTool({ program, args }: Invocation): ReturnType<typeof pick> {
+	const sub = args[0] ?? "";
+	const machine = args.some((a) => /json|sarif|junit|checkstyle|xml|github|gitlab|codeclimate|teamcity|tap\b/i.test(a));
+	if (machine) return undefined;
+	if (INSTALL[program]?.includes(sub) || (program === "yarn" && !sub) || (program === "uv" && (["add", "sync"].includes(sub) || (sub === "pip" && ["install", "sync"].includes(args[1] ?? "")))) || ((program === "flutter" || program === "dart") && sub === "pub" && args[1] === "get"))
+		return { kind: "install", run: compactInstall };
+	if (program in LINTERS) {
+		const subs = LINTERS[program];
+		// `ruff .` is `ruff check .` in older versions.
+		if (!subs || subs.includes(sub) || (program === "ruff" && sub.startsWith("-"))) return { kind: "lint", run: compactLint };
+		return undefined;
+	}
+	if (program === "pytest" || program === "py.test") return { kind: "tests", run: compactPytest };
+	if (program === "jest" || program === "vitest") return { kind: "tests", run: compactJest };
+	if (program === "mvn" || program === "mvnw" || program === "mvnd")
+		return args.some((a) => /dependency:tree$/.test(a)) ? { kind: "tree", run: compactMavenTree } : { kind: args.includes("test") ? "tests" : "build", run: compactMaven };
+	if (program === "javac") return { kind: "build", run: compactJavac };
+	if (LOG_COMMANDS(program, args)) return hasFlag(args, ["--follow"], ["f"]) ? undefined : { kind: "logs", run: compactLogs };
+	if (program === "adb") return pickAdb(args);
+	if (((program === "docker" || program === "podman") && (sub === "build" || (sub === "buildx" && args[1] === "build") || (sub === "compose" && args[1] === "build"))) || (program === "docker-compose" && sub === "build"))
+		return { kind: "build", run: compactDockerBuild };
+	if (program === "xcodebuild") return { kind: args.includes("test") ? "tests" : "build", run: compactXcode };
+	if (program === "swift" && (sub === "build" || sub === "test")) return { kind: sub === "test" ? "tests" : "build", run: compactXcode };
+	return undefined;
+}
+
+function pick(command: string, isFile?: (path: string) => boolean): { kind: Kind; run: (out: string, l: Limits) => Squeezed | undefined } | undefined {
+	const parsed = parse(command);
+	if (!parsed) return undefined;
+	const inv = unwrap(parsed);
+	// Relative paths in the output are relative to the `cd`, which the file check does not know.
+	const local = /^\s*cd\s/.test(command) ? undefined : isFile;
+	const { program, args } = inv;
+	if (SEARCH.has(program)) {
+		const files = hasFlag(args, LIST_ONLY.long, program === "rg" ? LIST_ONLY.short : [...LIST_ONLY.short, "L"]);
+		if (files) return hasFlag(args, NOT_A_LIST.long, NOT_A_LIST.short) ? undefined : { kind: "paths", run: compactPaths };
+		if (hasFlag(args, NOT_PLAIN_SEARCH.long, NOT_PLAIN_SEARCH.short)) return undefined;
+		// ack: `-f` / `-g` list files; `-h` drops the path.
+		if (program === "ack" && hasFlag(args, ["--no-filename"], ["f", "g", "h"])) return hasFlag(args, [], ["f", "g"]) ? { kind: "paths", run: compactPaths } : undefined;
+		const plain = plainSearch(args, local);
+		return plain ?? { kind: "search", run: compactRg };
+	}
+	if (PATHS.has(program)) {
+		if (program === "find" ? !plainFind(args) : hasFlag(args, NOT_PLAIN_PATHS.long, NOT_PLAIN_PATHS.short)) return undefined;
+		return { kind: "paths", run: compactPaths };
+	}
+	if (program === "git") return pickGit(args);
+	if (program === "cargo") return pickCargo(args);
+	if (program === "tsc") return { kind: "build", run: compactTsc };
+	if (program === "gradle" || program === "gradlew") return args.some((a) => /(^|:)dependencies$/.test(a)) ? { kind: "tree", run: compactGradleDeps } : { kind: "build", run: compactGradle };
+	if (program === "go" && args[0] === "test") return hasFlag(args, ["-json", "--json"]) ? undefined : { kind: "tests", run: compactGoTest };
+	if (program === "bun" && args[0] === "test") return { kind: "tests", run: compactBunTest };
+	if (program === "tree" || ((program === "eza" || program === "exa" || program === "lsd") && hasFlag(args, ["--tree"], ["T"]))) return hasFlag(args, ["-J", "--json", "-H", "--html"]) ? undefined : { kind: "tree", run: compactTree };
+	if (program === "dust") return hasFlag(args, ["--output-json"], ["j"]) ? undefined : { kind: "listing", run: compactDust };
+	if (LISTING.has(program)) {
+		if (!hasFlag(args, ["--long"], ["l"])) return undefined;
+		// Other column sets (inode, blocks, group only, full time, numeric ids, octal) do not parse.
+		if (hasFlag(args, ["--inode", "--blocks", "--size", "--full-time", "--time-style", "--numeric-uid-gid", "--git", "--header", "--octal-permissions", "--total-size", "--context"], ["i", "s", "n", "g", "o", "H", "Z"])) return undefined;
+		return { kind: "listing", run: compactLsd };
+	}
+	return pickTool(inv);
+}
+
+/** True when a native compactor takes care of `command`'s output (whatever the switches say). */
+export const handles = (command: string): boolean => pick(unpipe(command)) !== undefined;
+
+/** Kinds whose output is worth compacting when the command failed: there the failures (or the crash's stack trace) are the point. */
+const FAILED_OK = new Set<Kind>(["tests", "build", "lint", "install", "logs"]);
+
+/** Compacts the output of `command`, or returns undefined to leave it exactly as it is. */
+export function compact(full: string, output: string, opts: Options = {}): Result | undefined {
+	const command = unpipe(full);
+	const { limits = DEFAULT_LIMITS, minChars = 400, maxRatio = 0.9, kinds = {}, failed = false, isFile } = opts;
+	if (output.length < minChars) return undefined;
+	const small = (sq: Squeezed | undefined): sq is Squeezed => sq !== undefined && sq.text.length <= output.length * maxRatio;
+	const allowed = (kind: Kind) => kinds[kind] !== false && (!failed || FAILED_OK.has(kind));
+	const done = (sq: Squeezed, kind: Kind): Result => ({ text: sq.text, kind, truncated: sq.truncated, before: output.length, after: sq.text.length });
+
+	const chosen = pick(command, isFile);
+	if (chosen && allowed(chosen.kind)) {
+		const sq = chosen.run(output, limits);
+		if (small(sq)) return done(sq, chosen.kind);
+	}
+	if (isContent(command)) return undefined;
+	for (const s of SNIFFERS) {
+		if (!allowed(s.kind)) continue;
+		const sq = s.run(output, limits);
+		if (small(sq)) return done(sq, s.kind);
+	}
+	// Nothing specific fits: still drop colour codes, progress frames and repeated lines.
+	if (failed || kinds.generic === false) return undefined;
+	const sq = compactGeneric(output);
+	return small(sq) ? done(sq, "generic") : undefined;
+}

package/extensions/core/config.ts

@@ -0,0 +1,109 @@
+/**
+ * The persisted settings: <agent dir>/squeeze.json.
+ *
+ * A hand-edited file can hold anything, so `sanitizeConfig` keeps valid values and defaults the
+ * rest. A missing file is not a problem (defaults); a broken one is reported, never thrown.
+ */
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { KINDS, type Kind } from "./compact.ts";
+
+export interface Config {
+	/** Master switch: when false nothing is compacted. */
+	enabled: boolean;
+	/** Show the savings in the status line. */
+	showStatus: boolean;
+	/** Which compactors run. */
+	kinds: Record<Kind, boolean>;
+	/** Rewrite commands to their `rtk` form (git, cargo, docker, …) when the rtk binary is installed. */
+	rtk: boolean;
+	/** Output shorter than this many characters is never touched. */
+	minChars: number;
+	/** Longest line kept whole in search results. */
+	lineChars: number;
+	/** Match lines kept per file. */
+	perGroup: number;
+	/** Lines in a whole compacted result. */
+	total: number;
+}
+
+export const DEFAULT_CONFIG: Config = {
+	enabled: true,
+	showStatus: true,
+	rtk: true,
+	kinds: Object.fromEntries(KINDS.map((k) => [k, true])) as Record<Kind, boolean>,
+	minChars: 400,
+	lineChars: 240,
+	perGroup: 15,
+	total: 250,
+};
+
+export const clampInt = (v: unknown, min: number, max: number, fallback: number): number =>
+	typeof v === "number" && Number.isFinite(v) ? Math.min(max, Math.max(min, Math.round(v))) : fallback;
+
+const bool = (v: unknown, fallback: boolean): boolean => (typeof v === "boolean" ? v : fallback);
+
+export function sanitizeConfig(raw: unknown): Config {
+	const r = (typeof raw === "object" && raw !== null && !Array.isArray(raw) ? raw : {}) as Record<string, unknown>;
+	const k = (typeof r.kinds === "object" && r.kinds !== null ? r.kinds : {}) as Record<string, unknown>;
+	const d = DEFAULT_CONFIG;
+	return {
+		enabled: bool(r.enabled, d.enabled),
+		showStatus: bool(r.showStatus, d.showStatus),
+		rtk: bool(r.rtk, d.rtk),
+		kinds: Object.fromEntries(KINDS.map((kind) => [kind, bool(k[kind], d.kinds[kind])])) as Record<Kind, boolean>,
+		minChars: clampInt(r.minChars, 100, 1_000_000, d.minChars),
+		lineChars: clampInt(r.lineChars, 40, 4000, d.lineChars),
+		perGroup: clampInt(r.perGroup, 1, 500, d.perGroup),
+		total: clampInt(r.total, 20, 5000, d.total),
+	};
+}
+
+/** Where pi keeps its config: PI_CODING_AGENT_DIR, then $XDG_CONFIG_HOME/pi/agent, then ~/.pi/agent. */
+export function resolveAgentDir(env: Record<string, string | undefined>, home: string): string {
+	if (env.PI_CODING_AGENT_DIR) return env.PI_CODING_AGENT_DIR;
+	if (env.XDG_CONFIG_HOME) return join(env.XDG_CONFIG_HOME, "pi", "agent");
+	return join(home, ".pi", "agent");
+}
+
+export const configPath = (env: Record<string, string | undefined> = process.env, home = homedir()): string =>
+	join(resolveAgentDir(env, home), "squeeze.json");
+
+/** The config, plus a `problem` when the file exists but cannot be used. */
+export async function readConfig(path = configPath()): Promise<{ config: Config; problem?: string }> {
+	let raw: string;
+	try {
+		raw = await readFile(path, "utf8");
+	} catch (e) {
+		const code = (e as { code?: string } | null)?.code;
+		return code === "ENOENT" ? { config: sanitizeConfig({}) } : { config: sanitizeConfig({}), problem: `cannot read ${path} (${code ?? "error"})` };
+	}
+	try {
+		return { config: sanitizeConfig(JSON.parse(raw)) };
+	} catch {
+		return { config: sanitizeConfig({}), problem: `${path} is not valid JSON` };
+	}
+}
+
+export async function loadConfig(path = configPath()): Promise<Config> {
+	return (await readConfig(path)).config;
+}
+
+/** Atomic: written to a temp file and renamed, so a crash or a second pi session never leaves half a file. */
+export async function saveConfig(config: Config, path = configPath()): Promise<void> {
+	await mkdir(join(path, ".."), { recursive: true });
+	const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+	try {
+		await writeFile(tmp, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+		await rename(tmp, path);
+	} catch (e) {
+		await Promise.allSettled([rm(tmp, { force: true })]); // the original error matters more
+		throw e;
+	}
+}
+
+/** The compaction options this config stands for. */
+export function optionsOf(c: Config) {
+	return { limits: { lineChars: c.lineChars, perGroup: c.perGroup, total: c.total }, minChars: c.minChars, kinds: c.kinds };
+}

package/extensions/core/diff.ts

@@ -0,0 +1,93 @@
+/**
+ * `git diff` output: the file headers shrink to one line each (`path (new, +12 −0)`), the
+ * `index` / mode / `---` / `+++` lines go, and every hunk keeps all of its changed lines but
+ * only one line of context on each side of a change. Long files are cut with a marker.
+ *
+ * The parse is exact: hunk lengths come from the `@@` headers, so any line that does not fit
+ * the unified-diff grammar makes the whole output pass through untouched.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+/** Lines kept per file: a new file is mostly boilerplate to the reader, a change is not. */
+const NEW_FILE_LINES = 40;
+const FILE_LINES = 120;
+
+const HEADER = /^(index |new file mode |deleted file mode |old mode |new mode |similarity index |dissimilarity index |rename from |rename to |copy from |copy to )/;
+const HUNK = /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/;
+
+type File = { path: string; status: string; added: number; removed: number; body: string[]; binary: boolean };
+
+function parseFile(lines: string[], start: number): { file: File; next: number } | undefined {
+	const m = /^diff --git a\/(.+) b\/(.+)$/.exec(lines[start]!);
+	if (!m) return undefined;
+	const file: File = { path: m[2]!, status: "", added: 0, removed: 0, body: [], binary: false };
+	let i = start + 1;
+	for (; i < lines.length; i++) {
+		const l = lines[i]!;
+		if (l.startsWith("diff --git ") || l.startsWith("@@")) break;
+		if (l.startsWith("--- ") || l.startsWith("+++ ")) continue;
+		if (l.startsWith("new file mode")) file.status = "new";
+		else if (l.startsWith("deleted file mode")) file.status = "deleted";
+		else if (l.startsWith("rename to ")) file.status = `renamed from ${m[1]}`;
+		else if (/^Binary files .* differ$/.test(l)) file.binary = true;
+		else if (!HEADER.test(l)) return undefined;
+	}
+	while (i < lines.length && lines[i]!.startsWith("@@")) {
+		const h = HUNK.exec(lines[i]!);
+		if (!h) return undefined;
+		let old = h[1] === undefined ? 1 : Number(h[1]);
+		let neu = h[2] === undefined ? 1 : Number(h[2]);
+		const hunk = [lines[i]!];
+		i++;
+		while (old > 0 || neu > 0 || lines[i]?.startsWith("\\")) {
+			const l = lines[i];
+			if (l === undefined) return undefined;
+			if (l.startsWith("\\")) hunk.push(l);
+			else if (l.startsWith("+")) (neu--, file.added++, hunk.push(l));
+			else if (l.startsWith("-")) (old--, file.removed++, hunk.push(l));
+			else if (l.startsWith(" ") || l === "") (old--, neu--, hunk.push(l));
+			else return undefined;
+			i++;
+		}
+		file.body.push(...trimContext(hunk));
+	}
+	return { file, next: i };
+}
+
+/** One context line on each side of a change; the `@@` header stays. */
+function trimContext(hunk: string[]): string[] {
+	const isChange = (l: string) => l.startsWith("+") || l.startsWith("-") || l.startsWith("\\");
+	const keep = hunk.map((l, i) => i === 0 || isChange(l) || (i > 1 && isChange(hunk[i - 1]!)) || (i + 1 < hunk.length && isChange(hunk[i + 1]!)));
+	return hunk.filter((_, i) => keep[i]);
+}
+
+export function compactDiff(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines[0]?.startsWith("diff --git ")) return undefined;
+
+	const files: File[] = [];
+	for (let i = 0; i < lines.length; ) {
+		const r = parseFile(lines, i);
+		if (!r) return undefined;
+		files.push(r.file);
+		i = r.next;
+	}
+
+	const added = files.reduce((n, f) => n + f.added, 0);
+	const removed = files.reduce((n, f) => n + f.removed, 0);
+	const out = [`${files.length} file${files.length === 1 ? "" : "s"} changed, +${added} −${removed} (context trimmed to 1 line)`];
+	let cut = false;
+	for (const f of files) {
+		const tag = f.binary ? "binary" : f.status;
+		out.push(`${f.path} (${tag ? `${tag}, ` : ""}+${f.added} −${f.removed})`);
+		const max = f.status === "new" ? NEW_FILE_LINES : FILE_LINES;
+		for (const l of f.body.slice(0, max)) out.push(cutLine(l, limits.lineChars));
+		if (f.body.length > max) {
+			out.push(`… [+${f.body.length - max} more lines in ${f.path}]`);
+			cut = true;
+		}
+	}
+	const capped = capLines(out, limits.total * 2);
+	return { text: capped.text, truncated: cut || capped.truncated };
+}

package/extensions/core/docker.ts

@@ -0,0 +1,58 @@
+/**
+ * `docker build` (BuildKit plain progress and the classic builder): bookkeeping steps
+ * (`[internal]` loads, context transfer, CACHED, DONE, layer pushes, image export) go;
+ * each build step keeps its header and what its command printed, without the `#N 0.123`
+ * prefix. Errors stay whole.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { stripAnsi } from "./generic.ts";
+
+const STEP = /^#(\d+) (.*)$/;
+/** BuildKit lines with nothing to say once the build is over. */
+const QUIET = /^(building with |DONE [\d.]+s|CACHED|transferring |resolve |sha256:[\da-f]+ |extracting sha256:|exporting |writing image |naming to |unpacking to |preparing layers|load build definition|load \.dockerignore|load metadata for |\[auth\] )/;
+/** Classic builder bookkeeping. */
+const CLASSIC = /^( ---> |Removing intermediate container |Sending build context to Docker daemon|Successfully built [\da-f]+$)/;
+
+export function compactDockerBuild(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = stripAnsi(output).split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const buildkit = lines.some((l) => /^#\d+ \[/.test(l));
+	const classic = lines.some((l) => /^Step \d+\/\d+ : /.test(l));
+	if (!buildkit && !classic) return undefined;
+	const internal = new Set<string>();
+	const cached = new Set<string>();
+	/** Where each step's header went, to mark it CACHED. */
+	const steps = new Map<string, number>();
+	const out: string[] = [];
+	for (const l of lines) {
+		const m = STEP.exec(l);
+		if (!m) {
+			if (CLASSIC.test(l) || (l === "" && (out.length === 0 || out.at(-1) === ""))) continue;
+			out.push(cutLine(l, limits.lineChars));
+			continue;
+		}
+		const [, id, rest] = m as unknown as [string, string, string];
+		if (/^\[internal\]/.test(rest) || internal.has(id)) {
+			internal.add(id);
+			if (/^ERROR/.test(rest)) out.push(l);
+			continue;
+		}
+		if (rest === "CACHED" && steps.has(id)) {
+			cached.add(id);
+			out[steps.get(id)!] += " (cached)";
+		}
+		if (/^\[/.test(rest)) {
+			// BuildKit repeats a step's header when its output resumes after another step's.
+			if (!steps.has(id)) steps.set(id, out.push(cutLine(`#${id} ${rest}`, limits.lineChars)) - 1);
+		} else if (/^ERROR|^error/.test(rest)) out.push(cutLine(l, limits.lineChars));
+		else if (!QUIET.test(rest)) {
+			// `#7 0.512 npm warn …`: the command's own output.
+			const printed = /^[\d.]+(?: (.*))?$/.exec(rest);
+			if (printed && !printed[1]?.trim()) continue;
+			out.push(cutLine(printed ? `   ${printed[1]}` : `#${id} ${rest}`, limits.lineChars));
+		}
+	}
+	const head = buildkit ? [`docker build: ${steps.size} steps${cached.size ? `, ${cached.size} cached` : ""}`] : [];
+	const capped = capLines([...head, ...out], limits.total);
+	return { text: capped.text, truncated: capped.truncated };
+}

package/extensions/core/dust.ts

@@ -0,0 +1,24 @@
+/**
+ * `dust` without the bar chart: the size, the tree and the share stay, the 35 columns of
+ * `█░` bars go.
+ *
+ *    26Mi   ┌── lib                14%
+ *
+ * Strict: a line without the bar column makes it return undefined.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const ROW = /^(\s*\S+\s+.*?)\s*│[█▓▒░ ]+│\s*(\d+%)\s*$/;
+
+export function compactDust(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n").map((l) => l.replace(/^\r\s*\r/, "").replace(/\r$/, ""));
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (lines.length < 3) return undefined;
+	const out: string[] = [];
+	for (const l of lines) {
+		const m = ROW.exec(l);
+		if (!m) return undefined;
+		out.push(`${m[1]}  ${m[2]}`);
+	}
+	return capLines(out, limits.total);
+}

package/extensions/core/elide.ts

@@ -0,0 +1,31 @@
+/** Shared limits and truncation helpers: every cut leaves a visible marker behind. */
+
+export type Limits = {
+	/** Longest line kept whole; longer ones are cut with a note. */
+	lineChars: number;
+	/** Lines kept per file or group. */
+	perGroup: number;
+	/** Lines in the whole result. */
+	total: number;
+};
+
+export const DEFAULT_LIMITS: Limits = { lineChars: 240, perGroup: 15, total: 250 };
+
+export type Squeezed = {
+	text: string;
+	/** True when content was left out (not merely reformatted): the full output is worth saving. */
+	truncated: boolean;
+};
+
+export function cutLine(line: string, max: number): string {
+	if (line.length <= max) return line;
+	return `${line.slice(0, max)}… [+${line.length - max} chars]`;
+}
+
+/** Caps `lines` at `total`, replacing the rest with a one-line marker. */
+export function capLines(lines: string[], total: number): Squeezed {
+	if (lines.length <= total) return { text: lines.join("\n"), truncated: false };
+	const kept = lines.slice(0, total);
+	kept.push(`… [+${lines.length - total} more lines]`);
+	return { text: kept.join("\n"), truncated: true };
+}