@hheei/pi-ext-ui 0.6.0 → 0.7.0

package/dist/runtime.d.ts

@@ -0,0 +1,13 @@
+import { NestedCallArgsIndex, ToolExecutionTracker } from "./tracker.js";
+/**
+ * The mutable state one extension runtime owns: nested-call captures, the session-branch argument
+ * index, and the tool background preference. Two Pi runtimes in one process never share it, so a
+ * restart, cleanup or settings change in one cannot reach the other.
+ */
+export declare class ToolUiRuntime {
+    readonly tracker: ToolExecutionTracker;
+    readonly nestedCalls: NestedCallArgsIndex;
+    /** Pi-native per-tool backgrounds are opt-in; the default is the quiet transparent row. */
+    backgrounds: boolean;
+    clear(): void;
+}

package/dist/runtime.js

@@ -0,0 +1,16 @@
+import { NestedCallArgsIndex, ToolExecutionTracker } from "./tracker.js";
+/**
+ * The mutable state one extension runtime owns: nested-call captures, the session-branch argument
+ * index, and the tool background preference. Two Pi runtimes in one process never share it, so a
+ * restart, cleanup or settings change in one cannot reach the other.
+ */
+export class ToolUiRuntime {
+    tracker = new ToolExecutionTracker();
+    nestedCalls = new NestedCallArgsIndex();
+    /** Pi-native per-tool backgrounds are opt-in; the default is the quiet transparent row. */
+    backgrounds = false;
+    clear() {
+        this.tracker.clear();
+        this.nestedCalls.setSource(undefined);
+    }
+}

package/dist/settings.d.ts

@@ -1,6 +1,9 @@
 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;
+/** Off by default: a tool row only paints Pi's own surface when the reader asks for it. */
+export declare function toolBackgroundsEnabled(state: SettingsState | undefined): boolean;
 export declare function createToolGroupSettings(options: {
     readonly onEnabled: (enabled: boolean) => void;
+    readonly onBackgrounds: (enabled: boolean) => void;
 }): SettingsProvider;

package/dist/settings.js

@@ -1,11 +1,16 @@
 import { createJsonSettingsStorage, } from "@hheei/pi-ext-core";
 const GROUP = "toolGroups";
 const FIELD = "enabled";
+const BACKGROUNDS = "toolBackgrounds";
 /** 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;
 }
+/** Off by default: a tool row only paints Pi's own surface when the reader asks for it. */
+export function toolBackgroundsEnabled(state) {
+    return state?.[GROUP]?.[BACKGROUNDS] === true;
+}
 export function createToolGroupSettings(options) {
     return {
         id: "pi-ext-ui",
@@ -24,13 +29,25 @@ export function createToolGroupSettings(options) {
                         description: "Group consecutive tool, thinking, and notification rows in the TUI transcript.",
                         parse: (draft) => draft === "true",
                     },
+                    {
+                        id: BACKGROUNDS,
+                        label: "Tool backgrounds",
+                        type: "boolean",
+                        defaultValue: false,
+                        description: "Paint each tool with Pi's own success/error surface, one padding row above and below, and no leading rail. The activity group then stays transparent.",
+                        parse: (draft) => draft === "true",
+                    },
                 ],
             },
         ],
         storage: createJsonSettingsStorage({ group: GROUP }),
         onChange(change) {
-            if (change.groupId === GROUP && change.fieldId === FIELD)
+            if (change.groupId !== GROUP)
+                return;
+            if (change.fieldId === FIELD)
                 options.onEnabled(change.value === true);
+            if (change.fieldId === BACKGROUNDS)
+                options.onBackgrounds(change.value === true);
         },
     };
 }

package/dist/tool-group-view.d.ts

@@ -7,28 +7,60 @@ export interface Usage {
     readonly cacheRead: number;
     readonly cacheWrite: number;
 }
-export type MemberKind = "assistant" | "tool" | "notice";
+export type MemberKind = "thinking" | "tool" | "notice";
 export type Category = "tools" | "thinking" | "notices";
+/**
+ * One model request the block owns, in transcript order. A block's requests are not the same set
+ * as its displayed members: the assistant text that ends a loop is native content, but its usage
+ * still belongs to the block whose work it answers.
+ */
+export interface RequestFact {
+    readonly usage?: Usage;
+}
 /** One transcript entry a block owns, reduced to the facts the collapsed frame draws. */
 export interface Member {
     readonly kind: MemberKind;
     readonly component: Component;
+    /**
+     * Every original component this member stands for. A thinking member is one continuous run, so
+     * it can span several assistant messages; the raw view prints them in order.
+     */
+    readonly parts?: readonly Component[];
     readonly title?: string;
     readonly summary?: string;
     readonly status?: ToolStatusKind;
     readonly children?: readonly ToolViewChild[];
     /** Nested calls the member made, when `children` is only what fits. */
     readonly childCount?: number;
+    /** Full thinking text of the run, kept regardless of the host's hide preference. */
     readonly thinking?: string;
-    readonly thinkingChars?: number;
-    readonly usage?: Usage;
-    readonly detail?: (width: number) => string[];
+    /** Pi hides thinking by default: show one preview row that opens the full text. */
+    readonly thinkingHidden?: boolean;
+    /**
+     * A tool enters the block's counts only after its final result arrived. Streaming args, an
+     * execution start, and partial results are not completed calls; a cancelled or failed call that
+     * did receive its final result is.
+     */
+    readonly completed?: boolean;
+    /** Rows this member shows directly under its label: a notice body or a preview. */
+    readonly content?: (width: number) => readonly string[];
+    /** Rows opening this member reveals; its presence is what makes the item expandable. */
+    readonly detail?: (width: number) => readonly string[];
 }
-/** One agent loop. Blocks created during the run share its origin; ending it freezes them. */
-export interface ToolGroupRun {
+/** Runtime duration of one continuous activity block. */
+export interface ToolGroupClock {
     readonly startedAt: number;
     endedAt?: number;
 }
+/** Every original component of a member, in transcript order. */
+export declare function memberParts(member: Member): readonly Component[];
+export declare class TailUnit implements Component {
+    #private;
+    constructor(member: Member);
+    render(width: number): string[];
+    handleMouse(event: Parameters<NonNullable<Component["handleMouse"]>>[0]): import("@earendil-works/pi-tui").TuiMouseEventResult | undefined;
+    invalidate(): void;
+}
 /**
  * The collapsed frame of one activity block.
  *
@@ -38,8 +70,20 @@ export interface ToolGroupRun {
  */
 export declare class ToolGroupView extends Container {
     #private;
-    constructor(ui: ExtensionUIContext, redraw: () => void, run: ToolGroupRun | undefined);
-    update(members: Member[], settled: boolean): void;
+    constructor(ui: ExtensionUIContext, redraw: () => void);
+    /**
+     * Release the block's own lifetime. The projection drops a block when it is evicted, when
+     * grouping is disabled, or when the patch unloads; an idempotent dispose keeps that path honest,
+     * so a removed block can never ask for a repaint.
+     */
+    dispose(): void;
+    /**
+     * `clock` belongs to this continuous block. Restored history has none until live content joins it.
+     *
+     * `tail` is the block's last visible unit, which the projection draws outside the group; its calls,
+     * requests, and background state still belong to this block.
+     */
+    update(members: Member[], tail: Member | undefined, requests: readonly RequestFact[], clock: ToolGroupClock | undefined): void;
     invalidate(): void;
     render(width: number): string[];
 }