@hheei/pi-ext-ui 0.2.0 → 0.3.0

package/dist/extension.js

@@ -1,4 +1,15 @@
-import { registerCollapsibleToolRenderer } from "./renderer.js";
+import { messageViewPoint, registerExtensionHook, registerExtensionLifecycle, toolRendererPoint, } from "@hheei/pi-ext-core";
+import { createMessageView } from "./message-view.js";
+import { createOptionalToolRendererFactory, registerCollapsibleToolRenderer } from "./renderer.js";
 export default function (pi) {
     registerCollapsibleToolRenderer(pi);
+    registerExtensionLifecycle(pi, {
+        key: "@hheei/pi-ext-ui",
+        start(context) {
+            const toolRenderers = registerExtensionHook(pi, toolRendererPoint, createOptionalToolRendererFactory(pi));
+            context.resources.add("tool-renderer", () => toolRenderers.dispose());
+            const handle = registerExtensionHook(context.pi, messageViewPoint, createMessageView);
+            context.resources.add("message-view", () => handle.dispose());
+        },
+    });
 }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { type DiffHunk, type DiffLine, type DiffSource, type DiffStats, DiffView, type DiffViewOptions, diffStats, } from "./diff-view.js";
+export { createMessageView, type MessageRows, type MessageTone, MessageView, type MessageViewHeader, type MessageViewSpec, } from "./message-view.js";
 export { extractChildToolCopyText, NestedCallsView, type NestedCallsViewProps, } from "./nested-calls-view.js";
 export { type CollapsibleToolRendererOptions, createCollapsibleToolRendererResolver, estimateStreamingTokens, inlinePresentation, type NestedCallRecord, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, type SpecializedToolRendererName, type ToolRenderContext, WEB_ACCESS_TOOLS, type WebAccessToolName, } from "./renderer.js";
 export { type Collapsible, createToolView, type FoldLevel, formatStatusGlyph, formatToolHeaderText, isCollapsible, type RailColorToken, type RailSection, type ToolStatusKind, ToolView, type ToolViewCopySpec, type ToolViewHeaderSpec, type ToolViewSpec, transitionFoldLevel, } from "./tool-view.js";

package/dist/index.js

@@ -1,4 +1,5 @@
 export { DiffView, diffStats, } from "./diff-view.js";
+export { createMessageView, MessageView, } from "./message-view.js";
 export { extractChildToolCopyText, NestedCallsView, } from "./nested-calls-view.js";
 export { createCollapsibleToolRendererResolver, estimateStreamingTokens, inlinePresentation, registerCollapsibleToolRenderer, SPECIALIZED_TOOL_RENDERERS, WEB_ACCESS_TOOLS, } from "./renderer.js";
 export { createToolView, formatStatusGlyph, formatToolHeaderText, isCollapsible, ToolView, transitionFoldLevel, } from "./tool-view.js";

package/dist/message-view.d.ts

