pi-compact-tools 0.10.0 → 0.11.0

package/README.md

@@ -1,22 +1,8 @@
 # pi-compact-tools
 
-Compact, expandable rendering for Pi's built-in tools and for custom tools from other packages, with a GitHub Dark theme.
+Compact, expandable tool rows for Pi in its own compact style or Claude Code's, with a silent mode and a GitHub Dark theme. Works with custom tools from other packages.
 
-![Compact rows for built-in and custom tools, including a web search and an edit with its diff and line counts](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif)
-
-![Syntax-highlighted edit diff with lines added and removed](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/edit-diff.gif)
-
-![Numbered read code view](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/code-aware-results.gif)
-
-## Features
-
-- Compact rows for `read`, `write`, `edit`, `bash`, `powershell`, `grep`, `find`, and `ls`, with status, duration, and line count
-- The same compact rows for custom tools registered by other packages, such as web search or MCP tools, with no setup
-- Syntax-highlighted edit diffs and numbered `read`/`write` code views, including Markdown code fences
-- Edits report what they changed on their status line, lines added and removed in the diff colors: `(+3 -1)`
-- Animated working label above the prompt, lit in the session's own thinking-level color, and a `Ctrl+T` thinking summary/detail cycle
-- Theme-agnostic chrome: rails, the tool indicator, and the working label are derived from the active theme and stay legible on light and dark backgrounds
-- No Nerd Font required
+![The compact style, then the Claude style, each switched to silent mode mid-run and back](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/overview.gif)
 
 ## Install
 
@@ -24,70 +10,66 @@ Compact, expandable rendering for Pi's built-in tools and for custom tools from
 pi install npm:pi-compact-tools
 ```
 
-Then restart Pi or run `/reload`. For the bundled theme, set `"theme": "github-dark-pro"` in `~/.pi/agent/settings.json`.
+Restart Pi or run `/reload`. For the bundled theme, set `"theme": "github-dark-pro"` in `~/.pi/agent/settings.json`.
 
-## Configuration
+## Usage
 
-Optional. Put it in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.json`:
+Pick a style. Silent mode works on top of either.
 
-```json
-{
-  "tools": ["read", "write", "edit", "bash"],
-  "previewLines": 10,
-  "auto_compact": { "read": true, "write": true, "edit": false, "bash": true }
-}
-```
+| | Setting | Shows | How |
+|---|---|---|---|
+| **Compact** | Style | every tool call, one short row each | `"style": "compact"` (default) |
+| **Claude** | Style | reads and searches folded into one line, like Claude Code | `"style": "claude"` |
+| **Silent** | Mode | only your prompts and the answers | `Ctrl+'` or `/silent` |
 
