pi-ui-extend 0.1.13 → 0.1.15

package/dist/app/session/pix-system-message.d.ts

@@ -0,0 +1,16 @@
+import type { AgentSession, SessionEntry } from "@earendil-works/pi-coding-agent";
+export declare const PIX_SYSTEM_MESSAGE_CUSTOM_TYPE = "pix-system";
+export declare const PIX_SYSTEM_DISPLAY_ENTRY_CUSTOM_TYPE = "pix:system_message";
+export declare const PIX_SESSION_ENTRY_ID_FIELD = "__pixSessionEntryId";
+export declare function appendPixSystemDisplayEntry(session: AgentSession, text: string): void;
+export declare function sessionHistoryDisplayMessages(session: AgentSession): readonly unknown[];
+export type SessionHistoryOlderMessagesReader = {
+    hasOlder(): boolean;
+    readOlder(limit: number): Promise<readonly unknown[]>;
+};
+export declare function sessionHistoryOlderMessagesReader(session: AgentSession): SessionHistoryOlderMessagesReader | undefined;
+export declare function sessionHistoryDisplayMessagesFromEntries(branch: readonly SessionEntry[]): readonly unknown[];
+export type FullBranchSessionEntryReader = {
+    readFullBranchEntries(): Promise<readonly SessionEntry[]>;
+};
+export declare function sessionHistoryFullBranchEntries(session: AgentSession): Promise<readonly SessionEntry[]>;

package/dist/app/session/pix-system-message.js

@@ -0,0 +1,64 @@
+import { isRecord } from "../guards.js";
+export const PIX_SYSTEM_MESSAGE_CUSTOM_TYPE = "pix-system";
+export const PIX_SYSTEM_DISPLAY_ENTRY_CUSTOM_TYPE = "pix:system_message";
+export const PIX_SESSION_ENTRY_ID_FIELD = "__pixSessionEntryId";
+export function appendPixSystemDisplayEntry(session, text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return;
+    session.sessionManager.appendCustomEntry(PIX_SYSTEM_DISPLAY_ENTRY_CUSTOM_TYPE, { text: trimmed });
+}
+export function sessionHistoryDisplayMessages(session) {
+    const branch = session.sessionManager.getBranch();
+    if (branch.length === 0)
+        return session.messages;
+    return sessionHistoryDisplayMessagesFromEntries(branch);
+}
+export function sessionHistoryOlderMessagesReader(session) {
+    const reader = session.sessionManager.createHistoryReader?.();
+    if (!reader)
+        return undefined;
+    return {
+        hasOlder: () => reader.hasOlder(),
+        readOlder: async (limit) => sessionHistoryDisplayMessagesFromEntries(await reader.readOlder(limit)),
+    };
+}
+export function sessionHistoryDisplayMessagesFromEntries(branch) {
+    const messages = [];
+    for (const entry of branch) {
+        if (entry.type === "message") {
+            messages.push(withSessionEntryId(entry.message, entry.id));
+        }
+        else if (entry.type === "custom_message") {
+            messages.push({
+                role: "custom",
+                customType: entry.customType,
+                content: entry.content,
+                display: entry.display,
+            });
+        }
+        else if (isPixSystemDisplayEntry(entry)) {
+            messages.push({
+                role: "custom",
+                customType: PIX_SYSTEM_MESSAGE_CUSTOM_TYPE,
+                content: entry.data.text,
+                display: true,
+            });
+        }
+    }
+    return messages;
+}
+export async function sessionHistoryFullBranchEntries(session) {
+    const reader = session.sessionManager;
+    return await reader.readFullBranchEntries?.() ?? session.sessionManager.getBranch();
+}
+function withSessionEntryId(message, entryId) {
+    return isRecord(message) ? { ...message, [PIX_SESSION_ENTRY_ID_FIELD]: entryId } : message;
+}
+function isPixSystemDisplayEntry(entry) {
+    return entry.type === "custom"
+        && entry.customType === PIX_SYSTEM_DISPLAY_ENTRY_CUSTOM_TYPE
+        && isRecord(entry.data)
+        && typeof entry.data.text === "string"
+        && entry.data.text.trim().length > 0;
+}

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

