pi-ui-extend 0.1.32 → 0.1.34

package/dist/app/screen/mouse-controller.js

@@ -28,6 +28,8 @@ export class AppMouseController {
     statusDraftQueueTarget;
     statusThinkingExpandTarget;
     statusCompactToolsTarget;
+    statusQuickScrollUpTarget;
+    statusQuickScrollDownTarget;
     statusTerminalBellSoundTarget;
     statusSessionTarget;
     statusPromptEnhancerTarget;
@@ -78,6 +80,8 @@ export class AppMouseController {
             return;
         if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusModelUsageClick(event)))
             return;
+        if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusQuickScrollClick(event)))
+            return;
         if (event.button === 0 && this.withClickFlash(event, () => this.handleStatusSessionClick(event)))
             return;
         if (event.button === 0 && this.withClickFlash(event, () => this.handleExtensionInputClick(event)))
@@ -316,6 +320,8 @@ export class AppMouseController {
             this.statusUserJumpTarget,
             this.statusThinkingExpandTarget,
             this.statusCompactToolsTarget,
+            this.statusQuickScrollUpTarget,
+            this.statusQuickScrollDownTarget,
             this.statusTerminalBellSoundTarget,
             this.statusSessionTarget,
             this.statusPromptEnhancerTarget,
@@ -600,6 +606,16 @@ export class AppMouseController {
         this.host.toggleVoiceLanguage();
         return true;
     }
+    handleStatusQuickScrollClick(event) {
+        const target = [this.statusQuickScrollUpTarget, this.statusQuickScrollDownTarget].find((candidate) => !!candidate
+            && event.y === candidate.row
+            && event.x >= candidate.startColumn
+            && event.x < candidate.endColumn);
+        if (!target)
+            return false;
+        this.host.scrollConversationQuick(target.direction);
+        return true;
+    }
     handleInputClick(event) {
         const columns = this.host.terminalColumns();
         const terminalRows = this.host.terminalRows();

package/dist/app/screen/scroll-controller.d.ts

@@ -12,6 +12,10 @@ export type ConversationTextScrollTarget = {
     entryId?: string;
     needles: readonly string[];
 };
+export type AppScrollState = {
+    scrollFromBottom: number;
+    detachedScrollStart?: number;
+};
 export type AppScrollControllerHost = {
     conversationViewport(): ConversationViewport;
     editorLayoutRenderer(): EditorLayoutRenderer;
@@ -24,6 +28,11 @@ export type AppScrollControllerHost = {
         render?: boolean;
         onPrependedEntries?: (entries: readonly Entry[]) => void;
     }): Promise<boolean>;
+    hasNewerSessionHistory?(): boolean;
+    isLoadingNewerSessionHistory?(): boolean;
+    loadNewerSessionHistory?(options?: {
+        render?: boolean;
+    }): Promise<boolean>;
     render(): void;
 };
 export declare class AppScrollController {
@@ -34,6 +43,15 @@ export declare class AppScrollController {
     constructor(host: AppScrollControllerHost);
     reset(): void;
     scrollToBottom(): boolean;
+    scrollToTop(): boolean;
+    scrollToAbsoluteTop(): Promise<boolean>;
+    scrollToAbsoluteBottom(): Promise<boolean>;
+    quickScrollDirections(columns: number, bodyHeight: number): {
+        up: boolean;
+        down: boolean;
+    };
+    captureState(): AppScrollState;
+    restoreState(state: AppScrollState): void;
     conversationView(columns: number, bodyHeight: number): {
         lines: RenderedLine[];
         metrics: AppScrollMetrics;
@@ -45,7 +63,9 @@ export declare class AppScrollController {
         render?: boolean;
     }): boolean;
     private shouldLoadOlderHistory;
+    private shouldLoadNewerHistory;
     private loadOlderHistoryAnchored;
+    private loadNewerHistoryAnchored;
     adjustForHistoryWindowPrune(edge: "top" | "bottom", lineCount: number): void;
     scrollToConversationEntry(entryId: string): boolean;
     scrollToConversationText(target: ConversationTextScrollTarget): boolean;

package/dist/app/screen/scroll-controller.js

@@ -17,6 +17,59 @@ export class AppScrollController {
         this.detachedScrollStart = undefined;
         return changed;
     }
+    scrollToTop() {
+        const columns = this.host.terminalColumns();
+        const terminalRows = this.host.terminalRows();
+        const rows = editorLayoutRows(terminalRows, this.host.tabPanelRows(terminalRows));
+        const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
+        const metrics = this.scrollMetrics(columns, bodyHeight);
+        return this.setScrollStart(0, metrics);
+    }
+    async scrollToAbsoluteTop() {
+        let loadedOlder = false;
+        while (this.host.hasOlderSessionHistory?.() === true && this.host.isLoadingOlderSessionHistory?.() !== true) {
+            const loaded = await this.host.loadOlderSessionHistory?.({ render: false });
+            if (!loaded)
+                break;
+            loadedOlder = true;
+            this.host.render();
+            await yieldToEventLoop();
+        }
+        return this.scrollToTop() || loadedOlder;
+    }
+    async scrollToAbsoluteBottom() {
+        let loadedNewer = false;
+        while (this.host.hasNewerSessionHistory?.() === true && this.host.isLoadingNewerSessionHistory?.() !== true) {
+            const loaded = await this.host.loadNewerSessionHistory?.({ render: false });
+            if (!loaded)
+                break;
+            loadedNewer = true;
+            this.host.render();
+            await yieldToEventLoop();
+        }
+        return this.scrollToBottom() || loadedNewer;
+    }
+    quickScrollDirections(columns, bodyHeight) {
+        if (bodyHeight <= 0)
+            return { up: false, down: false };
+        const metrics = this.scrollMetrics(columns, bodyHeight);
+        return {
+            up: metrics.start > 0 || this.host.hasOlderSessionHistory?.() === true,
+            down: metrics.start < metrics.maxScroll || this.host.hasNewerSessionHistory?.() === true,
+        };
+    }
+    captureState() {
+        return {
+            scrollFromBottom: this.scrollFromBottom,
+            ...(this.detachedScrollStart === undefined ? {} : { detachedScrollStart: this.detachedScrollStart }),
+        };
+    }
+    restoreState(state) {
+        this.scrollFromBottom = Math.max(0, state.scrollFromBottom);
+        this.detachedScrollStart = state.detachedScrollStart === undefined
+            ? undefined
+            : Math.max(0, state.detachedScrollStart);
+    }
     conversationView(columns, bodyHeight) {
         const metrics = this.scrollMetrics(columns, bodyHeight);
         return {
@@ -55,16 +108,23 @@ export class AppScrollController {
         const rows = editorLayoutRows(terminalRows, this.host.tabPanelRows(terminalRows));
         const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
         const metrics = this.scrollMetrics(columns, bodyHeight);
-        const shouldLoadOlderHistory = this.shouldLoadOlderHistory(delta, metrics);
         const { conversationLineCount, maxScroll } = metrics;
         const nextScrollFromBottom = Math.max(0, Math.min(maxScroll, this.scrollFromBottom + -delta));
+        const nextStart = Math.max(0, maxScroll - nextScrollFromBottom);
+        const shouldLoadOlderHistory = this.shouldLoadOlderHistory(delta, metrics, nextStart);
+        const shouldLoadNewerHistory = this.shouldLoadNewerHistory(delta, metrics, nextStart);
+        const pinToTopAfterOlderHistoryLoad = shouldLoadOlderHistory && nextStart === 0;
         let changed = false;
         if (nextScrollFromBottom === this.scrollFromBottom) {
             if (nextScrollFromBottom === 0 && this.detachedScrollStart !== undefined && delta > 0) {
                 this.detachedScrollStart = undefined;
                 changed = true;
             }
-            else if (!shouldLoadOlderHistory) {
+            else if (pinToTopAfterOlderHistoryLoad && this.detachedScrollStart !== 0) {
+                this.detachedScrollStart = 0;
+                changed = true;
+            }
+            else if (!shouldLoadOlderHistory && !shouldLoadNewerHistory) {
                 return false;
             }
         }
@@ -76,15 +136,17 @@ export class AppScrollController {
             changed = true;
         }
         if (shouldLoadOlderHistory)
-            this.loadOlderHistoryAnchored(metrics, { render: shouldRender });
+            this.loadOlderHistoryAnchored(metrics, { render: shouldRender, pinToTop: pinToTopAfterOlderHistoryLoad });
+        if (shouldLoadNewerHistory)
+            this.loadNewerHistoryAnchored({ render: shouldRender, pinToBottom: nextScrollFromBottom === 0 });
         if (shouldRender)
             this.host.render();
-        return changed || shouldLoadOlderHistory;
+        return changed || shouldLoadOlderHistory || shouldLoadNewerHistory;
     }
-    shouldLoadOlderHistory(delta, metrics) {
+    shouldLoadOlderHistory(delta, metrics, nextStart = metrics.start) {
         if (delta >= 0)
             return false;
-        if (metrics.start > this.olderHistoryThresholdLines)
+        if (metrics.start > this.olderHistoryThresholdLines && nextStart > this.olderHistoryThresholdLines)
             return false;
         if (this.host.hasOlderSessionHistory?.() !== true)
             return false;
@@ -92,12 +154,29 @@ export class AppScrollController {
             return false;
         return true;
     }
+    shouldLoadNewerHistory(delta, metrics, nextStart = metrics.start) {
+        if (delta <= 0)
+            return false;
+        if (metrics.maxScroll - metrics.start > this.olderHistoryThresholdLines && metrics.maxScroll - nextStart > this.olderHistoryThresholdLines)
+            return false;
+        if (this.host.hasNewerSessionHistory?.() !== true)
+            return false;
+        if (this.host.isLoadingNewerSessionHistory?.() === true)
+            return false;
+        return true;
+    }
     loadOlderHistoryAnchored(metrics, options) {
         void this.host.loadOlderSessionHistory?.({
             render: false,
             onPrependedEntries: (entries) => {
+                if (this.detachedScrollStart === undefined)
+                    return;
+                if (options.pinToTop) {
+                    this.detachedScrollStart = 0;
+                    return;
+                }
                 const prependedLineCount = this.host.conversationViewport().measuredLineCountForEntries(metrics.viewportColumns, entries.map((entry) => entry.id));
-                if (prependedLineCount > 0 && this.detachedScrollStart !== undefined)
+                if (prependedLineCount > 0)
                     this.detachedScrollStart += prependedLineCount;
             },
         }).then((loaded) => {
@@ -105,6 +184,14 @@ export class AppScrollController {
                 this.host.render();
         });
     }
+    loadNewerHistoryAnchored(options) {
+        void this.host.loadNewerSessionHistory?.({ render: false }).then((loaded) => {
+            if (loaded && options.pinToBottom)
+                this.scrollToBottom();
+            if (loaded && options.render)
+                this.host.render();
+        });
+    }
     adjustForHistoryWindowPrune(edge, lineCount) {
         if (lineCount <= 0)
             return;
@@ -121,7 +208,7 @@ export class AppScrollController {
         const conversationViewport = this.host.conversationViewport();
         const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
         const metrics = this.scrollMetrics(columns, bodyHeight);
-        const position = conversationViewport.entryBlockPositions(metrics.viewportColumns).find((candidate) => candidate.entry.id === entryId);
+        const position = conversationViewport.entryBlockPositionById(metrics.viewportColumns, entryId);
         if (!position)
             return false;
         this.setScrollStart(position.offset, metrics);
@@ -138,9 +225,8 @@ export class AppScrollController {
         const conversationViewport = this.host.conversationViewport();
         const { bodyHeight } = this.host.editorLayoutRenderer().computeLayout(columns, rows);
         const metrics = this.scrollMetrics(columns, bodyHeight);
-        const positions = conversationViewport.entryBlockPositions(metrics.viewportColumns);
         const targetPosition = target.entryId
-            ? positions.find((position) => position.entry.id === target.entryId)
+            ? conversationViewport.entryBlockPositionById(metrics.viewportColumns, target.entryId)
             : undefined;
         const targetMatch = targetPosition ? lineMatchInPosition(targetPosition, needles) : undefined;
         if (targetMatch) {
@@ -153,6 +239,18 @@ export class AppScrollController {
             this.host.render();
             return true;
         }
+        for (const entry of conversationViewport.entries()) {
+            if (!entryMatchesNeedles(entry, needles))
+                continue;
+            const position = conversationViewport.entryBlockPositionById(metrics.viewportColumns, entry.id);
+            const match = position ? lineMatchInPosition(position, needles) : undefined;
+            if (!match)
+                continue;
+            this.setScrollStart(match.start, metrics);
+            this.host.render();
+            return true;
+        }
+        const positions = conversationViewport.entryBlockPositions(metrics.viewportColumns);
         const anyMatch = positions
             .map((position) => lineMatchInPosition(position, needles))
             .find((match) => match !== undefined);
@@ -177,6 +275,9 @@ export class AppScrollController {
         return safeColumns;
     }
 }
+async function yieldToEventLoop() {
+    await new Promise((resolve) => { setTimeout(resolve, 0); });
+}
 function editorLayoutRows(terminalRows, tabPanelRows) {
     return Math.max(1, terminalRows - tabPanelRows);
 }
@@ -195,6 +296,22 @@ function normalizeLineSearchNeedles(needles) {
 function normalizeLineSearchText(text) {
     return sanitizeText(text).replace(/…/gu, " ").replace(/\s+/gu, " ").trim().toLocaleLowerCase();
 }
+function entryMatchesNeedles(entry, needles) {
+    const text = normalizeLineSearchText(entrySearchText(entry));
+    return needles.some((needle) => text.includes(needle));
+}
+function entrySearchText(entry) {
+    switch (entry.kind) {
+        case "shell":
+            return [entry.command, entry.output, entry.status, entry.error ?? ""].join("\n");
+        case "tool":
+            return [entry.toolName, entry.argsText, entry.output, entry.status].join("\n");
+        case "custom":
+            return [entry.customType, entry.text].join("\n");
+        default:
+            return "text" in entry ? entry.text : "";
+    }
+}
 function lineMatchInPosition(position, needles) {
     const lineIndex = lineIndexForNeedles(position.block.lines, needles);
     return lineIndex === undefined ? undefined : { start: position.offset + lineIndex };

package/dist/app/session/lazy-session-manager.js

@@ -426,7 +426,7 @@ async function readTailSessionEntriesWithByteCount(filePath, byteCount, limit, s
             const firstNewline = buffer.indexOf(10);
             parseStart = firstNewline >= 0 ? firstNewline + 1 : buffer.length;
         }
-        return selectLastSessionEntries(parseSessionEntryBufferLines(buffer.subarray(parseStart), start + parseStart), limit, size);
+        return selectLastSessionEntries(parseSessionEntryBufferLines(buffer.subarray(parseStart), start + parseStart), limit, start, size);
     }
     catch {
         return { entries: [], startOffset: 0 };
@@ -445,12 +445,41 @@ async function readSessionEntriesBeforeOffset(filePath, endOffset, limit) {
     const maxBytes = Math.min(endOffset, MAX_TAIL_BYTES);
     while (byteCount <= maxBytes) {
         const result = await readSessionEntriesBeforeOffsetWithByteCount(filePath, endOffset, byteCount, limit);
-        if (result.entries.length >= limit || byteCount >= maxBytes || byteCount >= endOffset)
+        if (result.entries.length >= limit || byteCount >= endOffset)
             return result;
+        if (byteCount >= maxBytes)
+            return await readSessionEntriesBeforeOffsetStreaming(filePath, endOffset, limit);
         byteCount = Math.min(endOffset, Math.max(byteCount + 1, byteCount * 2));
     }
     return { entries: [], startOffset: 0 };
 }
+async function readSessionEntriesBeforeOffsetStreaming(filePath, endOffset, limit) {
+    const selected = [];
+    let offset = 0;
+    const stream = createReadStream(filePath, { encoding: "utf8", start: 0, end: Math.max(0, endOffset - 1) });
+    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+    try {
+        for await (const line of lines) {
+            const lineOffset = offset;
+            offset += Buffer.byteLength(line, "utf8") + 1;
+            if (lineOffset >= endOffset)
+                break;
+            const entry = parseSessionEntryLine(line);
+            if (!entry)
+                continue;
+            selected.push({ entry, offset: lineOffset });
+            if (selected.length > limit)
+                selected.shift();
+        }
+    }
+    finally {
+        stream.destroy();
+    }
+    return {
+        entries: selected.map((item) => item.entry),
+        startOffset: selected[0]?.offset ?? 0,
+    };
+}
 async function readSessionEntriesBeforeOffsetWithByteCount(filePath, endOffset, byteCount, limit) {
     let file;
     try {
@@ -463,7 +492,7 @@ async function readSessionEntriesBeforeOffsetWithByteCount(filePath, endOffset,
             const firstNewline = buffer.indexOf(10);
             parseStart = firstNewline >= 0 ? firstNewline + 1 : buffer.length;
         }
-        return selectLastSessionEntries(parseSessionEntryBufferLines(buffer.subarray(parseStart), start + parseStart), limit, start);
+        return selectLastSessionEntries(parseSessionEntryBufferLines(buffer.subarray(parseStart), start + parseStart), limit, start, start);
     }
     catch {
         return { entries: [], startOffset: 0 };
@@ -472,11 +501,12 @@ async function readSessionEntriesBeforeOffsetWithByteCount(filePath, endOffset,
         await file?.close();
     }
 }
-function selectLastSessionEntries(parsedEntries, limit, emptyStartOffset) {
+function selectLastSessionEntries(parsedEntries, limit, windowStartOffset, emptyStartOffset) {
     const selected = parsedEntries.slice(-limit);
+    const hasOlderEntriesBeforeSelected = windowStartOffset > 0 || parsedEntries.length > selected.length;
     return {
         entries: selected.map((item) => item.entry),
-        startOffset: selected[0]?.offset ?? emptyStartOffset,
+        startOffset: hasOlderEntriesBeforeSelected ? selected[0]?.offset ?? emptyStartOffset : 0,
     };
 }
 function parseSessionEntryBufferLines(buffer, baseOffset) {

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

@@ -2,6 +2,7 @@ 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 const PIX_THINKING_LEVEL_FIELD = "__pixThinkingLevel";
 export declare function appendPixSystemDisplayEntry(session: AgentSession, text: string): void;
 export declare function sessionHistoryDisplayMessages(session: AgentSession): readonly unknown[];
 export type SessionHistoryOlderMessagesReader = {

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

@@ -2,6 +2,7 @@ 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 const PIX_THINKING_LEVEL_FIELD = "__pixThinkingLevel";
 export function appendPixSystemDisplayEntry(session, text) {
     const trimmed = text.trim();
     if (!trimmed)
@@ -25,9 +26,13 @@ export function sessionHistoryOlderMessagesReader(session) {
 }
 export function sessionHistoryDisplayMessagesFromEntries(branch) {
     const messages = [];
+    let currentThinkingLevel;
     for (const entry of branch) {
         if (entry.type === "message") {
-            messages.push(withSessionEntryId(entry.message, entry.id));
+            messages.push(withSessionHistoryMetadata(entry.message, entry.id, currentThinkingLevel));
+        }
+        else if (entry.type === "thinking_level_change") {
+            currentThinkingLevel = typeof entry.thinkingLevel === "string" ? entry.thinkingLevel : currentThinkingLevel;
         }
         else if (entry.type === "custom_message") {
             messages.push({
@@ -52,8 +57,14 @@ 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 withSessionHistoryMetadata(message, entryId, thinkingLevel) {
+    if (!isRecord(message))
+        return message;
+    return {
+        ...message,
+        [PIX_SESSION_ENTRY_ID_FIELD]: entryId,
+        ...(thinkingLevel === undefined ? {} : { [PIX_THINKING_LEVEL_FIELD]: thinkingLevel }),
+    };
 }
 function isPixSystemDisplayEntry(entry) {
     return entry.type === "custom"

package/dist/app/session/queued-message-controller.d.ts

@@ -23,12 +23,14 @@ export type AppQueuedMessageControllerHost = {
 };
 export declare class AppQueuedMessageController {
     private readonly host;
+    readonly autoUserMessages: SubmittedUserMessage[];
     readonly deferredUserMessages: SubmittedUserMessage[];
-    private promptSubmissionInFlight;
-    private flushingDeferredUserMessages;
+    private promptSubmissionInFlightSession;
     private immediateSendInProgress;
     constructor(host: AppQueuedMessageControllerHost);
     reset(): void;
+    captureAutoUserMessages(): SubmittedUserMessage[];
+    restoreAutoUserMessages(messages: readonly SubmittedUserMessage[]): void;
     captureDeferredUserMessages(): SubmittedUserMessage[];
     restoreDeferredUserMessages(messages: readonly SubmittedUserMessage[]): void;
     createSubmittedUserMessage(promptText: string, displayText: string, images: ImageContent[]): SubmittedUserMessage;
@@ -36,7 +38,7 @@ export declare class AppQueuedMessageController {
     sendUserMessageToSession(message: SubmittedUserMessage, options?: {
         streamingBehavior?: "steer" | "followUp";
     }): Promise<void>;
-    flushDeferredUserMessages(): Promise<void>;
+    flushAutoUserMessages(): Promise<void>;
     queuedMessageCounts(): {
         steering: number;
         followUp: number;
@@ -54,10 +56,14 @@ export declare class AppQueuedMessageController {
     queuedEntries(): Extract<Entry, {
         kind: "queued";
     }>[];
+    autoQueuedEntries(): Extract<Entry, {
+        kind: "queued";
+    }>[];
     deferredQueuedEntries(): Extract<Entry, {
         kind: "queued";
     }>[];
-    private shouldDeferUserMessage;
+    private shouldQueueUserMessageAsSteering;
+    private queueUserMessageAsSteering;
     deferUserMessage(message: SubmittedUserMessage): void;
     private rewriteSdkQueuedMessages;
     private takeQueuedEntryForInterruptedSend;
@@ -71,4 +77,5 @@ export declare class AppQueuedMessageController {
     private restorableSubmittedMessageText;
     private cloneSubmittedUserMessage;
     private notifyDeferredUserMessagesChanged;
+    private notifyAutoUserMessagesChanged;
 }