pi-compact-tools 0.10.1 → 0.11.1

package/README.md

@@ -1,19 +1,8 @@
 # pi-compact-tools
 
-Compact, expandable tool rows for Pi, including 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.
 
-![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 rows for custom tools from other packages, with no setup
-- Syntax-highlighted edit diffs, with lines added and removed: `(+3 -1)`
-- Numbered code views for `read` and `write`
-- Silent mode: only prompts and final answers
-- Works with any theme; 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
 
@@ -23,62 +12,64 @@ pi install npm:pi-compact-tools
 
 Restart Pi or run `/reload`. For the bundled theme, set `"theme": "github-dark-pro"` in `~/.pi/agent/settings.json`.
 
-## Configuration
+## Usage
 
-All settings go in one optional file: `~/.pi/agent/compact-tools.json`, or `<project>/.pi/compact-tools.json` for one project. Every key is optional.
+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 },
-  "mode": "normal",
-  "custom_tools": { "enabled": true, "auto_compact": true, "exclude": [] }
-}
-```
+| | 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`: built-in tools to compact. Also available: `grep`, `find`, `ls`, `powershell`.
-- `auto_compact`: `true` starts a row hidden, `false` shows a preview of up to `previewLines` rows. Custom tool names work too.
-- `mode`: `"normal"` or `"silent"`. See [Silent mode](#silent-mode).
-- `custom_tools`: see [Custom tools](#custom-tools).
+Set `"style"` in the config below, then `/reload`. `"style": "off"` restores Pi's own rows.
 
-## Custom tools
+### Style: Compact
 
-![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)
+![Compact style: searches, reads, a test run, and an edit with its diff, one row each](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/compact-workflow.gif)
 
-Tools from other packages get compact rows automatically. Expanding a row shows the tool's own result view.
+- One row per call: status, duration, and line count.
+- Edits show a highlighted diff with `(+3 -1)`; reads and writes show numbered code.
 
-Set them with the `custom_tools` key in the same `compact-tools.json`:
+### Style: Claude
 
-```json
-{
-  "auto_compact": { "web_search": false },
-  "custom_tools": { "enabled": true, "auto_compact": true, "exclude": ["my_tool"] }
-}
-```
+![Claude style: reads and searches folded into one line, then Bash and Update rows](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/claude-style.gif)
 
-- `enabled`: `false` turns this off for every custom tool.
-- `auto_compact`: the default for every custom tool. Override one tool in the top-level `auto_compact`, like `web_search` above.
-- `exclude`: tools that keep their original look.
+- 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.
 
-## Silent mode
+### Mode: Silent
 
-![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)
+![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)
 
-Shows only your prompts and the final answers. Tool calls, thinking, and notices are hidden while a light under the prompt shows the agent is working.
+Shows only your prompts and the answers, in either style.
 
-- Toggle with `Ctrl+'` or `/silent` (`/silent on`, `/silent off`). `Ctrl+'` needs a terminal with the Kitty keyboard protocol, such as Ghostty, Kitty, or WezTerm.
-- Start every session silent with `"mode": "silent"`.
-- Turning it off brings every hidden row back.
-- Errors are hidden too. If a run ends without an answer, turn silent mode off to see why.
+- 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.
 
-## Controls
+## Configuration
+
+Optional, in `~/.pi/agent/compact-tools.json` or `<project>/.pi/compact-tools.json`:
+
+```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": [] }
+}
+```
 
-![Ctrl+O expands every tool row, then collapses them again](https://raw.githubusercontent.com/nedleeds/pi-compact-tools/main/assets/expand-collapse.gif)
+- `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.
+
+## Controls
 
-- Click a row or press `Ctrl+O` to expand or collapse results.
+- Click a row or group, or press `Ctrl+O`, to expand and collapse.
 - `Ctrl+T` cycles thinking: summary → detail → summary → hidden.
-- `Ctrl+'` or `/silent` toggles silent mode.
 
 ## Development
 
@@ -88,7 +79,7 @@ npm run check
 pi -e .
 ```
 
-Before publishing, add the new version's notes to `release-notes.json`. Pi shows them once after users update. Use `[]` for a release with nothing to announce.
+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
 

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 {