@hheei/pi-ext-ui 0.5.2 → 0.7.0

package/README.md

@@ -8,8 +8,8 @@ The shared view API owns fold levels, compact sections, status glyphs, copy feed
 
 Background Bash and subagent tools own their display formats through ext-core `ToolPresentation` providers. This resolver consumes those providers automatically, including nested codemode calls, and adds shared folding and copy controls. Without `pi-ext-ui`, the same tools retain native Pi renderers. No direct dependency on `pi-ext-ui` is required by the tool extensions.
 
-Activity groups are on by default for Pi **>=1.0.1** TUI sessions. Turn them off with the Tool UI setting `toolGroups.enabled` in `ext_settings.json` (the ext-core settings page). The change applies to the current session. A heading such as `▸ codemode ×2 · grep ×3` keeps one live summary row per tool beneath a single outer rail. Each thinking round and notification also keeps a summary row; notifications are not counted. Groups form while tools run and can span consecutive tool/thinking rounds. Prose, user messages, unknown components, images, and unknown tool renderers break groups. Any MessageView transcript notice stays inside the group, so bg-bash, subagent, memory, optimizer, and codemode-guard notices do not need their own allowlist. Notification rows show their text directly. Streaming arguments, partial results, completion, and errors update the existing row.
+Activity groups are on by default for Pi **>=1.0.1** TUI sessions. Turn them off with the Tool UI setting `toolGroups.enabled` in `ext_settings.json` (the ext-core settings page). The change applies to the current session. A heading such as `▸ codemode ×2 · grep ×3` keeps one live summary row per tool beneath a single outer rail. Each thinking round and notification also keeps a summary row; notifications are not counted. A thinking item shows a content preview while Pi hides thinking and opens the full text on demand; while thinking is visible the category prints it flat. Groups form while tools run and can span consecutive tool/thinking rounds. Prose, user messages, unknown components, images, and unknown tool renderers break groups. Any MessageView transcript notice stays inside the group, so bg-bash, subagent, memory, optimizer, and codemode-guard notices do not need their own allowlist. Notification rows show their own text once, indented and width-wrapped; only a MessageView with a real body gets an expand pin. Streaming arguments, partial results, completion, and errors update the existing row.
 
-Fullscreen: click the group heading to restore the original component layouts and interactions beneath the outer rail. Both terminal modes: Ctrl+O forces groups open; closing global expansion restores each group’s local choice. Appending members preserves that choice. Original per-tool fold choices remain intact. Groups are presentation only and are rebuilt on history navigation; session data, model context, and HTML export remain unchanged. Thinking summaries keep a label; expanding respects native thinking visibility. Each `ctx.ui.notify` call retains its full text for expansion. Notifications remain session-local, as in Pi.
+Fullscreen: click the group heading to restore the original component layouts and interactions beneath the outer rail. Both terminal modes: Ctrl+O forces groups open; closing global expansion restores each group’s local choice. Appending members preserves that choice. Original per-tool fold choices remain intact. Groups are presentation only and are rebuilt on history navigation; session data, model context, and HTML export remain unchanged. Thinking keeps its label; the hidden state shows a preview instead of dropping the text, and the visible state has no per-item arrow. Each `ctx.ui.notify` keeps its full text inline. Notifications remain session-local, as in Pi.
 
 Grouping uses two centralized, version-checked host prototype hooks: tool lookup and extension notifications. Thinking uses the existing assistant message, with no extra hook. Unsupported hosts or incompatible layouts report a warning and retain normal rendering. Cleanup restores the original methods; if another extension replaces the same methods, restart Pi to unload the conflicting patch. For workspace development use `pnpm run pi-dev`: running the bundled CLI beside physical host devDependencies can resolve a second host class, unlike the published installation.

package/dist/background.d.ts

@@ -0,0 +1,11 @@
+import type { Theme, ThemeBg } from "@earendil-works/pi-coding-agent";
+/**
+ * Paint one surface's rows. A surface owns its own background and nothing else: after any reset
+ * (`0`, `49`, or a compound sequence containing one) it re-asserts *its* background, so a row keeps
+ * the fill across the styled spans a theme or child renderer ends with `\x1b[0m`.
+ *
+ * It never guesses another surface's background. A nested surface that ended its own fill is gone;
+ * the rest of the row belongs to the surface painting it. Nested surfaces stay separate because each
+ * one paints the rows it draws, not because this function tracks ANSI state.
+ */
+export declare function backgroundFill(theme: Theme, token: ThemeBg): (text: string) => string;

package/dist/background.js

