pi-cc-extensions 0.8.32 → 0.8.33

package/extensions/compact-thinking.ts

@@ -1,5 +1,9 @@
+import * as piAi from "@earendil-works/pi-ai";
+import * as piCodingAgent from "@earendil-works/pi-coding-agent";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import * as piTui from "@earendil-works/pi-tui";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createJiti } from "jiti";
@@ -14,41 +18,163 @@ export type CompactThinkingController = {
 	updateConfig(next: CompactThinkingConfig): void;
 };
 
+type CompactThinkingOwner = {
+	owner: object;
+	stop(event?: any, ctx?: any): void;
+};
+
+const COMPACT_THINKING_OWNER = Symbol.for("pi.ccstyle.compact-thinking-owner");
+
 export function installCompactThinking(
 	pi: ExtensionAPI,
 	initialConfig: CompactThinkingConfig,
 ): CompactThinkingController {
+	const owner = {};
+	const host = globalThis as typeof globalThis & {
+		[COMPACT_THINKING_OWNER]?: CompactThinkingOwner;
+	};
+	host[COMPACT_THINKING_OWNER]?.stop();
+
 	const agentDir = process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
-	const configPath = join(agentDir, "compact-thinking.json");
-	let hasValidCompatibilityConfig = false;
-	try {
-		const value = JSON.parse(readFileSync(configPath, "utf8")) as Partial<CompactThinkingConfig>;
-		hasValidCompatibilityConfig =
-			typeof value.useSummaryTitlesAsThinkingTitle === "boolean" &&
-			Number.isInteger(value.previewLines) &&
-			(value.previewLines ?? -1) >= 0 &&
-			Number.isFinite(value.animationIntervalMs) &&
-			(value.animationIntervalMs ?? 0) >= 1;
-	} catch {
-		// The upstream loader needs a valid compatibility file on first install.
-	}
-	if (!hasValidCompatibilityConfig) {
-		if (!existsSync(agentDir)) mkdirSync(agentDir, { recursive: true });
-		writeFileSync(configPath, `${JSON.stringify(initialConfig, null, 2)}\n`, "utf8");
+	// Upstream requires this file while loading; mirror ccstyle into it and never read it back.
+	mkdirSync(agentDir, { recursive: true });
+	writeFileSync(
+		join(agentDir, "compact-thinking.json"),
+		`${JSON.stringify(initialConfig, null, 2)}\n`,
+		"utf8",
+	);
+
+	// Fork the upstream entry so a running subagent tool keeps the thinking
+	// loading animation until the model emits the next text/thinking boundary.
+	// Upstream finalizes on tool_execution_start, freezing the summary into a
+	// static "Thought for Xs" for the whole subagent run.
+	const upstreamRequire = createRequire(import.meta.url);
+	const upstreamIndexPath = upstreamRequire.resolve("pi-compact-thinking/index.ts");
+	const toolStartOriginal = `  pi.on("tool_execution_start", finishThinking);`;
+	const toolStartPatched = `  // Subagent tools can run for minutes: keep the thinking loading animation
+  // alive for the whole execution and only finalize once the model emits the
+  // next text/thinking boundary or the message ends.
+  function resumeAgentThinking(message: AssistantMessage | undefined) {
+    if (activeThinking) return;
+    const content = message?.content;
+    if (!Array.isArray(content)) return;
+    const index = content.findIndex((item) => item?.type === "thinking");
+    if (index < 0) return;
+    startThinking(message, index);
+  }
+  pi.on("tool_execution_start", (event: any) => {
+    if (event.toolName === "Agent" || event.toolName === "Agents") {
+      resumeAgentThinking(latestComponent?.lastMessage ?? undefined);
+    } else {
+      finishThinking();
+    }
+  });`;
+	const updateBoundaryOriginal = `    } else if (
+      update.type === "text_start" ||
+      update.type === "toolcall_start" ||
+      update.type === "toolcall_delta"
+    ) {
+      finishThinking();
+    }`;
+	const updateBoundaryPatched = `    } else if (update.type === "text_start") {
+      finishThinking();
+    } else if (
+      update.type === "toolcall_start" ||
+      update.type === "toolcall_delta"
+    ) {
+      if (
+        Array.isArray(event.message?.content) &&
+        event.message.content.some(
+          (content) =>
+            content?.type === "toolCall" &&
+            (content.name === "Agent" ||
+              content.name === "Agents" ||
+              content.args?.subagent_type != null),
+        )
+      ) {
+        resumeAgentThinking(event.message);
+      } else {
+        finishThinking();
+      }
+    }`;
+	let upstreamIndexSource = readFileSync(upstreamIndexPath, "utf8");
+	if (
+		upstreamIndexSource.includes(toolStartOriginal) &&
+		upstreamIndexSource.includes(updateBoundaryOriginal)
+	) {
+		upstreamIndexSource = upstreamIndexSource
+			.replace(toolStartOriginal, toolStartPatched)
+			.replace(updateBoundaryOriginal, updateBoundaryPatched);
+	} else {
+		// Upstream changed shape: fall back to the untouched entry so the loader
+		// keeps working; only the subagent animation nicety is lost.
+		upstreamIndexSource = readFileSync(upstreamIndexPath, "utf8");
 	}
 
-	// The package publishes TypeScript source only, so use the loader already used by fixed-editor.
-	const jiti = createJiti(import.meta.url);
+	// Reuse Pi's live modules so the upstream prototype patch reaches runtime components.
+	const jiti = createJiti(import.meta.url, {
+		virtualModules: {
+			"@earendil-works/pi-ai": piAi,
+			"@earendil-works/pi-coding-agent": piCodingAgent,
+			"@earendil-works/pi-tui": piTui,
+		},
+	});
 	const upstreamConfig = (
 		jiti("pi-compact-thinking/lib/config.ts") as { config: CompactThinkingConfig }
 	).config;
 	const compactThinking = (
-		jiti("pi-compact-thinking/index.ts") as {
+		jiti.evalModule(upstreamIndexSource, { filename: upstreamIndexPath }) as {
 			default: (api: ExtensionAPI) => void;
 		}
 	).default;
 	Object.assign(upstreamConfig, initialConfig);
-	compactThinking(pi);
+
+	// Upstream restores completedDurations from sessionManager.getBranch() (the
+	// current leaf path). After compaction or a branch switch, duration entries
+	// of older messages leave that path, so scrolling back renders a bare
+	// "Thinking..." instead of "Thought for Xs". Restore from every entry.
+	const restoreAllDurations = (ctx: any): any => {
+		const sessionManager = ctx?.sessionManager;
+		if (!sessionManager || typeof sessionManager.getEntries !== "function") return ctx;
+		return {
+			...ctx,
+			sessionManager: {
+				...sessionManager,
+				getBranch: () => sessionManager.getEntries(),
+			},
+		};
+	};
+
+	let session: { event: any; ctx: any } | undefined;
+	let shutdown: ((event: any, ctx: any) => void) | undefined;
+	let stopped = false;
+	const stop = (event?: any, ctx?: any) => {
+		if (stopped) return;
+		stopped = true;
+		shutdown?.(event ?? session?.event ?? {}, ctx ?? session?.ctx ?? { mode: "rpc", ui: {} });
+		if (host[COMPACT_THINKING_OWNER]?.owner === owner) delete host[COMPACT_THINKING_OWNER];
+	};
+	compactThinking({
+		on(event: string, handler: (event: any, ctx: any) => void) {
+			if (event === "session_start") {
+				pi.on(event, (startEvent, ctx) => {
+					session = { event: startEvent, ctx };
+					handler(startEvent, restoreAllDurations(ctx));
+				});
+			} else if (event === "session_shutdown") {
+				shutdown = handler;
+				pi.on(event, (shutdownEvent, ctx) => {
+					if (host[COMPACT_THINKING_OWNER]?.owner === owner) stop(shutdownEvent, ctx);
+				});
+			} else {
+				pi.on(event as any, (e: any, ctx: any) =>
+					handler(e, event === "session_tree" ? restoreAllDurations(ctx) : ctx),
+				);
+			}
+		},
+		appendEntry: (...args: any[]) => (pi.appendEntry as any)(...args),
+	} as unknown as ExtensionAPI);
+	host[COMPACT_THINKING_OWNER] = { owner, stop };
 
 	return {
 		updateConfig(next) {

package/extensions/fixed-editor.ts

@@ -12,21 +12,46 @@ const terminalSplit = jiti("@tifan/pi-fixed-editor/src/terminal-split.js") as {
 	TerminalSplitCompositor?: { prototype: Record<PropertyKey, any> };
 };
 export type FixedEditorHitbox = { row: number; startCol: number; endCol: number };
+export type FixedEditorViewportSnapshot = {
+	tui: object;
+	visibleRootStart: number;
+	visibleScrollableRows: number;
+	visibleLines: readonly string[];
+	generation: number;
+};
 
-type FixedEditorSharedState = { scrollButtonHitbox: FixedEditorHitbox | null };
+type FixedEditorSharedState = {
+	scrollButtonHitbox: FixedEditorHitbox | null;
+	viewports: WeakMap<object, FixedEditorViewportSnapshot>;
+	generation: number;
+};
 const FIXED_EDITOR_STATE_KEY = Symbol.for("pi.ccstyle.fixed-editor.state");
 const fixedEditorState = (() => {
 	const host = globalThis as typeof globalThis & {
 		[FIXED_EDITOR_STATE_KEY]?: FixedEditorSharedState;
 	};
-	host[FIXED_EDITOR_STATE_KEY] ??= { scrollButtonHitbox: null };
-	return host[FIXED_EDITOR_STATE_KEY];
+	const state = (host[FIXED_EDITOR_STATE_KEY] ??= {
+		scrollButtonHitbox: null,
+		viewports: new WeakMap(),
+		generation: 0,
+	});
+	state.viewports ??= new WeakMap();
+	state.generation ??= 0;
+	return state;
 })();
 
 export function getFixedEditorScrollButtonHitbox(): FixedEditorHitbox | null {
 	return fixedEditorState.scrollButtonHitbox;
 }
 
+export function getFixedEditorViewport(tui: object): FixedEditorViewportSnapshot | null {
+	return fixedEditorState.viewports.get(tui) ?? null;
+}
+
+function clearFixedEditorViewport(): void {
+	fixedEditorState.viewports = new WeakMap();
+}
+
 const FIXED_EDITOR_SPACING_PATCH = Symbol.for("pi.ccstyle.fixed-editor-spacing-patch");
 const clusterModule = jiti("@tifan/pi-fixed-editor/src/cluster.js") as {
 	renderFixedEditorCluster?: (input: any) => any;
@@ -70,6 +95,9 @@ const loaded = jiti("@tifan/pi-fixed-editor/src/index.ts") as {
 const fixedEditor = loaded.default ?? (loaded as unknown as FixedEditorExtension);
 
 const IME_CURSOR_PATCH = Symbol.for("pi.ccstyle.fixed-editor-ime-cursor-patch");
+const VIEWPORT_PATCH = Symbol.for("pi.ccstyle.fixed-editor-viewport-patch");
+const MOUSE_WRITE_PATCH = Symbol.for("pi.ccstyle.fixed-editor-mouse-write-patch");
+const MOUSE_WRITE_RESTORE_PATCH = Symbol.for("pi.ccstyle.fixed-editor-mouse-write-restore-patch");
 
 function positionHiddenImeCursor(compositor: any): void {
 	if (
@@ -93,17 +121,68 @@ export function installFixedEditorImePatch(compositorClass: {
 	prototype: Record<PropertyKey, any>;
 }): void {
 	const prototype = compositorClass.prototype;
-	if (prototype[IME_CURSOR_PATCH]) return;
-	for (const name of ["write", "requestRepaint"] as const) {
-		const original = prototype[name];
-		if (typeof original !== "function") continue;
-		prototype[name] = function (this: any, ...args: any[]) {
-			const result = Reflect.apply(original, this, args);
-			positionHiddenImeCursor(this);
+	if (!prototype[IME_CURSOR_PATCH]) {
+		for (const name of ["write", "requestRepaint"] as const) {
+			const original = prototype[name];
+			if (typeof original !== "function") continue;
+			prototype[name] = function (this: any, ...args: any[]) {
+				const result = Reflect.apply(original, this, args);
+				positionHiddenImeCursor(this);
+				return result;
+			};
+		}
+		prototype[IME_CURSOR_PATCH] = true;
+	}
+	if (!prototype[VIEWPORT_PATCH] && typeof prototype.renderScrollableRoot === "function") {
+		const originalRenderScrollableRoot = prototype.renderScrollableRoot;
+		prototype.renderScrollableRoot = function (this: any, ...args: any[]) {
+			const lines = Reflect.apply(originalRenderScrollableRoot, this, args);
+			if (this.tui && !this.disposed && Array.isArray(lines)) {
+				fixedEditorState.viewports.set(this.tui, {
+					tui: this.tui,
+					visibleRootStart: Number(this.visibleRootStart) || 0,
+					visibleScrollableRows: Number(this.visibleScrollableRows) || lines.length,
+					visibleLines: [...lines],
+					generation: ++fixedEditorState.generation,
+				});
+			}
+			return lines;
+		};
+		prototype[VIEWPORT_PATCH] = true;
+	}
+	if (!prototype[MOUSE_WRITE_PATCH] && typeof prototype.install === "function") {
+		const originalInstall = prototype.install;
+		prototype.install = function (this: any, ...args: any[]) {
+			if (!Object.hasOwn(this, MOUSE_WRITE_PATCH) && typeof this.originalWrite === "function") {
+				const originalWrite = this.originalWrite;
+				this.originalWrite = (data: string) =>
+					Reflect.apply(originalWrite, this, [data.replaceAll("\x1b[?1002h", "\x1b[?1003h")]);
+				this[MOUSE_WRITE_PATCH] = originalWrite;
+			}
+			const wasInstalled = Boolean(this.installed);
+			const result = Reflect.apply(originalInstall, this, args);
+			// Dependents re-wrap doRender only after the compositor actually owns it.
+			if (!wasInstalled && this.installed && !this.disposed) compositorInstallNotify?.();
 			return result;
 		};
+		prototype[MOUSE_WRITE_PATCH] = true;
+	}
+	if (!prototype[MOUSE_WRITE_RESTORE_PATCH] && typeof prototype.dispose === "function") {
+		const originalDispose = prototype.dispose;
+		prototype.dispose = function (this: any, ...args: any[]) {
+			const originalWrite = Object.hasOwn(this, MOUSE_WRITE_PATCH)
+				? this[MOUSE_WRITE_PATCH]
+				: undefined;
+			try {
+				return Reflect.apply(originalDispose, this, args);
+			} finally {
+				if (typeof originalWrite === "function" && this.terminal) {
+					this.terminal.write = originalWrite;
+				}
+			}
+		};
+		prototype[MOUSE_WRITE_RESTORE_PATCH] = true;
 	}
-	prototype[IME_CURSOR_PATCH] = true;
 }
 
 if (terminalSplit.TerminalSplitCompositor) {
@@ -112,6 +191,8 @@ if (terminalSplit.TerminalSplitCompositor) {
 
 export type FixedEditorController = {
 	setEnabled(enabled: boolean): void;
+	/** Fires after compositor install/reinstall (session start, enable, footer rebuild). */
+	onRebuild(listener: () => void): () => void;
 };
 
 type FixedEditorOwner = {
@@ -120,6 +201,39 @@ type FixedEditorOwner = {
 };
 
 const FIXED_EDITOR_OWNER = Symbol.for("pi.ccstyle.fixed-editor-owner");
+const FIXED_EDITOR_FOOTER_HOOK = Symbol.for("pi.ccstyle.fixed-editor-footer-hook");
+
+/** Active owner callback; fired from compositor.install after a fresh install succeeds. */
+let compositorInstallNotify: (() => void) | undefined;
+let compositorInstallNotifyOwner: object | undefined;
+/** Runs before fixed-editor start/probe so dependents can unwrap doRender before capture. */
+let beforeFixedEditorStart: (() => void) | undefined;
+
+/** Register a pre-start hook (e.g. unwrap mouse doRender before compositor construction). */
+export function setBeforeFixedEditorStart(listener: (() => void) | undefined): void {
+	beforeFixedEditorStart = listener;
+}
+
+type FooterHookState = { listener?: () => void };
+
+function observeFooterReplacement(ui: any, listener: () => void): () => void {
+	let state = ui[FIXED_EDITOR_FOOTER_HOOK] as FooterHookState | undefined;
+	if (!state) {
+		const original = ui.setFooter;
+		state = {};
+		const hookState = state;
+		ui.setFooter = function (this: unknown, ...args: unknown[]) {
+			const result = Reflect.apply(original, this, args);
+			hookState.listener?.();
+			return result;
+		};
+		ui[FIXED_EDITOR_FOOTER_HOOK] = state;
+	}
+	state.listener = listener;
+	return () => {
+		if (state.listener === listener) state.listener = undefined;
+	};
+}
 
 /** Adds runtime on/off control around pi-fixed-editor's session lifecycle. */
 export function installFixedEditor(
@@ -139,24 +253,74 @@ export function installFixedEditor(
 	let enabled = initiallyEnabled;
 	let active = false;
 	let session: { event: any; ctx: any } | undefined;
+	let unobserveFooter: (() => void) | undefined;
+	let footerRestartQueued = false;
+	const rebuildListeners = new Set<() => void>();
+	const notifyRebuild = () => {
+		for (const listener of rebuildListeners) listener();
+	};
 
-	const deactivate = () => {
+	const unhookFooter = () => {
+		unobserveFooter?.();
+		unobserveFooter = undefined;
+	};
+	const hookFooter = () => {
+		const ui = session?.ctx?.ui;
+		if (typeof ui?.setFooter !== "function") return;
+		unobserveFooter = observeFooterReplacement(ui, () => {
+			if (!active || footerRestartQueued) return;
+			footerRestartQueued = true;
+			const currentSession = session;
+			queueMicrotask(() => {
+				footerRestartQueued = false;
+				if (!active || session !== currentSession) return;
+				// Dispose old compositor first, then reinstall and rebind dependents.
+				deactivate();
+				activate();
+			});
+		});
+	};
+	function clearInstallNotify() {
+		if (compositorInstallNotifyOwner === owner) {
+			compositorInstallNotify = undefined;
+			compositorInstallNotifyOwner = undefined;
+		}
+	}
+	function deactivate() {
 		fixedEditorState.scrollButtonHitbox = null;
+		clearFixedEditorViewport();
 		const current = (globalThis as any)[FIXED_EDITOR_OWNER] as FixedEditorOwner | undefined;
 		if (current?.owner === owner) current.stop();
-		else active = false;
-	};
-	const activate = () => {
+		else {
+			clearInstallNotify();
+			unhookFooter();
+			active = false;
+		}
+	}
+	function activate() {
 		if (!session || session.ctx?.mode !== "tui" || active) return;
 		const previous = (globalThis as any)[FIXED_EDITOR_OWNER] as FixedEditorOwner | undefined;
 		if (previous?.owner !== owner) previous?.stop();
 		const currentSession = session;
+		// Register before start/probe so the first real compositor.install notifies us.
+		compositorInstallNotify = () => {
+			if (!active) return;
+			if ((globalThis as any)[FIXED_EDITOR_OWNER]?.owner !== owner) return;
+			notifyRebuild();
+		};
+		compositorInstallNotifyOwner = owner;
+		// Unwrap outer doRender patches before compositor construction captures it.
+		beforeFixedEditorStart?.();
 		start?.(currentSession.event, currentSession.ctx);
 		active = true;
+		hookFooter();
 		(globalThis as any)[FIXED_EDITOR_OWNER] = {
 			owner,
 			stop: () => {
 				if (!active) return;
+				clearInstallNotify();
+				unhookFooter();
+				clearFixedEditorViewport();
 				shutdown?.(currentSession.event, currentSession.ctx);
 				active = false;
 				if ((globalThis as any)[FIXED_EDITOR_OWNER]?.owner === owner) {
@@ -164,7 +328,7 @@ export function installFixedEditor(
 				}
 			},
 		} satisfies FixedEditorOwner;
-	};
+	}
 
 	pi.on("session_start", (event, ctx) => {
 		session = { event, ctx };
@@ -181,5 +345,11 @@ export function installFixedEditor(
 			if (nextEnabled) activate();
 			else deactivate();
 		},
+		onRebuild(listener) {
+			rebuildListeners.add(listener);
+			return () => {
+				rebuildListeners.delete(listener);
+			};
+		},
 	};
 }

package/extensions/tool-grouping.ts

@@ -154,6 +154,10 @@ function toolSummary(tool: any): { main: string; detail: string } {
 		return `${titled} ${oneLine(found || fallback)}`;
 	};
 	if (lowerName === "agent" || lowerName === "agents") {
+		const displayName = args.subagent_type ?? args.agent_type ?? args.agent;
+		if (typeof displayName === "string" && displayName) {
+			return { main: `${titled} ${displayName}`, detail: "" };
+		}
 		return {
 			main: value(
 				lowerName === "agent" ? "launch agent" : "launch agents",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-cc-extensions",
-	"version": "0.8.32",
+	"version": "0.8.33",
 	"description": "A Pi productivity suite with Claude Code-style UI, fixed editor, context inspection, and agent/session references",
 	"type": "module",
 	"keywords": [