pi-squeeze 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sorin Albu-Irimies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,116 @@
-# Temporary Holding Version
+# pi-squeeze
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm](https://img.shields.io/npm/v/pi-squeeze.svg)](https://www.npmjs.com/package/pi-squeeze)
+[![CI](https://github.com/sorinirimies/pi-squeeze/actions/workflows/ci.yml/badge.svg)](https://github.com/sorinirimies/pi-squeeze/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Audit](https://github.com/sorinirimies/pi-squeeze/actions/workflows/security.yml/badge.svg)](https://github.com/sorinirimies/pi-squeeze/actions/workflows/security.yml)
+[![Fuzz](https://github.com/sorinirimies/pi-squeeze/actions/workflows/fuzz.yml/badge.svg)](https://github.com/sorinirimies/pi-squeeze/actions/workflows/fuzz.yml)
+
+Shrinks bash output before it reaches the agent's context: native compactors for git, search, listings, tests, builds (cargo, gradle, Maven, javac, Xcode, tsc, docker), Android (adb, lint, detekt), linters, package installs and logs, plus rtk when installed. Full output stays one temp file away.
+
+A [pi](https://github.com/earendil-works/pi-coding-agent) extension.
+
+## Install
+
+```bash
+pi install npm:pi-squeeze
+```
+
+## What it does
+
+After a `bash` command, pi-squeeze replaces its output with a shorter form with the same facts.
+It only touches output it fully understands, and otherwise passes it through unchanged:
+
+| Command | Becomes |
+|---|---|
+| `rg -n` / `grep -rn` / `ack` | totals line, then matches grouped by file (path written once, indent trimmed, long lines and busy files cut) |
+| `rg pattern dir` / `grep -r` (no `-n`) | the same, but only when every `path:` prefix is a file that exists in the session's directory (a colon in the text is never taken for a path) |
+| `fd`, `find` | paths grouped by directory |
+| `lsd -l`, `eza -l`, `ls -l` | type, size, short date and name (owner, group, permissions and the `total` line dropped) |
+| `git diff` | one header line per file (`path (new, +12 −0)`), `index`/mode/`---`/`+++` lines dropped, every changed line kept, context trimmed to 1 line, long files cut |
+| `cargo test` | totals line, then only warnings, failures, panics and result lines (build progress and passing tests dropped); also when the run failed |
+| `rg -l` / `rg --files` / `grep -l` / `git ls-files` / `git diff --name-only` | paths grouped by directory |
+| `git status` | `## main...origin/main [ahead 2]`, then `staged:` / `unstaged:` / `untracked:` with `M`/`A`/`D`/`R` codes; the hints go |
+| `git log` | one line per commit (short hash, date, author, subject); the body stays, capped at 8 lines; one author is said once |
+| `git show` | that commit line, then the compacted diff |
+| `git blame` | one header per run of lines from the same commit |
+| `dust` | size, tree and share; the bar chart goes |
+| `cargo build` / `check` / `clippy` / `doc` | errors keep their whole block; warnings become one line each, grouped by lint (`clippy::needless_return (2)`); `Compiling`/`Finished` lines go |
+| `cargo audit` | one line per advisory (id, crate, version, kind, title, fix) |
+| `cargo tree`, `tree`, `eza --tree` | cut below 3 levels, `… [+15 lines deeper]` under each cut |
+| `tsc` | errors grouped by file (`a.ts (8)`, `1:7 TS2322 …`) |
+| `gradle`, `./gradlew` | task lines counted (`11 tasks (5 executed, 4 no-source, 2 up-to-date)`); failures, compiler errors, test failures and the `BUILD` line stay; daemon, configuration-cache, JVM and `--scan` chatter goes; reported files lose their shared directory |
+| `bun test`, `go test` | passing tests counted, not listed; failures and totals stay |
+| `pytest` | session header, progress dots and `PASSED` lines go; failures, warnings and the short summary stay; full-width `====` banners shrink |
+| `jest`, `vitest` | passing tests and files go, skipped ones are counted; failures with their diff and frame, and the totals, stay |
+| `xcodebuild`, `swift build` / `test` | build steps (`CompileSwift`, `Ld`, `CodeSign` and their command lines) and progress counted, not listed; warnings grouped by message; errors keep frame and notes; passing XCTest / Swift Testing tests counted; the `** BUILD SUCCEEDED **` line stays |
+| `eslint`, `biome`, `ruff`, `flake8`, `mypy`, `pylint`, `ktlint`, `detekt`, `swiftlint`, `shellcheck`, `flutter analyze` | findings grouped by rule and message, each location once (`error eqeqeq: … (5)` then `m.js:2:46 m1.js:2:47 …`), the shared directory said once; frames and fix suggestions go |
+| `npm` / `pnpm` / `yarn` / `bun install`, `pip install`, `uv sync`, `pod install`, `bundle install`, `flutter pub get` | download and progress lines go; per-package lines become one line (`Collecting (9): requests, rich, …`); deprecation warnings become one list of names; errors and the summary stay |
+| `docker build` | `[internal]` steps, layer downloads, `CACHED` / `DONE` lines go; each step keeps its header and what it printed |
+| `docker logs`, `docker compose logs`, `kubectl logs`, `journalctl`, `adb logcat` (not `-f` / `--follow`) | 3+ lines that differ only in timestamps and numbers keep the first and last; framework stack frames fold; logcat drops the date and thread id; past the limit the start goes, not the end |
+| `gradle` on Android | also: Kotlin / KSP warnings, detekt / ktlint findings and Android Lint issues grouped by message with their locations (lint's source lines, explanations and baseline advice go); repeated warnings and `--warning-mode all` deprecations said once with a count, without the upgrade-guide links; R8 `Missing class` and `Duplicate class` lines become one list of classes; "Searched in the following locations" becomes a count; `A failure occurred while executing …` wrappers go and the failure summary does not repeat what was printed above it; framework frames fold |
+| `gradle tasks`, `gradle projects`, `dependencyInsight`, `dependencies` | tasks: names per group, descriptions go; projects: every path once, grouped by the first segment (`:api (261): …`); insight: the attribute tables go; dependencies: cut like a tree |
+| `mvn`, `./mvnw`, `mvnd` | `Downloading` / `Downloaded` lines and their progress counted; `[INFO]` lines go except the result, the test totals and modules that failed; a passing test class takes its output (Spring banners, logs) with it; errors said once, the `[Help 1]` footer goes; `dependency:tree` is cut like a tree |
+| `javac` | errors keep their source line, caret and `symbol:` / `location:`; warnings grouped by kind (`warning rawtypes: found raw type: List (2)`); `Recompile with -Xlint` notes go |
+| a JVM stack trace from anything (`java -jar`, a test JVM, a log) | framework frames (java., kotlin., android., org.junit., org.springframework.…) fold to `… N framework frames`; the exception, each `Caused by:`, your own frames and `... N more` stay; also when the command failed |
+| `adb exec-out uiautomator dump /dev/tty` | one line per node that says something, indented by nesting, with where to tap: `TextView "Network & internet" #title @375,608`; empty wrappers and off-screen nodes go |
+| `adb shell getprop`, `settings list …` | keys that share a prefix written once, every value kept: `aaudio: hw_burst_min_usec=2000 mmap_policy=2` |
+| `adb shell ps -A`, `top -n 1` | kernel threads and idle processes counted, not listed; column padding goes |
+| `adb shell dumpsys …` | lines deeper than an entry's own go with a count; 3+ lines of the same shape keep their ends |
+| `adb shell pm list packages [-f]` | grouped by the first two name segments; with `-f`, name then path, hashed install directories elided |
+| `adb logcat` (`threadtime`, `time`, `brief`) | as logs above; with `adb -s <serial>` too |
+| `… \| tail -50`, `… \| head -n 20` | the command before the pipe picks the compactor |
+| anything else | colour codes dropped, progress bars (`\r`) keep their last frame, 4+ identical lines become `line  [×N]`, 3+ blank lines become one. Never for `cat`, `head`, `jq`, `curl`… (content commands) |
+| `git`, `cargo`, `docker`… | rewritten through [rtk](https://github.com/rtk-ai/rtk) when it is installed (switch: `/squeeze rtk off`) |
+
+Output with a marker of its own (a `tsc` error list, a gradle or Maven build, `javac` errors, a JVM stack trace, a `uiautomator` dump, a `bun test` run, rustc diagnostics) is recognised whatever ran it: `just check`, `npm run build`, `make test`, `… 2>&1`.
+A **failed** command is compacted too, but only for test and build output, where the errors are the point.
+`git -C dir …`, `git --no-pager …`, `--color=never` and `cargo +nightly …` are read as the plain command.
+
+Safety rules:
+
+* Pipes, redirects, chains and `--json`/`-c`/`-l`/`-x` style flags are never touched: the output is no longer the tool's own format.
+* A line that does not parse makes the whole output pass through.
+* The result must be clearly smaller (under 90%) and the output at least 400 characters.
+* Every cut leaves a marker (`… [+12 more in this file]`), and the full original goes to a temp file whose path is in the output.
+* `read`, `edit` and `write` are never changed.
+
+## Commands
+
+| Command | |
+|---|---|
+| `/squeeze` or `/squeeze status` | the settings and the tokens saved so far |
+| `/squeeze [on\|off]` | switch everything |
+| `/squeeze [search\|paths\|listing\|diff\|tests\|git\|build\|lint\|install\|logs\|tree\|generic] [on\|off]` | switch one compactor |
+| `/squeeze rtk [on\|off]` | rewrite git, cargo, docker… through [rtk](https://github.com/rtk-ai/rtk), when installed |
+| `/squeeze min <chars>` | smallest output worth compacting (default 400) |
+
+Settings are remembered in `<pi agent dir>/squeeze.json` (`PI_CODING_AGENT_DIR`, else `~/.pi/agent`); it also holds
+`lineChars`, `perGroup` and `total`, the limits of a compacted result. `PI_SQUEEZE=off` disables it at start.
+The status line shows the tokens saved.
+
+## Development
+
+```bash
+bun install
+just check   # typecheck + tests (95% coverage gate) + pack check + nu script tests
+just --list  # everything else: fuzz, audit, release, remotes
+```
+
+Layout:
+
+| Path | What |
+|---|---|
+| `extensions/squeeze.ts` | the extension: pure functions plus a thin default export |
+| `tests/` | `bun test`: `core` (pure logic), `extension` (hooks), `fuzz` (randomised properties) |
+| `scripts/` | Nushell only, each with a test in `scripts/tests/` |
+| `.github/`, `.gitea/` | CI, release, nightlies on both hosts |
+
+Releases run in CI: **Actions → Release → Run workflow** with a bump (`patch`, `minor`, `major`, or
+`current` for the version already in `package.json`), or `just release-ci patch`. The workflow runs the
+quality gate, bumps `package.json`, regenerates `CHANGELOG.md` with git-cliff, commits, tags, pushes and
+publishes to npm (secret `NPM_TOKEN`). Locally, `just release patch` does the same up to the tag push.
+
+## License
+
+MIT

package/extensions/command/parse.ts

@@ -0,0 +1,82 @@
+/** `/squeeze ...`: parsing and argument completion. Pure: the handler in squeeze.ts acts on the result. */
+import { KINDS, type Kind } from "../core/compact.ts";
+
+export type Command =
+	| { kind: "status" }
+	| { kind: "on" }
+	| { kind: "off" }
+	| { kind: "compactor"; compactor: Kind; on: boolean }
+	| { kind: "rtk"; on: boolean }
+	| { kind: "min"; chars: number }
+	| { kind: "invalid"; message: string };
+
+
+export const USAGE = `Usage: /squeeze [status] · on · off · ${KINDS.join("|")}|rtk <on|off> · min <chars>`;
+
+export function parseCommand(args: string | undefined): Command {
+	const [cmd, p1] = (args ?? "").trim().toLowerCase().split(/\s+/).filter(Boolean);
+	switch (cmd) {
+		case undefined:
+		case "status":
+			return { kind: "status" };
+		case "on":
+		case "enable":
+			return { kind: "on" };
+		case "off":
+		case "disable":
+			return { kind: "off" };
+		case "min": {
+			const n = Number(p1);
+			return Number.isInteger(n) && n >= 100 && n <= 1_000_000
+				? { kind: "min", chars: n }
+				: { kind: "invalid", message: "Usage: /squeeze min <chars> (100 to 1000000)" };
+		}
+		case "rtk":
+			return p1 === "on" || p1 === "off" ? { kind: "rtk", on: p1 === "on" } : { kind: "invalid", message: "Usage: /squeeze rtk <on|off>" };
+		default:
+			if ((KINDS as readonly string[]).includes(cmd)) {
+				return p1 === "on" || p1 === "off"
+					? { kind: "compactor", compactor: cmd as Kind, on: p1 === "on" }
+					: { kind: "invalid", message: `Usage: /squeeze ${cmd} <on|off>` };
+			}
+			return { kind: "invalid", message: `Unknown option "${cmd}". ${USAGE}` };
+	}
+}
+
+export interface CompletionItem {
+	value: string;
+	/** Required by pi: it calls `label.endsWith(...)` when applying a completion. */
+	label: string;
+	description?: string;
+}
+
+const TOP_LEVEL: CompletionItem[] = [
+	{ value: "status", label: "status", description: "Show the settings and the savings" },
+	{ value: "on", label: "on", description: "Turn pi-squeeze on" },
+	{ value: "off", label: "off", description: "Turn it off (nothing is compacted)" },
+	{ value: "search ", label: "search", description: "rg / grep results grouped by file (on or off)" },
+	{ value: "paths ", label: "paths", description: "fd / find results grouped by directory (on or off)" },
+	{ value: "listing ", label: "listing", description: "lsd / eza -l listings (on or off)" },
+	{ value: "diff ", label: "diff", description: "git diff with trimmed context (on or off)" },
+	{ value: "tests ", label: "tests", description: "cargo test without build noise and passing tests (on or off)" },
+	{ value: "git ", label: "git", description: "git status, log, show and blame, shorter (on or off)" },
+	{ value: "build ", label: "build", description: "cargo build/clippy/audit, tsc and gradle, errors kept and warnings grouped (on or off)" },
+	{ value: "tree ", label: "tree", description: "cargo tree, tree and eza --tree cut below a depth (on or off)" },
+	{ value: "generic ", label: "generic", description: "ANSI codes, progress frames and repeated lines in any output (on or off)" },
+	{ value: "rtk ", label: "rtk", description: "Rewrite git, cargo, docker… through rtk, when installed (on or off)" },
+	{ value: "min ", label: "min", description: "Smallest output to compact, in characters" },
+];
+
+/** `prefix` is the whole argument text typed so far (pi replaces it with `value`). */
+export function completions(prefix: string): CompletionItem[] | null {
+	const text = (prefix ?? "").toLowerCase().replace(/^\s+/, "");
+	const kind = [...KINDS, "rtk"].find((k) => text.startsWith(`${k} `));
+	const pool: CompletionItem[] = kind
+		? [
+				{ value: `${kind} on`, label: "on", description: kind === "rtk" ? "Rewrite commands through rtk" : `Compact ${kind} output` },
+				{ value: `${kind} off`, label: "off", description: kind === "rtk" ? "Run commands as written" : `Leave ${kind} output alone` },
+			]
+		: TOP_LEVEL;
+	const out = pool.filter((i) => i.value.startsWith(text));
+	return out.length > 0 ? out : null;
+}

package/extensions/core/adb.ts

@@ -0,0 +1,231 @@
+/**
+ * `adb shell pm list packages`: the `package:` prefix goes and names are grouped by their
+ * first two segments, each name still complete once its group is read:
+ *
+ *   com.google.android (3): apps.messaging gms gsf
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+import { shape } from "./logs.ts";
+
+export function compactPackages(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n").map((l) => l.trimEnd());
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.length || !lines.every((l) => /^package:[\w.]+$/.test(l))) return undefined;
+	const groups = new Map<string, string[]>();
+	for (const l of lines.map((l) => l.slice("package:".length)).sort()) {
+		const parts = l.split(".");
+		const key = parts.length > 2 ? parts.slice(0, 2).join(".") : "";
+		groups.set(key, [...(groups.get(key) ?? []), key ? parts.slice(2).join(".") : l]);
+	}
+	const out = [`${lines.length} packages`];
+	// A group line may run long: it is still one line of names, cut only far past the usual width.
+	const width = limits.lineChars * 8;
+	let cut = false;
+	for (const [key, names] of groups) {
+		const line = key ? `${key} (${names.length}): ${names.join(" ")}` : names.join(" ");
+		cut ||= line.length > width;
+		out.push(cutLine(line, width));
+	}
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: cut || capped.truncated };
+}
+
+/** `adb shell pm list packages -f`: `package:/path/base.apk=name` → `name  /path`, hashed install dirs elided. */
+export function compactPackagePaths(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n").map((l) => l.trimEnd());
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const rows = lines.map((l) => /^package:(\/\S+)=([\w.]+)$/.exec(l));
+	if (!rows.length || rows.some((r) => !r)) return undefined;
+	const out = rows
+		.map((r) => `${r![2]}  ${r![1]!.replace(/\/~~[^/]+==\/[\w.]+-[^/]+==\//, "/…/")}`)
+		.sort()
+		.map((l) => cutLine(l, limits.lineChars));
+	const capped = capLines([`${rows.length} packages`, ...out], limits.total);
+	return { text: capped.text, truncated: capped.truncated };
+}
+
+/** A value as `key=value` shows it: quoted when empty or holding spaces. */
+const shown = (v: string) => (v === "" || /\s/.test(v) ? JSON.stringify(v) : v);
+
+/**
+ * Properties and settings (`adb shell getprop`, `settings list global|secure|system`):
+ * keys that share a prefix are written once, values all kept:
+ *
+ *   ro.build: version.release=16 version.sdk=36 type=user
+ */
+export function compactProperties(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const raw = output.split("\n").map((l) => l.trimEnd());
+	while (raw.length && raw.at(-1) === "") raw.pop();
+	// A getprop value may span lines: they belong to the `[key]: [` line above.
+	const lines: string[] = [];
+	for (const l of raw) {
+		if (lines.length && /^\[[^\]]+\]: \[/.test(lines.at(-1)!) && !/\]$/.test(lines.at(-1)!)) lines[lines.length - 1] += `\\n${l}`;
+		else lines.push(l);
+	}
+	if (lines.length < 5) return undefined;
+	const getprop = lines.every((l) => /^\[[^\]]+\]: \[.*\]$/.test(l));
+	const pairs = lines.map((l) => (getprop ? /^\[([^\]]+)\]: \[(.*)\]$/.exec(l) : /^([\w.:-]+)=(.*)$/.exec(l)));
+	if (pairs.some((p) => !p)) return undefined;
+	const sep = getprop ? "." : "_";
+	const groups = new Map<string, string[]>();
+	for (const p of pairs) {
+		const key = p![1]!;
+		// getprop keys group by their first two segments (`ro.build`), settings by the first word.
+		const parts = key.split(sep);
+		const n = Math.min(getprop ? 2 : 1, parts.length - 1);
+		const [head, tail] = n > 0 && parts[0] ? [parts.slice(0, n).join(sep), parts.slice(n).join(sep)] : ["", key];
+		groups.set(head, [...(groups.get(head) ?? []), `${tail}=${shown(p![2]!)}`]);
+	}
+	let cut = false;
+	const out: string[] = [];
+	const item = (i: string) => {
+		cut ||= i.length > limits.lineChars;
+		return cutLine(i, limits.lineChars);
+	};
+	for (const [head, items] of groups) {
+		if (!head || items.length === 1) {
+			out.push(...items.map((i) => item(head ? `${head}${sep}${i}` : i)));
+			continue;
+		}
+		// Long groups wrap rather than lose values: a new line repeats the prefix.
+		let line = `${head}:`;
+		for (const i of items.map(item)) {
+			if (line.length + i.length + 1 > limits.lineChars * 2 && line !== `${head}:`) (out.push(line), (line = `${head}:`));
+			line += ` ${i}`;
+		}
+		out.push(line);
+	}
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: cut || capped.truncated };
+}
+
+/**
+ * Process lists (`adb shell ps -A`, `adb shell top -n 1`): kernel threads (no memory of their
+ * own) and idle rows of `top` are counted, not listed; column padding goes.
+ */
+export function compactProcesses(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n").map((l) => l.trimEnd());
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const header = lines.findIndex((l) => /^\s*(?:USER\s+PID\s+PPID|PID\s+USER\s+PR\s+NI)\b/.test(l));
+	if (header < 0 || lines.length - header < 5) return undefined;
+	const cols = lines[header]!.trim().split(/\s+/);
+	const ps = cols[0] === "USER";
+	const vsz = cols.indexOf("VSZ");
+	const cpu = cols.findIndex((c) => /%CPU/.test(c));
+	let hidden = 0;
+	const rows: string[] = [];
+	for (const l of lines.slice(header + 1)) {
+		const f = l.trim().split(/\s+/);
+		// ps: kernel threads have no virtual memory; top: rows that used no CPU.
+		const idle = ps ? f[vsz] === "0" : Number(f[cpu + (cols[cpu] === "S[%CPU]" ? 1 : 0)]) === 0;
+		if (idle) hidden++;
+		else rows.push(cutLine(f.join(" "), limits.lineChars));
+	}
+	const squeeze = (l: string) => l.trim().replace(/\s{2,}/g, " ");
+	const out = [...lines.slice(0, header).map(squeeze), squeeze(lines[header]!), ...rows];
+	if (hidden) out.push(`… ${hidden} ${ps ? "kernel threads" : "idle processes"} not listed`);
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: hidden > 0 || capped.truncated };
+}
+
+/** Indent deeper than this goes in a dumpsys report (sections, then their entries, stay). */
+const DUMPSYS_DEPTH = 8;
+
+/**
+ * `adb shell dumpsys …`: lines indented deeper than an entry's own line go (with a count),
+ * runs of 3+ lines of the same shape keep their ends, and long reports are capped.
+ */
+export function compactDumpsys(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n").map((l) => l.trimEnd());
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (lines.length < 20) return undefined;
+	const out: string[] = [];
+	let deeper = 0;
+	const flush = () => {
+		if (deeper) out.push(`${" ".repeat(DUMPSYS_DEPTH + 2)}… [+${deeper} deeper lines]`);
+		deeper = 0;
+	};
+	for (const l of lines) {
+		if (l.length - l.trimStart().length > DUMPSYS_DEPTH) {
+			deeper++;
+			continue;
+		}
+		flush();
+		out.push(l);
+	}
+	flush();
+	const runs: string[] = [];
+	for (let i = 0; i < out.length; ) {
+		const s = shape(out[i]!);
+		let j = i + 1;
+		while (j < out.length && shape(out[j]!) === s) j++;
+		runs.push(...(j - i >= 3 ? [out[i]!, `${out[i]!.match(/^\s*/)![0]}… [${j - i - 2} similar]`, out[j - 1]!] : out.slice(i, j)));
+		i = j;
+	}
+	const capped = capLines(
+		runs.map((l) => cutLine(l, limits.lineChars)),
+		limits.total,
+	);
+	return { text: capped.text, truncated: true };
+}
+
+const ENTITY: Record<string, string> = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+const unescape = (s: string) => s.replace(/&(amp|lt|gt|quot|apos|#(\d+));/g, (_, e: string, n?: string) => (n ? String.fromCodePoint(Number(n)) : ENTITY[e]!));
+
+/**
+ * `uiautomator dump` XML (`adb exec-out uiautomator dump /dev/tty`): one line per node that
+ * says something (text, description, id, or something to tap), indented by nesting, with its
+ * centre to tap at; empty wrappers and off-screen nodes go.
+ *
+ *   Button "OK" #ok click @540,1820
+ */
+export function compactUiDump(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	if (!/<hierarchy\b/.test(output)) return undefined;
+	const out: string[] = [];
+	/** For every open node: did it print (and so indent its children)? */
+	const open: boolean[] = [];
+	let nodes = 0;
+	for (const m of output.matchAll(/<node\b([^>]*?)(\/?)>|<\/node>/g)) {
+		if (!m[1] && !m[2] && m[0] === "</node>") {
+			open.pop();
+			continue;
+		}
+		nodes++;
+		const a: Record<string, string> = {};
+		for (const [, k, v] of m[1]!.matchAll(/([\w-]+)="([^"]*)"/g)) a[k!] = unescape(v!);
+		const b = /^\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]$/.exec(a.bounds ?? "");
+		const [x1, y1, x2, y2] = (b ?? []).slice(1).map(Number) as number[];
+		const visible = !!b && x2! > x1! && y2! > y1!;
+		const id = (a["resource-id"] ?? "").replace(/^.*:id\//, "");
+		const flags = [
+			a.clickable === "true" && "click",
+			a["long-clickable"] === "true" && "long-click",
+			a.scrollable === "true" && "scroll",
+			a.checkable === "true" && (a.checked === "true" ? "checked" : "unchecked"),
+			a.selected === "true" && "selected",
+			a.focused === "true" && "focused",
+			a.enabled === "false" && "disabled",
+			a.password === "true" && "password",
+		].filter(Boolean);
+		// An id alone names a leaf worth finding (an icon, an input); on a container it is layout.
+		const says = visible && (a.text || a["content-desc"] || a.hint || flags.length || (id && m[2]));
+		if (says) {
+			const depth = open.filter(Boolean).length;
+			const parts = [
+				(a.class ?? "").split(".").pop(),
+				a.text && JSON.stringify(a.text),
+				a["content-desc"] && `desc=${JSON.stringify(a["content-desc"])}`,
+				a.hint && `hint=${JSON.stringify(a.hint)}`,
+				id && `#${id}`,
+				...flags,
+				`@${Math.round((x1! + x2!) / 2)},${Math.round((y1! + y2!) / 2)}`,
+			].filter(Boolean);
+			out.push(cutLine(`${"  ".repeat(depth)}${parts.join(" ")}`, limits.lineChars));
+		}
+		if (!m[2]) open.push(!!says);
+	}
+	if (!nodes) return undefined;
+	const pkg = /package="([^"]+)"/.exec(output)?.[1];
+	const capped = capLines([`ui: ${out.length} of ${nodes} nodes${pkg ? ` (${pkg})` : ""}`, ...out], limits.total);
+	return { text: capped.text, truncated: true };
+}

package/extensions/core/audit.ts

@@ -0,0 +1,53 @@
+/**
+ * `cargo audit` advisories, one line each:
+ *
+ *   RUSTSEC-2025-0141 bincode 1.3.3 unmaintained: Bincode is unmaintained  (fix: upgrade to >=1.3.4)
+ *
+ * The dependency-tree dump under a vulnerability, the date and the URL go. Strict: a block
+ * without an `ID:` line makes it return undefined.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const FIELD = /^([A-Z][A-Za-z ]*?):\s+(.*)$/;
+
+export function compactAudit(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	const head: string[] = [];
+	const rows: string[] = [];
+	const tail: string[] = [];
+	let fields: Record<string, string> | undefined;
+	let inTree = false;
+	const finish = () => {
+		if (!fields) return true;
+		const f = fields;
+		fields = undefined;
+		if (!f.ID || !f.Crate) return false;
+		const kind = f.Warning ?? (f.Severity ? `vulnerability (${f.Severity})` : "vulnerability");
+		rows.push(cutLine(`${f.ID} ${f.Crate} ${f.Version ?? ""} ${kind}: ${f.Title ?? ""}${f.Solution ? `  (fix: ${f.Solution})` : ""}`, limits.lineChars));
+		return true;
+	};
+	for (const l of lines) {
+		if (l === "") {
+			inTree = false;
+			if (!finish()) return undefined;
+			continue;
+		}
+		if (fields && l.startsWith("Dependency tree:")) {
+			inTree = true;
+			continue;
+		}
+		const m = FIELD.exec(l);
+		if (m && m[1] === "Crate") {
+			if (!finish()) return undefined;
+			fields = { Crate: m[2]! };
+		} else if (fields && m && !inTree) {
+			fields[m[1]!] = m[2]!;
+		} else if (fields) {
+			if (!inTree) return undefined;
+		} else if (rows.length || /^(warning|error): \d+ /.test(l)) tail.push(l);
+		else head.push(l);
+	}
+	if (!finish() || !rows.length) return undefined;
+	const scanned = head.find((l) => /^\s+Scanning /.test(l));
+	return capLines([...(scanned ? [scanned.trim()] : []), `${rows.length} advisories`, ...rows, ...tail], limits.total);
+}

package/extensions/core/blame.ts

@@ -0,0 +1,32 @@
+/**
+ * `git blame` with one header per run of lines from the same commit:
+ *
+ *   bd6a3dd4 Sorin Albu-Irimies 2026-10-16
+ *     1: # Dodai UI
+ *     2:
+ *
+ * Strict: a line that is not in the default blame format returns undefined.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const ROW = /^(\^?[0-9a-f]{6,40}) (?:\S+ +)?\((.+?) +(\d{4}-\d\d-\d\d) \d\d:\d\d:\d\d [+-]\d{4} +(\d+)\) ?(.*)$/;
+
+export function compactBlame(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.length) return undefined;
+	const out: string[] = [];
+	let last = "";
+	for (const l of lines) {
+		const m = ROW.exec(l);
+		if (!m) return undefined;
+		const [, hash, author, date, no, text] = m;
+		const key = `${hash} ${author} ${date}`;
+		if (key !== last) {
+			out.push(key);
+			last = key;
+		}
+		out.push(cutLine(`  ${no}: ${text}`, limits.lineChars));
+	}
+	return capLines(out, limits.total);
+}

package/extensions/core/command.ts

@@ -0,0 +1,86 @@
+/**
+ * Reads a bash command line just far enough to know which program ran and with which
+ * arguments. Anything that reshapes the output (pipes, redirects, chains, substitution)
+ * makes it return undefined: the output is then not in the program's own format and
+ * must pass through untouched.
+ */
+
+export type Invocation = { program: string; args: string[] };
+
+const OPERATOR = /[|;&<>`]|\$\(/;
+
+/** Split on whitespace, honouring single/double quotes and backslash escapes. */
+export function tokenize(line: string): string[] | undefined {
+	const out: string[] = [];
+	let cur = "";
+	let has = false;
+	let quote: "'" | '"' | undefined;
+	for (let i = 0; i < line.length; i++) {
+		const c = line[i]!;
+		if (quote) {
+			if (c === quote) quote = undefined;
+			else if (c === "\\" && quote === '"' && i + 1 < line.length) cur += line[++i];
+			else cur += c;
+		} else if (c === "'" || c === '"') {
+			quote = c;
+			has = true;
+		} else if (c === "\\" && i + 1 < line.length) {
+			cur += line[++i];
+			has = true;
+		} else if (/\s/.test(c)) {
+			if (has || cur) out.push(cur);
+			cur = "";
+			has = false;
+		} else {
+			cur += c;
+			has = true;
+		}
+	}
+	if (quote) return undefined;
+	if (has || cur) out.push(cur);
+	return out;
+}
+
+/** True when `text` contains a shell operator outside quotes. */
+export function hasOperator(text: string): boolean {
+	let quote: "'" | '"' | undefined;
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i]!;
+		if (quote) {
+			if (c === quote) quote = undefined;
+			else if (c === "\\" && quote === '"') i++;
+			else if (quote === '"' && (c === "`" || (c === "$" && text[i + 1] === "("))) return true;
+		} else if (c === "'" || c === '"') quote = c;
+		else if (c === "\\") i++;
+		else if (OPERATOR.test(c === "$" ? text.slice(i, i + 2) : c)) return true;
+	}
+	return false;
+}
+
+/** Drop a leading `cd <dir> &&`, which only sets the working directory. */
+export function stripCd(command: string): string {
+	return command.replace(/^\s*cd\s+(?:"[^"]*"|'[^']*'|[^\s;&|]+)\s*&&\s*/, "");
+}
+
+/** The single simple command a line runs, or undefined when it is anything more. */
+export function parse(command: string): Invocation | undefined {
+	// `2>&1` only merges the streams, which is how pi shows them anyway.
+	const line = stripCd(command).replace(/\s+2>&1\s*$/, "").trim();
+	if (!line || hasOperator(line)) return undefined;
+	const words = tokenize(line);
+	if (!words) return undefined;
+	while (words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[0]!)) words.shift();
+	const first = words.shift();
+	if (!first) return undefined;
+	return { program: first.split("/").pop()!, args: words };
+}
+
+/** Does a short or long flag appear in `args` (also inside combined short flags like -rn)? */
+export function hasFlag(args: string[], long: string[], short: string[] = []): boolean {
+	for (const a of args) {
+		if (a === "--") return false;
+		if (long.includes(a) || long.some((l) => a.startsWith(`${l}=`))) return true;
+		if (/^-[A-Za-z]+$/.test(a) && short.some((s) => a.includes(s))) return true;
+	}
+	return false;
+}