-- `tools`: tools to render compactly. Also available: `grep`, `find`, `ls`, `powershell`.
-- `auto_compact`: `true` starts hidden, `false` starts with a preview of up to `previewLines` rows (`1`–`100`). Custom tools can be listed by name too, such as `"web_search": false`.
-- `mode`: `"normal"` (default) or `"silent"`. See [Silent mode](#silent-mode).
-- `custom_tools`: compact rendering for tools from other packages. See [Custom tools](#custom-tools).
+Set `"style"` in the config below, then `/reload`. `"style": "off"` restores Pi's own rows.
 
-## Custom tools
+### Style: Compact
 
-Tools registered by other packages get the same row as the built-ins: a status indicator, the tool name, a one-line summary of the call, then duration and line count once it finishes. It works for any tool, whichever package registered it, with nothing to configure.
+![Compact style: a web search, ls, and an edit as compact rows with status dots, then the edit's diff](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif)
 
-Expanding a row shows the call's arguments and then the result as the tool's own package renders it, so a package's custom result view is kept. Tools without a result renderer show their text output.
+- One row per call: status, duration, and line count.
+- Edits show a highlighted diff with `(+3 -1)`; reads and writes show numbered code.
 
-```json
-{
-  "custom_tools": { "enabled": true, "auto_compact": true, "exclude": ["my_tool"] }
-}
-```
+### Style: Claude
 
-- `enabled`: `false` leaves every custom tool with its own renderer. `"custom_tools": false` is shorthand.
-- `auto_compact`: like the built-in setting, `true` starts rows hidden and `false` starts with a preview. A tool named in the top-level `auto_compact` uses its own setting instead.
-- `exclude`: tool names that keep their own renderer.
+![Claude style: reads and searches fold into one line, then Bash and Update rows; silent mode hides them mid-run and brings them back](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/claude-style.gif)
 
-Built-in tools follow `tools` above: a built-in left out of that list keeps Pi's default renderer.
+- Reads, searches, and listings fold into one line: `Searched for 2 patterns, read 3 files`.
+- `Bash`, `Update`, `Write`, and custom tools keep their own rows with short previews.
 
-Pi has no public API for changing how another package's tool is drawn, so this wraps the renderer lookup of Pi's tool row component. Nothing in Pi's installation is modified, and it only applies while this extension is loaded. If a Pi release changes that component, custom tools fall back to their own renderers and Pi shows a warning once.
+### Mode: Silent
 
-## Silent mode
+![Silent mode switched on mid-run: the rows fold into a moving light, the answer stays, and every row comes back when it is off](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/silent-mode.gif)
 
-![Silent mode switched on mid-run: the tool rows fold away into a moving light, the answer stays, and every row comes back when it is off](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/silent-mode.gif)
+Shows only your prompts and the answers, in either style.
 
-Silent mode shows only your prompts and the final answers. Tool calls (including custom tools from other packages), the assistant's in-between turns, thinking, error and abort notices, extension notices such as web-search progress, and Pi's own status lines are hidden while the animated working label shows what is running.
+- Toggle with `Ctrl+'` or `/silent`. Tool rows and thinking fold into a moving light while the agent works.
+- Turn it off and every row comes back. `"mode": "silent"` starts sessions with it on.
 
-- While the agent works, a light runs back and forth along a short line beneath your latest prompt, above the working label and just as long, leaving a fading afterimage in the thinking level's color. It steps aside once the answer starts.
-- `Ctrl+'` or `/silent` toggles it for the current session; `/silent on` and `/silent off` set it explicitly.
-- `Ctrl+'` needs a terminal that reports it as its own key (the Kitty keyboard protocol: Ghostty, Kitty, WezTerm, and others). Where it only types `'`, use `/silent`.
-- Set `"mode": "silent"` in `compact-tools.json` to start every session silent.
-- Turning it off brings back every hidden row. Nothing is removed from the session or the model's context.
-- Errors are hidden too, so a run that fails ends without an answer. Turn silent mode off to see what went wrong.
+## Configuration
 
-Pi has no public API for hiding other extensions' tool rows, so silent mode wraps Pi's transcript components. If a future Pi release changes them, `/silent` reports that it is unavailable and the transcript renders normally.
+Optional, in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.json`:
 
-## Controls
+```json
+{
+  "style": "compact",
+  "mode": "normal",
+  "tools": ["read", "write", "edit", "bash"],
+  "previewLines": 10,
+  "auto_compact": { "read": true, "write": true, "edit": false, "bash": true },
+  "custom_tools": { "enabled": true, "auto_compact": true, "exclude": [] }
+}
+```
 
-- Click a row or press `Ctrl+O` to expand or collapse results.
-- In fullscreen mode, expanding or collapsing every row, cycling thinking, and toggling silent mode keep the text you were reading in place instead of jumping.
-- `Ctrl+T` cycles thinking: summary → detail → summary → hidden.
-- `Ctrl+'` or `/silent` toggles silent mode.
+- `tools`: built-ins to compact. Also `grep`, `find`, `ls`, `powershell`.
+- `auto_compact`: `true` starts a row collapsed; `false` shows up to `previewLines` rows. Custom tool names work too.
+- `custom_tools`: rows for tools from other packages. `exclude` keeps a tool's own look.
 
-## Release notes
+## Controls
 
-After an update, the next new conversation opens with a bordered "What's new" block, the way Pi shows its own changelog: once, listing every release since the last one shown. A resumed session keeps it for the next new one, and so does silent mode. The block lives only in the TUI; it is never saved to the session or sent to the model. When publishing a new version, add its changes to `release-notes.json`; `npm run check` requires an entry matching `package.json`.
+- Click a row or group, or press `Ctrl+O`, to expand and collapse.
+- `Ctrl+T` cycles thinking: summary → detail → summary → hidden.
 
 ## Development
 
@@ -97,6 +79,8 @@ npm run check
 pi -e .
 ```
 
+Renders are pinned in `tests/golden/render.json`. After an intended change to the output, record it with `UPDATE_GOLDEN=1 npm test` and review the diff. Before publishing, add the version's notes to `release-notes.json` (`[]` for none).
+
 ## License
 
 MIT

package/extensions/compact-tools-claude.ts

@@ -0,0 +1,227 @@
+import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { normalizeLineEndings } from "./compact-tools-core.ts";
+import {
+	countEditChanges,
+	formatResultLineSummary,
+	shellSegments,
+	summarizeCustomArguments,
+	summarizeFailure,
+} from "./compact-tools-invocation.ts";
+import type { ToolArgs } from "./compact-tools-types.ts";
+
+/**
+ * Rows Claude Code shows of a command's output before "… +N lines". Output is
+ * wrapped to the width first, so a long line counts as the rows it takes.
+ */
+export const CLAUDE_OUTPUT_ROWS = 3;
+/** Rows Claude Code shows of what a write put in the file. */
+export const CLAUDE_WRITE_ROWS = 10;
+/** Lines of context Claude Code keeps around each change in an edit's diff. */
+export const CLAUDE_DIFF_CONTEXT_LINES = 3;
+
+/** Claude Code's names for the tools Pi shares with it. */
+const LABELS: Readonly<Record<string, string>> = {
+	read: "Read",
+	grep: "Search",
+	find: "Search",
+	ls: "List",
+	bash: "Bash",
+	powershell: "PowerShell",
+	edit: "Update",
+	write: "Write",
+};
+
+export function claudeLabel(name: string): string {
+	return LABELS[name] ?? name;
+}
+
+export function pathOf(args: ToolArgs): string {
+	const value = args.path ?? args.file_path;
+	return typeof value === "string" ? normalizeLineEndings(value) : "";
+}
+
+function oneLine(text: string): string {
+	const lines = normalizeLineEndings(stripTerminalSequences(text)).split("\n").map((line) => line.trim()).filter(Boolean);
+	if (lines.length === 0) return "";
+	return lines.length > 1 ? `${lines[0]} …` : lines[0]!;
+}
+
+function commandOf(args: ToolArgs): string {
+	return typeof args.command === "string" ? args.command : "";
+}
+
+/** What goes between the parentheses: `Bash(npm test)`, `Search(pattern: "x", path: "src")`. */
+export function claudeArgument(name: string, args: ToolArgs): string {
+	const path = pathOf(args);
+	if (name === "bash" || name === "powershell") return oneLine(commandOf(args));
+	if (name === "grep" || name === "find") {
+		const pattern = typeof args.pattern === "string" ? oneLine(args.pattern) : "";
+		// Arguments stream in; until the pattern arrives there is nothing to name.
+		if (!pattern) return "";
+		return path ? `pattern: "${pattern}", path: "${path}"` : `pattern: "${pattern}"`;
+	}
+	if (name === "ls") return path || ".";
+	if (name === "read" || name === "edit" || name === "write") return path;
+	return formatArguments(args);
+}
+
+function formatValue(value: unknown): string | undefined {
+	if (typeof value === "string") return JSON.stringify(oneLine(value));
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value) && value.every((item) => typeof item !== "object" || item === null)) {
+		return `[${value.map((item) => formatValue(item) ?? "null").join(", ")}]`;
+	}
+	return undefined;
+}
+
+/** A custom tool's arguments as Claude Code lists them: `query: "pi tui", limit: 5`. */
+export function formatArguments(args: ToolArgs): string {
+	const parts: string[] = [];
+	for (const [key, value] of Object.entries(args)) {
+		const formatted = formatValue(value);
+		if (formatted !== undefined) parts.push(`${key}: ${formatted}`);
+	}
+	return parts.length > 0 ? parts.join(", ") : summarizeCustomArguments(args);
+}
+
+export function claudeTitle(name: string, args: ToolArgs): { label: string; argument: string } {
+	return { label: claudeLabel(name), argument: claudeArgument(name, args) };
+}
+
+// Claude Code's own lists: a command made only of these only looks around, so it
+// folds into a group with reads and searches.
+const SEARCH_COMMANDS = new Set(["find", "grep", "rg", "ag", "ack", "locate", "which", "whereis"]);
+const READ_COMMANDS = new Set([
+	"cat", "head", "tail", "less", "more", "wc", "stat", "file", "strings", "jq", "awk", "cut", "sort", "uniq", "tr",
+]);
+const LIST_COMMANDS = new Set(["ls", "tree", "du"]);
+const NEUTRAL_COMMANDS = new Set(["echo", "printf", "true", "false", ":"]);
+
+export type LookKind = "search" | "read" | "list";
+
+/** Split one shell step at its unquoted pipes. */
+function pipeStages(segment: string): string[] {
+	const stages: string[] = [];
+	let current = "";
+	let quote: string | undefined;
+	for (let index = 0; index < segment.length; index++) {
+		const character = segment[index]!;
+		if (quote) {
+			if (character === quote) quote = undefined;
+		} else if (character === "'" || character === '"' || character === "`") {
+			quote = character;
+		} else if (character === "|" && segment[index + 1] !== "|") {
+			stages.push(current);
+			current = "";
+			continue;
+		}
+		current += character;
+	}
+	stages.push(current);
+	return stages.map((stage) => stage.trim()).filter(Boolean);
+}
+
+/**
+ * How a shell command looks around, if that is all it does: `rg x | head` searches,
+ * `cat a.ts` reads, `ls src` lists. Anything that runs something else is undefined.
+ */
+export function classifyShellCommand(command: string): LookKind | undefined {
+	let search = false;
+	let read = false;
+	let list = false;
+	for (const stage of shellSegments(normalizeLineEndings(command)).flatMap(pipeStages)) {
+		const program = stage.split(/\s+/u)[0];
+		if (!program || NEUTRAL_COMMANDS.has(program)) continue;
+		if (SEARCH_COMMANDS.has(program)) search = true;
+		else if (READ_COMMANDS.has(program)) read = true;
+		else if (LIST_COMMANDS.has(program)) list = true;
+		else return undefined;
+	}
+	// Claude Code counts a call once: as a listing first, then a search, then a read.
+	return list ? "list" : search ? "search" : read ? "read" : undefined;
+}
+
+/** Whether a call only looks around, and how; such calls fold into one group. */
+export function lookKind(name: string, args: ToolArgs): LookKind | undefined {
+	if (name === "read") return "read";
+	if (name === "grep" || name === "find") return "search";
+	if (name === "ls") return "list";
+	if (name === "bash" || name === "powershell") return classifyShellCommand(commandOf(args));
+	return undefined;
+}
+
+/** What a group's second line names while a call runs: a path, a pattern, a command. */
+export function lookHint(name: string, args: ToolArgs): string {
+	if (name === "grep" || name === "find") {
+		const pattern = typeof args.pattern === "string" ? oneLine(args.pattern) : "";
+		return pattern ? `"${pattern}"` : "";
+	}
+	if (name === "bash" || name === "powershell") {
+		const command = oneLine(commandOf(args));
+		return command ? `$ ${command}` : "";
+	}
+	return name === "ls" ? pathOf(args) || "." : pathOf(args);
+}
+
+function plural(count: number, singular: string): string {
+	return count === 1 ? singular : `${singular}s`;
+}
+
+function countOf(summary: string | undefined): number {
+	return Number.parseInt(summary ?? "0", 10) || 0;
+}
+
+/**
+ * The result line for tools whose outcome is a sentence rather than output, worded
+ * as Claude Code words it: "Read 42 lines", "Added 3 lines, removed 1 line". `bold`
+ * marks the counts and paths Claude Code sets in bold. Tools whose output is the
+ * result, commands and custom tools, return undefined and show it instead.
+ */
+export function claudeOutcome(
+	name: string,
+	args: ToolArgs,
+	result: AgentToolResult<unknown>,
+	output: string,
+	bold: (text: string) => string = (text) => text,
+): string | undefined {
+	const lines = countOf(formatResultLineSummary(name, args, result, output));
+	const count = (value: number, singular: string) => `${bold(String(value))} ${plural(value, singular)}`;
+	switch (name) {
+		case "read": return `Read ${count(lines, "line")}`;
+		case "grep": return `Found ${count(lines, "line")}`;
+		case "find": return `Found ${count(lines, "file")}`;
+		case "ls": return `Listed ${count(lines, "path")}`;
+		case "write": return `Wrote ${count(lines, "line")} to ${bold(pathOf(args))}`;
+		case "edit": {
+			const { added, removed } = countEditChanges(result) ?? { added: 0, removed: 0 };
+			if (added > 0 && removed > 0) return `Added ${count(added, "line")}, removed ${count(removed, "line")}`;
+			if (added > 0) return `Added ${count(added, "line")}`;
+			if (removed > 0) return `Removed ${count(removed, "line")}`;
+			return undefined;
+		}
+		default: return undefined;
+	}
+}
+
+const SHELL_STATUS = /^Command (?:exited with code (\d+)|(timed out.*|aborted|terminated.*))$/iu;
+
+/**
+ * A failure as Claude Code reports it. A command leads with its exit code and
+ * then shows what it printed; another tool leads with its reason alone.
+ */
+export function claudeFailure(name: string, output: string): { headline: string; detail: string } {
+	if (name === "bash" || name === "powershell" || !TOOL_NAMES.has(name)) {
+		const lines = normalizeLineEndings(output).trimEnd().split("\n");
+		const status = lines.at(-1)?.trim().match(SHELL_STATUS);
+		if (status) {
+			const headline = status[1] !== undefined ? `Error: Exit code ${status[1]}` : `Error: ${status[2]}`;
+			return { headline, detail: lines.slice(0, -1).join("\n").trimEnd() };
+		}
+		if (name === "bash" || name === "powershell") return { headline: "Error", detail: output.trimEnd() };
+	}
+	const reason = summarizeFailure(name, output);
+	return { headline: reason ? `Error: ${reason}` : "Error", detail: "" };
+}
+
+const TOOL_NAMES = new Set(Object.keys(LABELS));