@@ -0,0 +1,31 @@
+const MARK = "\u0000";
+/** Any SGR sequence: parameters are `;`-separated, an empty parameter list means reset. */
+const SGR = /\x1b\[([0-9;]*)m/g;
+/**
+ * Paint one surface's rows. A surface owns its own background and nothing else: after any reset
+ * (`0`, `49`, or a compound sequence containing one) it re-asserts *its* background, so a row keeps
+ * the fill across the styled spans a theme or child renderer ends with `\x1b[0m`.
+ *
+ * It never guesses another surface's background. A nested surface that ended its own fill is gone;
+ * the rest of the row belongs to the surface painting it. Nested surfaces stay separate because each
+ * one paints the rows it draws, not because this function tracks ANSI state.
+ */
+export function backgroundFill(theme, token) {
+    const [start, end] = theme.bg(token, MARK).split(MARK);
+    if (start === undefined || end === undefined)
+        return (text) => text;
+    return (text) => {
+        let out = start;
+        let from = 0;
+        for (const match of text.matchAll(SGR)) {
+            const params = match[1] ?? "";
+            const resets = params === "" || params.split(";").some((code) => code === "0" || code === "49");
+            const next = (match.index ?? 0) + match[0].length;
+            out += text.slice(from, next);
+            if (resets)
+                out += start;
+            from = next;
+        }
+        return `${out}${text.slice(from)}${end}`;
+    };
+}

package/dist/extension.js

@@ -2,12 +2,15 @@ import { getRuntimeSettingsRegistry, messageViewPoint, registerExtensionHook, re
 import { installHostToolGroups } from "./host-transcript-patch.js";
 import { createMessageView } from "./message-view.js";
 import { createOptionalToolRendererFactory, registerCollapsibleToolRenderer } from "./renderer.js";
-import { activityGroupsEnabled, createToolGroupSettings } from "./settings.js";
-import { clearCapturedNestedCalls } from "./tracker.js";
+import { ToolUiRuntime } from "./runtime.js";
+import { activityGroupsEnabled, createToolGroupSettings, toolBackgroundsEnabled, } from "./settings.js";
+import { TOOL_SPINNER_INTERVAL_MS } from "./tool-view.js";
 export default function (pi) {
+    // One runtime per extension instance: two Pi runtimes in one process never share these facts.
+    const runtime = new ToolUiRuntime();
     let redrawGroups;
     pi.on("agent_settled", () => redrawGroups?.());
-    registerCollapsibleToolRenderer(pi);
+    registerCollapsibleToolRenderer(pi, runtime);
     registerExtensionLifecycle(pi, {
         key: "@hheei/pi-ext-ui",
         async start(context) {
@@ -31,7 +34,60 @@ export default function (pi) {
                     context.extension.ui.notify(error instanceof Error ? error.message : String(error), "warning");
                 }
             };
-            const provider = createToolGroupSettings({ onEnabled: apply });
+            const applyBackgrounds = (enabled) => {
+                runtime.backgrounds = enabled;
+                redrawGroups?.();
+            };
+            const provider = createToolGroupSettings({
+                onEnabled: apply,
+                onBackgrounds: applyBackgrounds,
+            });
+            const onAgentStart = pi.on("agent_start", () => {
+                patch?.beginRun();
+                redrawGroups?.();
+            });
+            // A live tool animates its status glyph. The ticker exists only while one is running, and the
+            // frame itself comes from one shared clock, so a phase never restarts on a status change.
+            let liveTools = 0;
+            let ticker;
+            const stopTicker = () => {
+                if (ticker === undefined)
+                    return;
+                clearInterval(ticker);
+                ticker = undefined;
+            };
+            const onAgentEnd = pi.on("agent_end", () => {
+                patch?.endRun();
+                // No tool outlives the agent loop, so the animation cannot keep a ticker alive either.
+                liveTools = 0;
+                stopTicker();
+                redrawGroups?.();
+            });
+            const onToolStart = pi.on("tool_execution_start", () => {
+                liveTools += 1;
+                if (ticker !== undefined)
+                    return;
+                ticker = setInterval(() => {
+                    if (liveTools === 0 || redrawGroups === undefined) {
+                        stopTicker();
+                        return;
+                    }
+                    redrawGroups();
+                }, TOOL_SPINNER_INTERVAL_MS);
+            });
+            const onToolEnd = pi.on("tool_execution_end", () => {
+                liveTools = Math.max(0, liveTools - 1);
+                if (liveTools === 0)
+                    stopTicker();
+            });
+            context.resources.add("run-clock", () => {
+                onAgentStart();
+                onAgentEnd();
+                onToolStart();
+                onToolEnd();
+                stopTicker();
+                liveTools = 0;
+            });
             context.resources.add("tool-group-settings", registerSettings(provider, getRuntimeSettingsRegistry(pi)));
             context.resources.add("tool-groups", () => {
                 redrawGroups = undefined;
@@ -39,9 +95,14 @@ export default function (pi) {
                 patch = undefined;
             });
             context.resources.add("tracker-cleanup", () => {
-                clearCapturedNestedCalls();
+                runtime.tracker.clear();
             });
-            const toolRenderers = registerExtensionHook(pi, toolRendererPoint, createOptionalToolRendererFactory(pi));
+            // Resume reads the host's own nested-call record for the current branch, never another one.
+            runtime.nestedCalls.setSource(context.extension.sessionManager);
+            context.resources.add("nested-call-source", () => {
+                runtime.nestedCalls.setSource(undefined);
+            });
+            const toolRenderers = registerExtensionHook(pi, toolRendererPoint, createOptionalToolRendererFactory(pi, runtime));
             context.resources.add("tool-renderer", () => toolRenderers.dispose());
             const handle = registerExtensionHook(context.pi, messageViewPoint, createMessageView);
             context.resources.add("message-view", () => handle.dispose());
@@ -50,14 +111,17 @@ export default function (pi) {
                     sessionId: context.extension.sessionManager.getSessionId(),
                     signal: context.signal,
                 });
-                if (!context.signal.aborted)
+                if (!context.signal.aborted) {
                     apply(activityGroupsEnabled(state));
+                    applyBackgrounds(toolBackgroundsEnabled(state));
+                }
             }
             catch (error) {
                 if (!context.signal.aborted) {
                     const detail = error instanceof Error ? error.message : String(error);
                     context.extension.ui.notify(`Tool activity groups settings unreadable: ${detail}`, "warning");
                     apply(true);
+                    applyBackgrounds(false);
                 }
             }
         },

package/dist/host-transcript-patch.d.ts

@@ -3,4 +3,6 @@ import { type ExtensionContext } from "@earendil-works/pi-coding-agent";
 export declare function installHostToolGroups(context: ExtensionContext): {
     dispose(): void;
     requestRender(): void;
+    beginRun(): void;
+    endRun(): void;
 };