pi-squeeze 0.0.0-stage → 0.1.0

package/extensions/core/rg.ts

@@ -0,0 +1,126 @@
+/**
+ * `rg -n` / `grep -n` output (`path:line:text`, context lines `path-line-text`) grouped by
+ * file, so each path is written once instead of on every match:
+ *
+ *   src/a.ts (3)
+ *     12: const x = 1;
+ *     13- context
+ *
+ * Without line numbers (`rg pattern dir`, `path:text`) the path cannot be told from text that
+ * has a colon, so `compactRgPlain` only groups when every path is a file that exists.
+ *
+ * Strict: when any line is not in that format (`--heading`, `-c`, `-l`, `--json`) it returns
+ * undefined and the output passes through unchanged.
+ */
+import { cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+type Row = { path: string; line: number; sep: ":" | "-"; text: string };
+
+const MATCH = /^(.+?):(\d+):(.*)$/;
+
+export function parseRows(output: string): Row[] | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.length) return undefined;
+	const rows: Row[] = [];
+	const files = new Set<string>();
+	const pending: { index: number; raw: string }[] = [];
+	for (const raw of lines) {
+		if (raw === "--") continue;
+		const m = MATCH.exec(raw);
+		if (m) {
+			if (m[1]!.includes(":")) return undefined; // `12:foo:3:bar` is single-file output, not a path
+			files.add(m[1]!);
+			rows.push({ path: m[1]!, line: Number(m[2]), sep: ":", text: m[3]! });
+		} else {
+			pending.push({ index: rows.length, raw });
+			rows.push(undefined as unknown as Row);
+		}
+	}
+	if (!files.size) return undefined;
+	// Context lines (`path-line-text`) only count for files that also had a real match.
+	for (const { index, raw } of pending) {
+		let row: Row | undefined;
+		for (const path of files) {
+			if (!raw.startsWith(`${path}-`)) continue;
+			const m = /^(\d+)-(.*)$/.exec(raw.slice(path.length + 1));
+			if (m) {
+				row = { path, line: Number(m[1]), sep: "-", text: m[2]! };
+				break;
+			}
+		}
+		if (!row) return undefined;
+		rows[index] = row;
+	}
+	return rows;
+}
+
+/** At most this many distinct paths are looked up on disk. */
+const MAX_LOOKUPS = 500;
+
+/** `path:text` rows (no line numbers), or undefined unless every path is an existing file. */
+export function parsePlainRows(output: string, isFile: (path: string) => boolean): Row[] | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (!lines.length) return undefined;
+	const known = new Map<string, boolean>();
+	const rows: Row[] = [];
+	for (const raw of lines) {
+		const at = raw.indexOf(":");
+		if (at <= 0) return undefined;
+		const path = raw.slice(0, at);
+		let ok = known.get(path);
+		if (ok === undefined) {
+			if (known.size >= MAX_LOOKUPS) return undefined;
+			ok = isFile(path);
+			known.set(path, ok);
+		}
+		if (!ok) return undefined;
+		rows.push({ path, line: 0, sep: ":", text: raw.slice(at + 1) });
+	}
+	return rows;
+}
+
+export function compactRg(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const rows = parseRows(output);
+	return rows && render(rows, limits);
+}
+
+export function compactRgPlain(output: string, limits: Limits, isFile: (path: string) => boolean): Squeezed | undefined {
+	const rows = parsePlainRows(output, isFile);
+	return rows && render(rows, limits);
+}
+
+function render(rows: Row[], limits: Limits): Squeezed {
+	const groups = new Map<string, Row[]>();
+	for (const r of rows) {
+		const g = groups.get(r.path);
+		if (g) g.push(r);
+		else groups.set(r.path, [r]);
+	}
+	const matchCount = rows.filter((r) => r.sep === ":").length;
+	const out: string[] = [`${matchCount} matches in ${groups.size} file${groups.size === 1 ? "" : "s"}`];
+	let truncated = false;
+	let hiddenFiles = 0;
+	for (const [path, list] of groups) {
+		if (out.length >= limits.total) {
+			hiddenFiles++;
+			truncated = true;
+			continue;
+		}
+		const matches = list.filter((r) => r.sep === ":").length;
+		out.push(`${path} (${matches})`);
+		let shown = 0;
+		for (const r of list) {
+			if (shown >= limits.perGroup) break;
+			out.push(`  ${r.line ? `${r.line}${r.sep} ` : ""}${cutLine(r.text.trim(), limits.lineChars)}`);
+			shown++;
+		}
+		if (list.length > shown) {
+			out.push(`  … [+${list.length - shown} more in this file]`);
+			truncated = true;
+		}
+	}
+	if (hiddenFiles) out.push(`… [+${hiddenFiles} more files]`);
+	return { text: out.join("\n"), truncated };
+}

