pi-compact-tools 0.13.1 → 0.14.0

package/extensions/compact-tools-codex.ts

@@ -0,0 +1,453 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences, visibleWidth } from "@earendil-works/pi-tui";
+import { normalizeLineEndings } from "./compact-tools-core.ts";
+import { parseShell, writesOrRuns } from "./compact-tools-shell.ts";
+import type { ToolArgs } from "./compact-tools-types.ts";
+
+/** Rows Codex shows of a call's output, its last ones, before offering the rest. */
+export const CODEX_PREVIEW_ROWS = 3;
+/**
+ * Codex 0.160.0's chrome: `• Ran …`, then `  └ ` under the bullet with the output two
+ * columns after it, and every later row four columns in. Pi draws every row one column
+ * in, so each prefix keeps that geometry one column further right.
+ */
+export const CODEX_RESULT_PREFIX = "   └ ";
+export const CODEX_INDENT = "     ";
+/** Where an opened command's wrapped lines continue, four columns past the `$`. */
+export const CODEX_COMMAND_INDENT = "     ";
+/** The left margin every Codex row starts after. */
+export const CODEX_MARGIN = " ";
+export const CODEX_BULLET = "•";
+/** Codex draws a tab as four columns. */
+export const CODEX_TAB = "    ";
+/** Codex's key is ctrl+t; in Pi the key that opens a row is ctrl+o. */
+export const CODEX_EXPAND_KEY = "ctrl+o";
+
+/** How Codex prints how long a call took: `250ms`, `1.50s`, `1m 15s`. */
+export function formatCodexDuration(milliseconds: number): string {
+	const millis = Math.max(0, Math.floor(milliseconds));
+	if (millis < 1000) return `${millis}ms`;
+	if (millis < 60_000) return `${(millis / 1000).toFixed(2)}s`;
+	const seconds = Math.floor((millis % 60_000) / 1000);
+	return `${Math.floor(millis / 60_000)}m ${String(seconds).padStart(2, "0")}s`;
+}
+
+/**
+ * The control under a collapsed or opened call. Codex starts it at a quarter of the
+ * width, at most four columns in, and drops the key hint when the row cannot fit it.
+ */
+export function codexDisclosure(width: number, expanded: boolean, hiddenLines?: number): string {
+	const indent = CODEX_MARGIN + " ".repeat(Math.min(Math.floor(width / 4), 4));
+	if (expanded) return `${indent}− Show less`;
+	if (hiddenLines === undefined) return `${indent}+ Show details`;
+	const label = `+ ${hiddenLines} ${hiddenLines === 1 ? "line" : "lines"}`;
+	const hint = ` (${CODEX_EXPAND_KEY} to expand)`;
+	return visibleWidth(indent + label + hint) <= width ? indent + label + hint : indent + label;
+}
+
+/**
+ * The last path segment, as Codex names files in its exploration lines; `src`, `dist`,
+ * `build`, and `node_modules` say nothing about the file and are skipped.
+ */
+export function shortDisplayPath(path: string): string {
+	const trimmed = path.replace(/\\/gu, "/").replace(/\/+$/u, "");
+	const parts = trimmed.split("/").reverse()
+		.filter((part) => part && part !== "build" && part !== "dist" && part !== "node_modules" && part !== "src");
+	return parts[0] ?? trimmed;
+}
+
+/** One thing an exploration call does, the way Codex parses it out of the command. */
+export type ExploreAction =
+	| { kind: "read"; name: string }
+	| { kind: "search"; query?: string; path?: string; command: string }
+	| { kind: "list"; path?: string; command: string };
+
+/** Operands, skipping flags and the values the given flags take. */
+function operands(args: readonly string[], flagsWithValues: readonly string[] = []): string[] {
+	const out: string[] = [];
+	let afterDashes = false;
+	for (let index = 0; index < args.length; index++) {
+		const arg = args[index]!;
+		if (afterDashes) {
+			out.push(arg);
+		} else if (arg === "--") {
+			afterDashes = true;
+		} else if (arg.startsWith("--") && arg.includes("=")) {
+			continue;
+		} else if (flagsWithValues.includes(arg)) {
+			index++;
+		} else if (!arg.startsWith("-")) {
+			out.push(arg);
+		}
+	}
+	return out;
+}
+
+const digits = (value: string | undefined) => value !== undefined && /^\d+$/u.test(value);
+const signedDigits = (value: string | undefined) => value !== undefined && /^\+?\d+$/u.test(value);
+
+function isSedRange(value: string | undefined): boolean {
+	return value !== undefined && /^\d+(?:,\d+)?p$/u.test(value);
+}
+
+function sedReadPath(args: readonly string[]): string | undefined {
+	if (args.some((arg) => arg === "-i" || arg.startsWith("-i") || arg === "--in-place") || !args.includes("-n")) return undefined;
+	let range = false;
+	for (let index = 0; index < args.length; index++) {
+		if (args[index] === "-e" || args[index] === "--expression") {
+			if (isSedRange(args[index + 1])) range = true;
+			index++;
+		}
+	}
+	if (!range) range = args.some((arg) => !arg.startsWith("-") && isSedRange(arg));
+	if (!range) return undefined;
+	const rest = operands(args, ["-e", "-f", "--expression", "--file"]);
+	if (rest.length === 0) return undefined;
+	return isSedRange(rest[0]) ? rest[1] : rest[0];
+}
+
+/** Commands that only reshape another's output, which Codex leaves out of a pipeline's summary. */
+function isFormatting(words: readonly string[]): boolean {
+	const [program, ...args] = words;
+	switch (program) {
+		// Codex counts xargs and tee as formatting too; they run and write, so here they are never left out.
+		case "wc": case "tr": case "cut": case "sort": case "uniq": case "column": case "yes": case "printf":
+			return true;
+		case "head":
+			return args.length === 0 || (args.length === 1 && args[0]!.startsWith("-"))
+				|| (args.length === 2 && (args[0] === "-n" || args[0] === "-c") && digits(args[1]));
+		case "tail":
+			return args.length === 0 || (args.length === 1 && args[0]!.startsWith("-"))
+				|| (args.length === 2 && (args[0] === "-n" || args[0] === "-c") && signedDigits(args[1]));
+		case "sed":
+			return !args.some((arg) => arg.startsWith("-i")) && sedReadPath(args) === undefined;
+		default:
+			return false;
+	}
+}
+
+/** A head or tail of a file: `-n N file`, `-nN file`, or the file alone. */
+function headTailPath(args: readonly string[], signed: boolean): string | undefined {
+	const count = signed ? signedDigits : digits;
+	const first = args[0];
+	const counted = (first === "-n" && count(args[1])) || (first?.startsWith("-n") === true && first.length > 2 && count(first.slice(2)));
+	if (counted) {
+		const rest = first === "-n" ? args.slice(2) : args.slice(1);
+		const path = rest.find((arg) => !arg.startsWith("-"));
+		if (path !== undefined) return path;
+	}
+	return args.length === 1 && !args[0]!.startsWith("-") ? args[0] : undefined;
+}
+
+function single(values: readonly string[]): string | undefined {
+	return values.length === 1 ? values[0] : undefined;
+}
+
+const read = (path: string | undefined): ExploreAction | undefined =>
+	path === undefined ? undefined : { kind: "read", name: shortDisplayPath(path) };
+
+/** What one command does, or undefined when it does anything but look around. */
+function summarize(words: readonly string[]): ExploreAction | undefined {
+	const [program, ...args] = words;
+	const command = words.join(" ");
+	const short = (path: string | undefined) => path === undefined ? undefined : shortDisplayPath(path);
+	switch (program) {
+		case "ls": case "eza": case "exa":
+			return { kind: "list", path: short(operands(args, ["-I", "-w", "--block-size", "--format", "--time-style", "--color", "--quoting-style", "--ignore-glob", "--sort", "--time"])[0]), command };
+		case "tree":
+			return { kind: "list", path: short(operands(args, ["-L", "-P", "-I", "--charset", "--filelimit", "--sort"])[0]), command };
+		case "du":
+			return { kind: "list", path: short(operands(args, ["-d", "--max-depth", "-B", "--block-size", "--exclude", "--time-style"])[0]), command };
+		case "rg": case "rga": case "ripgrep-all": {
+			const rest = operands(args, ["-g", "--glob", "--iglob", "-t", "--type", "--type-add", "--type-not", "-m", "--max-count", "-A", "-B", "-C", "--context", "--max-depth"]);
+			if (args.includes("--files")) return { kind: "list", path: short(rest[0]), command };
+			return { kind: "search", query: rest[0], path: short(rest[1]), command };
+		}
+		case "grep": case "egrep": case "fgrep": {
+			let pattern: string | undefined;
+			const rest: string[] = [];
+			for (let index = 0; index < args.length; index++) {
+				const arg = args[index]!;
+				if (arg === "-e" || arg === "--regexp" || arg === "-f" || arg === "--file") pattern ??= args[++index];
+				else if (["-m", "--max-count", "-C", "--context", "-A", "--after-context", "-B", "--before-context"].includes(arg)) index++;
+				else if (!arg.startsWith("-")) rest.push(arg);
+			}
+			if (pattern === undefined) pattern = rest.shift();
+			return { kind: "search", query: pattern, path: short(rest[0]), command };
+		}
+		case "ag": case "ack": case "pt": {
+			const rest = operands(args, ["-G", "-g", "--file-search-regex", "--ignore-dir", "--ignore-file", "--path-to-ignore"]);
+			return { kind: "search", query: rest[0], path: short(rest[1]), command };
+		}
+		case "fd": {
+			const rest = operands(args, ["-t", "--type", "-e", "--extension", "-E", "--exclude", "--search-path"]);
+			if (rest.length === 1) {
+				return /[/\\]|^\.\.?$/u.test(rest[0]!) ? { kind: "list", path: short(rest[0]), command } : { kind: "search", query: rest[0], command };
+			}
+			return rest.length === 0 ? { kind: "list", command } : { kind: "search", query: rest[0], path: short(rest[1]), command };
+		}
+		case "find": {
+			const root = args.find((arg) => !arg.startsWith("-") && arg !== "!" && arg !== "(" && arg !== ")");
+			const flag = args.findIndex((arg) => arg === "-name" || arg === "-iname" || arg === "-path" || arg === "-regex");
+			const query = flag >= 0 ? args[flag + 1] : undefined;
+			return query === undefined ? { kind: "list", path: short(root), command } : { kind: "search", query, path: short(root), command };
+		}
+		case "git": {
+			const [sub, ...rest] = args;
+			if (sub === "grep") {
+				const search = summarize(["grep", ...rest]);
+				return search && { ...search, command } as ExploreAction;
+			}
+			if (sub === "ls-files") return { kind: "list", path: short(operands(rest, ["--exclude", "--exclude-from", "--pathspec-from-file"])[0]), command };
+			return undefined;
+		}
+		case "cat": case "more":
+			return read(single(operands(args)));
+		case "bat": case "batcat":
+			return read(single(operands(args, ["--theme", "--language", "--style", "--terminal-width", "--tabs", "--line-range", "--map-syntax"])));
+		case "less":
+			return read(single(operands(args, ["-p", "-P", "-x", "-y", "-z", "-j", "--pattern", "--prompt", "--tabs", "--shift", "--jump-target"])));
+		case "head":
+			return read(headTailPath(args, false));
+		case "tail":
+			return read(headTailPath(args, true));
+		case "nl":
+			return read(operands(args, ["-s", "-w", "-v", "-i", "-b"])[0]);
+		case "sed":
+			return read(sedReadPath(args));
+		default:
+			return undefined;
+	}
+}
+
+/**
+ * What a shell command does, call by call, if all it does is read, search, and list;
+ * otherwise undefined, and Codex shows it as a command it ran. Formatting stages,
+ * a `cd`, a leading `echo`, and a `true` say nothing and are left out. Like Codex,
+ * only plain words are read: a redirection or a substitution is a command it ran.
+ * Unlike Codex, a command that can write or run something else, `xargs rm`, `tee`,
+ * `find -delete`, never passes for exploring, since the group would hide it.
+ */
+export function parseExploreCommand(command: string): ExploreAction[] | undefined {
+	const parsed = parseShell(normalizeLineEndings(command));
+	if (!parsed || parsed.opaque || parsed.commands.some((each) => each.redirects.length > 0)) return undefined;
+	let commands = parsed.commands.map((each) => each.words);
+	if (commands.some(writesOrRuns)) return undefined;
+	if (commands.length > 1) commands = commands.filter((each) => !isFormatting(each));
+	commands = commands.filter((each, index) => each[0] !== "cd" && !(each.length === 1 && each[0] === "true")
+		&& !(each[0] === "echo" && index === 0 && commands.length > 1));
+	if (commands.length === 0) return undefined;
+	const actions: ExploreAction[] = [];
+	for (const each of commands) {
+		const action = summarize(each);
+		if (!action) return undefined;
+		actions.push(action);
+	}
+	return actions;
+}
+
+function argument(args: ToolArgs, key: string): string | undefined {
+	const value = args[key];
+	return typeof value === "string" && value.trim() ? normalizeLineEndings(value) : undefined;
+}
+
+/** A Pi tool's path argument, whichever name it uses. */
+export function codexPath(args: ToolArgs): string {
+	return argument(args, "path") ?? argument(args, "file_path") ?? "";
+}
+
+/**
+ * What a call does, as Codex's exploration lines name it. Pi's dedicated tools map to
+ * the verb Codex would give the command they stand for; a shell command is parsed.
+ */
+export function exploreActions(name: string, args: ToolArgs): ExploreAction[] | undefined {
+	const path = codexPath(args);
+	const short = path ? shortDisplayPath(path) : undefined;
+	switch (name) {
+		case "read": return path ? [{ kind: "read", name: shortDisplayPath(path) }] : undefined;
+		case "grep": case "find": {
+			const pattern = argument(args, "pattern");
+			return pattern ? [{ kind: "search", query: firstLine(pattern), path: short, command: name }] : undefined;
+		}
+		case "ls": return [{ kind: "list", path: short, command: "ls" }];
+		case "bash": case "powershell": {
+			const command = argument(args, "command");
+			return command ? parseExploreCommand(command) : undefined;
+		}
+		default: return undefined;
+	}
+}
+
+function firstLine(text: string): string {
+	return normalizeLineEndings(stripTerminalSequences(text)).split("\n").find((line) => line.trim())?.trim() ?? "";
+}
+
+/** One exploration line: its verb and the parts after it, each marked plain or dim. */
+export type ExploreLine = { verb: "Read" | "Search" | "List"; parts: Array<{ text: string; dim?: boolean }>; failure?: { text: string; quiet: boolean } };
+
+export type ExploreCall = { actions: ExploreAction[]; failure?: { text: string; quiet: boolean } };
+
+/**
+ * Codex's exploration lines for a run of calls: consecutive reads that succeeded
+ * merge into one line of distinct names; every other action is a line of its own, and
+ * a failed call's last line ends with why.
+ */
+export function exploreLines(calls: readonly ExploreCall[]): ExploreLine[] {
+	const lines: ExploreLine[] = [];
+	for (let index = 0; index < calls.length;) {
+		const call = calls[index]!;
+		const readsOnly = call.actions.every((action) => action.kind === "read");
+		if (readsOnly && !call.failure) {
+			const names: string[] = [];
+			while (index < calls.length && !calls[index]!.failure && calls[index]!.actions.every((action) => action.kind === "read")) {
+				for (const action of calls[index]!.actions) {
+					const name = (action as { name: string }).name;
+					if (!names.includes(name)) names.push(name);
+				}
+				index++;
+			}
+			const parts = names.flatMap((name, position) => position === 0 ? [{ text: name }] : [{ text: ", ", dim: true }, { text: name }]);
+			lines.push({ verb: "Read", parts });
+			continue;
+		}
+		call.actions.forEach((action, position) => {
+			const line = actionLine(action);
+			if (call.failure && position === call.actions.length - 1) line.failure = call.failure;
+			lines.push(line);
+		});
+		index++;
+	}
+	return lines;
+}
+
+/** Text that spans lines, such as a quoted multi-line pattern, shows its first line and that more follows. */
+function oneLine(text: string): string {
+	const lines = text.split("\n");
+	return lines.length > 1 ? `${lines[0]} …` : text;
+}
+
+function actionLine(action: ExploreAction): ExploreLine {
+	if (action.kind === "read") return { verb: "Read", parts: [{ text: oneLine(action.name) }] };
+	if (action.kind === "list") return { verb: "List", parts: [{ text: oneLine(action.path ?? action.command) }] };
+	if (action.query === undefined) return { verb: "Search", parts: [{ text: oneLine(action.command) }] };
+	const query = oneLine(action.query);
+	return { verb: "Search", parts: action.path ? [{ text: query }, { text: " in ", dim: true }, { text: oneLine(action.path) }] : [{ text: query }] };
+}
+
+const SHELL_STATUS = /^Command (?:exited with code (\d+)|(timed out.*|aborted|terminated.*))$/iu;
+
+/**
+ * A command's outcome as Pi reports it: the exit code from the line Pi ends a failed
+ * run with, and the output without that line. A run that timed out or was aborted
+ * keeps its line, the only place that says why.
+ */
+export function shellOutcome(output: string): { exitCode?: number; output: string } {
+	const lines = normalizeLineEndings(output).trimEnd().split("\n");
+	const status = lines.at(-1)?.trim().match(SHELL_STATUS);
+	if (status?.[1] === undefined) return { output: lines.join("\n") };
+	return { exitCode: Number(status[1]), output: lines.slice(0, -1).join("\n").trimEnd() };
+}
+
+/** Pi's bash reports a run that printed nothing as "(no output)"; Codex has its own words for it. */
+export function isEmptyOutput(output: string): boolean {
+	const trimmed = normalizeLineEndings(output).trim();
+	return !trimmed || trimmed === "(no output)";
+}
+
+/**
+ * A failed exploration call's note: the exit code a command gave, or that a tool
+ * failed. A compound command has one exit code for all it did, so Codex says so.
+ */
+export function exploreFailure(name: string, output: string, isError: boolean, actions: readonly ExploreAction[]): ExploreCall["failure"] {
+	if (!isError) return undefined;
+	if (name !== "bash" && name !== "powershell") return { text: " (failed)", quiet: false };
+	const { exitCode } = shellOutcome(output);
+	if (exitCode === undefined) return { text: " (failed)", quiet: false };
+	// A search's exit 1 can mean it found nothing; Codex reports the code without calling it a failure.
+	const quiet = exitCode === 1 && actions.some((action) => action.kind === "search");
+	return { text: actions.length > 1 ? ` (command exit ${exitCode})` : ` (exit ${exitCode})`, quiet };
+}
+
+/**
+ * The calls of every exploration opened this frame. Codex lists an opened group's
+ * calls with one "− Show less" beneath them all, so a call listed there leaves out
+ * its own. Refilled as the chat is drawn, before any row in it is.
+ */
+export const openExplorations = new Set<string>();
+
+/** The last lines of output, the way Codex previews a call. */
+export function tailLines(text: string, count = CODEX_PREVIEW_ROWS): string[] {
+	const lines = normalizeLineEndings(text).replace(/\n+$/u, "").split("\n");
+	return lines.slice(Math.max(0, lines.length - count));
+}
+
+export type ThemeColor = Parameters<Theme["fg"]>[0];
+/** A run of text and the color it is painted in. Text is wrapped as text and painted after. */
+export type Segment = { text: string; color?: ThemeColor };
+
+export function paintSegments(segments: readonly Segment[], theme: Theme): string {
+	return segments.map((segment) => segment.color ? theme.fg(segment.color, segment.text) : segment.text).join("");
+}
+
+/** Plain text as lines of one color each. */
+export function textLines(text: string, color?: ThemeColor): Segment[][] {
+	return normalizeLineEndings(text).split("\n").map((line) => line ? [{ text: line, color }] : []);
+}
+
+/**
+ * Where each row of word-wrapped text starts and ends, in graphemes: a row breaks
+ * at its last space when it can and mid-word when it cannot, and the spaces it
+ * breaks at begin no row. The first row has `first` columns and every later one `rest`.
+ */
+function wrapRanges(characters: readonly string[], first: number, rest: number): Array<[number, number]> {
+	const rows: Array<[number, number]> = [];
+	let start = 0;
+	while (start < characters.length) {
+		if (rows.length > 0) while (characters[start] === " ") start++;
+		if (start >= characters.length) break;
+		const limit = Math.max(1, rows.length === 0 ? first : rest);
+		let end = start;
+		let used = 0;
+		while (end < characters.length) {
+			const columns = visibleWidth(characters[end]!);
+			if (used + columns > limit && end > start) break;
+			used += columns;
+			end++;
+		}
+		if (end < characters.length && characters[end] !== " ") {
+			const space = characters.lastIndexOf(" ", end - 1);
+			if (space > start) end = space;
+		}
+		let trimmed = end;
+		while (trimmed > start && characters[trimmed - 1] === " ") trimmed--;
+		rows.push([start, trimmed > start ? trimmed : end]);
+		start = end;
+	}
+	return rows;
+}
+
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+/** Segments word-wrapped into rows, each piece keeping its color. */
+export function wrapSegments(segments: readonly Segment[], first: number, rest: number): Segment[][] {
+	const owners: number[] = [];
+	const characters: string[] = [];
+	segments.forEach((segment, index) => {
+		// A grapheme, not a code point: an emoji joined from several stays whole on one row.
+		for (const { segment: character } of graphemes.segment(segment.text)) {
+			characters.push(character);
+			owners.push(index);
+		}
+	});
+	if (characters.length === 0) return [[]];
+	return wrapRanges(characters, first, rest).map(([start, end]) => {
+		const row: Segment[] = [];
+		for (let position = start; position < end; position++) {
+			const color = segments[owners[position]!]!.color;
+			const last = row.at(-1);
+			if (last && owners[position] === owners[position - 1] && position > start) last.text += characters[position];
+			else row.push({ text: characters[position]!, color });
+		}
+		return row;
+	});
+}

