pi-ui-extend 0.1.1

package/dist/app/session-history.js

@@ -0,0 +1,164 @@
+import { isRecord } from "./guards.js";
+import { createId } from "./id.js";
+import { extractImageContents, renderContent, renderUserMessageContent, stringifyUnknown } from "./message-content.js";
+const SYSTEM_CUSTOM_MESSAGE_TYPE = "pix-system";
+const HISTORICAL_SUBAGENTS_OBSERVATION = { showSnapshot: false };
+const DEFAULT_HISTORY_CHUNK_SIZE = 50;
+const DEFAULT_HISTORY_TAIL_MESSAGE_COUNT = 80;
+export function loadSessionHistoryEntries(options) {
+    const { messages } = options;
+    if (!messages || messages.length === 0)
+        return;
+    const toolResults = buildToolResults(messages, options, 0, messages.length);
+    addSessionHistoryRangeEntries(messages, 0, messages.length, toolResults, options.addEntry, options);
+}
+export async function loadSessionHistoryEntriesAsync(options) {
+    const { messages } = options;
+    if (!messages || messages.length === 0)
+        return !options.isCancelled();
+    const chunkSize = Math.max(1, options.chunkSize ?? DEFAULT_HISTORY_CHUNK_SIZE);
+    const tailMessageCount = Math.max(1, options.tailMessageCount ?? DEFAULT_HISTORY_TAIL_MESSAGE_COUNT);
+    const toolResults = new Map();
+    if (options.isCancelled())
+        return false;
+    const tailStart = expandedTailStart(messages, Math.max(0, messages.length - tailMessageCount));
+    buildToolResults(messages, options, tailStart, messages.length, toolResults);
+    addSessionHistoryRangeEntries(messages, tailStart, messages.length, toolResults, options.addEntry, options);
+    options.render();
+    await yieldToEventLoop();
+    for (let end = tailStart; end > 0; end -= chunkSize) {
+        if (options.isCancelled())
+            return false;
+        const start = Math.max(0, end - chunkSize);
+        buildToolResults(messages, options, start, end, toolResults);
+        const entries = [];
+        addSessionHistoryRangeEntries(messages, start, end, toolResults, (entry) => entries.push(entry), options);
+        if (entries.length > 0)
+            options.prependEntries(entries);
+        options.render();
+        await yieldToEventLoop();
+    }
+    return !options.isCancelled();
+}
+function expandedTailStart(messages, initialStart) {
+    let start = initialStart;
+    while (start > 0) {
+        const message = messages[start];
+        if (!isRecord(message) || message.role !== "toolResult")
+            break;
+        start -= 1;
+    }
+    return start;
+}
+function buildToolResults(messages, observers, start, end, toolResults = new Map()) {
+    // Build a map from toolCallId -> tool result content for pairing.
+    for (let index = start; index < end; index += 1) {
+        const message = messages[index];
+        if (isRecord(message) && message.role === "toolResult") {
+            if (typeof message.toolName === "string")
+                observers.observeSubagentsToolResult(message.toolName, message.details, HISTORICAL_SUBAGENTS_OBSERVATION);
+            toolResults.set(String(message.toolCallId), {
+                content: Array.isArray(message.content) ? message.content : [],
+                ...(message.details === undefined ? {} : { details: message.details }),
+                isError: Boolean(message.isError),
+                ...(typeof message.toolName === "string" ? { toolName: message.toolName } : {}),
+            });
+        }
+    }
+    return toolResults;
+}
+function addSessionHistoryRangeEntries(messages, start, end, toolResults, addEntry, options) {
+    for (let index = start; index < end; index += 1) {
+        const message = messages[index];
+        if (!isRecord(message))
+            continue;
+        if (message.role === "custom") {
+            const entry = customMessageEntry(message);
+            if (entry)
+                addEntry(entry);
+        }
+        else if (message.role === "user") {
+            const text = renderUserMessageContent(message.content);
+            if (text) {
+                const images = extractImageContents(message.content);
+                addEntry({ id: createId("user"), kind: "user", text, ...(images.length === 0 ? {} : { images }) });
+            }
+        }
+        else if (message.role === "assistant") {
+            renderAssistantHistoryMessage(message, toolResults, { ...options, addEntry });
+        }
+        // toolResult messages are rendered inline with their tool entries, skip.
+    }
+}
+async function yieldToEventLoop() {
+    await new Promise((resolve) => { setTimeout(resolve, 0); });
+}
+export function customMessageEntry(message) {
+    if (message.display !== true)
+        return undefined;
+    const customType = typeof message.customType === "string" ? message.customType : "custom";
+    const text = renderUserMessageContent(message.content);
+    if (!text)
+        return undefined;
+    if (customType === SYSTEM_CUSTOM_MESSAGE_TYPE)
+        return { id: createId("system"), kind: "system", text };
+    return { id: createId("custom"), kind: "custom", customType, text };
+}
+function renderAssistantHistoryMessage(message, toolResults, options) {
+    const content = message.content;
+    if (!Array.isArray(content))
+        return;
+    let assistantText = "";
+    let thinkingText = "";
+    for (const block of content) {
+        if (!isRecord(block))
+            continue;
+        if (block.type === "toolCall") {
+            // Flush accumulated text/thinking before tool call.
+            if (thinkingText) {
+                options.addEntry({ id: createId("thinking"), kind: "thinking", text: thinkingText, expanded: false, status: "done" });
+                thinkingText = "";
+            }
+            if (assistantText) {
+                options.addEntry({ id: createId("assistant"), kind: "assistant", text: assistantText });
+                assistantText = "";
+            }
+            const toolCallId = String(block.id ?? createId("tool"));
+            const result = toolResults.get(toolCallId);
+            const toolName = result?.toolName ?? String(block.name ?? "unknown");
+            const argsText = stringifyUnknown(block.arguments);
+            const output = result ? renderContent(result.content) : "";
+            const images = result ? extractImageContents(result.content) : [];
+            if (result?.details !== undefined)
+                options.observeSubagentsToolResult(toolName, result.details, HISTORICAL_SUBAGENTS_OBSERVATION);
+            const entryId = createId("tool");
+            options.addEntry({
+                id: entryId,
+                kind: "tool",
+                toolCallId,
+                toolName,
+                argsText,
+                output,
+                ...(images.length === 0 ? {} : { images }),
+                ...(result?.details === undefined ? {} : { details: result.details }),
+                expanded: options.toolDefaultExpanded(toolName),
+                isError: result?.isError ?? false,
+                status: "done",
+            });
+            options.setToolEntryId(toolCallId, entryId);
+        }
+        else if (block.type === "thinking") {
+            thinkingText += typeof block.thinking === "string" ? block.thinking : "";
+        }
+        else if (typeof block.text === "string") {
+            assistantText += block.text;
+        }
+    }
+    // Flush remaining text.
+    if (thinkingText) {
+        options.addEntry({ id: createId("thinking"), kind: "thinking", text: thinkingText, expanded: false, status: "done" });
+    }
+    if (assistantText) {
+        options.addEntry({ id: createId("assistant"), kind: "assistant", text: assistantText });
+    }
+}

