@hheei/pi-ext-ui 0.5.0 → 0.5.1

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.
 
-Opt into activity groups with `pi --ui-tool-groups` after installing this extension (Pi **>=1.0.1**). 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. 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. Groups form while tools run and can span consecutive tool/thinking rounds. Prose, user messages, unknown components, images, and unknown tool renderers break groups. 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.
 
-This optional feature 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 --ui-tool-groups`: running the bundled CLI beside physical host devDependencies can resolve a second host class, unlike the published installation.
+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/extension.js

@@ -1,33 +1,50 @@
-import { messageViewPoint, registerExtensionHook, registerExtensionLifecycle, toolRendererPoint, } from "@hheei/pi-ext-core";
+import { getRuntimeSettingsRegistry, messageViewPoint, registerExtensionHook, registerExtensionLifecycle, registerSettings, toolRendererPoint, } from "@hheei/pi-ext-core";
 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";
+function sessionId(extension) {
+    const manager = extension.sessionManager;
+    if (typeof manager !== "object" || manager === null || !("getSessionId" in manager))
+        return "";
+    const read = manager.getSessionId;
+    return typeof read === "function" ? String(read.call(manager)) : "";
+}
 export default function (pi) {
-    pi.registerFlag("ui-tool-groups", {
-        type: "boolean",
-        default: false,
-        description: "Group tool summaries, thinking and notifications (Pi >=1.0.1 runtime patch)",
-    });
     let redrawGroups;
     pi.on("agent_settled", () => redrawGroups?.());
     registerCollapsibleToolRenderer(pi);
     registerExtensionLifecycle(pi, {
         key: "@hheei/pi-ext-ui",
-        start(context) {
-            if (context.extension.mode === "tui" && pi.getFlag("ui-tool-groups") === true) {
+        async start(context) {
+            let patch;
+            const apply = (enabled) => {
+                if (context.extension.mode !== "tui")
+                    return;
+                if (!enabled) {
+                    redrawGroups = undefined;
+                    patch?.dispose();
+                    patch = undefined;
+                    return;
+                }
+                if (patch !== undefined)
+                    return;
                 try {
-                    const patch = installHostToolGroups(context.extension);
+                    patch = installHostToolGroups(context.extension);
                     redrawGroups = patch.requestRender;
-                    context.resources.add("tool-groups", () => {
-                        redrawGroups = undefined;
-                        patch.dispose();
-                    });
                 }
                 catch (error) {
                     context.extension.ui.notify(error instanceof Error ? error.message : String(error), "warning");
                 }
-            }
+            };
+            const provider = createToolGroupSettings({ onEnabled: apply });
+            context.resources.add("tool-group-settings", registerSettings(provider, getRuntimeSettingsRegistry(pi)));
+            context.resources.add("tool-groups", () => {
+                redrawGroups = undefined;
+                patch?.dispose();
+                patch = undefined;
+            });
             context.resources.add("tracker-cleanup", () => {
                 clearCapturedNestedCalls();
             });
@@ -35,6 +52,21 @@ export default function (pi) {
             context.resources.add("tool-renderer", () => toolRenderers.dispose());
             const handle = registerExtensionHook(context.pi, messageViewPoint, createMessageView);
             context.resources.add("message-view", () => handle.dispose());
+            try {
+                const state = await provider.storage.load({
+                    sessionId: sessionId(context.extension),
+                    signal: context.signal,
+                });
+                if (!context.signal.aborted)
+                    apply(activityGroupsEnabled(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);
+                }
+            }
         },
     });
 }

package/dist/settings.d.ts

@@ -0,0 +1,6 @@
+import { type SettingsProvider, type SettingsState } from "@hheei/pi-ext-core";
+/** Missing or non-boolean values stay on; only an explicit false disables groups. */
+export declare function activityGroupsEnabled(state: SettingsState | undefined): boolean;
+export declare function createToolGroupSettings(options: {
+    readonly onEnabled: (enabled: boolean) => void;
+}): SettingsProvider;

package/dist/settings.js

@@ -0,0 +1,36 @@
+import { createJsonSettingsStorage, } from "@hheei/pi-ext-core";
+const GROUP = "toolGroups";
+const FIELD = "enabled";
+/** Missing or non-boolean values stay on; only an explicit false disables groups. */
+export function activityGroupsEnabled(state) {
+    const value = state?.[GROUP]?.[FIELD];
+    return value !== false;
+}
+export function createToolGroupSettings(options) {
+    return {
+        id: "pi-ext-ui",
+        title: "Tool UI",
+        origin: "@hheei/pi-ext-ui",
+        groups: [
+            {
+                id: GROUP,
+                title: "Tool activity",
+                fields: [
+                    {
+                        id: FIELD,
+                        label: "Activity groups",
+                        type: "boolean",
+                        defaultValue: true,
+                        description: "Group consecutive tool, thinking, and notification rows in the TUI transcript.",
+                        parse: (draft) => draft === "true",
+                    },
+                ],
+            },
+        ],
+        storage: createJsonSettingsStorage({ group: GROUP }),
+        onChange(change) {
+            if (change.groupId === GROUP && change.fieldId === FIELD)
+                options.onEnabled(change.value === true);
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hheei/pi-ext-ui",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Collapsible tool rendering frame and tool renderer pilot for Pi.",
   "type": "module",
   "main": "dist/index.js",