pi-compact-tools 0.4.2 → 0.5.0

package/README.md

@@ -31,8 +31,8 @@ Completed `edit` rows show their full diff initially by default. The per-tool `a
 - Compact rendering for `read`, `write`, `edit`, `bash`, `powershell`, `grep`, `find`, and `ls`
 - Animated configurable spinner in fullscreen TUI mode
 - Millisecond-precision duration and configurable completion icons
-- Per-tool initial compaction with `auto_compact: true` or `false`
-- Click or `Ctrl+O` always cycles through meaningful detail levels
+- Per-tool initial compaction and global-toggle participation with `auto_compact: true` or `false`
+- Click cycles one row through meaningful detail levels; `Ctrl+O` expands or collapses all participating rows
 - Short previews, full output, and initially visible edit diffs by default
 - Dark `│` and `└─` visual grouping
 - Distinct cool-blue thinking text
@@ -104,13 +104,13 @@ These defaults use emoji and standard Unicode, so they work without a Nerd Font.
 
 For a minimal blinking spinner that reuses the successful-tool circle, copy [`examples/compact-tools-2.json`](examples/compact-tools-2.json). Its frames use `● ● (blank) ● ●` at 120 ms intervals. The renderer's built-in frame dimming turns this into a fade-out/fade-in animation without Nerd Font glyphs. Duration indicators use a small `•` whose color changes by elapsed time; the fast tier uses the theme's warning color value `#E0A052` directly. Rename it to `compact-tools.json` or copy its contents to the active configuration path.
 
-`auto_compact` controls each tool's initial state independently:
+`auto_compact` controls each tool's initial state and whether it participates in the global `Ctrl+O` toggle:
 
-- `true` starts at the compact summary.
-- `false` starts at the most detailed available level.
-- Click or `Ctrl+O` continues to cycle through available levels in either case.
+- `true` starts at the compact summary and participates in `Ctrl+O`.
+- `false` starts at the most detailed available level and is unaffected by `Ctrl+O`.
+- Clicking any compact-rendered row still cycles that row through its available levels.
 
-Unspecified entries inherit the previous configuration layer. By default, `read`, `write`, and `bash` start compact, while `edit` starts expanded so code diffs are immediately visible.
+Unspecified entries inherit the previous configuration layer. By default, `read`, `write`, and `bash` start compact and participate in the global toggle, while `edit` starts expanded and remains unaffected so code diffs stay visible.
 
 `durationIndicators` must have ascending `underMs` values, with a final fallback entry that omits `underMs`. `color` is optional and accepts a supported theme color or six-digit hex value. Existing icon-only configurations remain compatible.
 
@@ -150,13 +150,19 @@ The escaped code points remain readable on GitHub and are decoded to Nerd Font i
 
 ## Controls
 
-`Ctrl+O` or a mouse click cycles only through available content:
+A mouse click cycles one row through its available content:
 
 ```text
 summary → arguments → output preview → full output → summary
 ```
 
-The `auto_compact` boolean only chooses where that cycle starts. With the default `edit: false`, the diff starts visible and the next click collapses it.
+`Ctrl+O` operates on all rows whose tool has `auto_compact: true`:
+
+- If any participating row is not fully expanded, it expands all participating rows.
+- If every participating row is fully expanded, it collapses all participating rows.
+- Rows whose tool has `auto_compact: false` are left unchanged.
+
+The extension handles and consumes `Ctrl+O` directly, so no Pi keybinding changes are required. With the default `edit: false`, edit diffs start visible and are excluded from the global toggle, while clicking an edit row still collapses or expands it.
 
 ## Notes
 

package/extensions/compact-tools-core.ts

@@ -13,6 +13,14 @@ export type DurationIndicatorConfig = {
 	color?: DurationIndicatorColor;
 };
 export type RowStatus = "pending" | "running" | "success" | "error";
+export type ExpandableLevelState = {
+	level?: number;
+	levels: readonly number[];
+};
+
+export function shouldExpandAll(rows: readonly ExpandableLevelState[]): boolean {
+	return rows.some(({ level, levels }) => level !== levels.at(-1));
+}
 
 const DURATION_INDICATOR_COLOR_SET = new Set<string>(DURATION_INDICATOR_COLORS);
 export const HEX_COLOR_PATTERN = /^#[0-9a-f]{6}$/i;

package/extensions/compact-tools.ts

