@esso0428/pi-subagents 0.15.4 → 0.15.6

package/dist/ui/conversation-blocks.js

@@ -0,0 +1,214 @@
+const DEFAULT_MAX_CHARS = 16_000;
+const TRUNCATION_NOTICE = "\n… [truncated in subagent viewer]";
+function charLimit(value, fallback) {
+    if (value === undefined || !Number.isFinite(value))
+        return fallback;
+    return Math.max(0, Math.floor(value));
+}
+/** Normalize terminal/platform line endings, then keep the result bounded. */
+function bound(value, limit) {
+    const text = value.replace(/\r\n?/g, "\n");
+    if (text.length <= limit)
+        return text;
+    if (limit <= 0)
+        return "";
+    if (limit <= TRUNCATION_NOTICE.length)
+        return TRUNCATION_NOTICE.slice(0, limit);
+    return text.slice(0, limit - TRUNCATION_NOTICE.length) + TRUNCATION_NOTICE;
+}
+function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+/** Extract displayable text without leaking provider-specific or unknown parts. */
+function contentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const part of content) {
+        if (!part || typeof part !== "object")
+            continue;
+        const item = part;
+        if (item.type === "text" && typeof item.text === "string") {
+            parts.push(item.text);
+        }
+        else if (item.type === "image") {
+            parts.push("[image]");
+        }
+    }
+    return parts.join("\n");
+}
+function firstNonEmptyLine(text) {
+    const line = text.split("\n").find((candidate) => candidate.trim().length > 0);
+    if (!line)
+        return "(no output)";
+    return line.trim().replace(/\s+/g, " ");
+}
+function toolSummary(name, call) {
+    const args = call.arguments && typeof call.arguments === "object"
+        ? call.arguments
+        : call.input && typeof call.input === "object"
+            ? call.input
+            : {};
+    const path = asString(args.path) ?? asString(args.filePath) ?? asString(args.filename);
+    if (["read", "edit", "write"].includes(name) && path)
+        return path;
+    if (asString(args.command))
+        return asString(args.command);
+    if (path)
+        return path;
+    try {
+        const encoded = JSON.stringify(args);
+        return encoded === "{}" ? "" : encoded;
+    }
+    catch {
+        return "";
+    }
+}
+function blockId(messageIndex, emitted, toolIndex) {
+    if (emitted === 0)
+        return `message-${messageIndex}`;
+    return `message-${messageIndex}-tool-${toolIndex ?? emitted}`;
+}
+function textBlock(id, role, markdown) {
+    return {
+        id,
+        kind: "text",
+        role,
+        header: role === "user" ? "User" : "Assistant",
+        markdown,
+        copyText: markdown,
+        fullText: markdown,
+    };
+}
+function toolCallBlock(id, name, summary) {
+    const toolLine = `· ${name} → ${summary || "(no details)"}`;
+    return {
+        id,
+        kind: "tool",
+        role: "assistant",
+        header: "Assistant tool call",
+        markdown: "",
+        copyText: toolLine,
+        fullText: toolLine,
+        toolLine,
+    };
+}
+function toolResultBlock(id, message, maxChars) {
+    const name = asString(message.toolName) ?? "tool";
+    const output = contentText(message.content);
+    const normalized = output.replace(/\r\n?/g, "\n");
+    if (!normalized.trim() && maxChars === 0)
+        return undefined;
+    const success = message.isError === true ? "✗" : "✓";
+    const lineCount = normalized.length === 0 ? 0 : normalized.split("\n").length;
+    const charCount = normalized.length;
+    const summary = firstNonEmptyLine(normalized);
+    const toolLine = `· ${name} ${success} ${summary} ${lineCount}L/${charCount}c`;
+    const fullText = bound(`${name} ${success}\n${normalized}`, maxChars);
+    return {
+        id,
+        kind: "tool",
+        role: "tool",
+        header: `${name} result`,
+        markdown: "",
+        copyText: fullText,
+        fullText,
+        toolLine,
+    };
+}
+function bashBlock(id, message, maxChars) {
+    const command = asString(message.command) ?? "";
+    const output = asString(message.output) ?? contentText(message.content);
+    const body = command ? `$ ${command}${output ? `\n${output}` : ""}` : output;
+    if (!body.trim() && maxChars === 0)
+        return undefined;
+    const toolLine = `· bash → ${command || "(no command)"}`;
+    const fullText = bound(body, maxChars);
+    return {
+        id,
+        kind: "tool",
+        role: "tool",
+        header: "bash",
+        markdown: "",
+        copyText: fullText,
+        fullText,
+        toolLine,
+    };
+}
+function metaBlock(id, header, value, maxChars) {
+    const text = typeof value === "string" ? value : contentText(value);
+    const markdown = bound(text, maxChars);
+    if (!markdown.trim())
+        return undefined;
+    return {
+        id,
+        kind: "meta",
+        role: "meta",
+        header,
+        markdown,
+        copyText: markdown,
+        fullText: markdown,
+    };
+}
+export function formatConversationMessages(messages, options) {
+    const maxEntryChars = charLimit(options?.maxEntryChars, DEFAULT_MAX_CHARS);
+    const maxToolResultChars = charLimit(options?.maxToolResultChars, DEFAULT_MAX_CHARS);
+    const blocks = [];
+    for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+        const message = messages[messageIndex];
+        const role = message?.role;
+        let emitted = 0;
+        if (role === "user") {
+            const text = bound(contentText(message.content), maxEntryChars);
+            if (text.trim())
+                blocks.push(textBlock(blockId(messageIndex, emitted++), "user", text));
+            continue;
+        }
+        if (role === "assistant") {
+            const parts = Array.isArray(message.content) ? message.content : [];
+            const text = bound(contentText(parts), maxEntryChars);
+            if (text.trim())
+                blocks.push(textBlock(blockId(messageIndex, emitted++), "assistant", text));
+            let toolIndex = 0;
+            for (const part of parts) {
+                if (!part || typeof part !== "object" || part.type !== "toolCall")
+                    continue;
+                const call = part;
+                const name = asString(call.name) ?? asString(call.toolName) ?? "unknown";
+                blocks.push(toolCallBlock(blockId(messageIndex, emitted++, toolIndex), name, toolSummary(name, call)));
+                toolIndex++;
+            }
+            continue;
+        }
+        if (role === "toolResult") {
+            const block = toolResultBlock(blockId(messageIndex, emitted), message, maxToolResultChars);
+            if (block)
+                blocks.push(block);
+            continue;
+        }
+        if (role === "bashExecution") {
+            const block = bashBlock(blockId(messageIndex, emitted), message, maxToolResultChars);
+            if (block)
+                blocks.push(block);
+            continue;
+        }
+        if (role === "custom") {
+            if (message.display === false)
+                continue;
+            const header = asString(message.customType) || "Custom";
+            const block = metaBlock(blockId(messageIndex, emitted), header, message.content, maxEntryChars);
+            if (block)
+                blocks.push({ ...block, role: "custom" });
+            continue;
+        }
+        if (role === "compactionSummary" || role === "branchSummary" || role === "summary") {
+            const header = role === "summary" ? "Summary" : role === "compactionSummary" ? "Compaction summary" : "Branch summary";
+            const block = metaBlock(blockId(messageIndex, emitted), header, message.summary, maxEntryChars);
+            if (block)
+                blocks.push(block);
+        }
+    }
+    return blocks;
+}