package/dist/app/session-lifecycle-controller.d.ts

@@ -0,0 +1,55 @@
+import type { AgentSession, AgentSessionEvent, AgentSessionRuntime, ExtensionCommandContextActions, ExtensionError } from "@earendil-works/pi-coding-agent";
+import type { InputEditor } from "../input-editor.js";
+import type { AppOptions, Entry, PixExtensionUIContext, SessionActivity } from "./types.js";
+export type AppSessionLifecycleHost = {
+    options: AppOptions;
+    createRuntime(): Promise<AgentSessionRuntime>;
+    entries: Entry[];
+    runtime(): AgentSessionRuntime | undefined;
+    setRuntime(runtime: AgentSessionRuntime | undefined): void;
+    isRunning(): boolean;
+    setRunning(running: boolean): void;
+    inputText(): string;
+    setInput(value: string): void;
+    inputEditor(): InputEditor;
+    enableTerminal(): void;
+    disposeRuntimeForQuit(runtime: AgentSessionRuntime): Promise<void>;
+    loadRequestHistory(): Promise<void>;
+    startSubagentsPolling(): void;
+    closeSdkMenuForBind(): void;
+    clearExtensionWidgets(): void;
+    createExtensionUIContext(): PixExtensionUIContext;
+    extensionShutdownHandler(): () => void;
+    createExtensionCommandContextActions(runtime: AgentSessionRuntime): ExtensionCommandContextActions;
+    handleExtensionError(error: ExtensionError): void;
+    handleSessionEvent(event: AgentSessionEvent): void;
+    addEntry(entry: Entry): void;
+    setStatus(status: string): void;
+    showToast(message: string, kind: "success" | "error" | "warning" | "info"): void;
+    setSessionStatus(session: AgentSession | undefined): void;
+    setSessionActivity(activity: SessionActivity): void;
+    sessionEventsReset(): void;
+    resetSubagentsWidget(): void;
+    resetTodoWidget(): void;
+    conversationViewportClear(): void;
+    queuedMessagesReset(): void;
+    resetConversationMenuState(): void;
+    clearMouseRenderState(): void;
+    scrollReset(): void;
+    loadSessionHistoryEntries(): void;
+    syncUserSessionEntryMetadata(): void;
+    restoreTabsAfterStartup(): Promise<void>;
+    render(): void;
+};
+export declare class AppSessionLifecycleController {
+    private readonly host;
+    private unsubscribe;
+    constructor(host: AppSessionLifecycleHost);
+    start(): Promise<void>;
+    bindCurrentSession(): Promise<void>;
+    unsubscribeSession(): void;
+    afterSessionReplacement(message?: string): void;
+    resetSessionView(): void;
+    loadSessionHistory(): void;
+    requireRuntime(): AgentSessionRuntime;
+}

