@hheei/pi-ext-ui 0.5.2 → 0.6.0

package/dist/nested-calls-view.js

@@ -67,6 +67,7 @@ export class NestedCallsView {
     #props;
     #inMemoryLevels = new Map();
     #copiedIndex = undefined;
+    #failedIndex = undefined;
     #copiedTimer = undefined;
     #lineMapping = [];
     #renderCache;
@@ -96,14 +97,11 @@ export class NestedCallsView {
                 typeof copiedState.until === "number") {
                 const remaining = copiedState.until - Date.now();
                 if (remaining > 0) {
-                    this.#copiedIndex = copiedState.index;
+                    const failed = copiedState.failed === true;
+                    this.#copiedIndex = failed ? undefined : copiedState.index;
+                    this.#failedIndex = failed ? copiedState.index : undefined;
                     this.#copiedTimer = setTimeout(() => {
-                        this.#copiedIndex = undefined;
-                        this.#renderCache = undefined;
-                        const s = this.#props.stateHolder;
-                        if (s !== undefined) {
-                            delete s[NESTED_CALLS_COPIED_KEY];
-                        }
+                        this.#clearCopyFeedback();
                         this.#props.invalidate?.();
                     }, remaining);
                     this.#copiedTimer.unref?.();
@@ -162,9 +160,9 @@ export class NestedCallsView {
      */
     #callContext(call) {
         const { context } = this.#props;
-        const toolCallId = "toolCallId" in call && typeof call.toolCallId === "string"
-            ? call.toolCallId
-            : context.toolCallId;
+        // A captured call carries its own id. A persisted record has none, so it falls back to the
+        // parent's id — the only identity the host offers, and never a child's guess.
+        const toolCallId = "id" in call ? call.id : context.toolCallId;
         return {
             ...context,
             lastComponent: undefined,
@@ -187,39 +185,54 @@ export class NestedCallsView {
         if (!text)
             return;
         const writeClip = this.#props.copyToClipboard ?? copyToSystemClipboard;
-        void writeClip(text).catch(() => { });
         const durationMs = 1500;
+        // Feedback starts when the write settles: a rejected clipboard write is not a copy.
+        void writeClip(text).then(() => this.#showCopyFeedback(callIndex, durationMs, false), () => this.#showCopyFeedback(callIndex, durationMs, true));
+    }
+    /** One feedback window on one row: ✓ when the text reached the clipboard, ✗ when it did not. */
+    #showCopyFeedback(callIndex, durationMs, failed) {
         const until = Date.now() + durationMs;
-        this.#copiedIndex = callIndex;
+        this.#copiedIndex = failed ? undefined : callIndex;
+        this.#failedIndex = failed ? callIndex : undefined;
         this.#renderCache = undefined;
         const state = this.#props.stateHolder;
         if (state !== undefined) {
             state[NESTED_CALLS_COPIED_KEY] = {
                 index: callIndex,
                 until,
+                ...(failed ? { failed: true } : {}),
             };
         }
         if (this.#copiedTimer !== undefined) {
             clearTimeout(this.#copiedTimer);
         }
         this.#copiedTimer = setTimeout(() => {
-            this.#copiedIndex = undefined;
-            this.#renderCache = undefined;
-            const s = this.#props.stateHolder;
-            if (s !== undefined) {
-                delete s[NESTED_CALLS_COPIED_KEY];
-            }
+            this.#clearCopyFeedback();
             this.#props.invalidate?.();
         }, durationMs);
         this.#copiedTimer.unref?.();
         this.#props.invalidate?.();
     }
+    /** Drops the copy marker, its timer, and the shared record it left behind. */
+    #clearCopyFeedback() {
+        if (this.#copiedTimer !== undefined) {
+            clearTimeout(this.#copiedTimer);
+            this.#copiedTimer = undefined;
+        }
+        this.#copiedIndex = undefined;
+        this.#failedIndex = undefined;
+        this.#renderCache = undefined;
+        const state = this.#props.stateHolder;
+        if (state !== undefined)
+            delete state[NESTED_CALLS_COPIED_KEY];
+    }
     render(width) {
         const safeWidth = Math.max(1, width);
         const levelsKey = this.#getLevelsKey();
         if (this.#renderCache !== undefined &&
             this.#renderCache.width === safeWidth &&
             this.#renderCache.copiedIndex === this.#copiedIndex &&
+            this.#renderCache.failedIndex === this.#failedIndex &&
             this.#renderCache.levelsKey === levelsKey) {
             this.#lineMapping = this.#renderCache.lineMapping;
             return this.#renderCache.lines;
@@ -254,7 +267,11 @@ export class NestedCallsView {
                 summary: [childSummary, duration].filter(Boolean).join(" · "),
             }, theme);
             const isCopied = this.#copiedIndex === i;
-            const copyIcon = isCopied ? theme.fg("success", "✓") : theme.fg("dim", "󰆏");
+            const copyIcon = this.#failedIndex === i
+                ? theme.fg("error", "✗")
+                : isCopied
+                    ? theme.fg("success", "✓")
+                    : theme.fg("dim", "󰆏");
             const copySlotWidth = 2 + rightMargin;
             const maxLeft = Math.max(1, width - copySlotWidth);
             const truncatedLeft = truncate(leftContent, maxLeft);
@@ -290,6 +307,7 @@ export class NestedCallsView {
         this.#renderCache = {
             width: safeWidth,
             copiedIndex: this.#copiedIndex,
+            failedIndex: this.#failedIndex,
             levelsKey,
             lines,
             lineMapping: this.#lineMapping,
@@ -390,17 +408,13 @@ export class NestedCallsView {
         return { handled: true };
     }
     dispose() {
-        if (this.#copiedTimer !== undefined) {
-            clearTimeout(this.#copiedTimer);
-            this.#copiedTimer = undefined;
-        }
+        this.#clearCopyFeedback();
         this.#renderCache = undefined;
     }
     collapseAll() {
-        if (this.#copiedTimer !== undefined) {
-            clearTimeout(this.#copiedTimer);
-            this.#copiedTimer = undefined;
-        }
+        // The marker points at a row that is no longer on screen; leaving it behind would bring a
+        // permanent checkmark back when the same view expands again.
+        this.#clearCopyFeedback();
         this.#inMemoryLevels.clear();
         const state = this.#props.stateHolder;
         if (state !== undefined) {

package/dist/payload-parser.js

@@ -166,16 +166,16 @@ export function extractSummaryArg(toolName, args) {
             return firstLine(parsed.code);
         case "bg_bash_get":
         case "bg_bash_stop":
-        case "agent_send":
-        case "agent_get":
-        case "agent_stop":
+        case "agents_get":
+        case "agents_stop":
             return typeof parsed.id === "string" ? parsed.id.trim() : "";
-        case "agent_spawn": {
+        case "agents_delegate": {
             const agent = typeof parsed.agent === "string" ? parsed.agent.trim() : "";
+            const id = typeof parsed.id === "string" ? parsed.id.trim() : "";
             const task = firstLine(parsed.task);
             if (agent && task)
                 return `${agent}: ${task}`;
-            return agent || task;
+            return agent || id || task;
         }
         case "tool_search":
             return typeof parsed.query === "string" ? parsed.query.trim() : "";

package/dist/renderer.js

@@ -79,6 +79,47 @@ function resolveToolCallSummary(params) {
     // Tier 2: Contractual Fallback for built-in tools
     return extractSummaryArg(toolName, args);
 }
+function isCapturedCall(call) {
+    return "args" in call || "result" in call;
+}
+/** Nested facts for a consumer that lists children outside the container's own body. */
+function nestedChildren(calls) {
+    return calls.map((call) => {
+        if (isCapturedCall(call)) {
+            const isError = call.isError === true;
+            const inline = inlinePresentation(call.toolName, call.args, call.result?.details, isError);
+            return {
+                title: call.toolName,
+                ...(inline === undefined ? {} : { summary: inline.summary }),
+                // The tracker records a call when it starts, so a missing result means it is still
+                // running, not that it succeeded.
+                status: isError
+                    ? "error"
+                    : call.result === undefined
+                        ? "running"
+                        : "ok",
+                ...(call.durationMs === undefined ? {} : { durationMs: call.durationMs }),
+                ...(call.result === undefined
+                    ? {}
+                    : { detail: extractResultText(call.toolName, call.result).outputText }),
+            };
+        }
+        return {
+            title: call.toolName,
+            ...(call.summary === undefined ? {} : { summary: call.summary }),
+            // Same precedence as formatNestedCallRow: a cancelled call is a warning, not a success.
+            status: call.status === "running"
+                ? "running"
+                : call.isWarning === true
+                    ? "warn"
+                    : call.isError === true || call.status === "error"
+                        ? "error"
+                        : "ok",
+            ...(call.durationMs === undefined ? {} : { durationMs: call.durationMs }),
+            ...(call.error === undefined ? {} : { detail: call.error }),
+        };
+    });
+}
 function formatArgsPreview(args) {
     if (args === undefined || args === null)
         return "";
@@ -256,6 +297,7 @@ function renderGenericResult(params) {
             invalidate: () => context.invalidate(),
         })
         : undefined;
+    const children = nestedChildren(childCalls);
     const collapsedRows = codemodeNestedView !== undefined
         ? codemodeNestedView
         : isMetaTool && nestedCalls.length > 0
@@ -366,6 +408,7 @@ function renderGenericResult(params) {
         },
         railToken: toolRailToken,
         collapsedRows,
+        ...(children.length === 0 ? {} : { children }),
         sections,
         copy,
         outputPad: context.outputPad,
@@ -534,6 +577,8 @@ function renderOwnedPresentation(params) {
                     .map((line) => theme.fg("error", stripTerminalSequences(line)))
                 : undefined;
         })(),
+        ...(presentation.children === undefined ? {} : { children: presentation.children }),
+        ...(presentation.childCount === undefined ? {} : { childCount: presentation.childCount }),
         sections,
         copy,
         outputPad: context.outputPad,

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

@@ -0,0 +1,45 @@
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
+import { type Component, Container } from "@earendil-works/pi-tui";
+import { type ToolStatusKind, type ToolViewChild } from "./tool-view.js";
+export interface Usage {
+    readonly input: number;
+    readonly output: number;
+    readonly cacheRead: number;
+    readonly cacheWrite: number;
+}
+export type MemberKind = "assistant" | "tool" | "notice";
+export type Category = "tools" | "thinking" | "notices";
+/** One transcript entry a block owns, reduced to the facts the collapsed frame draws. */
+export interface Member {
+    readonly kind: MemberKind;
+    readonly component: 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;
+    readonly thinking?: string;
+    readonly thinkingChars?: number;
+    readonly usage?: Usage;
+    readonly detail?: (width: number) => string[];
+}
+/** One agent loop. Blocks created during the run share its origin; ending it freezes them. */
+export interface ToolGroupRun {
+    readonly startedAt: number;
+    endedAt?: number;
+}
+/**
+ * The collapsed frame of one activity block.
+ *
+ * The frame owns only layout and hit testing: tool rows keep their own component so their glyph,
+ * colors, copy action, and fold level stay the ones the transcript already draws. Anything this
+ * view synthesized itself would drift from those rows.
+ */
+export declare class ToolGroupView extends Container {
+    #private;
+    constructor(ui: ExtensionUIContext, redraw: () => void, run: ToolGroupRun | undefined);
+    update(members: Member[], settled: boolean): void;
+    invalidate(): void;
+    render(width: number): string[];
+}