package/dist/ui/conversation-nvim.d.ts

@@ -0,0 +1,7 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { TUI } from "@earendil-works/pi-tui";
+import type { ConversationBlock } from "./conversation-blocks.js";
+/** Open a bounded conversation block without allowing edits to the transcript. */
+export declare function viewConversationBlockInNvim(tui: TUI, ctx: ExtensionContext, block: ConversationBlock): Promise<void>;
+/** Edit a live assistant block and send the saved text as a new user message. */
+export declare function editLiveAssistantBlockInNvim(pi: ExtensionAPI, tui: TUI, ctx: ExtensionContext, block: ConversationBlock): Promise<boolean>;

package/dist/ui/conversation-nvim.js

@@ -0,0 +1,116 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+const DEFAULT_EDITOR = "nvim";
+function safeFilename(role, id) {
+    const safeRole = role.replace(/[^a-z0-9]/gi, "") || "message";
+    const safeId = id.replace(/[^a-z0-9]/gi, "").slice(0, 24) || "x";
+    return `${safeRole}-${safeId}.md`;
+}
+function vimStringLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function notify(ctx, message, level = "error") {
+    ctx.ui.notify(message, level);
+}
+function runFullscreen(tui, ctx, editor, args) {
+    try {
+        tui.stop();
+        process.stdout.write("\x1b[2J\x1b[H");
+        const result = spawnSync(editor, args, {
+            cwd: ctx.cwd,
+            env: process.env,
+            stdio: "inherit",
+        });
+        if (result.error) {
+            notify(ctx, `${editor} failed: ${result.error.message}`);
+            return null;
+        }
+        return result.status;
+    }
+    catch (error) {
+        notify(ctx, `${editor} failed: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+    finally {
+        try {
+            tui.start();
+            tui.requestRender(true);
+        }
+        catch (error) {
+            notify(ctx, `Could not restore terminal UI: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+/** Open a bounded conversation block without allowing edits to the transcript. */
+export async function viewConversationBlockInNvim(tui, ctx, block) {
+    let dir;
+    try {
+        dir = await mkdtemp(path.join(tmpdir(), "pi-subagents-view-"));
+        const filePath = path.join(dir, safeFilename(block.role, block.id));
+        await writeFile(filePath, `${block.fullText}\n`, "utf8");
+        const editor = process.env.VISUAL || process.env.EDITOR || DEFAULT_EDITOR;
+        runFullscreen(tui, ctx, editor, ["-R", filePath]);
+    }
+    catch (error) {
+        notify(ctx, `Could not open block in nvim: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        if (dir) {
+            try {
+                await rm(dir, { recursive: true, force: true });
+            }
+            catch (error) {
+                notify(ctx, `Could not remove temporary nvim file: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+}
+/** Edit a live assistant block and send the saved text as a new user message. */
+export async function editLiveAssistantBlockInNvim(pi, tui, ctx, block) {
+    if (block.role !== "assistant") {
+        notify(ctx, "Only assistant messages can be edited and sent back", "warning");
+        return false;
+    }
+    let dir;
+    try {
+        dir = await mkdtemp(path.join(tmpdir(), "pi-subagents-edit-"));
+        const filePath = path.join(dir, safeFilename(block.role, block.id));
+        const savedPath = path.join(dir, "saved");
+        await writeFile(filePath, `${block.fullText}\n`, "utf8");
+        const editor = process.env.VISUAL || process.env.EDITOR || DEFAULT_EDITOR;
+        const autocmd = `autocmd BufWritePost <buffer> call writefile(['1'], ${vimStringLiteral(savedPath)}) | qall`;
+        const status = runFullscreen(tui, ctx, editor, ["-c", autocmd, filePath]);
+        if (status !== 0) {
+            notify(ctx, `${editor} exited with code ${status ?? "unknown"}`, "warning");
+            return false;
+        }
+        if (!existsSync(savedPath)) {
+            notify(ctx, "No save detected; nothing sent", "info");
+            return false;
+        }
+        const edited = (await readFile(filePath, "utf8")).trimEnd();
+        if (!edited.trim()) {
+            notify(ctx, "Saved text is empty; nothing sent", "warning");
+            return false;
+        }
+        pi.sendUserMessage(`I edited an earlier assistant response in Neovim. Treat this as my correction / direction:\n\n${edited}`);
+        return true;
+    }
+    catch (error) {
+        notify(ctx, `Could not edit block in nvim: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+    finally {
+        if (dir) {
+            try {
+                await rm(dir, { recursive: true, force: true });
+            }
+            catch (error) {
+                notify(ctx, `Could not remove temporary nvim file: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+}

package/dist/ui/conversation-search.d.ts

@@ -0,0 +1,38 @@
+/** Search and highlighting helpers for rendered conversation lines. */
+/** A substring match in a rendered line's plain-text representation. */
+export type ConversationMatch = {
+    lineIdx: number;
+    col: number;
+    len: number;
+};
+type ConversationLine = {
+    plain: string;
+};
+type HighlightMatch = ConversationMatch & {
+    current?: boolean;
+};
+/**
+ * Remove ANSI CSI/OSC control sequences from a string.
+ *
+ * This deliberately follows the escape-sequence grammar used by the terminal
+ * renderer, rather than stripping only colour codes: hyperlinks and other
+ * styled output must not affect plain-text search columns either.
+ */
+export declare function stripAnsi(text: string): string;
+/**
+ * Find all non-overlapping substring matches using smartcase semantics.
+ * Lowercase queries match case-insensitively; queries containing uppercase
+ * characters match case-sensitively.
+ */
+export declare function findConversationMatches(lines: ConversationLine[], query: string): ConversationMatch[];
+/**
+ * Inject match backgrounds into an ANSI-styled line without counting escape
+ * sequences as plain-text columns. Existing foreground/style sequences are
+ * copied verbatim, so syntax highlighting remains intact.
+ */
+export declare function highlightConversationLine(text: string, matches: HighlightMatch[], openMatch: string, openCurrent: string, close: string): string;
+/** Find the first match at or after a line, wrapping to the first match. */
+export declare function nearestConversationMatchAfter(matches: ConversationMatch[], lineIdx: number): number;
+/** Find the last match at or before a line, wrapping to the last match. */
+export declare function nearestConversationMatchBefore(matches: ConversationMatch[], lineIdx: number): number;
+export {};

package/dist/ui/conversation-search.js

@@ -0,0 +1,123 @@
+/** Search and highlighting helpers for rendered conversation lines. */
+function isSmartcaseInsensitive(query) {
+    return query === query.toLowerCase();
+}
+/**
+ * Remove ANSI CSI/OSC control sequences from a string.
+ *
+ * This deliberately follows the escape-sequence grammar used by the terminal
+ * renderer, rather than stripping only colour codes: hyperlinks and other
+ * styled output must not affect plain-text search columns either.
+ */
+export function stripAnsi(text) {
+    let result = "";
+    let i = 0;
+    while (i < text.length) {
+        if (text[i] !== "\x1b") {
+            result += text[i];
+            i++;
+            continue;
+        }
+        const match = text.slice(i).match(ANSI_ESCAPE_RE);
+        if (match) {
+            i += match[0].length;
+            continue;
+        }
+        // An incomplete escape sequence has no visible representation. This also
+        // prevents a malformed trailing escape from leaking into search text.
+        if (i + 1 < text.length) {
+            i += 2;
+        }
+        else {
+            i++;
+        }
+    }
+    return result;
+}
+/**
+ * Find all non-overlapping substring matches using smartcase semantics.
+ * Lowercase queries match case-insensitively; queries containing uppercase
+ * characters match case-sensitively.
+ */
+export function findConversationMatches(lines, query) {
+    if (!query)
+        return [];
+    const matches = [];
+    const caseInsensitive = isSmartcaseInsensitive(query);
+    const needle = caseInsensitive ? query.toLowerCase() : query;
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const plain = lines[lineIdx]?.plain ?? "";
+        const haystack = caseInsensitive ? plain.toLowerCase() : plain;
+        let position = 0;
+        while (position < haystack.length) {
+            const col = haystack.indexOf(needle, position);
+            if (col === -1)
+                break;
+            matches.push({ lineIdx, col, len: query.length });
+            position = col + Math.max(1, query.length);
+        }
+    }
+    return matches;
+}
+/**
+ * Inject match backgrounds into an ANSI-styled line without counting escape
+ * sequences as plain-text columns. Existing foreground/style sequences are
+ * copied verbatim, so syntax highlighting remains intact.
+ */
+export function highlightConversationLine(text, matches, openMatch, openCurrent, close) {
+    if (matches.length === 0)
+        return text;
+    const sorted = [...matches].sort((a, b) => a.col - b.col);
+    let result = "";
+    let plainCol = 0;
+    let i = 0;
+    let active = null;
+    let nextIdx = 0;
+    while (i < text.length) {
+        if (text[i] === "\x1b") {
+            const escape = text.slice(i).match(ANSI_ESCAPE_RE);
+            if (escape) {
+                result += escape[0];
+                i += escape[0].length;
+                continue;
+            }
+        }
+        if (!active && nextIdx < sorted.length && plainCol >= sorted[nextIdx].col) {
+            active = sorted[nextIdx];
+            result += active.current ? openCurrent : openMatch;
+        }
+        result += text[i];
+        plainCol++;
+        i++;
+        if (active && plainCol >= active.col + active.len) {
+            result += close;
+            active = null;
+            nextIdx++;
+        }
+    }
+    if (active)
+        result += close;
+    return result;
+}
+/** Find the first match at or after a line, wrapping to the first match. */
+export function nearestConversationMatchAfter(matches, lineIdx) {
+    if (matches.length === 0)
+        return -1;
+    for (let i = 0; i < matches.length; i++) {
+        if (matches[i].lineIdx >= lineIdx)
+            return i;
+    }
+    return 0;
+}
+/** Find the last match at or before a line, wrapping to the last match. */
+export function nearestConversationMatchBefore(matches, lineIdx) {
+    if (matches.length === 0)
+        return -1;
+    for (let i = matches.length - 1; i >= 0; i--) {
+        if (matches[i].lineIdx <= lineIdx)
+            return i;
+    }
+    return matches.length - 1;
+}
+/** ANSI CSI/OSC sequences emitted by the TUI renderer. */
+const ANSI_ESCAPE_RE = /^(?:\x1b\][^\x07]*(?:\x07|\x1b\\)|\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]))/;

package/dist/ui/conversation-viewer.d.ts

@@ -1,20 +1,25 @@
 /**
- * conversation-viewer.ts — Live conversation overlay for viewing agent sessions.
+ * conversation-viewer.ts — Live and historical conversation overlay.
  *
- * Displays a scrollable, live-updating view of an agent's conversation.
- * Subscribes to session events for real-time streaming updates.
+ * The viewer deliberately keeps rendering state separate from the transcript:
+ * blocks are formatted data, while Markdown/ANSI lines are a bounded cache.
  */
-import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, AgentSession } from "@earendil-works/pi-coding-agent";
 import { type Component, type TUI } from "@earendil-works/pi-tui";
 import type { AgentRecord } from "../types.js";
 import type { Theme } from "./agent-widget.js";
 import { type AgentActivity } from "./agent-widget.js";
 import { type ViewerKeybindings } from "./viewer-keys.js";
-/** Height ceiling shared by the overlay's `maxHeight` and the viewer's internal viewport cap. */
 export declare const VIEWPORT_HEIGHT_PCT = 70;
 /** The live fields needed by the viewer; historical viewers use a static source. */
 export type ConversationSource = Pick<AgentSession, "messages" | "subscribe">;
 export declare function createStaticConversationSource(messages: AgentSession["messages"]): ConversationSource;
+/** Optional operations are appended so all existing constructor call sites stay valid. */
+export interface ConversationViewerOperations {
+    pi: ExtensionAPI;
+    ctx: ExtensionContext;
+    readOnly?: boolean;
+}
 export declare class ConversationViewer implements Component {
     private tui;
     private session;
@@ -22,39 +27,70 @@ export declare class ConversationViewer implements Component {
     private activity;
     private theme;
     private done;
-    /** Abort the agent shown here. Omitted → no stop affordance (e.g. read-only history). */
+    /** Abort the agent shown here. Omitted means read-only history. */
     private onStop?;
-    /** Send a steering message to the agent. Omitted → no compose affordance. */
+    /** Send a steering message to the agent. */
     private onSteer?;
+    /** Optional clipboard/nvim operation context, appended for compatibility. */
+    private operations?;
+    private blocks;
+    private showTools;
+    private selectedMessageIdx;
+    private cachedWidth;
+    private cachedLines;
+    private cachedMessageStarts;
+    private cachedMessageBlocks;
+    private cacheVersion;
+    private cachedVersion;
     private scrollOffset;
     private autoScroll;
     private unsubscribe;
     private lastInnerW;
     private closed;
-    /** Two-press confirm guard for the stop key, so a stray key can't kill the agent. */
     private stopArmed;
     private keys;
-    /** Steering composer — present while the user is typing a message to the agent. */
     private composer;
+    private searchMode;
+    private searchQuery;
+    private searchMatches;
+    private currentMatchIdx;
     constructor(tui: TUI, session: ConversationSource, record: AgentRecord, activity: AgentActivity | undefined, theme: Theme, done: (result: undefined) => void, 
-    /** Abort the agent shown here. Omitted → no stop affordance (e.g. read-only history). */
+    /** Abort the agent shown here. Omitted means read-only history. */
     onStop?: (() => void) | undefined, 
-    /** User keybindings from `ctx.ui.custom()`. Omitted → hardcoded defaults. */
+    /** User keybindings from ctx.ui.custom(). */
     keybindings?: ViewerKeybindings, 
-    /** Send a steering message to the agent. Omitted → no compose affordance. */
-    onSteer?: ((message: string) => void) | undefined);
+    /** Send a steering message to the agent. */
+    onSteer?: ((message: string) => void) | undefined, 
+    /** Optional clipboard/nvim operation context, appended for compatibility. */
+    operations?: ConversationViewerOperations | undefined);
     handleInput(data: string): void;
     render(width: number): string[];
-    /** Stoppable only when a stop handler exists and the agent is still active. */
-    private isStoppable;
-    /** Steerable only when a steer handler exists and the agent is still active. */
-    private canSteer;
-    /** Open the inline steering composer and route subsequent input to it. */
-    private openComposer;
     invalidate(): void;
     dispose(): void;
     private viewportHeight;
     private chromeLines;
     private invocationLine;
     private buildContentLines;
+    private currentMessageIndex;
+    private currentBlockGlobalIndex;
+    private activeHeaderLine;
+    private currentBlock;
+    private messageIndexForOffset;
+    private jumpToMessage;
+    private scrollBy;
+    private scrollToTop;
+    private scrollToBottom;
+    private enterSearch;
+    private handleSearchInput;
+    private recomputeMatches;
+    private gotoMatch;
+    private scrollToMatch;
+    private copyCurrentMessage;
+    private viewCurrentInNvim;
+    private editCurrentInNvim;
+    private isReadOnly;
+    private isLive;
+    private isStoppable;
+    private canSteer;
+    private openComposer;
 }