package/extensions/core/rtk.ts

@@ -0,0 +1,50 @@
+/**
+ * The optional rtk layer: commands that have no native compactor here (git, cargo, docker, …) are
+ * rewritten to their `rtk` form, which prints a compact output itself.
+ *
+ * `rtk rewrite <command>` is the single source of truth for what rtk can take over. Exit 0 and 3
+ * mean "rewritten" (3: the host should ask for approval, pi has no such step); 1 means no rewrite
+ * and 2 a deny. Never rewritten: what a native compactor handles (its output format is ours to
+ * parse) and file reads (`rtk read` may drop lines, and a read must stay exact).
+ */
+import { spawnSync } from "node:child_process";
+import { handles } from "./compact.ts";
+
+export type Run = (command: string) => { status: number | null; stdout: string; missing?: boolean };
+
+const spawnRun: Run = (command) => {
+	const r = spawnSync("rtk", ["rewrite", command], { encoding: "utf8", timeout: 2000 });
+	return { status: r.status, stdout: r.stdout ?? "", missing: (r.error as NodeJS.ErrnoException | undefined)?.code === "ENOENT" };
+};
+
+let run: Run = spawnRun;
+/** For tests: replace the process runner (no argument restores it). */
+export const useRunner = (r: Run = spawnRun): void => {
+	run = r;
+};
+
+const cache = new Map<string, string | undefined>();
+const CACHE_MAX = 500;
+let missing = false;
+
+/** The command to run instead of `command`, or undefined to run it as written. */
+export function rewrite(command: string): string | undefined {
+	if (missing || command.trim() === "" || handles(command)) return undefined;
+	if (cache.has(command)) return cache.get(command);
+	const r = run(command);
+	if (r.missing) {
+		missing = true;
+		return undefined;
+	}
+	const out = r.stdout.trim();
+	const rewritten = (r.status === 0 || r.status === 3) && out !== "" && out !== command && !/^rtk read\b/.test(out) ? out : undefined;
+	if (cache.size >= CACHE_MAX) cache.clear();
+	cache.set(command, rewritten);
+	return rewritten;
+}
+
+/** For tests: forget what was learned (the cache and a missing binary). */
+export function resetRtk(): void {
+	cache.clear();
+	missing = false;
+}

package/extensions/core/runners.ts