@@ -0,0 +1,15 @@
+import { type Component, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+import type { MessageViewSpec } from "@hheei/pi-ext-core";
+export type { MessageRows, MessageTone, MessageViewHeader, MessageViewSpec, } from "@hheei/pi-ext-core";
+export declare function createMessageView(spec: MessageViewSpec): MessageView;
+export declare class MessageView implements Component {
+    #private;
+    constructor(spec: MessageViewSpec);
+    get expandable(): boolean;
+    /** What the user sees. Host ctrl+o wins over the remembered collapse. */
+    get expanded(): boolean;
+    toggle(): void;
+    render(width: number): string[];
+    invalidate(): void;
+    handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined;
+}

package/dist/message-view.js

@@ -0,0 +1,130 @@
+import { truncateToWidth, } from "@earendil-works/pi-tui";
+import { toContentRows, toSingleRow } from "./tool-view.js";
+/**
+ * A transcript notice, not a tool execution.
+ *
+ * ToolView owns status, copy, rails, and the three-level fold. A message is a kind plus a
+ * summary, optional preview lines, and a body that opens in one step. Expansion is remembered
+ * on `stateHolder` by identity, so a host rebuild does not write a field into a session entry.
+ */
+const expansion = new WeakMap();
+const truncate = (text, width) => truncateToWidth(text, width, "…");
+function remembered(holder, fallback) {
+    if (holder === undefined)
+        return fallback;
+    return expansion.get(holder) ?? fallback;
+}
+function remember(holder, value) {
+    if (holder === undefined)
+        return;
+    expansion.set(holder, value);
+}
+function hasRows(source) {
+    if (source === undefined)
+        return false;
+    if (typeof source === "string")
+        return source.trim() !== "";
+    if (Array.isArray(source))
+        return source.some((line) => line.trim() !== "");
+    return true;
+}
+function isComponent(source) {
+    return typeof source !== "string" && !Array.isArray(source);
+}
+function layRows(source, width) {
+    if (source === undefined || !hasRows(source))
+        return [];
+    const inner = Math.max(1, width - 2);
+    const raw = isComponent(source)
+        ? source.render(inner).flatMap((line) => toContentRows(line))
+        : (typeof source === "string" ? [source] : source).flatMap((line) => toContentRows(line));
+    return raw.map((line) => truncate(`  ${line}`, width));
+}
+function invalidateRows(source) {
+    if (source !== undefined && isComponent(source))
+        source.invalidate();
+}
+export function createMessageView(spec) {
+    return new MessageView(spec);
+}
+export class MessageView {
+    #spec;
+    #localExpanded;
+    #lastWidth = 80;
+    #lastHeight = 0;
+    #cache;
+    constructor(spec) {
+        this.#spec = spec;
+        this.#localExpanded = remembered(spec.stateHolder, spec.defaultExpanded === true);
+    }
+    get expandable() {
+        return hasRows(this.#spec.body);
+    }
+    /** What the user sees. Host ctrl+o wins over the remembered collapse. */
+    get expanded() {
+        return this.expandable && (this.#spec.forcedExpanded === true || this.#localExpanded);
+    }
+    toggle() {
+        if (!this.expandable)
+            return;
+        const next = !this.expanded;
+        this.#localExpanded = next;
+        remember(this.#spec.stateHolder, next);
+        this.#cache = undefined;
+        this.#spec.invalidate?.();
+    }
+    render(width) {
+        const expanded = this.expanded;
+        if (this.#cache !== undefined &&
+            this.#cache.width === width &&
+            this.#cache.expanded === expanded) {
+            return this.#cache.lines;
+        }
+        const pad = Math.max(0, this.#spec.outputPad ?? 0);
+        const safeWidth = Math.max(1, width - pad * 2);
+        this.#lastWidth = width;
+        const leftPad = pad > 0 ? " ".repeat(pad) : "";
+        const lines = [
+            this.#header(safeWidth, expanded),
+            ...layRows(this.#spec.preview, safeWidth),
+            ...(expanded ? layRows(this.#spec.body, safeWidth) : []),
+        ].map((line) => (leftPad === "" ? line : `${leftPad}${line}`));
+        this.#lastHeight = lines.length;
+        this.#cache = { width, expanded, lines };
+        return lines;
+    }
+    invalidate() {
+        this.#cache = undefined;
+        invalidateRows(this.#spec.preview);
+        invalidateRows(this.#spec.body);
+    }
+    handleMouse(event) {
+        if (!this.expandable ||
+            event.type === "wheel" ||
+            event.type !== "click" ||
+            event.button !== "left") {
+            return undefined;
+        }
+        const effectiveWidth = event.width > 0 ? event.width : this.#lastWidth;
+        const pad = Math.max(0, this.#spec.outputPad ?? 0);
+        const innerX = event.x - pad;
+        const innerWidth = Math.max(1, effectiveWidth - pad * 2);
+        if (innerX < 0 || innerX >= innerWidth)
+            return undefined;
+        if (this.#lastHeight > 0 && (event.y < 0 || event.y >= this.#lastHeight))
+            return undefined;
+        if (event.y !== 0)
+            return undefined;
+        this.toggle();
+        return { handled: true, render: true };
+    }
+    #header(width, expanded) {
+        const { theme, header } = this.#spec;
+        const kind = theme.fg("dim", toSingleRow(header.kind));
+        const summaryRaw = header.summary === undefined ? "" : toSingleRow(header.summary);
+        const summary = summaryRaw === "" ? "" : theme.fg(header.tone ?? "dim", summaryRaw);
+        const label = summary === "" ? kind : `${kind}${theme.fg("dim", " · ")}${summary}`;
+        const pin = this.expandable ? `${theme.fg("dim", expanded ? "▾" : "▸")} ` : "";
+        return truncate(`${pin}${label}`, width);
+    }
+}

package/dist/nested-calls-view.js

@@ -15,14 +15,9 @@ export function extractChildToolCopyText(call, full) {
     if (toolName === "write" && isRecord(args) && typeof args.content === "string") {
         return args.content;
     }
-    if (toolName === "apply_patch" && isRecord(args) && typeof args.patch === "string") {
-        return args.patch;
-    }
     const heavyCommand = toolName === "bash" && isRecord(args) && typeof args.command === "string"
         ? args.command
-        : (toolName === "python_eval" || toolName === "codemode") &&
-            isRecord(args) &&
-            typeof args.code === "string"
+        : toolName === "codemode" && isRecord(args) && typeof args.code === "string"
             ? args.code
             : undefined;
     if (heavyCommand !== undefined && heavyCommand.trim() !== "") {
@@ -31,17 +26,6 @@ export function extractChildToolCopyText(call, full) {
         const output = resultText(result);
         return output === undefined ? heavyCommand : `${heavyCommand}\n---\n${output}`;
     }
-    if (toolName === "edit" && result && isRecord(result.details)) {
-        const editView = result.details.__piExtToolsEditView;
-        if (isRecord(editView) && Array.isArray(editView.ops)) {
-            const opsText = editView.ops
-                .map((op) => isRecord(op) && typeof op.newContent === "string" ? op.newContent : "")
-                .filter(Boolean)
-                .join("\n---\n");
-            if (opsText)
-                return opsText;
-        }
-    }
     if (result && Array.isArray(result.content)) {
         const texts = result.content
             .filter((c) => isRecord(c) && c.type === "text" && typeof c.text === "string")
@@ -172,12 +156,31 @@ export class NestedCallsView {
             state[NESTED_CALLS_EXPANDED_KEY] = record;
         }
     }
+    /**
+     * The render context of one nested call. A nested call has no host-mounted component, so its
+     * context is the parent's with the child's own args, id, duration and failure state.
+     */
+    #callContext(call) {
+        const { context } = this.#props;
+        const toolCallId = "toolCallId" in call && typeof call.toolCallId === "string"
+            ? call.toolCallId
+            : context.toolCallId;
+        return {
+            ...context,
+            args: "args" in call ? call.args : undefined,
+            toolCallId,
+            durationMs: call.durationMs,
+            isError: Boolean(call.isError || ("status" in call && call.status === "error")),
+            isPartial: false,
+            argsComplete: true,
+        };
+    }
     #triggerCopy(callIndex, full) {
         const call = this.#props.calls[callIndex];
         if (!call)
             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);
+        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)
@@ -239,7 +242,7 @@ export class NestedCallsView {
             const inline = inlinePresentation(toolName, rawArgs ?? rawSummary, "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);
+            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);
@@ -288,7 +291,7 @@ export class NestedCallsView {
         return lines;
     }
     #renderChildBody(call, width, expansionLevel = 1) {
-        const { theme, context, resolveChildRenderer } = this.#props;
+        const { theme, resolveChildRenderer } = this.#props;
         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;
@@ -297,11 +300,7 @@ export class NestedCallsView {
             if (renderer?.renderResult) {
                 try {
                     const childContext = {
-                        ...context,
-                        toolCallId: "toolCallId" in call ? call.toolCallId : context.toolCallId,
-                        args,
-                        durationMs: call.durationMs,
-                        isError: Boolean(call.isError || ("status" in call && call.status === "error")),
+                        ...this.#callContext(call),
                         state: undefined,
                     };
                     const comp = renderer.renderResult(result, { expanded: expansionLevel === 2, isPartial: false }, theme, childContext);

package/dist/payload-parser.d.ts

@@ -1,13 +1,8 @@
-import type { AgentToolResult } from "@earendil-works/pi-coding-agent";
-import { type DiffLine, type DiffSource } from "./diff-view.js";
+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 APPLY_PATCH_TOOL_NAME = "apply_patch";
-export declare const PYTHON_EVAL_TOOL_NAME = "python_eval";
-export declare const PYTHON_EVAL_DETAILS_FORMAT = "pi-ext-tools-python-eval";
 export declare const EDIT_TOOL_NAME = "edit";
 export declare const WRITE_TOOL_NAME = "write";
-export declare const EDIT_VIEW_KEY = "__piExtToolsEditView";
-export declare const WRITE_VIEW_KEY = "__piExtToolsWriteView";
 export declare const CODEMODE_OPTIONS_PREFIX = "// @options:";
 export declare const CODEMODE_SCRIPT_HEADER: RegExp;
 export interface NestedCallRecord {
@@ -43,78 +38,18 @@ export declare function resolveContainerStatus(params: {
     readonly selfFailed: boolean;
 }): ToolStatusKind;
 export declare function toolPath(args: unknown): string;
-export declare function editPath(args: unknown): string;
-export declare function numericField(value: unknown, key: string): number | undefined;
-export type WritePresentation = {
-    readonly kind: "diff";
-    readonly source: DiffSource;
-    readonly added: number;
-    readonly removed: number;
-} | {
-    readonly kind: "content";
-    readonly label: string;
-    readonly content: string;
-} | {
-    readonly kind: "noChange";
-};
-export declare function writeStoredDiff(lines: readonly unknown[]): DiffSource | undefined;
-/** Uses only the baseline and content already stored by the write tool. */
-export declare function writePresentation(args: unknown, details: unknown): WritePresentation | undefined;
 /** 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;
+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;
-export declare function editViewSource(view: unknown): DiffSource | undefined;
-export declare function editViewHunks(view: unknown): readonly {
-    readonly lines: readonly DiffLine[];
-}[];
-export declare function hunksForEditOp(op: Record<string, unknown>): readonly {
-    readonly lines: readonly DiffLine[];
-}[];
-export declare function splitFragment(text: string): readonly string[];
-/** Line LCS of one stored before/after fragment. No file context is invented. */
-export declare function lineHunks(before: string, after: string, startLine: number): readonly {
-    readonly lines: readonly DiffLine[];
-}[];
-export declare function patchTextForCopy(details: unknown): string | undefined;
-export declare function patchSummary(files: number, added: number, removed: number): string;
 /**
  * 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;
-/**
- * One row of the eval cell transcript: printed text, display value, nested call, the final
- * value, or the kernel's namespace report.
- */
-export type EvalRow = {
-    readonly kind: "text";
-    readonly text: string;
-} | {
-    readonly kind: "display";
-    readonly text: string;
-} | {
-    readonly kind: "tool";
-    readonly name: string;
-    readonly args: unknown;
-    readonly durationMs: number | undefined;
-    readonly error: string | undefined;
-} | {
-    readonly kind: "result";
-    readonly text: string;
-} | {
-    readonly kind: "state";
-    readonly text: string;
-};
-export interface EvalFacts {
-    readonly rows: readonly EvalRow[];
-    readonly error: string | undefined;
-}
-/** Reads only the persisted `pi-ext-tools-eval` details; other shapes degrade to plain output. */
-export declare function pythonEvalFacts(details: unknown): EvalFacts | undefined;