package/dist/app/session-lifecycle-controller.js

@@ -0,0 +1,116 @@
+import { createId } from "./id.js";
+import { stringifyUnknown } from "./message-content.js";
+import { collectStartupAvailabilityIssues } from "./startup-checks.js";
+import { createStartupInfoMessage, isEmptyStartupSession } from "./startup-info.js";
+export class AppSessionLifecycleController {
+    host;
+    unsubscribe;
+    constructor(host) {
+        this.host = host;
+    }
+    async start() {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new Error("pi-ui-extend needs an interactive TTY");
+        }
+        this.host.enableTerminal();
+        await this.host.loadRequestHistory();
+        this.host.setRunning(true);
+        this.host.startSubagentsPolling();
+        this.host.render();
+        try {
+            const runtime = await this.host.createRuntime();
+            if (!this.host.isRunning()) {
+                await this.host.disposeRuntimeForQuit(runtime);
+                return;
+            }
+            this.host.setRuntime(runtime);
+            runtime.setRebindSession(async () => {
+                await this.bindCurrentSession();
+            });
+            await this.bindCurrentSession();
+            if (isEmptyStartupSession(runtime)) {
+                this.host.addEntry({ id: createId("system"), kind: "system", text: createStartupInfoMessage(runtime) });
+            }
+            await this.host.restoreTabsAfterStartup();
+            const availabilityIssues = await collectStartupAvailabilityIssues(runtime);
+            for (const issue of availabilityIssues) {
+                this.host.addEntry({
+                    id: createId(issue.kind),
+                    kind: issue.kind === "error" ? "error" : "system",
+                    text: issue.message,
+                });
+            }
+            if (availabilityIssues.some((issue) => issue.kind === "error")) {
+                this.host.showToast("Startup dependency unavailable", "error");
+            }
+            else if (availabilityIssues.length > 0) {
+                this.host.showToast("Startup dependency warning", "warning");
+            }
+            if (runtime.modelFallbackMessage) {
+                this.host.addEntry({ id: createId("system"), kind: "system", text: runtime.modelFallbackMessage });
+            }
+            for (const diag of runtime.diagnostics ?? []) {
+                const kind = diag.type === "error" ? "error" : "system";
+                this.host.addEntry({ id: createId("system"), kind, text: `[${diag.type}] ${diag.message}` });
+            }
+            this.host.setSessionStatus(runtime.session);
+            this.host.setSessionActivity(runtime.session.isStreaming ? "running" : "idle");
+            this.host.render();
+        }
+        catch (error) {
+            this.host.addEntry({ id: createId("error"), kind: "error", text: stringifyUnknown(error) });
+            this.host.showToast("Session startup failed", "error");
+            this.host.setSessionStatus(undefined);
+            this.host.render();
+        }
+    }
+    async bindCurrentSession() {
+        const runtime = this.requireRuntime();
+        this.unsubscribe?.();
+        this.host.closeSdkMenuForBind();
+        this.host.clearExtensionWidgets();
+        await runtime.session.bindExtensions({
+            uiContext: this.host.createExtensionUIContext(),
+            commandContextActions: this.host.createExtensionCommandContextActions(runtime),
+            shutdownHandler: this.host.extensionShutdownHandler(),
+            onError: (error) => this.host.handleExtensionError(error),
+        });
+        this.unsubscribe = runtime.session.subscribe((event) => {
+            this.host.handleSessionEvent(event);
+        });
+    }
+    unsubscribeSession() {
+        this.unsubscribe?.();
+    }
+    afterSessionReplacement(message) {
+        this.resetSessionView();
+        this.loadSessionHistory();
+        if (message)
+            this.host.addEntry({ id: createId("system"), kind: "system", text: message });
+        const session = this.host.runtime()?.session;
+        this.host.setSessionStatus(session);
+        this.host.setSessionActivity(session?.isStreaming ? "running" : "idle");
+        this.host.render();
+    }
+    resetSessionView() {
+        this.host.entries.length = 0;
+        this.host.sessionEventsReset();
+        this.host.resetSubagentsWidget();
+        this.host.resetTodoWidget();
+        this.host.conversationViewportClear();
+        this.host.queuedMessagesReset();
+        this.host.resetConversationMenuState();
+        this.host.clearMouseRenderState();
+        this.host.scrollReset();
+    }
+    loadSessionHistory() {
+        this.host.loadSessionHistoryEntries();
+        this.host.syncUserSessionEntryMetadata();
+    }
+    requireRuntime() {
+        const runtime = this.host.runtime();
+        if (!runtime)
+            throw new Error("Runtime is not initialized");
+        return runtime;
+    }
+}