package/extensions/compact-tools-config.ts

@@ -3,10 +3,12 @@ import { join } from "node:path";
 import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 import {
 	DISPLAY_MODES,
+	DISPLAY_STYLES,
 	SUPPORTED_TOOL_SET,
 	type CompactToolName,
 	type CompactToolsConfig,
 	type DisplayMode,
+	type DisplayStyle,
 } from "./compact-tools-types.ts";
 
 const CONFIG_FILE = "compact-tools.json";
@@ -14,6 +16,7 @@ type JsonObject = Record<string, unknown>;
 
 export const DEFAULT_CONFIG: CompactToolsConfig = {
 	mode: "normal",
+	style: "compact",
 	tools: ["read", "write", "edit", "bash"],
 	previewLines: 10,
 	auto_compact: {
@@ -45,9 +48,9 @@ function isIntegerInRange(value: unknown, minimum: number, maximum: number): val
 	return typeof value === "number" && Number.isInteger(value) && value >= minimum && value <= maximum;
 }
 
-function parseMode(value: unknown, path: string): DisplayMode | undefined {
-	if ((DISPLAY_MODES as readonly unknown[]).includes(value)) return value as DisplayMode;
-	warn(path, `mode must be one of ${DISPLAY_MODES.join(", ")}; using previous value`);
+function parseChoice<T extends string>(value: unknown, choices: readonly T[], key: string, path: string): T | undefined {
+	if ((choices as readonly unknown[]).includes(value)) return value as T;
+	warn(path, `${key} must be one of ${choices.join(", ")}; using previous value`);
 	return undefined;
 }
 
@@ -121,7 +124,8 @@ export function mergeConfig(base: CompactToolsConfig, value: unknown, path: stri
 		warn(path, "expected a JSON object; using previous values");
 		return base;
 	}
-	const mode = value.mode === undefined ? base.mode : (parseMode(value.mode, path) ?? base.mode);
+	const mode = value.mode === undefined ? base.mode : (parseChoice<DisplayMode>(value.mode, DISPLAY_MODES, "mode", path) ?? base.mode);
+	const style = value.style === undefined ? base.style : (parseChoice<DisplayStyle>(value.style, DISPLAY_STYLES, "style", path) ?? base.style);
 	const tools = value.tools === undefined ? base.tools : (parseTools(value.tools, path) ?? base.tools);
 	const auto_compact = parseAutoCompact(base.auto_compact, value.auto_compact, path);
 	const custom_tools = parseCustomTools(base.custom_tools, value.custom_tools, path);
@@ -130,7 +134,7 @@ export function mergeConfig(base: CompactToolsConfig, value: unknown, path: stri
 	if (value.previewLines !== undefined && !isIntegerInRange(value.previewLines, 1, 100)) {
 		warn(path, "previewLines must be 1–100; using previous value");
 	}
-	return { mode, tools, auto_compact, custom_tools, previewLines };
+	return { mode, style, tools, auto_compact, custom_tools, previewLines };
 }
 
 function readJson(path: string): unknown {