@@ -0,0 +1,50 @@
+/**
+ * Test runners other than cargo: `bun test` and `go test`. Passing tests are counted, not
+ * listed; failures (with their source frame and message), skips and the totals stay.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+/** `(pass) name [1ms]` lines go, and a file header left with nothing under it goes too. */
+export function compactBunTest(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) => /^Ran \d+ tests? across \d+ files?\./.test(l))) return undefined;
+	const kept: string[] = [];
+	for (const l of lines) {
+		if (/^\(pass\) /.test(l)) continue;
+		// The file header (`path.test.ts:`) is only worth keeping when something stayed under it.
+		if (l === "" && (kept.length === 0 || kept.at(-1) === "")) continue;
+		kept.push(l);
+	}
+	const out: string[] = [];
+	for (let i = 0; i < kept.length; i++) {
+		const header = /^\S+\.(test|spec)\.\w+:$/.test(kept[i]!);
+		const empty = kept[i + 1] === undefined || kept[i + 1] === "" || /^\S+\.(test|spec)\.\w+:$/.test(kept[i + 1]!);
+		if (header && empty) continue;
+		out.push(kept[i]!);
+	}
+	const tidy = out.filter((l, i) => !(l === "" && (i === 0 || out[i - 1] === "")));
+	return capLines(tidy, limits.total);
+}
+
+/** `ok pkg 0.3s`, `? pkg [no test files]` and `PASS` collapse into one count line; `=== RUN` and `--- PASS` go. */
+export function compactGoTest(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	let ok = 0;
+	let failed = 0;
+	let none = 0;
+	const kept: string[] = [];
+	for (const l of lines) {
+		if (/^ok\s+\S+/.test(l)) ok++;
+		else if (/^\?\s+\S+\s+\[no test files\]$/.test(l)) none++;
+		else if (/^(FAIL)\s+\S+(\s|$)/.test(l) && /\s\d/.test(l)) {
+			failed++;
+			kept.push(l);
+		} else if (/^(=== (RUN|PAUSE|CONT|NAME)|\s*--- PASS:|PASS$)/.test(l)) continue;
+		else kept.push(l);
+	}
+	if (!ok && !failed && !none) return undefined;
+	const parts = [`${ok} ok`, `${failed} failed`, ...(none ? [`${none} without tests`] : [])];
+	return capLines([`go test: ${parts.join(", ")}`, ...kept], limits.total);
+}

package/extensions/core/rustc.ts

@@ -0,0 +1,99 @@
+/**
+ * `cargo build` / `check` / `clippy` output. Errors keep their full block (they are why you
+ * ran the command); warnings shrink to one line each, grouped by lint:
+ *
+ *   clippy::needless_return (2)
+ *     src/lib.rs:2:55 unneeded `return` statement
+ *
+ * Build progress (`Compiling`, `Checking`, `Finished`) goes, an identical warning reported
+ * for several targets is listed once, and the summary lines stay.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const PROGRESS = /^\s+(Compiling|Checking|Downloaded|Downloading|Updating|Locking|Fresh|Blocking|Adding|Building|Documenting|Finished|Fixed|Generated) /;
+const HEAD = /^(warning|error)(?:\[(E\d+)\])?: (.*)$/;
+const WHERE = /^\s*--> (.+?:\d+:\d+)$/;
+const ERROR_LINES = 40;
+
+type Diag = { level: "warning" | "error"; code: string; message: string; where: string; lint: string; help: string; block: string[] };
+
+function lintOf(block: string[]): string {
+	for (const l of block) {
+		const a = /#\[(?:warn|deny|forbid)\(([\w:]+)\)\]/.exec(l);
+		if (a) return a[1]!;
+		const b = /rust-clippy\/[^#]*#(\w+)$/.exec(l);
+		if (b) return `clippy::${b[1]}`;
+	}
+	return "other";
+}
+
+function parseBlock(block: string[]): Diag | undefined {
+	const h = HEAD.exec(block[0] ?? "");
+	const w = block.map((l) => WHERE.exec(l)).find(Boolean);
+	if (!h || !w) return undefined;
+	const help = block.map((l) => /\^+ help: (.*)$/.exec(l)).find(Boolean)?.[1] ?? "";
+	return { level: h[1] as Diag["level"], code: h[2] ?? "", message: h[3]!, where: w[1]!, lint: lintOf(block), help, block };
+}
+
+export function compactRustc(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const blocks: string[][] = [[]];
+	for (const l of lines) {
+		if (PROGRESS.test(l)) continue;
+		if (l === "") blocks.push([]);
+		else blocks.at(-1)!.push(l);
+	}
+	const diags: Diag[] = [];
+	const other: string[] = [];
+	let seen = false;
+	const order: (Diag | string)[] = [];
+	for (const b of blocks) {
+		if (!b.length) continue;
+		const d = parseBlock(b);
+		if (d) {
+			seen = true;
+			diags.push(d);
+			order.push(d);
+		} else {
+			other.push(...b);
+			order.push(b.join("\n"));
+		}
+	}
+	if (!seen) return undefined;
+
+	const errors = diags.filter((d) => d.level === "error");
+	const warnings = new Map<string, Map<string, string>>();
+	for (const d of diags) {
+		if (d.level !== "warning") continue;
+		const group = warnings.get(d.lint) ?? new Map<string, string>();
+		warnings.set(d.lint, group);
+		group.set(`${d.where} ${d.message}`, cutLine(`  ${d.where} ${d.message}${d.help ? ` → ${d.help}` : ""}`, limits.lineChars));
+	}
+	const out: string[] = [];
+	const count = [...warnings.values()].reduce((n, g) => n + g.size, 0);
+	out.push(`${errors.length} error${errors.length === 1 ? "" : "s"}, ${count} warning${count === 1 ? "" : "s"}`);
+	let cut = false;
+	for (const e of errors) {
+		out.push("", ...e.block.slice(0, ERROR_LINES).map((l) => cutLine(l, limits.lineChars)));
+		if (e.block.length > ERROR_LINES) {
+			out.push(`  … [+${e.block.length - ERROR_LINES} more lines]`);
+			cut = true;
+		}
+	}
+	if (errors.length && warnings.size) out.push("");
+	for (const [lint, group] of warnings) {
+		out.push(`${lint} (${group.size})`);
+		const entries = [...group.values()];
+		out.push(...entries.slice(0, limits.perGroup));
+		if (entries.length > limits.perGroup) {
+			out.push(`  … [+${entries.length - limits.perGroup} more]`);
+			cut = true;
+		}
+	}
+	// Whatever is not a diagnostic (summaries, `error: could not compile`, notes) stays as it was.
+	const rest = other.filter((l) => l !== "");
+	if (rest.length) out.push("", ...rest);
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: cut || capped.truncated };
+}

package/extensions/core/save.ts

@@ -0,0 +1,11 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/** Writes the untouched output to a temp file so a truncated result can be recovered. */
+export function saveFull(text: string, dir = join(tmpdir(), "pi-squeeze")): string {
+	mkdirSync(dir, { recursive: true });
+	const path = join(dir, `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}.txt`);
+	writeFileSync(path, text);
+	return path;
+}