package/dist/app/session-search.d.ts

@@ -0,0 +1,24 @@
+import { type SessionInfo } from "@earendil-works/pi-coding-agent";
+import type { Entry, PixMenuItem } from "./types.js";
+export type SessionSearchMatch = {
+    sessionEntryId?: string;
+    role?: string;
+    text: string;
+    matchIndex: number;
+};
+export type SessionSearchResult = {
+    session: SessionInfo;
+    query: string;
+    snippet: string;
+    match: SessionSearchMatch;
+};
+export type SessionSearchOptions = {
+    cwd: string;
+    maxResults?: number;
+    snippetLength?: number;
+    onProgress?: (loaded: number, total: number) => void;
+};
+export declare function searchSessions(query: string, options: SessionSearchOptions): Promise<SessionSearchResult[]>;
+export declare function createSessionSearchMenuItems(results: readonly SessionSearchResult[]): PixMenuItem<SessionSearchResult>[];
+export declare function searchResultTargetEntry(entries: readonly Entry[], result: SessionSearchResult): Entry | undefined;
+export declare function searchResultScrollNeedles(result: SessionSearchResult): string[];

package/dist/app/session-search.js

@@ -0,0 +1,215 @@
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { isRecord } from "./guards.js";
+import { renderContent, renderUserMessageContent } from "./message-content.js";
+import { sanitizeText } from "./render-text.js";
+const DEFAULT_MAX_SEARCH_RESULTS = 50;
+const DEFAULT_SNIPPET_LENGTH = 160;
+const DEFAULT_SCROLL_SAMPLE_LENGTH = 80;
+export async function searchSessions(query, options) {
+    const needle = normalizeSearchText(query);
+    if (!needle)
+        return [];
+    const maxResults = Math.max(1, options.maxResults ?? DEFAULT_MAX_SEARCH_RESULTS);
+    const sessions = await SessionManager.list(options.cwd, undefined, options.onProgress);
+    const results = [];
+    for (const session of sessions) {
+        if (results.length >= maxResults)
+            break;
+        if (!normalizeSearchText(session.allMessagesText).includes(needle))
+            continue;
+        const match = findSessionMatch(session, needle);
+        if (!match)
+            continue;
+        results.push({
+            session,
+            query,
+            snippet: createSearchSnippet(match.text, needle, options.snippetLength ?? DEFAULT_SNIPPET_LENGTH),
+            match,
+        });
+    }
+    return results;
+}
+export function createSessionSearchMenuItems(results) {
+    return results.map((result) => {
+        const title = sessionSearchResultTitle(result.session);
+        const { date, time } = formatSessionSearchDateTime(result.session.modified);
+        const messages = `${result.session.messageCount} msg${result.session.messageCount !== 1 ? "s" : ""}`;
+        return {
+            value: result,
+            label: title,
+            description: `${result.snippet}  ·  ${date} ${time} · ${messages} · ${result.session.id.slice(0, 8)}`,
+            keywords: [
+                result.session.id,
+                result.session.name ?? "",
+                result.session.firstMessage,
+                result.snippet,
+                result.match.role ?? "",
+            ].filter(Boolean),
+        };
+    });
+}
+export function searchResultTargetEntry(entries, result) {
+    const targetSessionEntryId = result.match.sessionEntryId;
+    if (targetSessionEntryId) {
+        const userEntry = entries.find((entry) => (entry.kind === "user" && entry.sessionEntryId === targetSessionEntryId));
+        if (userEntry)
+            return userEntry;
+    }
+    const queryNeedle = normalizeSearchText(result.query);
+    if (queryNeedle) {
+        const queryMatch = entries.find((entry) => normalizeSearchText(entrySearchText(entry)).includes(queryNeedle));
+        if (queryMatch)
+            return queryMatch;
+    }
+    const matchNeedle = normalizeSearchText(result.match.text);
+    if (!matchNeedle)
+        return undefined;
+    return entries.find((entry) => {
+        const text = normalizeSearchText(entrySearchText(entry));
+        return text.includes(matchNeedle) || matchNeedle.includes(text);
+    });
+}
+export function searchResultScrollNeedles(result) {
+    const needle = normalizeSearchText(result.query);
+    return uniqueNonEmptyStrings([
+        createSearchSample(result.match.text, needle, DEFAULT_SCROLL_SAMPLE_LENGTH),
+        stripSnippetEllipses(result.snippet),
+        result.query,
+    ]);
+}
+function findSessionMatch(session, needle) {
+    try {
+        const manager = SessionManager.open(session.path);
+        for (const entry of manager.getBranch()) {
+            const text = sessionEntrySearchText(entry);
+            if (!text)
+                continue;
+            const matchIndex = normalizeSearchText(text).indexOf(needle);
+            if (matchIndex < 0)
+                continue;
+            const role = sessionEntryRole(entry);
+            return {
+                sessionEntryId: entry.id,
+                ...(role === undefined ? {} : { role }),
+                text,
+                matchIndex,
+            };
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function sessionEntrySearchText(entry) {
+    if (entry.type === "message")
+        return messageSearchText(entry.message);
+    if (entry.type === "custom_message")
+        return renderUserMessageContent(entry.content);
+    if (entry.type === "compaction")
+        return entry.summary;
+    if (entry.type === "branch_summary")
+        return entry.summary;
+    return "";
+}
+function sessionEntryRole(entry) {
+    if (entry.type === "custom_message")
+        return entry.customType;
+    if (entry.type !== "message" || !isRecord(entry.message))
+        return entry.type;
+    return typeof entry.message.role === "string" ? entry.message.role : entry.type;
+}
+function messageSearchText(message) {
+    if (!isRecord(message))
+        return "";
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return message.role === "user" ? renderUserMessageContent(content) : renderContent(content);
+}
+function entrySearchText(entry) {
+    switch (entry.kind) {
+        case "tool":
+            return `${entry.toolName}\n${entry.argsText}\n${entry.output}`;
+        case "shell":
+            return `${entry.command}\n${entry.output}`;
+        case "user":
+        case "assistant":
+        case "custom":
+        case "system":
+        case "session-aborted":
+        case "thinking":
+        case "error":
+        case "queued":
+            return entry.text;
+    }
+}
+function createSearchSnippet(text, needle, maxLength) {
+    const compact = compactDisplayText(text);
+    const normalized = normalizeSearchText(compact);
+    const matchIndex = normalized.indexOf(needle);
+    if (matchIndex < 0)
+        return compact.slice(0, maxLength);
+    const safeMaxLength = Math.max(20, maxLength);
+    const context = Math.max(10, Math.floor((safeMaxLength - needle.length) / 2));
+    const start = Math.max(0, matchIndex - context);
+    const end = Math.min(compact.length, matchIndex + needle.length + context);
+    const prefix = start > 0 ? "…" : "";
+    const suffix = end < compact.length ? "…" : "";
+    return `${prefix}${compact.slice(start, end)}${suffix}`;
+}
+function createSearchSample(text, needle, maxLength) {
+    const compact = compactDisplayText(text);
+    if (!compact)
+        return "";
+    const normalized = normalizeSearchText(compact);
+    const matchIndex = needle ? normalized.indexOf(needle) : -1;
+    if (matchIndex < 0)
+        return compact.slice(0, Math.max(20, maxLength));
+    const safeMaxLength = Math.max(20, maxLength, needle.length);
+    const context = Math.max(0, Math.floor((safeMaxLength - needle.length) / 2));
+    const start = Math.max(0, matchIndex - context);
+    const end = Math.min(compact.length, matchIndex + needle.length + context);
+    return compact.slice(start, end);
+}
+function stripSnippetEllipses(snippet) {
+    return compactDisplayText(snippet.replace(/^…/u, "").replace(/…$/u, ""));
+}
+function uniqueNonEmptyStrings(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const trimmed = value.trim();
+        if (!trimmed)
+            continue;
+        const key = normalizeSearchText(trimmed);
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(trimmed);
+    }
+    return result;
+}
+function compactDisplayText(text) {
+    return sanitizeText(text).replace(/\s+/gu, " ").trim();
+}
+function normalizeSearchText(text) {
+    return compactDisplayText(text).toLocaleLowerCase();
+}
+function sessionSearchResultTitle(session) {
+    const name = session.name?.trim();
+    if (name)
+        return name;
+    const firstMessage = compactDisplayText(session.firstMessage);
+    if (firstMessage)
+        return firstMessage.slice(0, 60);
+    return `session ${session.id.slice(0, 8)}`;
+}
+function formatSessionSearchDateTime(dateTime) {
+    return {
+        date: dateTime.toLocaleDateString("ru-RU", { day: "2-digit", month: "2-digit", year: "numeric" }),
+        time: dateTime.toLocaleTimeString("ru-RU", { hour: "2-digit", minute: "2-digit", hourCycle: "h23" }),
+    };
+}

package/dist/app/shell-command.d.ts

@@ -0,0 +1,27 @@
+export type InteractiveShellCommandResult = {
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    error?: string;
+};
+export type BangShellCommand = {
+    command: string;
+    interactive: boolean;
+};
+export type ChatShellCommandStream = "stdout" | "stderr";
+export type ChatShellCommandHandlers = {
+    onOutput?: (chunk: string, stream: ChatShellCommandStream) => void;
+    onSettled?: (result: InteractiveShellCommandResult) => void;
+};
+export type RunningChatShellCommand = {
+    pid?: number;
+    done: Promise<InteractiveShellCommandResult>;
+    writeInput(input: string): boolean;
+    interrupt(): boolean;
+    kill(signal?: NodeJS.Signals): boolean;
+    endInput(): void;
+};
+export declare function bangShellCommandFromInput(text: string): BangShellCommand | undefined;
+export declare function shellCommandFromBangInput(text: string): string | undefined;
+export declare function runChatShellCommand(command: string, cwd: string, handlers?: ChatShellCommandHandlers): RunningChatShellCommand;
+export declare function runInteractiveShellCommand(command: string, cwd: string): Promise<InteractiveShellCommandResult>;
+export declare function formatShellCommandEntry(command: string, result: InteractiveShellCommandResult, prefix?: string): string;