pi-compact-tools 0.9.3 → 0.10.1

package/extensions/compact-tools.ts

@@ -29,8 +29,10 @@ import {
 } from "./compact-tools-core.ts";
 import { colorizeRgb, interpolateRgb } from "./compact-tools-color.ts";
 import { loadConfig } from "./compact-tools-config.ts";
+import { installToolRowPatch, setRowResolver, type RowRenderers, type ToolRow } from "./compact-tools-custom.ts";
 import {
 	formatResultLineSummary,
+	countEditChanges,
 	getArgumentDetails,
 	getCallDetails,
 	getEditDiff,
@@ -39,12 +41,15 @@ import {
 	getTextResult,
 	isReadTextResult,
 	splitReadFooter,
+	summarizeCustomArguments,
+	summarizeFailure,
 	summarizeShellCommand,
 } from "./compact-tools-invocation.ts";
 import {
 	CachedContainer,
 	limitComponentLines,
 	prefixedText,
+	railComponent,
 	renderArguments,
 	renderCodeDiff,
 	renderCodeView,
@@ -54,15 +59,19 @@ import {
 } from "./compact-tools-layout.ts";
 import { chromePainter, indicatorPulse } from "./compact-tools-palette.ts";
 import { ProgressController } from "./compact-tools-progress.ts";
+import { showReleaseNotice } from "./compact-tools-release.ts";
 import { ToolRuntime } from "./compact-tools-runtime.ts";
+import { SilentModeController } from "./compact-tools-silent.ts";
 import { ThinkingCycleController } from "./compact-tools-thinking.ts";
-import type {
-	BuiltInDefinition,
-	CompactToolName,
-	RenderContext,
-	RowState,
-	ShellToolName,
-	ToolArgs,
+import { ViewportKeeper } from "./compact-tools-viewport.ts";
+import {
+	SUPPORTED_TOOL_SET,
+	type BuiltInDefinition,
+	type CompactToolName,
+	type RenderContext,
+	type RowState,
+	type ShellToolName,
+	type ToolArgs,
 } from "./compact-tools-types.ts";
 
 /** Context lines kept around each change while an edit result is collapsed. */
@@ -134,6 +143,8 @@ function renderControls(
 	running: boolean,
 	isError: boolean,
 	lineSummary?: string,
+	failureReason?: string,
+	changes?: { added: number; removed: number },
 ): Component {
 	const duration = running ? undefined : formatDuration(state);
 	const status = running
@@ -143,8 +154,24 @@ function renderControls(
 	// background, so the status word stays chrome rather than repeating that signal.
 	const chrome = chromePainter(theme);
 	let details = chrome(status);
-	if (lineSummary && !running) details += chrome(` (${lineSummary})`);
-	return prefixedText(details, chrome(" └─ "), "    ");
+	if (failureReason && isError && !running) details += chrome(" · ") + theme.fg("error", failureReason);
+	// An edit reports what it changed the way a diff does: lines added and removed.
+	else if (changes && !running && !isError) {
+		details += chrome(" (") + theme.fg("toolDiffAdded", `+${changes.added}`) + chrome(" ")
+			+ theme.fg("toolDiffRemoved", `-${changes.removed}`) + chrome(")");
+	}
+	// A failed call produced no result worth counting; "(0 lines)" would only mislead.
+	else if (lineSummary && !running && !isError) details += chrome(` (${lineSummary})`);
+	return prefixedText(details, chrome(" └ "), "   ");
+}
+
+/**
+ * A failed row whose output is hidden gets its reason on the status line. When
+ * the output shows, expanded or as a preview, it already says why, and repeating
+ * it there only doubles the error.
+ */
+function hiddenFailureReason(name: string, state: RowState, isError: boolean, output: string): string | undefined {
+	return isError && !state.expanded && !state.preview ? summarizeFailure(name, output) : undefined;
 }
 
 function renderCallTitle(name: string, theme: Theme, ctx: RenderContext, state: RowState): string {
@@ -234,7 +261,8 @@ function renderFileResult(
 		state.resultLineSummary = formatResultLineSummary(name, ctx.args, result, output);
 		state.resultLineSummaryComputed = true;
 	}
-	container.addChild(renderControls(theme, state, options.isPartial, ctx.isError, state.resultLineSummary));
+	container.addChild(renderControls(theme, state, options.isPartial, ctx.isError, state.resultLineSummary,
+		hiddenFailureReason(name, state, ctx.isError, output), name === "edit" ? countEditChanges(result) : undefined));
 	rememberResult(state, result, options, ctx);
 	return container;
 }
@@ -265,13 +293,14 @@ function renderShellResult(
 	runtime.syncExpansion(state, ctx.expanded, name);
 	if (canReuseResult(state, result, options, ctx)) return ctx.lastComponent;
 	const output = getTextResult(result);
+	const failureReason = hiddenFailureReason(name, state, ctx.isError, output);
 	runtime.setResultAvailable(state, name, output.length > 0);
 	if (!options.isPartial && !state.resultLineSummaryComputed) {
 		state.resultLineSummary = formatResultLineSummary(name, ctx.args, result, output);
 		state.resultLineSummaryComputed = true;
 	}
 	if (!state.expanded && !state.preview) {
-		const controls = renderControls(theme, state, options.isPartial, ctx.isError, state.resultLineSummary);
+		const controls = renderControls(theme, state, options.isPartial, ctx.isError, state.resultLineSummary, failureReason);
 		rememberResult(state, result, options, ctx);
 		return controls;
 	}
@@ -280,11 +309,107 @@ function renderShellResult(
 	if (component) {
 		container.addChild(state.expanded ? component : limitComponentLines(component, runtime.config.previewLines, theme));
 	}
-	container.addChild(renderControls(theme, state, options.isPartial, ctx.isError, state.resultLineSummary));
+	container.addChild(renderControls(theme, state, options.isPartial, ctx.isError, state.resultLineSummary, failureReason));
+	rememberResult(state, result, options, ctx);
+	return container;
+}
+
+function renderCustomCall(name: string, args: ToolArgs, theme: Theme, ctx: RenderContext): Component {
+	const state = runtime.syncRow(ctx, ctx.state.endedAt === undefined);
+	runtime.syncExpansion(state, ctx.expanded, name);
+	const summary = summarizeCustomArguments(args);
+	const container = new CachedContainer();
+	container.addChild(renderToolCall(
+		renderCallTitle(name, theme, ctx, state),
+		summary ? theme.fg("toolOutput", summary) : undefined,
+		theme,
+	));
+	if (state.expanded && Object.keys(args).length > 0) container.addChild(renderArguments(args, theme));
+	return container;
+}
+
+type AuthorResultRenderer = (expanded: boolean) => Component | undefined;
+
+function renderCustomBody(
+	output: string,
+	expanded: boolean,
+	theme: Theme,
+	isError: boolean,
+	renderAuthorResult: AuthorResultRenderer | undefined,
+): Component | undefined {
+	if (renderAuthorResult) {
+		try {
+			const component = renderAuthorResult(expanded);
+			if (component) return railComponent(component, theme);
+		} catch {
+			// A failing third-party renderer degrades to the plain text result.
+		}
+	}
+	return renderOutput(output, theme, isError);
+}
+
+function renderCustomResult(
+	name: string,
+	result: AgentToolResult<unknown>,
+	options: ToolRenderResultOptions,
+	theme: Theme,
+	ctx: RenderContext,
+	renderAuthorResult: AuthorResultRenderer | undefined,
+): Component {
+	const state = runtime.syncRow(ctx, options.isPartial, !options.isPartial);
+	runtime.syncExpansion(state, ctx.expanded, name);
+	if (canReuseResult(state, result, options, ctx)) return ctx.lastComponent;
+	const output = getTextResult(result);
+	runtime.setResultAvailable(state, name, output.length > 0 || renderAuthorResult !== undefined);
+	if (!options.isPartial && !state.resultLineSummaryComputed) {
+		state.resultLineSummary = output ? formatResultLineSummary(name, ctx.args, result, output) : undefined;
+		state.resultLineSummaryComputed = true;
+	}
+	const container = new CachedContainer();
+	if (state.expanded || state.preview) {
+		const body = renderCustomBody(output, state.expanded === true, theme, ctx.isError, renderAuthorResult);
+		if (body) container.addChild(state.expanded ? body : limitComponentLines(body, runtime.config.previewLines, theme));
+	}
+	const failureReason = hiddenFailureReason(name, state, ctx.isError, output);
+	container.addChild(renderControls(theme, state, options.isPartial, ctx.isError, state.resultLineSummary, failureReason));
 	rememberResult(state, result, options, ctx);
 	return container;
 }
 
+/**
+ * Compact renderers for one row of a tool this extension did not register. The
+ * author's result renderer still draws the expanded body; the row chrome, status,
+ * and collapse behavior match the built-ins.
+ */
+function createCustomRenderers(name: string, author: ToolDefinition<any, any, any> | undefined): RowRenderers {
+	// Pi hands both renderers the row's own state object, which belongs to the tool's
+	// author. Compact bookkeeping is kept here so neither side overwrites the other.
+	const state: RowState = {};
+	let authorResult: Component | undefined;
+	const own = (ctx: RenderContext<any>): RenderContext => ({ ...ctx, args: ctx.args ?? {}, state });
+	return {
+		renderCall: (args, theme, ctx) => renderCustomCall(name, (args ?? {}) as ToolArgs, theme, own(ctx)),
+		renderResult: (result, options, theme, ctx) => {
+			const authorRenderer = author?.renderResult;
+			const renderAuthorResult = authorRenderer
+				? (expanded: boolean) => {
+					authorResult = authorRenderer(result, { ...options, expanded }, theme, { ...ctx, lastComponent: authorResult });
+					return authorResult;
+				}
+				: undefined;
+			return renderCustomResult(name, result, options, theme, own(ctx), renderAuthorResult);
+		},
+	};
+}
+
+function resolveCustomRow(row: ToolRow): RowRenderers | undefined {
+	const customTools = runtime.config.custom_tools;
+	// Built-ins are governed by `tools`: ones left out keep Pi's own renderer.
+	if (!customTools.enabled || SUPPORTED_TOOL_SET.has(row.toolName)) return undefined;
+	if (customTools.exclude.includes(row.toolName)) return undefined;
+	return createCustomRenderers(row.toolName, row.toolDefinition);
+}
+
 const toolFactories: Record<CompactToolName, (cwd: string) => BuiltInDefinition> = {
 	read: createReadToolDefinition,
 	write: createWriteToolDefinition,
@@ -369,6 +494,11 @@ export default function compactTools(pi: ExtensionAPI): void {
 
 	const thinkingCycle = new ThinkingCycleController(pi);
 	const progress = new ProgressController(pi);
+	const viewport = new ViewportKeeper();
+	const silent = new SilentModeController(pi, showReleaseNotice);
+	const customRowsAvailable = installToolRowPatch();
+	setRowResolver(resolveCustomRow);
+	let customRowsWarned = false;
 	// Register once while the extension runtime is being built. In particular, this
 	// makes the overrides available before Pi restores the active tool set on /reload.
 	configure(pi, process.cwd());
@@ -376,16 +506,30 @@ export default function compactTools(pi: ExtensionAPI): void {
 		if (event.reason !== "reload") runtime.clearTimings();
 		configure(pi, ctx.cwd, ctx.isProjectTrusted());
 		if (ctx.mode === "tui") {
+			// First, so its input listener sees relayout keys before the thinking controller consumes them.
+			viewport.bind(ctx);
 			progress.bind(ctx);
 			thinkingCycle.bind(ctx);
+			silent.bind(ctx, runtime.config.mode, event.reason === "reload");
+			if (!silent.isEnabled()) showReleaseNotice(ctx);
+			if (runtime.config.custom_tools.enabled && !customRowsAvailable && !customRowsWarned) {
+				customRowsWarned = true;
+				ctx.ui.notify("Compact rendering for custom tools is unavailable in this version of Pi", "warning");
+			}
 		} else {
+			viewport.dispose();
 			progress.dispose();
 			thinkingCycle.dispose();
+			silent.dispose();
 		}
 	});
+	pi.on("tool_execution_start", (event) => runtime.noteExecutionStart(event.toolCallId));
+	pi.on("tool_execution_end", (event) => runtime.noteExecutionEnd(event.toolCallId));
 	pi.on("session_shutdown", (event) => {
 		thinkingCycle.dispose();
 		progress.dispose();
+		silent.dispose();
+		viewport.dispose();
 		runtime.reset(event.reason !== "reload");
 	});
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-compact-tools",
-  "version": "0.9.3",
-  "description": "Compact, expandable UI for pi's built-in tools, bundled with a polished GitHub Dark theme.",
+  "version": "0.10.1",
+  "description": "Compact, expandable UI for pi's built-in and custom tools, bundled with a polished GitHub Dark theme.",
   "type": "module",
   "license": "MIT",
   "author": "Dong Hyeong Lee",
@@ -26,6 +26,7 @@
     "examples",
     "scripts",
     "schemas",
+    "release-notes.json",
     "README.md",
     "LICENSE"
   ],

package/release-notes.json

@@ -0,0 +1,11 @@
+{
+  "0.10.1": [],
+  "0.10.0": [
+    "Silent mode shows only prompts and final answers (Ctrl+' or /silent)",
+    "Tools from other packages get the same compact rows as the built-ins",
+    "Edits show the lines they added and removed, in the diff colors",
+    "Thinking summaries are shown in full instead of cut off",
+    "Fullscreen scrolling stays in place when expanding rows or cycling thinking",
+    "Failed rows show a short reason while their output is hidden"
+  ]
+}

package/schemas/compact-tools.schema.json

@@ -8,6 +8,12 @@
     "$schema": {
       "type": "string"
     },
+    "mode": {
+      "description": "normal shows every tool row. silent leaves only your prompts and the final answers: tool rows, in-between assistant turns, thinking, error and abort notices, extension notices, and Pi's own status lines are hidden while a light animates beneath the prompt. Ctrl+' or /silent toggles it for the current session.",
+      "type": "string",
+      "enum": ["normal", "silent"],
+      "default": "normal"
+    },
     "tools": {
       "description": "Built-in tools that use compact rendering. Omitted tools keep Pi's default renderer.",
       "type": "array",
@@ -18,6 +24,32 @@
       },
       "default": ["read", "write", "edit", "bash"]
     },
+    "custom_tools": {
+      "description": "Compact rendering for tools registered by other extensions. true/false toggles it; the object form also sets whether rows start hidden and which tools keep their own renderer.",
+      "oneOf": [
+        { "type": "boolean" },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "enabled": { "type": "boolean", "default": true },
+            "auto_compact": {
+              "description": "True starts custom tool rows hidden; false starts with a bounded preview.",
+              "type": "boolean",
+              "default": true
+            },
+            "exclude": {
+              "description": "Tool names that keep their own renderer.",
+              "type": "array",
+              "uniqueItems": true,
+              "items": { "type": "string" },
+              "default": []
+            }
+          }
+        }
+      ],
+      "default": { "enabled": true, "auto_compact": true, "exclude": [] }
+    },
     "previewLines": {
       "description": "Maximum rendered lines shown initially when auto_compact is false. Explicit expansion always shows the complete result.",
       "type": "integer",
@@ -26,9 +58,9 @@
       "default": 10
     },
     "auto_compact": {
-      "description": "Whether each compact-rendered tool starts hidden. False starts with a bounded preview; Pi's normal click and Ctrl+O flow can expand either state.",
+      "description": "Whether each compact-rendered tool starts hidden. False starts with a bounded preview; Pi's normal click and Ctrl+O flow can expand either state. Custom tools can be listed by name too, which overrides custom_tools.auto_compact for that tool.",
       "type": "object",
-      "additionalProperties": false,
+      "additionalProperties": { "type": "boolean" },
       "properties": {
         "read": { "type": "boolean", "default": true },
         "write": { "type": "boolean", "default": true },

package/scripts/check-resources.mjs

@@ -5,6 +5,7 @@ const resources = [
   "examples/compact-tools.json",
   "examples/compact-tools-2.json",
   "schemas/compact-tools.schema.json",
+  "release-notes.json",
 ];
 
 for (const path of resources) {
@@ -70,4 +71,12 @@ if (schema.properties?.previewLines?.default !== 10) {
   throw new Error("schema must expose the bounded previewLines setting");
 }
 
+const manifest = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+const releaseNotes = JSON.parse(await readFile(new URL("../release-notes.json", import.meta.url), "utf8"));
+// Every published version needs an entry. An empty list is a quiet release that shows no notice.
+if (!Array.isArray(releaseNotes[manifest.version]) ||
+    releaseNotes[manifest.version].some((note) => typeof note !== "string" || !note.trim())) {
+  throw new Error(`release-notes.json must have an entry for v${manifest.version} before publishing; use [] for no notice`);
+}
+
 console.log("Resource checks passed");