package/extensions/core/stats.ts

@@ -0,0 +1,31 @@
+import { KINDS, type Kind, type Result } from "./compact.ts";
+
+export type Stats = { calls: number; before: number; after: number; byKind: Record<Kind, { calls: number; saved: number }> };
+
+export function emptyStats(): Stats {
+	return { calls: 0, before: 0, after: 0, byKind: Object.fromEntries(KINDS.map((k) => [k, { calls: 0, saved: 0 }])) as Stats["byKind"] };
+}
+
+export function record(stats: Stats, r: Result): void {
+	stats.calls++;
+	stats.before += r.before;
+	stats.after += r.after;
+	stats.byKind[r.kind].calls++;
+	stats.byKind[r.kind].saved += r.before - r.after;
+}
+
+/** Characters saved so far. */
+export const saved = (s: Stats): number => s.before - s.after;
+
+/** Rough token estimate: 4 characters per token. */
+export const tokens = (chars: number): number => Math.round(chars / 4);
+
+export function summary(stats: Stats): string {
+	if (!stats.calls) return "squeeze: nothing compacted yet in this session";
+	const pct = Math.round((saved(stats) / stats.before) * 100);
+	const kinds = (Object.entries(stats.byKind) as [Kind, { calls: number; saved: number }][])
+		.filter(([, v]) => v.calls)
+		.map(([k, v]) => `${k} ${v.calls}× (~${tokens(v.saved)} tokens)`)
+		.join(", ");
+	return `squeeze: ${stats.calls} outputs compacted, ~${tokens(saved(stats))} tokens saved (${pct}%): ${kinds}`;
+}

package/extensions/core/tests.ts

