pi-compact-tools 0.13.1 → 0.14.0

package/extensions/compact-tools-release.ts

@@ -1,14 +1,36 @@
 import { closeSync, mkdirSync, openSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { DynamicBorder, getAgentDir, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
-import { Spacer, Text } from "@earendil-works/pi-tui";
+import { DynamicBorder, getAgentDir, getMarkdownTheme, type ExtensionContext, type Theme } from "@earendil-works/pi-coding-agent";
+import { Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 
 /** One marker file per version shown, so two Pi processes can't both show it. */
 const NOTICE_DIRECTORY = "compact-tools-notices";
 const WIDGET_KEY = "compact-tools-release-notes";
 const VERSION = /^(\d+)\.(\d+)\.(\d+)$/;
 
-export type ReleaseNotes = Record<string, readonly string[]>;
+/** The headings a version's notes are grouped under, in the order they are shown. */
+export const RELEASE_SECTIONS = ["New", "Fix", "Deprecated"] as const;
+export type ReleaseSection = (typeof RELEASE_SECTIONS)[number];
+/** A version's notes: grouped under New, Fix, and Deprecated, or, as older versions have them, a plain list. */
+export type ReleaseEntry = readonly string[] | Partial<Record<ReleaseSection, readonly string[]>>;
+export type ReleaseNotes = Record<string, ReleaseEntry>;
+
+/**
+ * A version's notes as Markdown, the way Pi's own changelog reads: a `### New`
+ * heading over each group's `- ` items, or the items alone for a plain list.
+ */
+export function releaseMarkdown(entry: ReleaseEntry): string {
+	return releaseSections(entry)
+		.map(({ title, notes }) => [...(title ? [`### ${title}`, ""] : []), ...notes.map((note) => `- ${note}`)].join("\n"))
+		.join("\n\n");
+}
+
+/** A version's notes as the groups they are shown in: a heading for each section with notes, none for a plain list. */
+export function releaseSections(entry: ReleaseEntry): Array<{ title?: ReleaseSection; notes: readonly string[] }> {
+	if (Array.isArray(entry)) return entry.length > 0 ? [{ notes: entry }] : [];
+	const sections = entry as Partial<Record<ReleaseSection, readonly string[]>>;
+	return RELEASE_SECTIONS.flatMap((title) => sections[title]?.length ? [{ title, notes: sections[title]! }] : []);
+}
 
 type Chat = { children: unknown[]; addChild(component: unknown): void };
 
@@ -49,12 +71,12 @@ export function releasesToShow(
 	installed: string,
 	notes: ReleaseNotes,
 	lastShown: string | undefined,
-): Array<{ version: string; notes: readonly string[] }> {
+): Array<{ version: string; notes: ReleaseEntry }> {
 	const withNotes = Object.keys(notes)
 		.filter((version) =>
 			VERSION.test(version)
 			&& compareVersions(version, installed) <= 0
-			&& notes[version]!.length > 0)
+			&& releaseSections(notes[version]!).length > 0)
 		.sort((left, right) => compareVersions(right, left));
 	const versions = lastShown === undefined
 		? withNotes.slice(0, 1)
@@ -88,7 +110,8 @@ function addReleaseBlock(chat: Chat, theme: Theme, releases: ReturnType<typeof r
 		if (index > 0) chat.addChild(new Spacer(1));
 		chat.addChild(new Text(theme.bold(theme.fg("accent", `What's new in pi-compact-tools v${version}`)), 1, 0));
 		chat.addChild(new Spacer(1));
-		chat.addChild(new Text(notes.map((note) => theme.fg("dim", `• ${note}`)).join("\n"), 1, 0));
+		// Drawn as Pi draws its own changelog, so the headings and items look the same.
+		chat.addChild(new Markdown(releaseMarkdown(notes), 1, 0, getMarkdownTheme()));
 	});
 	chat.addChild(new DynamicBorder(border));
 }
@@ -131,7 +154,7 @@ export function showReleaseNotice(
 	ctx.ui.setWidget(WIDGET_KEY, undefined, { placement: "belowEditor" });
 	if (!shown) {
 		const text = releases.map(({ version: shownVersion, notes: shownNotes }) =>
-			`pi-compact-tools v${shownVersion}\n${shownNotes.map((note) => `  • ${note}`).join("\n")}`).join("\n");
+			`pi-compact-tools v${shownVersion}\n\n${releaseMarkdown(shownNotes)}`).join("\n\n");
 		ctx.ui.notify(text, "info");
 	}
 	return true;

package/extensions/compact-tools-runtime.ts

@@ -207,12 +207,14 @@ export class ToolRuntime {
 	 */
 	noteExecutionStart(toolCallId: string): void {
 		if (!this.executionTimings.has(toolCallId)) this.executionTimings.set(toolCallId, { startedAt: Date.now() });
+		this.trimTimings();
 	}
 
 	noteExecutionEnd(toolCallId: string): void {
 		const timing = this.executionTimings.get(toolCallId) ?? { startedAt: Date.now() };
 		timing.endedAt ??= Date.now();
 		this.executionTimings.set(toolCallId, timing);
+		this.trimTimings();
 	}
 
 	createTimedExecute(definition: BuiltInDefinition): TimedExecute {
@@ -222,6 +224,7 @@ export class ToolRuntime {
 			const startedAt = (toolCallId ? this.executionTimings.get(toolCallId)?.startedAt : undefined) ?? Date.now();
 			if (toolCallId && !this.executionTimings.has(toolCallId)) {
 				this.executionTimings.set(toolCallId, { startedAt });
+				this.trimTimings();
 			}
 			try {
 				return await execute.apply(definition, args);
@@ -295,7 +298,20 @@ export class ToolRuntime {
 		timing.startedAt = state.startedAt;
 		if (state.endedAt !== undefined) timing.endedAt = state.endedAt;
 		this.executionTimings.set(toolCallId, timing);
+		this.trimTimings();
+	}
+
+	/** Bound every insertion, including calls never drawn (for example in silent mode). */
+	private trimTimings(): void {
 		if (this.executionTimings.size <= MAX_TRACKED_ROWS) return;
+		// Prefer settled calls so a long-running sibling keeps its start time. If all
+		// 2,001 calls are active, retain the original FIFO fallback to stay bounded.
+		for (const [id, timing] of this.executionTimings) {
+			if (timing.endedAt !== undefined) {
+				this.executionTimings.delete(id);
+				return;
+			}
+		}
 		const oldest = this.executionTimings.keys().next().value;
 		if (oldest !== undefined) this.executionTimings.delete(oldest);
 	}

package/extensions/compact-tools-shell.ts

@@ -0,0 +1,277 @@
+/**
+ * Shell commands as both summary styles read them: split into words the way the
+ * shell would, and checked for anything that writes or runs something else. A row
+ * that folds into a "looked around" group hides its command, so a command that
+ * changes the disk must never pass for one that only reads it.
+ */
+
+/** A redirection and where it points: `>`, `2>`, `&>`, `>&` with `1`, `<`. */
+export type Redirect = { operator: string; target: string };
+
+/** One command between connectors: its words, and the redirections written into it. */
+export type ShellCommand = { words: string[]; redirects: Redirect[] };
+
+export type ParsedShell = {
+	commands: ShellCommand[];
+	/** `$(…)`, backticks, `<(…)`, a subshell, or a background job: what runs there cannot be read off the words. */
+	opaque: boolean;
+};
+
+const CONNECTORS = ["&&", "||", "|&", "|", ";"];
+const REDIRECTS = ["&>>", "&>", ">>", ">&", ">|", "<>", "<&", ">", "<"];
+
+/**
+ * Split a command the way the shell does: quotes removed, a quoted `;` or newline
+ * kept as text, and connectors, newlines outside quotes, and redirections kept
+ * apart from words. Undefined when it cannot be split: an unterminated quote, or a
+ * here-document whose body would read as commands.
+ */
+export function parseShell(source: string): ParsedShell | undefined {
+	const commands: ShellCommand[] = [{ words: [], redirects: [] }];
+	let opaque = false;
+	let word = "";
+	let started = false;
+	let redirect: string | undefined;
+	const current = () => commands[commands.length - 1]!;
+	const flush = () => {
+		if (!started) return;
+		if (redirect !== undefined) {
+			current().redirects.push({ operator: redirect, target: word });
+			redirect = undefined;
+		} else {
+			current().words.push(word);
+		}
+		word = "";
+		started = false;
+	};
+	const connect = () => {
+		flush();
+		if (redirect !== undefined) return false;
+		if (current().words.length > 0 || current().redirects.length > 0) commands.push({ words: [], redirects: [] });
+		return true;
+	};
+	for (let index = 0; index < source.length; index++) {
+		const character = source[index]!;
+		if (character === "'") {
+			const end = source.indexOf("'", index + 1);
+			if (end < 0) return undefined;
+			word += source.slice(index + 1, end);
+			started = true;
+			index = end;
+			continue;
+		}
+		if (character === "\"") {
+			let end = index + 1;
+			for (; end < source.length && source[end] !== "\""; end++) {
+				const inner = source[end]!;
+				if (inner === "\\" && end + 1 < source.length && "\"\\$`\n".includes(source[end + 1]!)) {
+					if (source[end + 1] !== "\n") word += source[end + 1];
+					end++;
+				} else {
+					if (inner === "`" || (inner === "$" && source[end + 1] === "(")) opaque = true;
+					word += inner;
+				}
+			}
+			if (end >= source.length) return undefined;
+			started = true;
+			index = end;
+			continue;
+		}
+		if (character === "\\") {
+			// A backslash before a newline joins the lines; before anything else it quotes it.
+			if (source[index + 1] !== "\n" && index + 1 < source.length) {
+				word += source[index + 1];
+				started = true;
+			}
+			index++;
+			continue;
+		}
+		if (character === " " || character === "\t") {
+			flush();
+			continue;
+		}
+		if (character === "\n") {
+			if (!connect()) return undefined;
+			continue;
+		}
+		if (character === "#" && !started) {
+			const end = source.indexOf("\n", index);
+			index = end < 0 ? source.length : end - 1;
+			continue;
+		}
+		if (character === "`" || (character === "$" && source[index + 1] === "(")) {
+			opaque = true;
+			word += character;
+			started = true;
+			continue;
+		}
+		const rest = source.slice(index);
+		if (rest.startsWith("<<")) return undefined;
+		if ((character === "<" || character === ">") && source[index + 1] === "(") {
+			opaque = true;
+			word += character;
+			started = true;
+			continue;
+		}
+		const redirection = REDIRECTS.find((operator) => rest.startsWith(operator));
+		if (redirection) {
+			// A word of digits right before it names the descriptor: `2>`.
+			const descriptor = started && /^\d+$/u.test(word) ? word : "";
+			if (descriptor) {
+				word = "";
+				started = false;
+			}
+			flush();
+			if (redirect !== undefined) return undefined;
+			redirect = descriptor + redirection;
+			index += redirection.length - 1;
+			continue;
+		}
+		const connector = CONNECTORS.find((operator) => rest.startsWith(operator));
+		if (connector) {
+			if (!connect()) return undefined;
+			index += connector.length - 1;
+			continue;
+		}
+		if (character === "&" || character === "(" || character === ")") {
+			opaque = true;
+			if (!connect()) return undefined;
+			continue;
+		}
+		word += character;
+		started = true;
+	}
+	flush();
+	if (redirect !== undefined) return undefined;
+	return { commands: commands.filter((command) => command.words.length > 0 || command.redirects.length > 0), opaque };
+}
+
+/** Whether a redirection only discards output or joins two streams, rather than reading or writing a file. */
+export function isHarmlessRedirect({ operator, target }: Redirect): boolean {
+	if (/[>&]&$/u.test(operator) || operator.endsWith("<&")) return /^(?:\d+|-)$/u.test(target);
+	return operator.includes(">") && target === "/dev/null";
+}
+
+const FIND_ACTIONS = new Set(["-delete", "-exec", "-execdir", "-ok", "-okdir", "-fprint", "-fprint0", "-fprintf", "-fls"]);
+
+function shortFlag(arg: string, letter: string): boolean {
+	return /^-[^-]/u.test(arg) && arg.slice(1).includes(letter);
+}
+
+function operandCount(args: readonly string[]): number {
+	return args.filter((arg) => !arg.startsWith("-") || arg === "-").length;
+}
+
+/**
+ * sed scripts given with -e, or the first operand when there is none. A short option
+ * takes its value from the rest of its word or the next one: `-e'w out'`, `-ne 'w out'`.
+ */
+function sedScripts(args: readonly string[]): string[] | undefined {
+	const scripts: string[] = [];
+	const operands: string[] = [];
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index]!;
+		if (arg === "--expression") scripts.push(args[++index] ?? "");
+		else if (arg.startsWith("--expression=")) scripts.push(arg.slice("--expression=".length));
+		// A script read from a file cannot be checked.
+		else if (arg === "--file" || arg.startsWith("--file=")) return undefined;
+		else if (/^-[^-]/u.test(arg)) {
+			// A cluster of single-letter options; e and f take what follows them.
+			for (let position = 1; position < arg.length; position++) {
+				const letter = arg[position];
+				if (letter === "f") return undefined;
+				if (letter !== "e") continue;
+				scripts.push(position + 1 < arg.length ? arg.slice(position + 1) : args[++index] ?? "");
+				break;
+			}
+		} else if (!arg.startsWith("-")) operands.push(arg);
+	}
+	if (scripts.length === 0 && operands[0] !== undefined) scripts.push(operands[0]);
+	return scripts;
+}
+
+/** Whether one sed command writes a file or runs one: `w`, `W`, `e`, or an `s` with the w or e flag. */
+function sedCommandWrites(command: string): boolean {
+	// Past the address: line numbers, `$`, `/regex/` ranges, and `!`.
+	const body = command.replace(/^\s*(?:(?:\d+|\$|\/(?:\\.|[^/])*\/)\s*(?:[,~]\s*(?:\d+|\$|\/(?:\\.|[^/])*\/))?\s*!?\s*)?/u, "");
+	const verb = body[0];
+	if (verb === "w" || verb === "W" || verb === "e") return true;
+	if (verb !== "s" || body.length < 2) return false;
+	const delimiter = body[1]!;
+	let seen = 0;
+	let index = 2;
+	for (; index < body.length && seen < 2; index++) {
+		if (body[index] === "\\") index++;
+		else if (body[index] === delimiter) seen++;
+	}
+	return /^[^;}\s]*[we]/u.test(body.slice(index));
+}
+
+function sedWrites(args: readonly string[]): boolean {
+	// An i before any e or f in a cluster is the in-place flag; after one it belongs to the script.
+	const inPlace = (arg: string) => /^-[^-ef]*i/u.test(arg);
+	if (args.some((arg) => arg === "--in-place" || arg.startsWith("--in-place=") || inPlace(arg))) return true;
+	const scripts = sedScripts(args);
+	if (!scripts) return true;
+	return scripts.some((script) => script.split(/[;\n]/u).some(sedCommandWrites));
+}
+
+/** awk can print into files and pipes and run commands; a program it reads from a file cannot be checked. */
+function awkWrites(args: readonly string[]): boolean {
+	let program: string | undefined;
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index]!;
+		if (arg === "-f" || arg.startsWith("--file")) return true;
+		if (arg === "-v" || arg === "-F") index++;
+		else if (!arg.startsWith("-")) {
+			program = arg;
+			break;
+		}
+	}
+	return program === undefined || /system\s*\(|[|>]/u.test(program);
+}
+
+/** An option given alone or with its value attached: `--pager`, `--pager=less`. */
+function hasOption(args: readonly string[], ...names: string[]): boolean {
+	return args.some((arg) => names.some((name) => arg === name || arg.startsWith(`${name}=`)));
+}
+
+/**
+ * Whether a command can change files or run another program, though the program it
+ * names usually only reads: `find -delete`, `fd -x`, `rg --pre`, a pager it is told
+ * to run, `sort -o`, an in-place or writing `sed`, an `awk` that prints to a file,
+ * and `xargs` and `tee`, which exist to run and to write.
+ */
+export function writesOrRuns(words: readonly string[]): boolean {
+	const [program, ...args] = words;
+	switch (program) {
+		case "git": {
+			// `git grep -O` opens its matches in a pager it runs; an option before the subcommand can set one.
+			const [sub, ...rest] = args;
+			if (sub !== "grep") return sub?.startsWith("-") === true;
+			return rest.some((arg) => /^-[^-]*O/u.test(arg)) || hasOption(rest, "--open-files-in-pager");
+		}
+		case "ag": case "ack": case "pt": case "bat": case "batcat":
+			return hasOption(args, "--pager");
+		case "xargs": case "tee":
+			return true;
+		case "find":
+			return args.some((arg) => FIND_ACTIONS.has(arg));
+		case "fd": case "fdfind":
+			return args.some((arg) => arg === "-x" || arg === "-X" || /^--exec(?:-batch)?(?:=|$)/u.test(arg));
+		case "rg":
+			return hasOption(args, "--pre", "--hostname-bin");
+		case "sort":
+			return args.some((arg) => arg.startsWith("--output") || arg.startsWith("--compress-program") || shortFlag(arg, "o"));
+		case "uniq":
+			return operandCount(args) >= 2;
+		case "tree":
+			return args.some((arg) => arg === "-o" || arg.startsWith("--output"));
+		case "sed":
+			return sedWrites(args);
+		case "awk": case "gawk": case "mawk": case "nawk":
+			return awkWrites(args);
+		default:
+			return false;
+	}
+}

package/extensions/compact-tools-silent.ts

@@ -274,8 +274,11 @@ export class SilentModeController {
 		pi.registerCommand("silent", {
 			description: `(${SILENT_SHORTCUT}) Show only prompts and final answers`,
 			getArgumentCompletions: (prefix) => {
+				// Pi applies a shown completion on Enter instead of running the command, so a value
+				// already typed in full is not offered again: Enter then runs it the first time.
+				const typed = prefix.trim().toLowerCase();
 				const items = COMMAND_ARGUMENTS
-					.filter((value) => value.startsWith(prefix.trim().toLowerCase()))
+					.filter((value) => value.startsWith(typed) && value !== typed)
 					.map((value) => ({ value, label: value }));
 				return items.length > 0 ? items : null;
 			},

package/extensions/compact-tools-types.ts

@@ -10,8 +10,8 @@ export type BuiltInDefinition = ToolDefinition<any, any, any>;
 
 export const DISPLAY_MODES = ["normal", "silent"] as const;
 export type DisplayMode = (typeof DISPLAY_MODES)[number];
-/** How tool rows are drawn: compactly, the way Claude Code draws them, or by Pi itself. */
-export const DISPLAY_STYLES = ["compact", "claude", "off"] as const;
+/** How tool rows are drawn: compactly, the way Claude Code or Codex draws them, or by Pi itself. */
+export const DISPLAY_STYLES = ["compact", "claude", "codex", "off"] as const;
 export type DisplayStyle = (typeof DISPLAY_STYLES)[number];
 
 export interface CustomToolsConfig {
@@ -50,6 +50,14 @@ export interface RowState {
 	lastResultPreview?: boolean;
 	lastResultError?: boolean;
 	lastResultConfigRevision?: object;
+	lastResultPalette?: object;
+	/** What a Codex row's head reads from its result: a command's exit code, an edit's counts. */
+	codex?: {
+		exitCode?: number;
+		changes?: { added: number; removed: number };
+		/** Whether the row draws opened at a width: Codex opens only a call whose preview leaves something out. */
+		opens?: (width: number) => boolean;
+	};
 }
 
 type BaseRenderContext = Parameters<NonNullable<BuiltInDefinition["renderCall"]>>[2];

package/extensions/compact-tools-viewport.ts

@@ -89,17 +89,15 @@ export function findAnchorTop(
 		else starts.set(line, [index]);
 	});
 	const bottom = Math.min(before.length, top + Math.max(1, height));
-	const candidates: number[] = [];
-	for (let row = top; row < bottom; row++) candidates.push(row);
-	for (let row = top - 1; row >= 0; row--) candidates.push(row);
-	for (const row of candidates) {
-		const window = before.slice(row, row + ANCHOR_LINES);
-		if (window.length < ANCHOR_LINES || !window.some(hasText)) continue;
+	// Visit the viewport first, then preceding rows, without copying candidate windows.
+	for (let candidate = 0; candidate < bottom; candidate++) {
+		const row = candidate < bottom - top ? top + candidate : bottom - candidate - 1;
+		if (row + ANCHOR_LINES > before.length || (!hasText(before[row]) && !hasText(before[row + 1]))) continue;
 		// Several places can match a short window; the one that keeps matching for
 		// longest is the same text, and distance only breaks a remaining tie.
 		let best: number | undefined;
 		let bestRun = 0;
-		for (const start of starts.get(window[0]!) ?? []) {
+		for (const start of starts.get(before[row]!) ?? []) {
 			const run = matchingRun(before, row, after, start, TIE_BREAK_LINES);
 			if (run < ANCHOR_LINES) continue;
 			if (best === undefined || run > bestRun