@@ -1,11 +1,14 @@
 import type { AgentSessionEvent, AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
 import type { ConversationViewport } from "../rendering/conversation-viewport.js";
+import { type LoadOlderSessionHistoryOptions } from "./session-history.js";
 import type { Entry, SessionActivity } from "../types.js";
 import type { WorkspaceMutation, WorkspaceMutationPreparation } from "../workspace/workspace-undo.js";
 export type AppSessionEventControllerHost = {
     readonly entries: Entry[];
     runtime(): AgentSessionRuntime | undefined;
     conversationViewport(): ConversationViewport;
+    conversationViewportColumns?(): number;
+    onHistoryWindowPruned?(edge: "top" | "bottom", lineCount: number): void;
     isRunning(): boolean;
     render(): void;
     scheduleRender(): void;
@@ -36,6 +39,7 @@ export declare class AppSessionEventController {
     readonly entryRenderVersions: Map<string, number>;
     private readonly toolEntryIdsByCallId;
     private readonly toolMutationPreparationsByCallId;
+    private olderHistoryLoader;
     private currentUserEntryId;
     private currentAssistantEntryId;
     private currentThinkingEntryId;
@@ -46,7 +50,11 @@ export declare class AppSessionEventController {
     loadSessionHistoryAsync(options: {
         isCancelled: () => boolean;
         render: () => void;
+        lazyOlderHistory?: boolean;
     }): Promise<boolean>;
+    hasOlderSessionHistory(): boolean;
+    isLoadingOlderSessionHistory(): boolean;
+    loadOlderSessionHistory(options?: LoadOlderSessionHistoryOptions): Promise<boolean>;
     handleSessionEvent(event: AgentSessionEvent): void;
     addCustomMessageEntry(message: Record<string, unknown>): void;
     findEntry(id: string): Entry | undefined;
@@ -56,6 +64,9 @@ export declare class AppSessionEventController {
     touchEntry(entry: Entry): void;
     addEntry(entry: Entry): void;
     private prependEntries;
+    private pruneHistoryWindow;
+    private measuredLineCountForEntries;
+    private forgetEntry;
     addSessionAbortedEntry(): void;
     private handleMessageStart;
     private handleMessageEnd;

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

@@ -1,14 +1,18 @@
 import { createId } from "../id.js";
 import { extractImageContents, renderContent, renderUserMessageContent, stringifyUnknown } from "../rendering/message-content.js";
 import { customMessageEntry, loadSessionHistoryEntries, loadSessionHistoryEntriesAsync } from "./session-history.js";
+import { sessionHistoryDisplayMessages, sessionHistoryOlderMessagesReader } from "./pix-system-message.js";
 import { isRecord } from "../guards.js";
 const DCP_MESSAGE_REFERENCE_PREFIX = "[dcp-id]: # (m";
 const DCP_BLOCK_REFERENCE_PREFIX = "[dcp-block-id]: # (b";
+const MAX_HISTORY_WINDOW_ENTRIES = 360;
+const HISTORY_WINDOW_TARGET_ENTRIES = 300;
 export class AppSessionEventController {
     host;
     entryRenderVersions = new Map();
     toolEntryIdsByCallId = new Map();
     toolMutationPreparationsByCallId = new Map();
+    olderHistoryLoader;
     currentUserEntryId;
     currentAssistantEntryId;
     currentThinkingEntryId;
@@ -24,13 +28,14 @@ export class AppSessionEventController {
         this.currentAssistantEntryId = undefined;
         this.currentThinkingEntryId = undefined;
         this.assistantTextBuffer = "";
+        this.olderHistoryLoader = undefined;
     }
     loadSessionHistory() {
         const runtime = this.host.runtime();
         if (!runtime)
             return;
         loadSessionHistoryEntries({
-            messages: runtime.session.messages,
+            messages: sessionHistoryDisplayMessages(runtime.session),
             addEntry: (entry) => this.addEntry(entry),
             setToolEntryId: (toolCallId, entryId) => this.toolEntryIdsByCallId.set(toolCallId, entryId),
             toolDefaultExpanded: (toolName) => this.host.toolDefaultExpanded(toolName),
@@ -42,8 +47,10 @@ export class AppSessionEventController {
         const runtime = this.host.runtime();
         if (!runtime)
             return !options.isCancelled();
+        this.olderHistoryLoader = undefined;
         return loadSessionHistoryEntriesAsync({
-            messages: runtime.session.messages,
+            messages: sessionHistoryDisplayMessages(runtime.session),
+            olderMessagesReader: sessionHistoryOlderMessagesReader(runtime.session),
             addEntry: (entry) => this.addEntry(entry),
             prependEntries: (entries) => this.prependEntries(entries),
             setToolEntryId: (toolCallId, entryId) => this.toolEntryIdsByCallId.set(toolCallId, entryId),
@@ -52,8 +59,21 @@ export class AppSessionEventController {
             observeTodoToolResult: (toolName, details, isError) => this.host.observeTodoToolResult(toolName, details, isError),
             isCancelled: options.isCancelled,
             render: options.render,
+            lazyOlderHistory: options.lazyOlderHistory === true,
+            onOlderLoaderReady: (loader) => {
+                this.olderHistoryLoader = loader;
+            },
         });
     }
+    hasOlderSessionHistory() {
+        return this.olderHistoryLoader?.hasOlder() === true;
+    }
+    isLoadingOlderSessionHistory() {
+        return this.olderHistoryLoader?.isLoading() === true;
+    }
+    async loadOlderSessionHistory(options = {}) {
+        return this.olderHistoryLoader?.loadOlder(options) ?? false;
+    }
     handleSessionEvent(event) {
         switch (event.type) {
             case "session_info_changed":
@@ -173,6 +193,7 @@ export class AppSessionEventController {
         this.host.entries.push(entry);
         this.entryRenderVersions.set(entry.id, 1);
         this.host.conversationViewport().deleteEntry(entry.id);
+        this.pruneHistoryWindow("top");
     }
     prependEntries(entries) {
         this.host.entries.unshift(...entries);
@@ -180,6 +201,41 @@ export class AppSessionEventController {
             this.entryRenderVersions.set(entry.id, 1);
             this.host.conversationViewport().deleteEntry(entry.id);
         }
+        this.pruneHistoryWindow("bottom");
+    }
+    pruneHistoryWindow(edge) {
+        const removeCount = this.host.entries.length - MAX_HISTORY_WINDOW_ENTRIES;
+        if (removeCount <= 0)
+            return;
+        const targetRemoveCount = Math.max(removeCount, this.host.entries.length - HISTORY_WINDOW_TARGET_ENTRIES);
+        const removedEntryIds = edge === "top"
+            ? this.host.entries.slice(0, targetRemoveCount).map((entry) => entry.id)
+            : this.host.entries.slice(Math.max(0, this.host.entries.length - targetRemoveCount)).map((entry) => entry.id);
+        const removedLineCount = this.measuredLineCountForEntries(removedEntryIds);
+        const removed = edge === "top"
+            ? this.host.entries.splice(0, targetRemoveCount)
+            : this.host.entries.splice(Math.max(0, this.host.entries.length - targetRemoveCount), targetRemoveCount);
+        for (const entry of removed)
+            this.forgetEntry(entry);
+        this.host.onHistoryWindowPruned?.(edge, removedLineCount);
+    }
+    measuredLineCountForEntries(entryIds) {
+        if (entryIds.length === 0)
+            return 0;
+        const viewport = this.host.conversationViewport();
+        if (typeof viewport.measuredLineCountForEntries !== "function")
+            return 0;
+        return viewport.measuredLineCountForEntries(this.host.conversationViewportColumns?.() ?? 80, entryIds);
+    }
+    forgetEntry(entry) {
+        this.entryRenderVersions.delete(entry.id);
+        this.host.conversationViewport().deleteEntry(entry.id);
+        if (entry.kind !== "tool")
+            return;
+        for (const [toolCallId, entryId] of this.toolEntryIdsByCallId) {
+            if (entryId === entry.id)
+                this.toolEntryIdsByCallId.delete(toolCallId);
+        }
     }
     addSessionAbortedEntry() {
         this.finishCurrentThinkingEntry();

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

@@ -16,6 +16,24 @@ export type LoadSessionHistoryAsyncOptions = LoadSessionHistoryOptions & {
     isCancelled: () => boolean;
     chunkSize?: number;
     tailMessageCount?: number;
+    lazyOlderHistory?: boolean;
+    olderMessagesReader?: OlderSessionHistoryMessagesReader | undefined;
+    onOlderLoaderReady?: (loader: SessionHistoryOlderLoader | undefined) => void;
+};
+export type LoadOlderSessionHistoryOptions = {
+    render?: boolean;
+    onPrependedEntries?: (entries: readonly Entry[]) => void;
+};
+export type SessionHistoryOlderLoader = {
+    hasOlder(): boolean;
+    isLoading(): boolean;
+    loadedMessageCount(): number;
+    totalMessageCount(): number;
+    loadOlder(options?: LoadOlderSessionHistoryOptions): Promise<boolean>;
+};
+export type OlderSessionHistoryMessagesReader = {
+    hasOlder(): boolean;
+    readOlder(limit: number): Promise<readonly unknown[]>;
 };
 export declare function loadSessionHistoryEntries(options: LoadSessionHistoryOptions): void;
 export declare function loadSessionHistoryEntriesAsync(options: LoadSessionHistoryAsyncOptions): Promise<boolean>;

package/dist/app/session/session-history.js

@@ -2,7 +2,7 @@ import { isRecord } from "../guards.js";
 import { createId } from "../id.js";
 import { isOnlyHiddenMetadata } from "../../markdown-format.js";
 import { extractImageContents, renderContent, renderUserMessageContent, stringifyUnknown } from "../rendering/message-content.js";
-const SYSTEM_CUSTOM_MESSAGE_TYPE = "pix-system";
+import { PIX_SESSION_ENTRY_ID_FIELD, PIX_SYSTEM_MESSAGE_CUSTOM_TYPE } from "./pix-system-message.js";
 const HISTORICAL_SUBAGENTS_OBSERVATION = { showSnapshot: false };
 const DEFAULT_HISTORY_CHUNK_SIZE = 50;
 const DEFAULT_HISTORY_TAIL_MESSAGE_COUNT = 80;
@@ -27,6 +27,11 @@ export async function loadSessionHistoryEntriesAsync(options) {
     addSessionHistoryRangeEntries(messages, tailStart, messages.length, toolResults, options.addEntry, options);
     options.render();
     await yieldToEventLoop();
+    if (options.lazyOlderHistory) {
+        const loader = createOlderHistoryLoader(messages, options, chunkSize, toolResults, tailStart, options.olderMessagesReader);
+        options.onOlderLoaderReady?.(loader.hasOlder() ? loader : undefined);
+        return !options.isCancelled();
+    }
     for (let end = tailStart; end > 0; end -= chunkSize) {
         if (options.isCancelled())
             return false;
@@ -41,6 +46,69 @@ export async function loadSessionHistoryEntriesAsync(options) {
     }
     return !options.isCancelled();
 }
+function createOlderHistoryLoader(messages, options, chunkSize, toolResults, initialEnd, olderMessagesReader) {
+    let nextEnd = initialEnd;
+    let loading = false;
+    let externallyLoadedMessageCount = 0;
+    return {
+        hasOlder: () => nextEnd > 0 || olderMessagesReader?.hasOlder() === true,
+        isLoading: () => loading,
+        loadedMessageCount: () => Math.max(0, messages.length - nextEnd) + externallyLoadedMessageCount,
+        totalMessageCount: () => messages.length + externallyLoadedMessageCount,
+        async loadOlder(loadOptions = {}) {
+            if (loading)
+                return !options.isCancelled();
+            if (nextEnd <= 0 && olderMessagesReader?.hasOlder() !== true)
+                return !options.isCancelled();
+            loading = true;
+            let didPrependEntries = false;
+            try {
+                while (!options.isCancelled() && (nextEnd > 0 || olderMessagesReader?.hasOlder() === true)) {
+                    const batch = nextEnd > 0
+                        ? inMemoryOlderMessagesBatch(messages, chunkSize, nextEnd)
+                        : await externalOlderMessagesBatch(olderMessagesReader, chunkSize);
+                    if (!batch)
+                        break;
+                    const { batchMessages } = batch;
+                    if (batch.external)
+                        externallyLoadedMessageCount += batchMessages.length;
+                    buildToolResults(batchMessages, options, 0, batchMessages.length, toolResults);
+                    const entries = [];
+                    addSessionHistoryRangeEntries(batchMessages, 0, batchMessages.length, toolResults, (entry) => entries.push(entry), options);
+                    nextEnd = batch.nextEnd;
+                    if (entries.length > 0) {
+                        options.prependEntries(entries);
+                        loadOptions.onPrependedEntries?.(entries);
+                        didPrependEntries = true;
+                        break;
+                    }
+                    await yieldToEventLoop();
+                }
+                if (options.isCancelled())
+                    return false;
+                if (didPrependEntries && loadOptions.render !== false)
+                    options.render();
+                return true;
+            }
+            finally {
+                loading = false;
+                if (nextEnd <= 0 && olderMessagesReader?.hasOlder() !== true)
+                    options.onOlderLoaderReady?.(undefined);
+            }
+        },
+    };
+}
+function inMemoryOlderMessagesBatch(messages, chunkSize, nextEnd) {
+    const end = nextEnd;
+    const start = Math.max(0, end - chunkSize);
+    return { batchMessages: messages.slice(start, end), nextEnd: start, external: false };
+}
+async function externalOlderMessagesBatch(olderMessagesReader, chunkSize) {
+    if (!olderMessagesReader?.hasOlder())
+        return undefined;
+    const batchMessages = await olderMessagesReader.readOlder(chunkSize);
+    return batchMessages.length === 0 ? undefined : { batchMessages, nextEnd: 0, external: true };
+}
 function expandedTailStart(messages, initialStart) {
     let start = initialStart;
     while (start > 0) {
@@ -82,7 +150,8 @@ function addSessionHistoryRangeEntries(messages, start, end, toolResults, addEnt
             const text = renderUserMessageContent(message.content);
             if (text) {
                 const images = extractImageContents(message.content);
-                addEntry({ id: createId("user"), kind: "user", text, ...(images.length === 0 ? {} : { images }) });
+                const sessionEntryId = typeof message[PIX_SESSION_ENTRY_ID_FIELD] === "string" ? message[PIX_SESSION_ENTRY_ID_FIELD] : undefined;
+                addEntry({ id: createId("user"), kind: "user", text, ...(sessionEntryId === undefined ? {} : { sessionEntryId }), ...(images.length === 0 ? {} : { images }) });
             }
         }
         else if (message.role === "assistant") {
@@ -101,7 +170,7 @@ export function customMessageEntry(message) {
     const text = renderUserMessageContent(message.content);
     if (!text)
         return undefined;
-    if (customType === SYSTEM_CUSTOM_MESSAGE_TYPE)
+    if (customType === PIX_SYSTEM_MESSAGE_CUSTOM_TYPE)
         return { id: createId("system"), kind: "system", text };
     return { id: createId("custom"), kind: "custom", customType, text };
 }

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

@@ -17,8 +17,10 @@ export type AppSessionLifecycleHost = {
     loadRequestHistory(): Promise<void>;
     startSubagentsPolling(): void;
     closeSdkMenuForBind(): void;
-    clearExtensionWidgets(): void;
-    createExtensionUIContext(): PixExtensionUIContext;
+    clearExtensionWidgets(scopeKey?: string, options?: {
+        cancelCustomUi?: boolean;
+    }): void;
+    createExtensionUIContext(scopeKey?: string): PixExtensionUIContext;
     extensionShutdownHandler(): () => void;
     createExtensionCommandContextActions(runtime: AgentSessionRuntime): ExtensionCommandContextActions;
     handleExtensionError(error: ExtensionError): void;
@@ -40,6 +42,7 @@ export type AppSessionLifecycleHost = {
     loadSessionHistoryEntriesAsync(options: {
         isCancelled: () => boolean;
         render: () => void;
+        lazyOlderHistory?: boolean;
     }): Promise<boolean>;
     syncUserSessionEntryMetadata(): void;
     restoreTabsAfterStartup(): Promise<void>;
@@ -57,4 +60,5 @@ export declare class AppSessionLifecycleController {
     resetSessionView(): void;
     loadSessionHistory(): void;
     requireRuntime(): AgentSessionRuntime;
+    private extensionUiScope;
 }

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

@@ -71,9 +71,10 @@ export class AppSessionLifecycleController {
             this.host.handleSessionEvent(event);
         });
         this.host.closeSdkMenuForBind();
-        this.host.clearExtensionWidgets();
+        const extensionUiScope = this.extensionUiScope(runtime.session);
+        this.host.clearExtensionWidgets(extensionUiScope, { cancelCustomUi: false });
         await runtime.session.bindExtensions({
-            uiContext: this.host.createExtensionUIContext(),
+            uiContext: this.host.createExtensionUIContext(extensionUiScope),
             commandContextActions: this.host.createExtensionCommandContextActions(runtime),
             shutdownHandler: this.host.extensionShutdownHandler(),
             onError: (error) => this.host.handleExtensionError(error),
@@ -91,6 +92,7 @@ export class AppSessionLifecycleController {
         await this.host.loadSessionHistoryEntriesAsync({
             isCancelled: () => !this.host.isRunning(),
             render: () => this.host.render(),
+            lazyOlderHistory: true,
         });
         this.host.syncUserSessionEntryMetadata();
         if (message)
@@ -121,4 +123,7 @@ export class AppSessionLifecycleController {
             throw new Error("Runtime is not initialized");
         return runtime;
     }
+    extensionUiScope(session) {
+        return session.sessionFile ?? session.sessionId;
+    }
 }

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

@@ -22,10 +22,12 @@ export type AppTabsControllerHost = {
     loadSessionHistoryAsync(options: {
         isCancelled: () => boolean;
         render: () => void;
+        lazyOlderHistory?: boolean;
     }): Promise<boolean>;
     syncUserSessionEntryMetadata(): void;
     captureInputState(): TabInputState;
     restoreInputState(state: TabInputState): void;
+    closeMenusForTabSwitch?(): void;
     captureDeferredUserMessages?(): readonly SubmittedUserMessage[];
     restoreDeferredUserMessages?(messages: readonly SubmittedUserMessage[]): void;
     addEntry(entry: Entry): void;
@@ -43,6 +45,8 @@ export declare class AppTabsController {
     private pendingActiveTabId;
     private historyLoadGeneration;
     private restored;
+    private retentionCleanupRunning;
+    private retentionCleanupScheduled;
     constructor(host: AppTabsControllerHost);
     tabs(): readonly SessionTab[];
     isSwitching(): boolean;
@@ -61,6 +65,7 @@ export declare class AppTabsController {
     restoreAfterStartup(): Promise<void>;
     openNewTab(): Promise<void>;
     openSessionInNewTab(sessionPath: string): Promise<boolean>;
+    forkSessionEntryInNewTab(entryId: string): Promise<boolean>;
     switchToTab(tabId: string): Promise<void>;
     closeTab(tabId: string): Promise<void>;
     private replaceLastTabWithNewSession;
@@ -70,6 +75,7 @@ export declare class AppTabsController {
     private runtimeForCommand;
     private idleRuntime;
     private activeTab;
+    private settleStartupTabPlaceholders;
     private storeActiveRuntime;
     private setRuntimeForTab;
     private deleteRuntimeForTab;
@@ -80,6 +86,7 @@ export declare class AppTabsController {
     private storeActiveInputState;
     private storeActiveDeferredUserMessages;
     private restoreInputState;
+    private inputStateFromText;
     private restoreDeferredUserMessages;
     private cloneSubmittedUserMessage;
     private runtimeForTab;
@@ -94,16 +101,21 @@ export declare class AppTabsController {
     private updateTabFromSession;
     private sessionPath;
     private sessionTitle;
+    private sessionTitleFromParts;
     private sessionActivity;
     private tabActivity;
     private clearTabAttention;
     private startAttentionBlink;
     private stopAttentionBlinkIfIdle;
-    private loadSessionTitles;
     private restoredTabs;
+    private defaultSessionTitleFromPath;
     private loadTabs;
     private parsePersistedInputState;
     private parsePersistedSubmittedUserMessages;
     private saveTabs;
     private filePath;
+    private sessionDir;
+    private scheduleProjectSessionRetention;
+    private cleanupOldProjectSessions;
+    private preservedSessionPaths;
 }