@hheei/pi-ext-ui 0.5.2 → 0.7.0

package/dist/nested-calls-view.js

@@ -1,6 +1,6 @@
 import { copyToClipboard as copyToSystemClipboard, getLanguageFromPath, highlightCode, } from "@earendil-works/pi-coding-agent";
 import { stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
-import { inlinePresentation } from "./renderer.js";
+import { extractChildToolCopyText, inlinePresentation, nativeRequestCopy } from "./native-tools.js";
 import { formatToolHeaderText, ToolView, toContentRows, transitionFoldLevel, } from "./tool-view.js";
 function truncate(text, width) {
     return truncateToWidth(text, Math.max(1, width));
@@ -8,53 +8,15 @@ function truncate(text, width) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-export function extractChildToolCopyText(call, full) {
-    const toolName = "toolName" in call ? call.toolName : call.name;
-    const result = "result" in call ? call.result : undefined;
-    const args = "args" in call ? call.args : undefined;
-    if (toolName === "write" && isRecord(args) && typeof args.content === "string") {
-        return args.content;
+/**
+ * A copy keeps the request half byte-exact and strips only what follows it: the result is display
+ * text, while the request is what the model sent and may legitimately contain escapes.
+ */
+function copyText(text, request) {
+    if (request === undefined || request === "" || !text.startsWith(request)) {
+        return stripTerminalSequences(text);
     }
-    const heavyCommand = toolName === "bash" && isRecord(args) && typeof args.command === "string"
-        ? args.command
-        : toolName === "codemode" && isRecord(args) && typeof args.code === "string"
-            ? args.code
-            : undefined;
-    if (heavyCommand !== undefined && heavyCommand.trim() !== "") {
-        if (full !== true)
-            return heavyCommand;
-        const output = resultText(result);
-        return output === undefined ? heavyCommand : `${heavyCommand}\n---\n${output}`;
-    }
-    if (result && Array.isArray(result.content)) {
-        const texts = result.content
-            .filter((c) => isRecord(c) && c.type === "text" && typeof c.text === "string")
-            .map((c) => c.text);
-        if (texts.length > 0)
-            return texts.join("\n");
-    }
-    if (args !== undefined) {
-        if (typeof args === "string")
-            return args;
-        try {
-            return JSON.stringify(args, null, 2);
-        }
-        catch {
-            return String(args);
-        }
-    }
-    if ("summary" in call && typeof call.summary === "string") {
-        return call.summary;
-    }
-    return "";
-}
-function resultText(result) {
-    if (result === undefined || !Array.isArray(result.content))
-        return undefined;
-    const texts = result.content
-        .filter((c) => isRecord(c) && c.type === "text" && typeof c.text === "string")
-        .map((c) => c.text);
-    return texts.length === 0 ? undefined : texts.join("\n");
+    return request + stripTerminalSequences(text.slice(request.length));
 }
 function formatDuration(ms) {
     if (ms === undefined || !Number.isFinite(ms))
@@ -67,6 +29,7 @@ export class NestedCallsView {
     #props;
     #inMemoryLevels = new Map();
     #copiedIndex = undefined;
+    #failedIndex = undefined;
     #copiedTimer = undefined;
     #lineMapping = [];
     #renderCache;
@@ -96,14 +59,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 +122,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 : undefined) ?? context.toolCallId;
         return {
             ...context,
             lastComponent: undefined,
@@ -182,44 +142,62 @@ export class NestedCallsView {
             return;
         const provider = this.#props.resolvePresentation?.(call.toolName);
         const presentation = provider?.("args" in call ? call.args : undefined, "result" in call ? call.result : undefined, this.#props.theme, this.#callContext(call));
-        const text = stripTerminalSequences((full ? presentation?.copy?.full : presentation?.copy?.primary) ??
-            extractChildToolCopyText(call, full));
-        if (!text)
+        const chosen = full ? presentation?.copy?.full : presentation?.copy?.primary;
+        const text = chosen ?? copyText(extractChildToolCopyText(call, full), nativeRequestCopy(call));
+        const durationMs = 1500;
+        if (text === "") {
+            // Nothing was recorded to copy. A summary is not the request, so the copy reports failure.
+            this.#showCopyFeedback(callIndex, durationMs, true);
             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;
@@ -240,21 +218,32 @@ export class NestedCallsView {
             const isExpanded = expansionLevel !== 0;
             const rawSummary = "summary" in call ? call.summary : undefined;
             const rawArgs = "args" in call ? call.args : undefined;
-            const inline = inlinePresentation(toolName, rawArgs ?? rawSummary, "result" in call ? call.result?.details : undefined, isError);
+            // A record's summary is the fact its owner stated; the arguments only fill in for a capture.
+            const inline = inlinePresentation(toolName, rawSummary ?? rawArgs, "result" in call ? call.result?.details : undefined, isError);
             const argText = typeof rawArgs === "string" ? rawArgs : typeof rawSummary === "string" ? rawSummary : "";
             const provider = this.#props.resolvePresentation?.(toolName);
             const presentation = provider?.(rawArgs, "result" in call ? call.result : undefined, theme, this.#callContext(call));
             // The child row is the child's own header minus the fold pin, so it carries the same token
             // assignment as the row the same call would draw at top level.
-            const childSummary = stripTerminalSequences(presentation?.summary ?? inline?.summary ?? argText);
-            const duration = formatDuration(call.durationMs);
+            const ownSummary = presentation?.summary === undefined
+                ? this.#props.headerSummary?.(toolName, rawArgs ?? rawSummary, theme)
+                : undefined;
+            const childSummary = ownSummary === undefined || ownSummary === ""
+                ? stripTerminalSequences(presentation?.summary ?? inline?.summary ?? argText)
+                : ownSummary;
             const leftContent = formatToolHeaderText({
                 status: isRunning ? "running" : isError ? "error" : "ok",
                 title: toolName,
-                summary: [childSummary, duration].filter(Boolean).join(" · "),
+                summary: childSummary,
+                ...(ownSummary === undefined || ownSummary === "" ? {} : { summaryStyled: true }),
+                meta: formatDuration(call.durationMs),
             }, 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 +279,7 @@ export class NestedCallsView {
         this.#renderCache = {
             width: safeWidth,
             copiedIndex: this.#copiedIndex,
+            failedIndex: this.#failedIndex,
             levelsKey,
             lines,
             lineMapping: this.#lineMapping,
@@ -304,22 +294,17 @@ export class NestedCallsView {
         if (result && resolveChildRenderer) {
             const renderer = resolveChildRenderer(toolName);
             if (renderer?.renderResult) {
-                try {
-                    const childContext = {
-                        ...this.#callContext(call),
-                        state: undefined,
-                    };
-                    const comp = renderer.renderResult(result, { expanded: expansionLevel === 2, isPartial: false }, theme, childContext);
-                    if (comp instanceof ToolView) {
-                        comp.setFoldLevel(expansionLevel);
-                        // Render body cleanly via deep headless interface without outer rail or header row
-                        return comp.renderBody(width, { noRail: true });
-                    }
-                    return comp.render(width);
-                }
-                catch {
-                    // Fall through to plain text extraction on renderer failure
+                const childContext = {
+                    ...this.#callContext(call),
+                    state: undefined,
+                };
+                const comp = renderer.renderResult(result, { expanded: expansionLevel === 2, isPartial: false }, theme, childContext);
+                if (comp instanceof ToolView) {
+                    comp.setFoldLevel(expansionLevel);
+                    // Render body cleanly via deep headless interface without outer rail or header row
+                    return comp.renderBody(width, { noRail: true });
                 }
+                return comp.render(width);
             }
         }
         // Fallback rendering
@@ -363,11 +348,29 @@ export class NestedCallsView {
         if ("error" in call && typeof call.error === "string" && call.error) {
             return call.error.split("\n").map((l) => theme.fg("error", l));
         }
+        if ("argsTruncated" in call && call.argsTruncated === true) {
+            const bytes = "argsBytes" in call && typeof call.argsBytes === "number" ? call.argsBytes : 0;
+            return [
+                theme.fg("dim", bytes > 0 ? `(request not recorded: ${String(bytes)} bytes)` : "(request not recorded)"),
+            ];
+        }
+        // The request as the model sent it: the command or source, not a JSON wrapper around it.
+        const request = nativeRequestCopy(call);
+        if (request !== undefined) {
+            return stripTerminalSequences(request)
+                .split("\n")
+                .map((line) => theme.fg("dim", line));
+        }
         if (args !== undefined) {
-            const text = typeof args === "string" ? args : JSON.stringify(args, null, 2);
+            const text = typeof args === "string" ? stripTerminalSequences(args) : JSON.stringify(args, null, 2);
             return text.split("\n").map((l) => theme.fg("dim", l));
         }
-        return [theme.fg("dim", "(no output)")];
+        // A persisted record keeps a summary, not its request: say so instead of implying an empty call.
+        return [
+            theme.fg("dim", "summary" in call && typeof call.summary === "string" && call.summary !== ""
+                ? "(request not recorded; summary only)"
+                : "(no output)"),
+        ];
     }
     handleMouse(event) {
         if (event.type !== "click" || event.button !== "left")
@@ -390,17 +393,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.d.ts

@@ -1,12 +1,17 @@
 import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
-import { type DiffSource } from "./diff-view.js";
 import type { ToolStatusKind } from "./tool-view.js";
-export declare const EDIT_TOOL_NAME = "edit";
-export declare const WRITE_TOOL_NAME = "write";
-export declare const CODEMODE_OPTIONS_PREFIX = "// @options:";
-export declare const CODEMODE_SCRIPT_HEADER: RegExp;
+export declare const RESOLVED_CALLS_KEY = "__piExtUiResolvedCalls";
 export interface NestedCallRecord {
     readonly toolName: string;
+    /** The host's call id (`<parent>/<n>`); the key its saved arguments are indexed under. */
+    readonly id?: string | undefined;
+    /** The request bytes when this process or the session branch still has them. */
+    readonly args?: unknown;
+    /** The session saved the size of the request but not the request itself. */
+    readonly argsTruncated?: boolean | undefined;
+    readonly argsBytes?: number | undefined;
+    /** Positive fact only: the host proved this call resolved to a real tool. */
+    readonly resolved?: boolean | undefined;
     readonly summary?: string | undefined;
     readonly status?: "running" | "ok" | "error" | "cancelled" | undefined;
     readonly isError?: boolean | undefined;
@@ -21,15 +26,8 @@ export declare function formatDurationMs(ms: number | undefined): string;
 export declare function formatCostUsd(cost: number | undefined): string;
 /** One header fact for a deadline, in the same shape codemode's `timeout_ms` renders as. */
 export declare function formatTimeoutFact(timeoutMs: number): string;
-export declare function extractCodemodeHeaderFacts(args: unknown): string;
 export declare function parseCallArgs(raw: unknown): Record<string, unknown> | undefined;
-export declare function extractSummaryArg(toolName: string, args: unknown): string;
-export declare function extractHeavyInputCommand(toolName: string, args: unknown): string | undefined;
 export declare function extractNestedCalls(result: AgentToolResult<unknown> | undefined): readonly NestedCallRecord[];
-export declare function extractResultText(toolName: string, result: AgentToolResult<unknown>): {
-    readonly outputText: string;
-    readonly wallTimeSeconds: number | undefined;
-};
 export declare function callStatsParts(total: number, failCount: number): string[];
 export declare function resolveContainerStatus(params: {
     readonly isError: boolean;
@@ -37,19 +35,3 @@ export declare function resolveContainerStatus(params: {
     readonly hasChildren: boolean;
     readonly selfFailed: boolean;
 }): ToolStatusKind;
-export declare function toolPath(args: unknown): string;
-/** Compact nested-row result: a one-line summary plus the status it reports. */
-export interface InlinePresentation {
-    readonly summary: string;
-    readonly status: ToolStatusKind;
-}
-export declare function fileToolPresentation(toolName: string, args: unknown, _details: unknown, isError: boolean): InlinePresentation | undefined;
-/** Pi native edit persists a unified patch plus the same change as a numbered display diff. */
-export declare function editDiffSource(details: unknown): DiffSource | undefined;
-export declare function displayDiffSource(diff: string): DiffSource | undefined;
-/**
- * One compact nested summary for a tool call. Adopts the tool's standard collapsed
- * single-line format when recognized, degrading to undefined so callers can use
- * the default argument rendering.
- */
-export declare function inlinePresentation(toolName: string, args: unknown, details: unknown, isError: boolean): InlinePresentation | undefined;