package/extensions/compact-tools-command.ts

@@ -0,0 +1,196 @@
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+import { CONFIG_DIR_NAME, getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { DISPLAY_STYLES, type CompactToolsConfig, type DisplayStyle } from "./compact-tools-types.ts";
+import { loadConfig } from "./compact-tools-config.ts";
+
+type Scope = "global" | "project";
+const SCOPES: readonly Scope[] = ["global", "project"];
+const HELP = "Usage: /compact-tools [compact|claude|codex|off] [global|project]\nWithout a scope the style is saved globally, or to this project when its settings choose the style.\n/compact-tools status · /compact-tools help\nCtrl+O expands rows; /silent toggles quiet mode. Styles switch at once, even while tools run; off reloads Pi.";
+const BUSY = "Wait for the current response to finish before changing tool styles.";
+const CHOICES: Record<DisplayStyle, string> = {
+	compact: "Compact — one expandable row per tool call",
+	claude: "Claude — group reads and searches",
+	codex: "Codex — explored groups and output tails, like Codex CLI",
+	off: "Off — restore Pi's default tool rows",
+};
+
+export function configPath(cwd: string, scope: Scope): string {
+	return scope === "global" ? join(getAgentDir(), "compact-tools.json")
+		: join(cwd, CONFIG_DIR_NAME, "compact-tools.json");
+}
+
+/** Preserve unrelated and future settings. Never overwrite a malformed file. */
+export function saveStyle(path: string, style: DisplayStyle): void {
+	let linked = false;
+	try {
+		linked = lstatSync(path).isSymbolicLink();
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+	// Update dotfiles-managed targets without replacing the link. A dangling link
+	// is an error, not permission to silently disconnect it.
+	if (linked) path = realpathSync(path);
+	let data: Record<string, unknown> = {};
+	let mode = 0o600;
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+			throw new Error("expected a JSON object");
+		}
+		data = parsed as Record<string, unknown>;
+		mode = statSync(path).mode & 0o777;
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+	}
+	mkdirSync(dirname(path), { recursive: true });
+	// Beside the target so the rename stays atomic, and short so a long target name still fits.
+	const temporary = join(dirname(path), `.compact-tools-${randomUUID()}.tmp`);
+	try {
+		writeFileSync(temporary, `${JSON.stringify({ ...data, style }, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+		// The creation mode passes through the umask; set the original mode exactly.
+		chmodSync(temporary, mode);
+		renameSync(temporary, path);
+	} finally {
+		rmSync(temporary, { force: true });
+	}
+}
+
+/** Whether a trusted project's own settings choose the style, which then outranks the global one. */
+function projectSetsStyle(cwd: string, trusted: boolean): boolean {
+	if (!trusted) return false;
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(configPath(cwd, "project"), "utf8"));
+		return !!parsed && typeof parsed === "object" && !Array.isArray(parsed) && "style" in parsed;
+	} catch {
+		return false;
+	}
+}
+
+function describePath(path: string): string {
+	return `${path} (${existsSync(path) ? "exists" : "not created"})`;
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Draw the saved style in place, without a reload, and say whether it could: a switch
+ * between the compact, Claude, and Codex styles keeps every tool's registration, so
+ * it applies at once, even while a response runs. Turning rows off or back on cannot.
+ */
+export type ApplyStyle = (cwd: string, trusted: boolean) => boolean;
+
+/** Whether a switch needs Pi to reload: only off hands tools to or takes them from Pi's own renderers. */
+function needsReload(from: DisplayStyle, to: DisplayStyle): boolean {
+	return from === "off" || to === "off";
+}
+
+export function registerCompactToolsCommand(pi: ExtensionAPI, getConfig: () => CompactToolsConfig, applyStyle?: ApplyStyle): void {
+	pi.registerCommand("compact-tools", {
+		description: "Choose compact/Claude/Codex/default tool rows, or show settings and controls",
+		getArgumentCompletions: (prefix) => {
+			const typed = prefix.trimStart().toLowerCase();
+			const parts = typed.split(/\s+/);
+			const scoped = parts.length === 2 && DISPLAY_STYLES.includes(parts[0] as DisplayStyle);
+			const values = scoped ? SCOPES.map((scope) => `${parts[0]} ${scope}`) : [...DISPLAY_STYLES, "status", "help"];
+			// 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 items = values.filter((value) => value.startsWith(typed) && value !== typed.trimEnd()).map((value) => ({ value, label: value }));
+			return items.length ? items : null;
+		},
+		handler: async (args, ctx) => {
+			const parts = args.trim() ? args.trim().toLowerCase().split(/\s+/) : [];
+			if (parts.length === 1 && parts[0] === "help") {
+				ctx.ui.notify(HELP, "info");
+				return;
+			}
+			if (parts.length === 1 && parts[0] === "status") {
+				const config = getConfig();
+				ctx.ui.notify([
+					`Style: ${config.style} · configured mode: ${config.mode} · preview: ${config.previewLines} lines`,
+					`Global: ${describePath(configPath(ctx.cwd, "global"))}`,
+					`Project: ${describePath(configPath(ctx.cwd, "project"))} (${ctx.isProjectTrusted() ? "trusted; overrides global" : "untrusted; ignored"})`,
+					"/silent is a session toggle; Ctrl+O expands rows.",
+				].join("\n"), "info");
+				return;
+			}
+			if (parts.length > 2 || (parts.length > 0 && !DISPLAY_STYLES.includes(parts[0] as DisplayStyle))
+				|| (parts[1] !== undefined && !SCOPES.includes(parts[1] as Scope))) {
+				ctx.ui.notify(HELP, "warning");
+				return;
+			}
+			// A switch between drawn styles applies in place, so only one that reloads waits for the response.
+			const named = parts[0] as DisplayStyle | undefined;
+			if (named && !ctx.isIdle() && (needsReload(getConfig().style, named) || !applyStyle)) {
+				ctx.ui.notify(BUSY, "warning");
+				return;
+			}
+			let style = named;
+			// Unnamed, the style is saved where it is decided: a trusted project that sets one would
+			// otherwise outrank a global save, and the switch would seem to do nothing.
+			let scope: Scope = (parts[1] as Scope | undefined) ?? (projectSetsStyle(ctx.cwd, ctx.isProjectTrusted()) ? "project" : "global");
+			if (!style) {
+				if (ctx.mode !== "tui") {
+					ctx.ui.notify(HELP, "info");
+					return;
+				}
+				const selected = await ctx.ui.select(`Tool style (current: ${getConfig().style})`, Object.values(CHOICES));
+				style = DISPLAY_STYLES.find((value) => CHOICES[value] === selected);
+				if (!style) return;
+				// A project that sets its own style outranks a global save, so it is offered first and the global
+				// choice says it will not show here.
+				const projectDecides = projectSetsStyle(ctx.cwd, ctx.isProjectTrusted());
+				const scopes = projectDecides
+					? ["Project — this trusted project only", "Global — all projects (this project keeps its own style)"]
+					: ["Global — all projects", ...(ctx.isProjectTrusted() ? ["Project — this trusted project only"] : [])];
+				const selectedScope = await ctx.ui.select("Save style where?", scopes);
+				if (!selectedScope) return;
+				scope = selectedScope.startsWith("Project") ? "project" : "global";
+			}
+			if (scope === "project" && !ctx.isProjectTrusted()) {
+				ctx.ui.notify("Project settings require a trusted project. No file was changed.", "warning");
+				return;
+			}
+			// The agent may have started while the user was choosing in a dialog.
+			const reloads = needsReload(getConfig().style, style) || !applyStyle;
+			if (reloads && !ctx.isIdle()) {
+				ctx.ui.notify(BUSY, "warning");
+				return;
+			}
+			const path = configPath(ctx.cwd, scope);
+			try {
+				saveStyle(path, style);
+			} catch (error) {
+				ctx.ui.notify(`Could not save ${path}: ${errorMessage(error)}. No settings were replaced.`, "error");
+				return;
+			}
+			const effective = loadConfig(ctx.cwd, ctx.isProjectTrusted()).style;
+			const where = scope === "project" ? "this project" : "global settings";
+			// Paths stay out of these lines, which Pi keeps in the chat; /compact-tools status shows them.
+			if (scope === "global" && effective !== style) {
+				// Saved, but this project's own style still decides what is drawn here: nothing switches.
+				ctx.ui.notify(`Saved ${style} to global settings, but this project keeps its own ${effective} style. Run /compact-tools ${style} to switch it here.`, "warning");
+				return;
+			}
+			if (!reloads && applyStyle!(ctx.cwd, ctx.isProjectTrusted())) {
+				ctx.ui.notify(`Switched to ${style} style (saved to ${where}).`, "info");
+				return;
+			}
+			if (!ctx.isIdle()) {
+				ctx.ui.notify(`Saved ${style} style to ${where}. It applies once the response finishes; run /reload then.`, "warning");
+				return;
+			}
+			ctx.ui.notify(`Switching to ${style} style (saved to ${where}). Reloading…`, "info");
+			// Reloading makes this ctx stale, so a failure is reported through the UI held from before.
+			const ui = ctx.ui;
+			try {
+				await ctx.reload();
+			} catch (error) {
+				ui.notify(`Style was saved, but reload failed: ${errorMessage(error)}. Run /reload to apply it.`, "error");
+			}
+		},
+	});
+}

package/extensions/compact-tools-custom.ts

@@ -29,6 +29,15 @@ export function setRowResolver(resolver: RowResolver | undefined): void {
 	(globalThis as ResolverSlot)[RESOLVER_KEY] = resolver;
 }
 
+/**
+ * Stop answering for rows, if `resolver` is still the one answering. The patch on
+ * Pi's rows outlives the extension, so a /reload that leaves it out must find no
+ * resolver, and Pi's own renderers draw every row made afterwards.
+ */
+export function clearRowResolver(resolver: RowResolver): void {
+	if ((globalThis as ResolverSlot)[RESOLVER_KEY] === resolver) setRowResolver(undefined);
+}
+
 /**
  * Pi routes every renderer lookup on a tool row through these four methods, so
  * answering them is enough to give any tool, whichever extension registered it,