@@ -0,0 +1,46 @@
+/**
+ * `cargo test` output: the build progress, the `test … ok` lines and the `running N tests`
+ * headers go; warnings, failures, panics, `Running …` and `test result` lines stay. A one-line
+ * summary of the totals comes first.
+ */
+import { capLines, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const PROGRESS = /^\s+(Compiling|Downloaded|Downloading|Updating|Locking|Fresh|Blocking|Adding|Packaging|Checking|Building|Finished) /;
+const OK = /^test .* \.\.\. (ok|ignored)(, .*)?$/;
+const RUNNING_N = /^running \d+ tests?$/;
+const RESULT = /^test result: (ok|FAILED)\. (\d+) passed; (\d+) failed; (\d+) ignored;/;
+
+export function compactTests(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	let passed = 0;
+	let failed = 0;
+	let ignored = 0;
+	let binaries = 0;
+	let sawProgress = false;
+	let inFailures = false;
+	const kept: string[] = [];
+	for (const l of lines) {
+		const r = RESULT.exec(l);
+		if (r) {
+			binaries++;
+			passed += Number(r[2]);
+			failed += Number(r[3]);
+			ignored += Number(r[4]);
+		}
+		if (l === "failures:") inFailures = true;
+		if (r) inFailures = false;
+		if (PROGRESS.test(l)) {
+			sawProgress = true;
+			continue;
+		}
+		if (OK.test(l) || RUNNING_N.test(l)) continue;
+		const run = /^(\s+Running .*?) \(target\/.*\)$/.exec(l);
+		const text = run ? run[1]! : l;
+		// Blank lines only separate blocks: they stay only inside the failure report, where they separate panics.
+		if (text === "" && !inFailures) continue;
+		kept.push(text);
+	}
+	if (binaries === 0 && !sawProgress) return undefined;
+	const head = binaries ? [`cargo test: ${passed} passed, ${failed} failed, ${ignored} ignored (${binaries} test binar${binaries === 1 ? "y" : "ies"})`] : [];
+	return capLines([...head, ...kept], limits.total);
+}

package/extensions/core/tree.ts

@@ -0,0 +1,44 @@
+/**
+ * Tree output (`cargo tree`, `tree`, `eza --tree`) cut below a depth, with a marker that says
+ * how many lines were left out under each cut:
+ *
+ *   ├── ratatui v0.30.2
+ *   │   ├── instability v0.3.14 (proc-macro)
+ *   │   │   ├── darling v0.24.1
+ *               … [+15 lines deeper]
+ *
+ * A cut of a single line is not worth a marker and is left in.
+ */
+import { cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const PREFIX = /^((?:│   |    )*)/;
+const BRANCH = /^(?:│   |    )*(?:├── |└── )/;
+
+/** Levels kept below the root. */
+const DEPTH = 3;
+
+export function compactTree(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	if (lines.length < 5 || !lines.some((l) => BRANCH.test(l))) return undefined;
+	const out: string[] = [];
+	let hidden: string[] = [];
+	const flush = () => {
+		if (hidden.length === 1) out.push(cutLine(hidden[0]!, limits.lineChars));
+		else if (hidden.length) out.push(`${"    ".repeat(DEPTH)}… [+${hidden.length} lines deeper]`);
+		hidden = [];
+	};
+	for (const l of lines) {
+		const units = PREFIX.exec(l)![1]!.length / 4;
+		const depth = BRANCH.test(l) || units > 0 ? units + 1 : 0;
+		if (depth > DEPTH) {
+			hidden.push(l);
+			continue;
+		}
+		flush();
+		out.push(cutLine(l, limits.lineChars));
+	}
+	flush();
+	if (out.length >= lines.length) return undefined;
+	return { text: out.join("\n"), truncated: true };
+}

package/extensions/core/tsc.ts

@@ -0,0 +1,49 @@
+/**
+ * `tsc` (plain, not `--pretty`) errors grouped by file:
+ *
+ *   a.ts (8)
+ *     1:7 TS2322 Type 'string' is not assignable to type 'number'.
+ *
+ * Continuation lines (indented) stay with their error. The `Found N errors` footer stays.
+ */
+import { capLines, cutLine, DEFAULT_LIMITS, type Limits, type Squeezed } from "./elide.ts";
+
+const ERROR = /^(.+?)\((\d+),(\d+)\): (error|warning) (TS\d+): (.*)$/;
+const FOOTER = /^Found \d+ errors?( in \d+ files?)?\.?$|^Errors +Files$|^ +\d+ +\S.*$/;
+
+export function compactTsc(output: string, limits: Limits = DEFAULT_LIMITS): Squeezed | undefined {
+	const lines = output.split("\n");
+	while (lines.length && lines.at(-1) === "") lines.pop();
+	const files = new Map<string, string[]>();
+	const tail: string[] = [];
+	let current: string[] | undefined;
+	let errors = 0;
+	for (const l of lines) {
+		const m = ERROR.exec(l);
+		if (m) {
+			errors++;
+			current = files.get(m[1]!) ?? [];
+			files.set(m[1]!, current);
+			current.push(cutLine(`  ${m[2]}:${m[3]} ${m[4] === "warning" ? "warning " : ""}${m[5]} ${m[6]}`, limits.lineChars));
+		} else if (/^\s+\S/.test(l) && current && !tail.length) current.push(cutLine(`    ${l.trim()}`, limits.lineChars));
+		else if (l === "" || FOOTER.test(l)) {
+			tail.push(l);
+			current = undefined;
+		} else return undefined;
+	}
+	if (!errors) return undefined;
+	const out = [`tsc: ${errors} error${errors === 1 ? "" : "s"} in ${files.size} file${files.size === 1 ? "" : "s"}`];
+	let cut = false;
+	for (const [file, entries] of files) {
+		out.push(`${file} (${entries.filter((e) => !e.startsWith("    ")).length})`);
+		out.push(...entries.slice(0, limits.perGroup * 2));
+		if (entries.length > limits.perGroup * 2) {
+			out.push(`  … [+${entries.length - limits.perGroup * 2} more lines]`);
+			cut = true;
+		}
+	}
+	const footer = tail.filter((l) => l !== "");
+	if (footer.length) out.push("", ...footer);
+	const capped = capLines(out, limits.total);
+	return { text: capped.text, truncated: cut || capped.truncated };
+}

package/extensions/squeeze.ts

@@ -0,0 +1,111 @@
+/**
+ * pi-squeeze: Squeezes tool output so the agent's context stays small.
+ *
+ * Pure logic lives in core/ and command/ (tested directly); this file only wires it to pi.
+ * Output is only ever replaced when the result is clearly smaller, and a truncated result
+ * says where the full output was saved. Settings persist in <agent dir>/squeeze.json.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { completions, parseCommand } from "./command/parse.ts";
+import { compact, KINDS } from "./core/compact.ts";
+import { type Config, DEFAULT_CONFIG, optionsOf, readConfig, saveConfig } from "./core/config.ts";
+import { rewrite } from "./core/rtk.ts";
+import { fileIn } from "./core/files.ts";
+import { saveFull } from "./core/save.ts";
+import { emptyStats, record, saved, summary, tokens } from "./core/stats.ts";
+
+type StatusUi = { ui: { setStatus(key: string, text: string): void } };
+
+export const settingsText = (c: Config): string =>
+	[c.enabled ? "on" : "off", `rtk ${c.rtk ? "on" : "off"}`, ...KINDS.map((k) => `${k} ${c.kinds[k] ? "on" : "off"}`), `min ${c.minChars} chars`].join(" · ");
+
+export default function (pi: ExtensionAPI) {
+	let config: Config = { ...DEFAULT_CONFIG, kinds: { ...DEFAULT_CONFIG.kinds } };
+	const stats = emptyStats();
+	if (process.env.PI_SQUEEZE === "off") config.enabled = false;
+
+	const showStatus = (ctx: StatusUi) => {
+		const n = tokens(saved(stats));
+		ctx.ui.setStatus("squeeze", config.enabled && config.showStatus && n > 0 ? `squeeze: ~${n >= 1000 ? `${(n / 1000).toFixed(1)}k` : n} tokens saved` : "");
+	};
+
+	pi.on("session_start", async (_event, ctx) => {
+		const { config: loaded, problem } = await readConfig();
+		config = loaded;
+		if (process.env.PI_SQUEEZE === "off") config.enabled = false;
+		if (problem) ctx.ui.notify(`squeeze: ${problem}; using the defaults`, "warning");
+		showStatus(ctx);
+	});
+
+	pi.on("tool_call", async (event) => {
+		if (!config.enabled || !config.rtk || event.toolName !== "bash") return;
+		const input = event.input as { command?: unknown };
+		if (typeof input.command !== "string") return;
+		const rewritten = rewrite(input.command);
+		if (rewritten) input.command = rewritten;
+	});
+
+	pi.on("tool_result", async (event, ctx) => {
+		if (!config.enabled || event.toolName !== "bash") return;
+		const command = (event.input as { command?: unknown }).command;
+		if (typeof command !== "string") return;
+		// pi already truncated this one: its text is not the tool's own format any more.
+		if ((event.details as { truncation?: unknown } | undefined)?.truncation) return;
+		const blocks = event.content;
+		if (blocks.length !== 1 || blocks[0]!.type !== "text") return;
+		const original = blocks[0]!.text;
+
+		const r = compact(command, original, { ...optionsOf(config), failed: event.isError, isFile: fileIn(ctx.cwd) });
+		if (!r) return;
+		record(stats, r);
+		showStatus(ctx);
+		const text = r.truncated ? `${r.text}\n[squeeze: output shortened; full output: ${saveFull(original)}]` : r.text;
+		return { content: [{ type: "text", text }] };
+	});
+
+	pi.registerCommand("squeeze", {
+		description: "pi-squeeze: status, on, off, <compactor>|rtk on|off, min <chars>",
+		getArgumentCompletions: (prefix: string) => completions(prefix),
+		handler: async (args, ctx) => {
+			const cmd = parseCommand(args);
+			// The setting applies to this session either way; a failed save only means it is not remembered.
+			const persist = async () => {
+				try {
+					await saveConfig(config);
+				} catch (error) {
+					ctx.ui.notify(`squeeze: could not save the setting (${(error as Error)?.message ?? String(error)}); it applies to this session only`, "warning");
+				}
+				showStatus(ctx);
+			};
+			switch (cmd.kind) {
+				case "status":
+					ctx.ui.notify(`squeeze ${settingsText(config)}\n${summary(stats)}`, "info");
+					return;
+				case "on":
+				case "off":
+					config.enabled = cmd.kind === "on";
+					await persist();
+					ctx.ui.notify(`squeeze ${cmd.kind}`, "info");
+					return;
+				case "rtk":
+					config.rtk = cmd.on;
+					await persist();
+					ctx.ui.notify(`squeeze: rtk ${cmd.on ? "on" : "off"}`, "info");
+					return;
+				case "compactor":
+					config.kinds[cmd.compactor] = cmd.on;
+					await persist();
+					ctx.ui.notify(`squeeze: ${cmd.compactor} ${cmd.on ? "on" : "off"}`, "info");
+					return;
+				case "min":
+					config.minChars = cmd.chars;
+					await persist();
+					ctx.ui.notify(`squeeze: output under ${cmd.chars} characters is left alone`, "info");
+					return;
+				case "invalid":
+					ctx.ui.notify(cmd.message, "warning");
+					return;
+			}
+		},
+	});
+}

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "pi-squeeze",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Shrinks bash output before it reaches the agent's context: native compactors for git, cargo, rg, ls, test and build output, plus rtk when installed. Full output stays one temp file away.",
+  "keywords": ["pi-package", "pi-extension", "pi", "tokens", "context", "compaction", "rtk"],
+  "license": "MIT",
+  "author": "Sorin Albu-Irimies",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sorinirimies/pi-squeeze.git"
+  },
+  "homepage": "https://github.com/sorinirimies/pi-squeeze#readme",
+  "files": ["extensions", "README.md", "LICENSE"],
+  "pi": {
+    "extensions": ["./extensions/squeeze.ts"]
+  },
+  "scripts": {
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "check": "nu scripts/ci/quality_gate.nu"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "overrides": {
+    "undici": "8.12.3",
+    "minimatch": "11.0.3"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^1.4.0",
+    "@types/bun": "^1.4.4",
+    "typescript": "^7.0.2"
+  }
+}