pi-compact-tools 0.6.1 → 0.7.7

package/extensions/compact-tools.ts

@@ -3,7 +3,6 @@ import type {
 	BashToolDetails,
 	BashToolInput,
 	ExtensionAPI,
-	ExtensionContext,
 	Theme,
 	ToolDefinition,
 	ToolRenderResultOptions,
@@ -22,28 +21,34 @@ import type { Component, Container } from "@earendil-works/pi-tui";
 import {
 	classifyCallStatus,
 	formatDurationMs,
+	indicatorGlyph,
+	indicatorStrength,
+	indicatorTone,
 	normalizeLineEndings,
 	type RowStatus,
 } from "./compact-tools-core.ts";
-import { isFullscreenMode, loadConfig } from "./compact-tools-config.ts";
-import { classifyToggleInput } from "./compact-tools-input.ts";
+import { colorizeRgb, interpolateRgb, themeColorRgb } from "./compact-tools-color.ts";
+import { loadConfig } from "./compact-tools-config.ts";
 import {
-	formatArgumentSummary,
-	formatReadResultSummary,
+	formatResultLineSummary,
 	getArgumentDetails,
 	getCallDetails,
+	getEditChanges,
 	getFileOutput,
 	getTextResult,
+	summarizeShellCommand,
 } from "./compact-tools-invocation.ts";
 import {
 	CachedContainer,
+	limitComponentLines,
 	prefixedText,
 	renderArguments,
+	renderEditChanges,
 	renderOutput,
 	renderToolCall,
 	styleMultiline,
-	wrapEditResult,
 } from "./compact-tools-layout.ts";
+import { ProgressController } from "./compact-tools-progress.ts";
 import { ToolRuntime } from "./compact-tools-runtime.ts";
 import { ThinkingCycleController } from "./compact-tools-thinking.ts";
 import type {
@@ -57,37 +62,27 @@ import type {
 
 const runtime = new ToolRuntime();
 const registeredTools = new Set<CompactToolName>();
-let unsubscribeTerminalInput: (() => void) | undefined;
-
-function bindTerminalInput(ctx: ExtensionContext): void {
-	unsubscribeTerminalInput?.();
-	unsubscribeTerminalInput = ctx.ui.onTerminalInput((data) => {
-		const input = classifyToggleInput(data);
-		if (!input) return undefined;
-		if (input === "release") return { consume: true };
-		const result = runtime.toggleTrackedRows();
-		if (result) ctx.ui.notify(`Compact tool rows: ${result}`, "info");
-		return { consume: true };
-	});
-}
-
-function spinnerTone(frameIndex: number, frameCount: number): "muted" | "dim" | "border" {
-	if (frameCount < 3) return "muted";
-	const distanceFromCenter = Math.abs(frameIndex / (frameCount - 1) - 0.5) * 2;
-	if (distanceFromCenter < 0.34) return "border";
-	return distanceFromCenter < 0.75 ? "dim" : "muted";
-}
+let registeredConfiguration: string | undefined;
 
 function callStatus(ctx: RenderContext, state: RowState): RowStatus {
-	return classifyCallStatus(ctx.isError, ctx.executionStarted, state.endedAt !== undefined);
+	// write/edit arguments can stream for much longer than their eventual filesystem
+	// operation. Treat that active tool-call phase as running so every built-in row
+	// animates consistently instead of waiting for execute() to begin.
+	const active = ctx.executionStarted || !ctx.argsComplete;
+	return classifyCallStatus(ctx.isError, active, state.endedAt !== undefined);
 }
 
-function renderIndicator(theme: Theme, state: RowState, status: RowStatus): string {
-	if (status === "error") return theme.fg("error", "●");
-	if (status === "success") return theme.fg("success", "●");
-	const frames = runtime.config.spinner.frames;
-	const frameIndex = state.frame ?? 0;
-	return theme.fg(spinnerTone(frameIndex, frames.length), frames[frameIndex] ?? frames[0] ?? "◐");
+function renderIndicator(theme: Theme, ctx: RenderContext, status: RowStatus): string {
+	const frame = runtime.syncIndicator(ctx.toolCallId, status === "running", () => ctx.invalidate());
+	const glyph = indicatorGlyph(status, frame);
+	if (status === "running") {
+		const bright = themeColorRgb(theme, "borderAccent");
+		const dim = themeColorRgb(theme, "borderMuted");
+		if (bright && dim) {
+			return colorizeRgb(theme, interpolateRgb(dim, bright, indicatorStrength(status, frame)), glyph);
+		}
+	}
+	return theme.fg(indicatorTone(status, frame), glyph);
 }
 
 function formatDuration(state: RowState): string | undefined {
@@ -95,33 +90,55 @@ function formatDuration(state: RowState): string | undefined {
 	return formatDurationMs((state.endedAt ?? Date.now()) - state.startedAt);
 }
 
+function canReuseResult<TDetails, TArgs>(
+	state: RowState,
+	result: AgentToolResult<TDetails>,
+	options: ToolRenderResultOptions,
+	ctx: RenderContext<TArgs>,
+): ctx is RenderContext<TArgs> & { lastComponent: Component } {
+	return ctx.lastComponent !== undefined
+		&& state.lastResultContent === result.content
+		&& state.lastResultDetails === result.details
+		&& state.lastResultPartial === options.isPartial
+		&& state.lastResultExpanded === state.expanded
+		&& state.lastResultPreview === state.preview
+		&& state.lastResultError === ctx.isError
+		&& state.lastResultConfigRevision === state.configRevision;
+}
+
+function rememberResult<TDetails, TArgs>(
+	state: RowState,
+	result: AgentToolResult<TDetails>,
+	options: ToolRenderResultOptions,
+	ctx: RenderContext<TArgs>,
+): void {
+	state.lastResultContent = result.content;
+	state.lastResultDetails = result.details;
+	state.lastResultPartial = options.isPartial;
+	state.lastResultExpanded = state.expanded;
+	state.lastResultPreview = state.preview;
+	state.lastResultError = ctx.isError;
+	state.lastResultConfigRevision = state.configRevision;
+}
+
 function renderControls(
 	theme: Theme,
 	state: RowState,
 	running: boolean,
 	isError: boolean,
-	summary?: string,
-	argumentSummary?: string,
+	lineSummary?: string,
 ): Component {
-	const duration = running && !runtime.animatesRows ? undefined : formatDuration(state);
+	const duration = running ? undefined : formatDuration(state);
 	const status = running
 		? (duration ?? "Running")
 		: `${isError ? "Failed" : "Done"}${duration ? ` in ${duration}` : ""}`;
 	let details = theme.fg("borderAccent", status);
-	if (argumentSummary && !running) details += theme.fg("borderAccent", ` (${argumentSummary})`);
-	if (summary) details += theme.fg("borderAccent", ` • ${summary}`);
-	if (state.hasResult) {
-		const clickAction = state.expanded ? "to hide" : "for result";
-		details += theme.fg(
-			"borderAccent",
-			`, ${theme.italic("ctrl+o")} toggle all • ${theme.italic("click")} ${clickAction}`,
-		);
-	}
+	if (lineSummary && !running) details += theme.fg("borderAccent", ` (${lineSummary})`);
 	return prefixedText(details, theme.fg("border", " └─ "), "    ");
 }
 
 function renderCallTitle(name: string, theme: Theme, ctx: RenderContext, state: RowState): string {
-	return `${renderIndicator(theme, state, callStatus(ctx, state))} ${theme.fg("toolTitle", theme.bold(name))}`;
+	return `${renderIndicator(theme, ctx, callStatus(ctx, state))} ${theme.fg("toolTitle", theme.bold(name))}`;
 }
 
 function renderFileCall(
@@ -132,7 +149,6 @@ function renderFileCall(
 ): Container {
 	const name = definition.name as CompactToolName;
 	const state = runtime.syncRow(ctx, ctx.state.endedAt === undefined);
-	runtime.track(ctx, name, state);
 	runtime.syncExpansion(state, ctx.expanded, name);
 	const callDetails = getCallDetails(name, args);
 	const details = callDetails
@@ -145,38 +161,21 @@ function renderFileCall(
 	return container;
 }
 
-function updateEditResult(
-	definition: BuiltInDefinition,
-	result: AgentToolResult<unknown>,
-	options: ToolRenderResultOptions,
-	theme: Theme,
-	ctx: RenderContext,
-	state: RowState,
-): void {
-	if (definition.name !== "edit" || !definition.renderResult) return;
-	state.originalResultComponent = definition.renderResult(
-		result,
-		{ ...options, expanded: state.expanded ?? false },
-		theme,
-		{ ...ctx, state: {}, lastComponent: state.originalResultComponent },
-	);
-}
-
 function appendFileResult(
 	container: Container,
 	definition: BuiltInDefinition,
 	state: RowState,
 	output: string,
+	editChanges: string,
 	theme: Theme,
 	isError: boolean,
 ): void {
-	if (!state.expanded) return;
-	if (definition.name === "edit") {
-		if (state.originalResultComponent) container.addChild(wrapEditResult(state.originalResultComponent, theme));
-		return;
-	}
-	const component = renderOutput(output, theme, isError);
-	if (component) container.addChild(component);
+	if (!state.expanded && !state.preview) return;
+	const component = definition.name === "edit" && editChanges
+		? renderEditChanges(editChanges, theme)
+		: renderOutput(output, theme, isError);
+	if (!component) return;
+	container.addChild(state.expanded ? component : limitComponentLines(component, runtime.config.previewLines, theme));
 }
 
 function renderFileResult(
@@ -185,18 +184,22 @@ function renderFileResult(
 	options: ToolRenderResultOptions,
 	theme: Theme,
 	ctx: RenderContext,
-): Container {
+): Component {
 	const name = definition.name as CompactToolName;
 	const state = runtime.syncRow(ctx, options.isPartial, !options.isPartial);
-	runtime.track(ctx, name, state);
+	runtime.syncExpansion(state, ctx.expanded, name);
+	if (canReuseResult(state, result, options, ctx)) return ctx.lastComponent;
 	const output = getFileOutput(name, ctx.args, result, ctx.isError);
-	runtime.setResultAvailable(state, name, name === "edit" || output.length > 0);
-	updateEditResult(definition, result, options, theme, ctx, state);
+	const editChanges = name === "edit" ? getEditChanges(result) : "";
+	runtime.setResultAvailable(state, name, editChanges.length > 0 || output.length > 0);
 	const container = new CachedContainer();
-	appendFileResult(container, definition, state, output, theme, ctx.isError);
-	const summary = name === "read" && !ctx.isError ? formatReadResultSummary(result) : undefined;
-	const argumentSummary = formatArgumentSummary(name, ctx.args);
-	container.addChild(renderControls(theme, state, options.isPartial, ctx.isError, summary, argumentSummary));
+	appendFileResult(container, definition, state, output, editChanges, theme, ctx.isError);
+	if (!options.isPartial && !state.resultLineSummaryComputed) {
+		state.resultLineSummary = formatResultLineSummary(name, ctx.args, result, output);
+		state.resultLineSummaryComputed = true;
+	}
+	container.addChild(renderControls(theme, state, options.isPartial, ctx.isError, state.resultLineSummary));
+	rememberResult(state, result, options, ctx);
 	return container;
 }
 
@@ -207,10 +210,11 @@ function renderShellCall(
 	ctx: RenderContext<BashToolInput>,
 ): Component {
 	const state = runtime.syncRow(ctx, ctx.state.endedAt === undefined);
-	runtime.track(ctx, name, state);
 	runtime.syncExpansion(state, ctx.expanded, name);
-	const command = normalizeLineEndings(args.command ?? "") || "…";
-	const details = styleMultiline(command, (line) => theme.fg("toolOutput", line));
+	const command = normalizeLineEndings(args.command ?? "");
+	const details = state.expanded
+		? styleMultiline(command || "…", (line) => theme.fg("toolOutput", line))
+		: theme.fg("toolOutput", summarizeShellCommand(name, command));
 	return renderToolCall(renderCallTitle(name, theme, ctx, state), details, theme);
 }
 
@@ -222,14 +226,26 @@ function renderShellResult(
 	ctx: RenderContext<BashToolInput>,
 ): Component {
 	const state = runtime.syncRow(ctx, options.isPartial, !options.isPartial);
-	runtime.track(ctx, name, state);
+	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);
-	if (!state.expanded) return renderControls(theme, state, options.isPartial, ctx.isError);
+	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);
+		rememberResult(state, result, options, ctx);
+		return controls;
+	}
 	const container = new CachedContainer();
 	const component = renderOutput(output, theme, ctx.isError);
-	if (component) container.addChild(component);
-	container.addChild(renderControls(theme, state, options.isPartial, ctx.isError));
+	if (component) {
+		container.addChild(state.expanded ? component : limitComponentLines(component, runtime.config.previewLines, theme));
+	}
+	container.addChild(renderControls(theme, state, options.isPartial, ctx.isError, state.resultLineSummary));
+	rememberResult(state, result, options, ctx);
 	return container;
 }
 
@@ -283,6 +299,8 @@ function registerShellTool(pi: ExtensionAPI, definition: BuiltInDefinition): voi
 function registerTools(pi: ExtensionAPI, cwd: string): void {
 	const enabledTools = new Set(runtime.config.tools);
 	for (const name of registeredTools) {
+		// Pi exposes no unregister API, so restoring a disabled tool means re-registering
+		// the built-in definition to release this extension's renderers.
 		if (!enabledTools.has(name)) pi.registerTool(createBuiltInDefinition(name, cwd));
 	}
 	registeredTools.clear();
@@ -295,24 +313,38 @@ function registerTools(pi: ExtensionAPI, cwd: string): void {
 }
 
 function configure(pi: ExtensionAPI, cwd?: string, projectTrusted = false): void {
-	runtime.configure(loadConfig(cwd, projectTrusted), isFullscreenMode());
-	registerTools(pi, cwd ?? process.cwd());
+	const resolvedCwd = cwd ?? process.cwd();
+	const config = loadConfig(resolvedCwd, projectTrusted);
+	const signature = JSON.stringify([resolvedCwd, config]);
+	if (signature === registeredConfiguration) return;
+	runtime.configure(config);
+	registerTools(pi, resolvedCwd);
+	registeredConfiguration = signature;
 }
 
 export default function compactTools(pi: ExtensionAPI): void {
 	const thinkingCycle = new ThinkingCycleController(pi);
-	configure(pi);
+	const progress = new ProgressController(pi);
+	// 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());
 	pi.on("session_start", (event, ctx) => {
 		if (event.reason !== "reload") runtime.clearTimings();
 		configure(pi, ctx.cwd, ctx.isProjectTrusted());
-		bindTerminalInput(ctx);
-		thinkingCycle.bind(ctx);
+		if (ctx.mode === "tui") {
+			progress.bind(ctx);
+			thinkingCycle.bind(ctx);
+		} else {
+			progress.dispose();
+			thinkingCycle.dispose();
+		}
 	});
-	pi.on("resources_discover", (_event, ctx) => configure(pi, ctx.cwd, ctx.isProjectTrusted()));
 	pi.on("session_shutdown", (event) => {
 		thinkingCycle.dispose();
-		unsubscribeTerminalInput?.();
-		unsubscribeTerminalInput = undefined;
+		progress.dispose();
 		runtime.reset(event.reason !== "reload");
+		// Some Pi hosts rebuild the active tool registry during reload while keeping
+		// this module instance. Force the next session to restore our renderers.
+		if (event.reason === "reload") registeredConfiguration = undefined;
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-tools",
-  "version": "0.6.1",
+  "version": "0.7.7",
   "description": "Compact, expandable UI for pi's built-in tools, bundled with a polished GitHub Dark theme.",
   "type": "module",
   "license": "MIT",

package/schemas/compact-tools.schema.json

@@ -18,8 +18,15 @@
       },
       "default": ["read", "write", "edit", "bash"]
     },
+    "previewLines": {
+      "description": "Maximum rendered lines shown initially when auto_compact is false. Explicit expansion always shows the complete result.",
+      "type": "integer",
+      "minimum": 1,
+      "maximum": 100,
+      "default": 10
+    },
     "auto_compact": {
-      "description": "Whether each compact-rendered tool starts compact and participates in the global Ctrl+O expand/collapse action. False starts expanded and excludes the tool from that action; clicking remains available.",
+      "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.",
       "type": "object",
       "additionalProperties": false,
       "properties": {
@@ -38,29 +45,6 @@
         "edit": false,
         "bash": true
       }
-    },
-    "spinner": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "frames": {
-          "description": "Animation frames. Use terminal-safe single-width characters for consistent alignment.",
-          "type": "array",
-          "minItems": 1,
-          "items": {
-            "type": "string",
-            "minLength": 1
-          },
-          "default": ["◐", "◓", "◑", "◒"]
-        },
-        "intervalMs": {
-          "description": "Milliseconds between spinner frames.",
-          "type": "integer",
-          "minimum": 40,
-          "maximum": 5000,
-          "default": 120
-        }
-      }
     }
   }
 }

package/scripts/check-resources.mjs

@@ -21,7 +21,7 @@ if (theme.name !== "github-dark-pro" || !theme.colors || typeof theme.colors !==
   throw new Error("themes/github-dark-pro.json is not a valid pi theme document");
 }
 if (!theme.colors.border || !theme.colors.dim || !theme.colors.muted) {
-  throw new Error("github-dark-pro must define spinner and separator colors");
+  throw new Error("github-dark-pro must define separator colors");
 }
 if (!theme.vars?.thinkingText || !theme.colors.thinkingMax) {
   throw new Error("github-dark-pro must define thinking text and summary colors");
@@ -33,31 +33,25 @@ if (!theme.colors.mdQuote || !theme.colors.mdCodeBlockBorder) {
 const example = JSON.parse(
   await readFile(new URL("../examples/compact-tools.json", import.meta.url), "utf8"),
 );
-if (!Array.isArray(example.spinner?.frames) || example.spinner.frames.length === 0) {
-  throw new Error("example spinner.frames must be a non-empty array");
-}
-if (!Number.isInteger(example.spinner.intervalMs)) {
-  throw new Error("example spinner.intervalMs must be an integer");
-}
 if (!example.auto_compact || example.auto_compact.edit !== false) {
   throw new Error("example auto_compact policy must keep edit diffs visible by default");
 }
 if (Object.values(example.auto_compact).some((enabled) => typeof enabled !== "boolean")) {
   throw new Error("example auto_compact values must be booleans");
 }
-if ("previewLines" in example) {
-  throw new Error("example must not contain the removed previewLines setting");
+if (!Number.isInteger(example.previewLines) || example.previewLines < 1 || example.previewLines > 100) {
+  throw new Error("example previewLines must be an integer from 1 to 100");
 }
-const blinkExample = JSON.parse(
+const alternateExample = JSON.parse(
   await readFile(new URL("../examples/compact-tools-2.json", import.meta.url), "utf8"),
 );
-if (JSON.stringify(blinkExample.spinner?.frames) !== JSON.stringify(["●", "●", " ", "●", "●"])) {
-  throw new Error("compact-tools-2 spinner must fade through repeated circles and a blank frame");
-}
-for (const [name, config] of [["compact-tools", example], ["compact-tools-2", blinkExample]]) {
+for (const [name, config] of [["compact-tools", example], ["compact-tools-2", alternateExample]]) {
   if ("durationIndicators" in config) {
     throw new Error(`${name} must not contain the removed durationIndicators setting`);
   }
+  if ("spinner" in config) {
+    throw new Error(`${name} must not contain the removed spinner setting`);
+  }
 }
 
 const schema = JSON.parse(
@@ -66,11 +60,14 @@ const schema = JSON.parse(
 if (schema.properties?.durationIndicators) {
   throw new Error("schema must not expose the removed durationIndicators setting");
 }
+if (schema.properties?.spinner) {
+  throw new Error("schema must not expose the removed spinner setting");
+}
 if (!schema.properties?.auto_compact?.properties?.edit) {
   throw new Error("schema must describe per-tool auto_compact policies");
 }
-if (schema.properties?.previewLines) {
-  throw new Error("schema must not expose the removed previewLines setting");
+if (schema.properties?.previewLines?.default !== 10) {
+  throw new Error("schema must expose the bounded previewLines setting");
 }
 
 console.log("Resource checks passed");

package/extensions/compact-tools-input.ts

@@ -1,8 +0,0 @@
-import { isKeyRelease, Key, matchesKey } from "@earendil-works/pi-tui";
-
-export type ToggleInput = "toggle" | "release";
-
-export function classifyToggleInput(data: string): ToggleInput | undefined {
-	if (!matchesKey(data, Key.ctrl("o"))) return undefined;
-	return isKeyRelease(data) ? "release" : "toggle";
-}