@hheei/pi-ext-ui 0.1.0 → 0.2.1

package/dist/payload-parser.d.ts

@@ -0,0 +1,55 @@
+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 interface NestedCallRecord {
+    readonly toolName: string;
+    readonly summary?: string | undefined;
+    readonly status?: "running" | "ok" | "error" | "cancelled" | undefined;
+    readonly isError?: boolean | undefined;
+    readonly isWarning?: boolean | undefined;
+    readonly durationMs?: number | undefined;
+    readonly cost?: number | undefined;
+    readonly error?: string | undefined;
+}
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function estimateStreamingTokens(args: unknown): number;
+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;
+    readonly isPartial: boolean;
+    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;

package/dist/payload-parser.js

@@ -0,0 +1,370 @@
+import { formatReadLineRange } from "@earendil-works/pi-coding-agent";
+import { stripTerminalSequences } from "@earendil-works/pi-tui";
+import { diffStats } from "./diff-view.js";
+export const EDIT_TOOL_NAME = "edit";
+export const WRITE_TOOL_NAME = "write";
+export const CODEMODE_OPTIONS_PREFIX = "// @options:";
+export const CODEMODE_SCRIPT_HEADER = /^Script (?:completed|failed)\r?\nWall time ([\d.]+) seconds\r?\nOutput:\r?\n/;
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function estimateStreamingTokens(args) {
+    if (args === undefined || args === null)
+        return 0;
+    try {
+        const serialized = typeof args === "string" ? args : JSON.stringify(args);
+        if (!serialized || serialized === "{}")
+            return 0;
+        return Math.max(1, Math.ceil(serialized.length / 4));
+    }
+    catch {
+        return 0;
+    }
+}
+export function formatDurationMs(ms) {
+    if (ms === undefined || !Number.isFinite(ms))
+        return "";
+    return ms < 1000 ? `${String(Math.round(ms))}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+export function formatCostUsd(cost) {
+    if (cost === undefined || !Number.isFinite(cost) || cost <= 0)
+        return "";
+    return `$${cost >= 0.01 ? cost.toFixed(2) : cost.toPrecision(2)}`;
+}
+/** One header fact for a deadline, in the same shape codemode's `timeout_ms` renders as. */
+export function formatTimeoutFact(timeoutMs) {
+    const label = timeoutMs >= 1000 ? `${String(Math.round(timeoutMs / 1000))}s` : `${String(timeoutMs)}ms`;
+    return `(timeout ${label})`;
+}
+export function extractCodemodeHeaderFacts(args) {
+    if (!isRecord(args))
+        return "";
+    const options = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (key !== "code" && value !== undefined && value !== null) {
+            options[key] = value;
+        }
+    }
+    if (typeof args.code === "string") {
+        const firstLine = args.code.split(/\r?\n/, 1)[0]?.trim() ?? "";
+        if (firstLine.startsWith(CODEMODE_OPTIONS_PREFIX)) {
+            try {
+                const parsed = JSON.parse(firstLine.slice(CODEMODE_OPTIONS_PREFIX.length).trim());
+                if (isRecord(parsed)) {
+                    Object.assign(options, parsed);
+                }
+            }
+            catch { }
+        }
+    }
+    const facts = [];
+    const timeoutMs = typeof options.timeout_ms === "number" ? options.timeout_ms : undefined;
+    if (timeoutMs !== undefined)
+        facts.push(formatTimeoutFact(timeoutMs));
+    if (typeof options.max_output_tokens === "number") {
+        facts.push(`(tokens ${String(options.max_output_tokens)})`);
+    }
+    if (typeof options.target === "string" && options.target !== "local") {
+        facts.push(`(${options.target})`);
+    }
+    return facts.join(" ");
+}
+export function parseCallArgs(raw) {
+    if (isRecord(raw))
+        return raw;
+    if (typeof raw !== "string")
+        return undefined;
+    const text = raw.trim();
+    if (text === "")
+        return undefined;
+    if (text.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(text);
+            if (isRecord(parsed))
+                return parsed;
+        }
+        catch {
+            const record = {};
+            const extractString = (key) => {
+                const regex = new RegExp(`"${key}"\\s*:\\s*"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"`);
+                const match = regex.exec(text);
+                if (match?.[1]) {
+                    record[key] = match[1].replace(/\\"/g, '"');
+                }
+            };
+            const extractNumber = (key) => {
+                const regex = new RegExp(`"${key}"\\s*:\\s*(-?\\d+(?:\\.\\d+)?)`);
+                const match = regex.exec(text);
+                if (match?.[1]) {
+                    record[key] = Number(match[1]);
+                }
+            };
+            extractString("path");
+            extractString("file_path");
+            extractString("command");
+            extractString("pattern");
+            extractString("glob");
+            extractString("query");
+            extractString("url");
+            extractString("id");
+            extractString("agent");
+            extractString("topic");
+            extractString("source");
+            extractNumber("offset");
+            extractNumber("limit");
+            if (Object.keys(record).length > 0)
+                return record;
+        }
+    }
+    return undefined;
+}
+export function extractSummaryArg(toolName, args) {
+    if (toolName === "codemode") {
+        return extractCodemodeHeaderFacts(args);
+    }
+    const parsed = parseCallArgs(args);
+    if (!parsed)
+        return "";
+    for (const key of [
+        "command",
+        "query",
+        "queries",
+        "url",
+        "urls",
+        "source",
+        "claim",
+        "id",
+        "search_id",
+        "topic",
+        "path",
+        "file_path",
+        "pattern",
+        "agent",
+    ]) {
+        const val = parsed[key];
+        if (typeof val === "string" && val.trim() !== "") {
+            return stripTerminalSequences(val.trim());
+        }
+        if (Array.isArray(val) && val.length > 0 && typeof val[0] === "string") {
+            const first = stripTerminalSequences(val[0].trim());
+            return val.length > 1 ? `${first} (+${String(val.length - 1)})` : first;
+        }
+    }
+    return "";
+}
+export function extractHeavyInputCommand(toolName, args) {
+    if (!isRecord(args))
+        return undefined;
+    if (toolName === "bash" && typeof args.command === "string") {
+        return args.command.trim();
+    }
+    if (toolName === "python_eval" && typeof args.code === "string") {
+        return args.code.trim();
+    }
+    if (toolName === "codemode" && typeof args.code === "string") {
+        return args.code.trim();
+    }
+    return undefined;
+}
+export function extractNestedCalls(result) {
+    if (result === undefined || !isRecord(result.details))
+        return [];
+    const rawList = Array.isArray(result.details.calls)
+        ? result.details.calls
+        : Array.isArray(result.details.nestedCalls)
+            ? result.details.nestedCalls
+            : undefined;
+    if (rawList === undefined)
+        return [];
+    const items = [];
+    for (const entry of rawList) {
+        if (!isRecord(entry))
+            continue;
+        const name = typeof entry.name === "string"
+            ? entry.name
+            : typeof entry.toolName === "string"
+                ? entry.toolName
+                : undefined;
+        if (name === undefined)
+            continue;
+        const rawStatus = entry.status;
+        const status = rawStatus === "running" ||
+            rawStatus === "ok" ||
+            rawStatus === "error" ||
+            rawStatus === "cancelled"
+            ? rawStatus
+            : undefined;
+        const summary = typeof entry.args === "string" && entry.args.trim() !== ""
+            ? entry.args
+            : typeof entry.summary === "string"
+                ? entry.summary
+                : undefined;
+        items.push({
+            toolName: name,
+            summary,
+            status,
+            isError: entry.isError === true || status === "error",
+            isWarning: entry.isWarning === true || status === "cancelled",
+            durationMs: typeof entry.durationMs === "number" ? entry.durationMs : undefined,
+            cost: typeof entry.cost === "number" ? entry.cost : undefined,
+            error: typeof entry.error === "string" ? entry.error : undefined,
+        });
+    }
+    return items;
+}
+export function extractResultText(toolName, result) {
+    const parts = [];
+    for (const block of result.content) {
+        if (block.type === "text" && block.text.trim() !== "") {
+            parts.push(block.text);
+        }
+    }
+    const joined = parts.join("\n");
+    if (toolName === "codemode") {
+        const stripped = stripTerminalSequences(joined);
+        const match = CODEMODE_SCRIPT_HEADER.exec(stripped);
+        const wallTimeSeconds = match?.[1] !== undefined ? Number.parseFloat(match[1]) : undefined;
+        const cleaned = joined.replace(CODEMODE_SCRIPT_HEADER, "").trim();
+        return { outputText: cleaned, wallTimeSeconds };
+    }
+    return { outputText: joined, wallTimeSeconds: undefined };
+}
+export function callStatsParts(total, failCount) {
+    if (failCount > 0) {
+        return [`${String(total - failCount)} ok`, `${String(failCount)} failed`];
+    }
+    return [`${String(total)} ${total === 1 ? "call" : "calls"}`];
+}
+export function resolveContainerStatus(params) {
+    if (params.selfFailed)
+        return "error";
+    if (params.hasChildren)
+        return "none";
+    if (params.isPartial)
+        return "running";
+    return params.isError ? "error" : "ok";
+}
+export function toolPath(args) {
+    const parsed = parseCallArgs(args);
+    if (!parsed)
+        return "";
+    const val = parsed.path ?? parsed.file_path;
+    return typeof val === "string" ? val.trim() : "";
+}
+export function fileToolPresentation(toolName, args, _details, isError) {
+    const path = toolPath(args);
+    if (toolName === "read") {
+        if (path === "")
+            return undefined;
+        const parsed = parseCallArgs(args);
+        const range = formatReadLineRange(parsed?.offset, parsed?.limit);
+        return { summary: `${path}${range}`, status: isError ? "error" : "ok" };
+    }
+    if (toolName === WRITE_TOOL_NAME) {
+        return path === "" ? undefined : { summary: path, status: isError ? "error" : "ok" };
+    }
+    return undefined;
+}
+/** Pi native edit persists a unified patch plus the same change as a numbered display diff. */
+export function editDiffSource(details) {
+    if (!isRecord(details))
+        return undefined;
+    if (typeof details.patch === "string" && details.patch.trim() !== "") {
+        return { kind: "unifiedPatch", text: details.patch };
+    }
+    if (typeof details.diff === "string" && details.diff.trim() !== "") {
+        return displayDiffSource(details.diff);
+    }
+    return undefined;
+}
+export function displayDiffSource(diff) {
+    const hunks = [];
+    let current = [];
+    let pendingBreak = false;
+    for (const raw of diff.split(/\r?\n/)) {
+        if (raw === "")
+            continue;
+        const sign = raw.charAt(0);
+        const match = /^ *(\d+)? ?(.*)$/.exec(raw.slice(1));
+        const lineNumber = match?.[1];
+        if (lineNumber === undefined) {
+            pendingBreak = true;
+            continue;
+        }
+        if (pendingBreak && current.length > 0) {
+            hunks.push(current);
+            current = [];
+        }
+        pendingBreak = false;
+        const kind = sign === "+" ? "add" : sign === "-" ? "del" : "ctx";
+        current.push({ kind, line: Number(lineNumber), text: match?.[2] ?? "" });
+    }
+    if (current.length === 0)
+        return undefined;
+    hunks.push(current);
+    return { kind: "hunks", hunks: hunks.map((lines) => ({ lines })) };
+}
+/**
+ * The name-free part of a summary for tools whose call arguments read well on their own. The tool
+ * name is the row's title, so repeating it here would print it twice.
+ */
+function formatArgumentSummary(toolName, parsed) {
+    const path = typeof parsed.path === "string"
+        ? parsed.path.trim()
+        : typeof parsed.file_path === "string"
+            ? parsed.file_path.trim()
+            : "";
+    switch (toolName) {
+        case "bash": {
+            const cmd = typeof parsed.command === "string" ? parsed.command.trim() : "";
+            if (!cmd)
+                return undefined;
+            return cmd.length > 70 ? `${cmd.slice(0, 67)}…` : cmd;
+        }
+        case "grep":
+        case "find": {
+            const pattern = typeof parsed.pattern === "string" ? parsed.pattern.trim() : "";
+            if (!pattern)
+                return undefined;
+            const target = path && path !== "." ? ` ${path}` : "";
+            return `${pattern}${target}`;
+        }
+        default: {
+            const keyArg = extractSummaryArg(toolName, parsed);
+            return keyArg ? keyArg : 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 function inlinePresentation(toolName, args, details, isError) {
+    const fileTool = fileToolPresentation(toolName, args, details, isError);
+    if (fileTool !== undefined)
+        return fileTool;
+    const parsed = parseCallArgs(args);
+    if (parsed === undefined)
+        return undefined;
+    if (toolName === EDIT_TOOL_NAME) {
+        const path = toolPath(parsed);
+        const source = isError ? undefined : editDiffSource(details);
+        const stats = source === undefined ? undefined : diffStats(source);
+        if (path === "" && stats === undefined)
+            return undefined;
+        return {
+            summary: stats === undefined
+                ? path
+                : `${path} (+${String(stats.added)} -${String(stats.removed)})`.trim(),
+            status: isError ? "error" : "ok",
+        };
+    }
+    const baseSummary = formatArgumentSummary(toolName, parsed);
+    if (baseSummary === undefined)
+        return undefined;
+    return {
+        summary: baseSummary,
+        status: isError ? "error" : "ok",
+    };
+}

package/dist/renderer.d.ts

@@ -1,12 +1,16 @@
-import type { ExtensionAPI, ToolRendererResolver, ToolRenderers } from "@earendil-works/pi-coding-agent";
-import { type ToolStatusKind } from "./tool-view.js";
+import { type ExtensionAPI, type ToolRendererResolver, type ToolRenderers } from "@earendil-works/pi-coding-agent";
 export type ToolRenderContext = Parameters<NonNullable<ToolRenderers["renderCall"]>>[2];
-/** Tools with a pi-ext-ui-owned renderer. Other tools stay on Pi's renderer. */
-export declare const SPECIALIZED_TOOL_RENDERERS: readonly ["edit", "write", "apply_patch", "python_eval", "codemode"];
+/**
+ * Upstream tools whose call and result views pi-ext-ui still frames itself. Concrete tool packages
+ * own their own presentation through ext-core's optional renderer point, so their names never
+ * appear here.
+ */
+export declare const SPECIALIZED_TOOL_RENDERERS: readonly ["codemode"];
 export type SpecializedToolRendererName = (typeof SPECIALIZED_TOOL_RENDERERS)[number];
 /** Web-access tools use the shared folding shell while retaining their native body renderer. */
 export declare const WEB_ACCESS_TOOLS: readonly ["web_search", "web_fetch", "web_open"];
 export type WebAccessToolName = (typeof WEB_ACCESS_TOOLS)[number];
+export { estimateStreamingTokens, inlinePresentation, type NestedCallRecord, } from "./payload-parser.js";
 export interface CollapsibleToolRendererOptions {
     readonly tools?: readonly string[] | undefined;
     readonly match?: ((toolName: string) => boolean) | undefined;
@@ -14,29 +18,7 @@ export interface CollapsibleToolRendererOptions {
     readonly defaultCollapsed?: boolean | undefined;
     readonly copyToClipboard?: ((text: string) => Promise<void>) | undefined;
 }
-export interface NestedCallRecord {
-    readonly toolName: string;
-    readonly summary?: string | undefined;
-    readonly status?: "running" | "ok" | "error" | "cancelled" | undefined;
-    readonly isError?: boolean | undefined;
-    readonly isWarning?: boolean | undefined;
-    readonly durationMs?: number | undefined;
-    readonly cost?: number | undefined;
-    readonly error?: string | undefined;
-}
-export declare function estimateStreamingTokens(args: unknown): number;
-export declare function extractCodemodeHeaderFacts(args: unknown): string;
-/** Compact nested-row result: a one-line summary plus the status it reports. */
-interface InlinePresentation {
-    readonly summary: string;
-    readonly status: ToolStatusKind;
-}
-/**
- * One compact nested summary for a file tool. Reports the delta only when the
- * caller actually has result details; a codemode nested record keeps arguments
- * alone, so it degrades to `<tool> <path>` instead of inventing counts.
- */
-export declare function inlinePresentation(toolName: string, args: unknown, details: unknown, isError: boolean): InlinePresentation | undefined;
 export declare function createCollapsibleToolRendererResolver(options?: CollapsibleToolRendererOptions): ToolRendererResolver;
+/** UI factory consumed by package-owned direct renderers, independently of host resolver precedence. */
+export declare function createOptionalToolRendererFactory(pi: ExtensionAPI, options?: CollapsibleToolRendererOptions): import("@hheei/pi-ext-core").ToolRendererFactory;
 export declare function registerCollapsibleToolRenderer(pi: ExtensionAPI, options?: CollapsibleToolRendererOptions): void;
-export {};