@@ -7,6 +7,7 @@ import type {
 	BashToolDetails,
 	BashToolInput,
 	ExtensionAPI,
+	ExtensionContext,
 	Theme,
 	ToolDefinition,
 	ToolRenderResultOptions,
@@ -24,7 +25,7 @@ import {
 	getAgentDir,
 } from "@earendil-works/pi-coding-agent";
 import type { Component } from "@earendil-works/pi-tui";
-import { Container, Text, visibleWidth } from "@earendil-works/pi-tui";
+import { Container, Key, matchesKey, Text, visibleWidth } from "@earendil-works/pi-tui";
 import {
 	classifyCallStatus,
 	formatDurationMs,
@@ -33,6 +34,7 @@ import {
 	parseDurationIndicators,
 	rgbToAnsi256,
 	selectDurationIndicator,
+	shouldExpandAll,
 	type DurationIndicatorConfig,
 	type RowStatus,
 	type ThemeDurationIndicatorColor,
@@ -82,13 +84,16 @@ export const DEFAULT_CONFIG: CompactToolsConfig = {
 };
 
 let config = DEFAULT_CONFIG;
+let configRevision: object = {};
 let animateRows = false;
+let unsubscribeTerminalInput: (() => void) | undefined;
 const registeredCompactTools = new Set<CompactToolName>();
 
 interface RowState {
 	level?: number;
 	availableLevels?: number[];
 	lastExpanded?: boolean;
+	configRevision?: object;
 	frame?: number;
 	startedAt?: number;
 	endedAt?: number;
@@ -240,7 +245,13 @@ export function loadConfig(cwd?: string, projectTrusted = false): CompactToolsCo
 
 const SPINNING_ROWS_KEY = Symbol.for("pi.compact-tools.spinning-rows");
 const EXECUTION_TIMINGS_KEY = Symbol.for("pi.compact-tools.execution-timings");
+const MAX_TRACKED_ROWS = 2_000;
 type ExecutionTiming = { startedAt: number; endedAt?: number };
+type TrackedRow = {
+	state: RowState;
+	name: CompactToolName;
+	invalidate: () => void;
+};
 const globalState = globalThis as typeof globalThis & {
 	[SPINNING_ROWS_KEY]?: Set<RowState>;
 	[EXECUTION_TIMINGS_KEY]?: Map<string, ExecutionTiming>;
@@ -250,12 +261,48 @@ for (const staleState of globalState[SPINNING_ROWS_KEY] ?? []) {
 }
 const spinningRows = new Set<RowState>();
 const executionTimings = globalState[EXECUTION_TIMINGS_KEY] ?? new Map<string, ExecutionTiming>();
+const trackedRows = new Map<string, TrackedRow>();
 globalState[SPINNING_ROWS_KEY] = spinningRows;
 globalState[EXECUTION_TIMINGS_KEY] = executionTimings;
 
+function trackRow(ctx: RenderContext, name: CompactToolName, state: RowState): void {
+	trackedRows.delete(ctx.toolCallId);
+	trackedRows.set(ctx.toolCallId, { state, name, invalidate: ctx.invalidate });
+	if (trackedRows.size <= MAX_TRACKED_ROWS) return;
+	const oldestToolCallId = trackedRows.keys().next().value;
+	if (oldestToolCallId !== undefined) trackedRows.delete(oldestToolCallId);
+}
+
+function toggleTrackedRows(): "expanded" | "collapsed" | undefined {
+	const rows = [...trackedRows.values()].filter(({ name, state }) => {
+		const levels = state.availableLevels ?? [0, 1];
+		return config.auto_compact[name] && levels.length > 1;
+	});
+	if (rows.length === 0) return undefined;
+
+	const expand = shouldExpandAll(rows.map(({ state }) => ({
+		level: state.level,
+		levels: state.availableLevels ?? [0, 1],
+	})));
+	for (const { state, invalidate } of rows) {
+		const levels = state.availableLevels ?? [0, 1];
+		state.level = expand ? (levels.at(-1) ?? 0) : (levels[0] ?? 0);
+		invalidate();
+	}
+	return expand ? "expanded" : "collapsed";
+}
+
+function initializeRowLevel(state: RowState, name: CompactToolName, levels = state.availableLevels): boolean {
+	if (state.configRevision === configRevision) return false;
+	state.configRevision = configRevision;
+	state.level = config.auto_compact[name] ? (levels?.[0] ?? 0) : (levels?.at(-1) ?? MAX_LEVEL);
+	return true;
+}
+
 function advanceLevel(state: RowState, expanded: boolean, name: CompactToolName): number {
+	const initialized = initializeRowLevel(state, name);
 	state.level ??= config.auto_compact[name] ? 0 : (state.availableLevels?.at(-1) ?? MAX_LEVEL);
-	if (state.lastExpanded === undefined) {
+	if (initialized || state.lastExpanded === undefined) {
 		state.lastExpanded = expanded;
 		return state.level;
 	}
@@ -270,6 +317,7 @@ function advanceLevel(state: RowState, expanded: boolean, name: CompactToolName)
 
 function setAvailableLevels(state: RowState, levels: number[], name: CompactToolName): void {
 	state.availableLevels = levels;
+	if (initializeRowLevel(state, name, levels)) return;
 	if (state.level === undefined) {
 		state.level = config.auto_compact[name] ? 0 : (levels.at(-1) ?? 0);
 	} else if (!levels.includes(state.level)) {
@@ -354,9 +402,20 @@ function syncRow(
 
 function resetUiState(clearTimings = false): void {
 	for (const state of [...spinningRows]) stopSpinner(state);
+	trackedRows.clear();
 	if (clearTimings) executionTimings.clear();
 }
 
+function bindTerminalInput(ctx: ExtensionContext): void {
+	unsubscribeTerminalInput?.();
+	unsubscribeTerminalInput = ctx.ui.onTerminalInput((data) => {
+		if (!matchesKey(data, Key.ctrl("o"))) return undefined;
+		const result = 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 position = frameIndex / (frameCount - 1);
@@ -419,7 +478,7 @@ function renderControls(theme: Theme, state: RowState, running: boolean, isError
 	const expandable = levels.length > 1;
 	const atLastLevel = state.level === levels.at(-1);
 	const action = expandable
-		? `${theme.italic("ctrl+o")} ${atLastLevel ? "to collapse" : "for more"}`
+		? `${theme.italic("ctrl+o")} toggle all • ${theme.italic("click")} ${atLastLevel ? "to collapse" : "for more"}`
 		: undefined;
 	const indicator = !running && !isError ? durationIndicator(state) : undefined;
 	const status = running
@@ -547,6 +606,7 @@ function renderFileCall(
 	// Animate and time from the first rendered call so large write/edit calls
 	// represent the full lifecycle, including streamed arguments and filesystem work.
 	const state = syncRow(ctx, ctx.state.endedAt === undefined);
+	trackRow(ctx, definition.name as CompactToolName, state);
 	// syncRow may restore a completed timing after /reload. Recompute from the
 	// synchronized state so a stale local value cannot leave the spinner visible.
 	const status = resolveCallStatus(ctx, state);
@@ -593,6 +653,7 @@ function renderFileResult(
 	ctx: RenderContext,
 ): Container {
 	const state = syncRow(ctx, options.isPartial, !options.isPartial);
+	trackRow(ctx, definition.name as CompactToolName, state);
 	const output = getFileOutput(definition.name, ctx.args, result, ctx.isError);
 	const hasArguments = Object.keys(getFileArgumentDetails(definition.name, ctx.args)).length > 0;
 	const levels = definition.name === "edit" ? [0, MAX_LEVEL] : [0, ...(hasArguments ? [1] : []), ...getOutputLevels(output)];
@@ -652,6 +713,7 @@ function renderShellCall(
 	ctx: RenderContext<BashToolInput>,
 ): Text {
 	const state = syncRow(ctx, ctx.state.endedAt === undefined);
+	trackRow(ctx, name, state);
 	// A completed timing can be restored inside syncRow. Derive the rendered
 	// status afterward so completion immediately replaces the spinner.
 	const status = resolveCallStatus(ctx, state);
@@ -671,6 +733,7 @@ function renderShellResult(
 	ctx: RenderContext<BashToolInput>,
 ): Component {
 	const state = syncRow(ctx, options.isPartial, !options.isPartial);
+	trackRow(ctx, name, state);
 	const output = getTextResult(result);
 	const hasDetailedCall = /\r\n?|\n/.test(ctx.args.command ?? "");
 	setAvailableLevels(state, [0, ...(hasDetailedCall ? [1] : []), ...getOutputLevels(output)], name);
@@ -735,6 +798,7 @@ function applyConfig(pi: ExtensionAPI, cwd: string, projectTrusted: boolean): vo
 	resetUiState();
 	animateRows = getConfiguredTuiMode() === "fullscreen";
 	config = loadConfig(cwd, projectTrusted);
+	configRevision = {};
 	registerBuiltInTools(pi, cwd);
 }
 
@@ -745,7 +809,12 @@ export default function (pi: ExtensionAPI): void {
 	pi.on("session_start", (event, ctx) => {
 		if (event.reason !== "reload") executionTimings.clear();
 		applyConfig(pi, ctx.cwd, ctx.isProjectTrusted());
+		bindTerminalInput(ctx);
 	});
 	pi.on("resources_discover", (_event, ctx) => applyConfig(pi, ctx.cwd, ctx.isProjectTrusted()));
-	pi.on("session_shutdown", (event) => resetUiState(event.reason !== "reload"));
+	pi.on("session_shutdown", (event) => {
+		unsubscribeTerminalInput?.();
+		unsubscribeTerminalInput = undefined;
+		resetUiState(event.reason !== "reload");
+	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-compact-tools",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "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

@@ -19,7 +19,7 @@
       "default": ["read", "write", "edit", "bash"]
     },
     "auto_compact": {
-      "description": "Whether each compact-rendered tool starts in its compact summary state. Click/Ctrl+O remains available regardless of this value.",
+      "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.",
       "type": "object",
       "additionalProperties": false,
       "properties": {