pi-ui-extend 0.1.13 → 0.1.15

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

@@ -3,6 +3,7 @@ export class AppScrollController {
     host;
     scrollFromBottom = 0;
     detachedScrollStart;
+    olderHistoryThresholdLines = 8;
     constructor(host) {
         this.host = host;
     }
@@ -37,20 +38,6 @@ export class AppScrollController {
         }
         return { bodyHeight, viewportColumns, conversationLineCount, maxScroll, start };
     }
-    scrollBarForMetrics(metrics) {
-        if (metrics.bodyHeight <= 0 || metrics.maxScroll <= 0 || metrics.conversationLineCount <= metrics.bodyHeight)
-            return undefined;
-        const thumbSize = Math.max(1, Math.min(metrics.bodyHeight, Math.round((metrics.bodyHeight * metrics.bodyHeight) / metrics.conversationLineCount)));
-        const travel = Math.max(0, metrics.bodyHeight - thumbSize);
-        const thumbOffset = travel === 0 ? 0 : Math.round((metrics.start / metrics.maxScroll) * travel);
-        return {
-            thumbStartRow: thumbOffset + 1,
-            thumbEndRow: thumbOffset + thumbSize,
-        };
-    }
-    scrollBarMetrics(columns, bodyHeight) {
-        return this.scrollBarForMetrics(this.scrollMetrics(columns, bodyHeight));
-    }
     scrollByPage(direction) {
         const rows = this.host.terminalRows();
         this.scrollByLines(direction * Math.max(1, editorLayoutRows(rows, this.host.tabPanelRows(rows)) - 4));
@@ -62,37 +49,64 @@ 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));
+        let changed = false;
         if (nextScrollFromBottom === this.scrollFromBottom) {
             if (nextScrollFromBottom === 0 && this.detachedScrollStart !== undefined && delta > 0) {
                 this.detachedScrollStart = undefined;
-                if (shouldRender)
-                    this.host.render();
-                return true;
+                changed = true;
+            }
+            else if (!shouldLoadOlderHistory) {
+                return false;
             }
-            return false;
         }
-        this.scrollFromBottom = nextScrollFromBottom;
-        this.detachedScrollStart = nextScrollFromBottom === 0
-            ? undefined
-            : Math.max(0, conversationLineCount - bodyHeight - nextScrollFromBottom);
+        else {
+            this.scrollFromBottom = nextScrollFromBottom;
+            this.detachedScrollStart = nextScrollFromBottom === 0
+                ? undefined
+                : Math.max(0, conversationLineCount - bodyHeight - nextScrollFromBottom);
+            changed = true;
+        }
+        if (shouldLoadOlderHistory)
+            this.loadOlderHistoryAnchored(metrics, { render: shouldRender });
         if (shouldRender)
             this.host.render();
-        return true;
+        return changed || shouldLoadOlderHistory;
     }
-    scrollToScrollbarPosition(bodyRow) {
-        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);
-        if (!this.scrollBarForMetrics(metrics))
+    shouldLoadOlderHistory(delta, metrics) {
+        if (delta >= 0)
+            return false;
+        if (metrics.start > this.olderHistoryThresholdLines)
+            return false;
+        if (this.host.hasOlderSessionHistory?.() !== true)
+            return false;
+        if (this.host.isLoadingOlderSessionHistory?.() === true)
             return false;
-        const clampedRow = Math.max(0, Math.min(Math.max(0, bodyHeight - 1), bodyRow));
-        const ratio = bodyHeight <= 1 ? 0 : clampedRow / (bodyHeight - 1);
-        const start = Math.round(metrics.maxScroll * ratio);
-        return this.scrollToStart(start, metrics);
+        return true;
+    }
+    loadOlderHistoryAnchored(metrics, options) {
+        void this.host.loadOlderSessionHistory?.({
+            render: false,
+            onPrependedEntries: (entries) => {
+                const prependedLineCount = this.host.conversationViewport().measuredLineCountForEntries(metrics.viewportColumns, entries.map((entry) => entry.id));
+                if (prependedLineCount > 0 && this.detachedScrollStart !== undefined)
+                    this.detachedScrollStart += prependedLineCount;
+            },
+        }).then((loaded) => {
+            if (loaded && options.render)
+                this.host.render();
+        });
+    }
+    adjustForHistoryWindowPrune(edge, lineCount) {
+        if (lineCount <= 0)
+            return;
+        if (edge !== "top")
+            return;
+        if (this.detachedScrollStart === undefined)
+            return;
+        this.detachedScrollStart = Math.max(0, this.detachedScrollStart - lineCount);
     }
     scrollToConversationEntry(entryId) {
         const columns = this.host.terminalColumns();
@@ -143,12 +157,6 @@ export class AppScrollController {
         }
         return false;
     }
-    scrollToStart(start, metrics) {
-        if (!this.setScrollStart(start, metrics))
-            return false;
-        this.host.render();
-        return true;
-    }
     setScrollStart(start, metrics) {
         const nextStart = Math.max(0, Math.min(metrics.maxScroll, start));
         const nextScrollFromBottom = Math.max(0, metrics.conversationLineCount - metrics.bodyHeight - nextStart);
@@ -158,12 +166,9 @@ export class AppScrollController {
         this.detachedScrollStart = nextDetachedScrollStart;
         return changed;
     }
-    viewportColumns(columns, bodyHeight) {
+    viewportColumns(columns, _bodyHeight) {
         const safeColumns = Math.max(1, columns);
-        if (safeColumns <= 1 || bodyHeight <= 0)
-            return safeColumns;
-        const lineCountWithoutScrollbar = this.host.conversationViewport().lineCount(safeColumns);
-        return lineCountWithoutScrollbar > bodyHeight ? safeColumns - 1 : safeColumns;
+        return safeColumns;
     }
 }
 function editorLayoutRows(terminalRows, tabPanelRows) {

package/dist/app/session/lazy-session-manager.d.ts

@@ -0,0 +1,11 @@
+import { SessionManager, type SessionEntry } from "@earendil-works/pi-coding-agent";
+export type LazySessionManagerOptions = {
+    cwdOverride?: string;
+    sessionDir?: string;
+    tailEntryCount?: number;
+};
+export type LazySessionHistoryReader = {
+    hasOlder(): boolean;
+    readOlder(limit: number): Promise<SessionEntry[]>;
+};
+export declare function openLazySessionManager(sessionPath: string, options?: LazySessionManagerOptions): SessionManager;

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

@@ -0,0 +1,539 @@
+import { randomUUID } from "node:crypto";
+import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readSync, statSync, writeFileSync } from "node:fs";
+import { open as openFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import { buildSessionContext, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { isRecord } from "../guards.js";
+const CURRENT_SESSION_VERSION = 3;
+const DEFAULT_TAIL_ENTRY_COUNT = 180;
+const INITIAL_TAIL_BYTES = 256 * 1024;
+const MAX_TAIL_BYTES = 16 * 1024 * 1024;
+export function openLazySessionManager(sessionPath, options = {}) {
+    return new LazySessionManager(sessionPath, options);
+}
+class LazySessionManager {
+    sessionFilePath;
+    sessionDirPath;
+    cwdPath;
+    header;
+    entries = [];
+    byId = new Map();
+    labelsById = new Map();
+    labelTimestampsById = new Map();
+    leafId = null;
+    hydrated;
+    tailEntryCount;
+    tailStartOffset = 0;
+    constructor(sessionPath, options = {}) {
+        this.sessionFilePath = resolve(sessionPath);
+        this.sessionDirPath = resolve(options.sessionDir ?? dirname(this.sessionFilePath));
+        this.tailEntryCount = Math.max(1, Math.floor(options.tailEntryCount ?? DEFAULT_TAIL_ENTRY_COUNT));
+        this.header = this.loadHeader(options.cwdOverride);
+        this.cwdPath = resolve(options.cwdOverride ?? this.header.cwd ?? process.cwd());
+        this.loadTailEntries();
+    }
+    setSessionFile(sessionFile) {
+        if (this.hydrated) {
+            this.hydrated.setSessionFile(sessionFile);
+            return;
+        }
+        this.sessionFilePath = resolve(sessionFile);
+        this.sessionDirPath = dirname(this.sessionFilePath);
+        this.header = this.loadHeader(this.cwdPath);
+        this.cwdPath = resolve(this.header.cwd || this.cwdPath);
+        this.loadTailEntries();
+    }
+    newSession(options) {
+        if (this.hydrated)
+            return this.hydrated.newSession(options);
+        const timestamp = new Date().toISOString();
+        const sessionId = options?.id ?? createSessionId();
+        const header = {
+            type: "session",
+            version: CURRENT_SESSION_VERSION,
+            id: sessionId,
+            timestamp,
+            cwd: this.cwdPath,
+        };
+        if (options?.parentSession !== undefined)
+            header.parentSession = options.parentSession;
+        this.header = header;
+        this.entries = [];
+        this.byId.clear();
+        this.labelsById.clear();
+        this.labelTimestampsById.clear();
+        this.leafId = null;
+        mkdirSync(this.sessionDirPath, { recursive: true });
+        this.sessionFilePath = join(this.sessionDirPath, `${timestamp.replace(/[:.]/g, "-")}_${sessionId}.jsonl`);
+        writeFileSync(this.sessionFilePath, `${JSON.stringify(header)}\n`, "utf8");
+        return this.sessionFilePath;
+    }
+    isPersisted() {
+        return true;
+    }
+    getCwd() {
+        return this.hydrated?.getCwd() ?? this.cwdPath;
+    }
+    getSessionDir() {
+        return this.hydrated?.getSessionDir() ?? this.sessionDirPath;
+    }
+    usesDefaultSessionDir() {
+        return this.hydrated?.usesDefaultSessionDir() ?? false;
+    }
+    getSessionId() {
+        return this.hydrated?.getSessionId() ?? this.header.id;
+    }
+    getSessionFile() {
+        return this.hydrated?.getSessionFile() ?? this.sessionFilePath;
+    }
+    getHeader() {
+        return this.hydrated?.getHeader() ?? this.header;
+    }
+    getEntries() {
+        return this.hydrated?.getEntries() ?? [...this.entries];
+    }
+    getBranch(fromId) {
+        if (this.hydrated)
+            return this.hydrated.getBranch(fromId);
+        if (fromId === undefined)
+            return [...this.entries];
+        if (fromId !== undefined && !this.byId.has(fromId))
+            return this.hydrate().getBranch(fromId);
+        return [...this.entries];
+    }
+    createHistoryReader() {
+        if (this.hydrated || this.tailStartOffset <= 0)
+            return undefined;
+        let cursorOffset = this.tailStartOffset;
+        const firstEntryOffset = readFirstSessionEntryOffset(this.sessionFilePath);
+        return {
+            hasOlder: () => cursorOffset > firstEntryOffset,
+            readOlder: async (limit) => {
+                if (cursorOffset <= firstEntryOffset)
+                    return [];
+                const result = await readSessionEntriesBeforeOffset(this.sessionFilePath, cursorOffset, Math.max(1, Math.floor(limit)));
+                cursorOffset = result.startOffset;
+                if (result.entries.length === 0)
+                    cursorOffset = firstEntryOffset;
+                return result.entries;
+            },
+        };
+    }
+    async readFullBranchEntries() {
+        if (this.hydrated)
+            return this.hydrated.getBranch();
+        const entries = await readAllSessionEntries(this.sessionFilePath);
+        return branchEntries(entries, this.leafId ?? entries.at(-1)?.id);
+    }
+    buildSessionContext() {
+        if (this.hydrated)
+            return this.hydrated.buildSessionContext();
+        const entries = this.contextEntries();
+        const byId = new Map(entries.map((entry) => [entry.id, entry]));
+        return buildSessionContext(entries, entries.at(-1)?.id ?? null, byId);
+    }
+    getSessionName() {
+        if (this.hydrated)
+            return this.hydrated.getSessionName();
+        for (let index = this.entries.length - 1; index >= 0; index -= 1) {
+            const entry = this.entries[index];
+            if (entry?.type === "session_info")
+                return entry.name?.trim() || undefined;
+        }
+        return undefined;
+    }
+    getLeafId() {
+        return this.hydrated?.getLeafId() ?? this.leafId;
+    }
+    getLeafEntry() {
+        if (this.hydrated)
+            return this.hydrated.getLeafEntry();
+        return this.leafId ? this.byId.get(this.leafId) : undefined;
+    }
+    getEntry(id) {
+        if (this.hydrated)
+            return this.hydrated.getEntry(id);
+        return this.byId.get(id) ?? this.hydrate().getEntry(id);
+    }
+    getChildren(parentId) {
+        if (this.hydrated)
+            return this.hydrated.getChildren(parentId);
+        return this.entries.filter((entry) => entry.parentId === parentId);
+    }
+    getLabel(id) {
+        return this.hydrated?.getLabel(id) ?? this.labelsById.get(id);
+    }
+    getTree() {
+        return this.hydrate().getTree();
+    }
+    branch(branchFromId) {
+        if (!this.byId.has(branchFromId)) {
+            this.hydrate().branch(branchFromId);
+            return;
+        }
+        this.leafId = branchFromId;
+    }
+    resetLeaf() {
+        if (this.hydrated) {
+            this.hydrated.resetLeaf();
+            return;
+        }
+        this.leafId = null;
+    }
+    createBranchedSession(leafId) {
+        return this.hydrate().createBranchedSession(leafId);
+    }
+    branchWithSummary(branchFromId, summary, details, fromHook) {
+        return this.hydrate().branchWithSummary(branchFromId, summary, details, fromHook);
+    }
+    appendLabelChange(targetId, label) {
+        if (this.hydrated)
+            return this.hydrated.appendLabelChange(targetId, label);
+        if (!this.byId.has(targetId))
+            return this.hydrate().appendLabelChange(targetId, label);
+        const entry = this.newEntry("label", { targetId, label });
+        this.appendEntry(entry);
+        if (label) {
+            this.labelsById.set(targetId, label);
+            this.labelTimestampsById.set(targetId, entry.timestamp);
+        }
+        else {
+            this.labelsById.delete(targetId);
+            this.labelTimestampsById.delete(targetId);
+        }
+        return entry.id;
+    }
+    appendMessage(message) {
+        if (this.hydrated)
+            return this.hydrated.appendMessage(message);
+        return this.appendEntry(this.newEntry("message", { message }));
+    }
+    appendThinkingLevelChange(thinkingLevel) {
+        if (this.hydrated)
+            return this.hydrated.appendThinkingLevelChange(thinkingLevel);
+        return this.appendEntry(this.newEntry("thinking_level_change", { thinkingLevel }));
+    }
+    appendModelChange(provider, modelId) {
+        if (this.hydrated)
+            return this.hydrated.appendModelChange(provider, modelId);
+        return this.appendEntry(this.newEntry("model_change", { provider, modelId }));
+    }
+    appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook) {
+        if (this.hydrated)
+            return this.hydrated.appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook);
+        const payload = { summary, firstKeptEntryId, tokensBefore };
+        if (details !== undefined)
+            payload.details = details;
+        if (fromHook !== undefined)
+            payload.fromHook = fromHook;
+        return this.appendEntry(this.newEntry("compaction", payload));
+    }
+    appendCustomEntry(customType, data) {
+        if (this.hydrated)
+            return this.hydrated.appendCustomEntry(customType, data);
+        const payload = { customType };
+        if (data !== undefined)
+            payload.data = data;
+        return this.appendEntry(this.newEntry("custom", payload));
+    }
+    appendSessionInfo(name) {
+        if (this.hydrated)
+            return this.hydrated.appendSessionInfo(name);
+        return this.appendEntry(this.newEntry("session_info", { name: name.trim() }));
+    }
+    appendCustomMessageEntry(customType, content, display, details) {
+        if (this.hydrated)
+            return this.hydrated.appendCustomMessageEntry(customType, content, display, details);
+        const payload = { customType, content, display };
+        if (details !== undefined)
+            payload.details = details;
+        return this.appendEntry(this.newEntry("custom_message", payload));
+    }
+    hydrate() {
+        if (!this.hydrated) {
+            this.hydrated = SessionManager.open(this.sessionFilePath, this.sessionDirPath, this.cwdPath);
+        }
+        return this.hydrated;
+    }
+    loadHeader(cwdOverride) {
+        if (!existsSync(this.sessionFilePath)) {
+            mkdirSync(dirname(this.sessionFilePath), { recursive: true });
+            const header = createSessionHeader(resolve(cwdOverride ?? process.cwd()));
+            writeFileSync(this.sessionFilePath, `${JSON.stringify(header)}\n`, "utf8");
+            return header;
+        }
+        const header = readSessionHeaderFast(this.sessionFilePath);
+        return header ?? createSessionHeader(resolve(cwdOverride ?? process.cwd()));
+    }
+    loadTailEntries() {
+        const result = readTailSessionEntries(this.sessionFilePath, this.tailEntryCount);
+        this.entries = result.entries;
+        this.tailStartOffset = result.startOffset;
+        this.rebuildIndexes();
+    }
+    rebuildIndexes() {
+        this.byId.clear();
+        this.labelsById.clear();
+        this.labelTimestampsById.clear();
+        this.leafId = null;
+        for (const entry of this.entries) {
+            this.byId.set(entry.id, entry);
+            this.leafId = entry.id;
+            if (entry.type === "label") {
+                if (entry.label) {
+                    this.labelsById.set(entry.targetId, entry.label);
+                    this.labelTimestampsById.set(entry.targetId, entry.timestamp);
+                }
+                else {
+                    this.labelsById.delete(entry.targetId);
+                    this.labelTimestampsById.delete(entry.targetId);
+                }
+            }
+        }
+    }
+    appendEntry(entry) {
+        this.entries.push(entry);
+        this.byId.set(entry.id, entry);
+        this.leafId = entry.id;
+        appendFileSync(this.sessionFilePath, `${JSON.stringify(entry)}\n`, "utf8");
+        return entry.id;
+    }
+    newEntry(type, payload) {
+        return {
+            type,
+            id: this.createEntryId(),
+            parentId: this.leafId,
+            timestamp: new Date().toISOString(),
+            ...payload,
+        };
+    }
+    createEntryId() {
+        for (let attempt = 0; attempt < 100; attempt += 1) {
+            const id = randomUUID().slice(0, 8);
+            if (!this.byId.has(id))
+                return id;
+        }
+        return randomUUID();
+    }
+    contextEntries() {
+        const entries = this.entries.filter((entry) => entry.type !== "label");
+        const start = contextStartIndex(entries);
+        const selected = entries.slice(start);
+        return selected.map((entry, index) => ({
+            ...entry,
+            parentId: index === 0 ? null : selected[index - 1].id,
+        }));
+    }
+}
+function createSessionHeader(cwd) {
+    return {
+        type: "session",
+        version: CURRENT_SESSION_VERSION,
+        id: createSessionId(),
+        timestamp: new Date().toISOString(),
+        cwd,
+    };
+}
+function createSessionId() {
+    return randomUUID();
+}
+function readSessionHeaderFast(filePath) {
+    const line = readFirstLine(filePath, 64 * 1024);
+    if (!line)
+        return undefined;
+    try {
+        const parsed = JSON.parse(line);
+        if (!isRecord(parsed) || parsed.type !== "session" || typeof parsed.id !== "string")
+            return undefined;
+        const header = parsed;
+        return typeof header.cwd === "string" ? header : { ...header, cwd: process.cwd() };
+    }
+    catch {
+        return undefined;
+    }
+}
+function readFirstLine(filePath, maxBytes) {
+    let fd;
+    try {
+        fd = openSync(filePath, "r");
+        const buffer = Buffer.alloc(maxBytes);
+        const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+        const text = buffer.toString("utf8", 0, bytesRead);
+        return text.split("\n")[0];
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+function readFirstSessionEntryOffset(filePath) {
+    let fd;
+    try {
+        fd = openSync(filePath, "r");
+        const buffer = Buffer.alloc(64 * 1024);
+        const bytesRead = readSync(fd, buffer, 0, buffer.length, 0);
+        const entries = parseSessionEntryBufferLines(buffer.subarray(0, bytesRead), 0);
+        return entries[0]?.offset ?? 0;
+    }
+    catch {
+        return 0;
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+function readTailSessionEntries(filePath, limit) {
+    if (!existsSync(filePath))
+        return { entries: [], startOffset: 0 };
+    const size = statSync(filePath).size;
+    if (size <= 0)
+        return { entries: [], startOffset: 0 };
+    let byteCount = Math.min(size, INITIAL_TAIL_BYTES);
+    const maxBytes = Math.min(size, MAX_TAIL_BYTES);
+    while (byteCount <= maxBytes) {
+        const result = readTailSessionEntriesWithByteCount(filePath, byteCount, limit);
+        if (result.entries.length >= limit || byteCount >= maxBytes || byteCount >= size)
+            return result;
+        byteCount = Math.min(size, Math.max(byteCount + 1, byteCount * 2));
+    }
+    return { entries: [], startOffset: 0 };
+}
+function readTailSessionEntriesWithByteCount(filePath, byteCount, limit) {
+    let fd;
+    try {
+        const size = statSync(filePath).size;
+        const start = Math.max(0, size - byteCount);
+        const buffer = Buffer.alloc(size - start);
+        fd = openSync(filePath, "r");
+        readSync(fd, buffer, 0, buffer.length, start);
+        let parseStart = 0;
+        if (start > 0) {
+            const firstNewline = buffer.indexOf(10);
+            parseStart = firstNewline >= 0 ? firstNewline + 1 : buffer.length;
+        }
+        return selectLastSessionEntries(parseSessionEntryBufferLines(buffer.subarray(parseStart), start + parseStart), limit, size);
+    }
+    catch {
+        return { entries: [], startOffset: 0 };
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+async function readSessionEntriesBeforeOffset(filePath, endOffset, limit) {
+    if (!existsSync(filePath) || endOffset <= 0)
+        return { entries: [], startOffset: 0 };
+    let byteCount = Math.min(endOffset, INITIAL_TAIL_BYTES);
+    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)
+            return result;
+        byteCount = Math.min(endOffset, Math.max(byteCount + 1, byteCount * 2));
+    }
+    return { entries: [], startOffset: 0 };
+}
+async function readSessionEntriesBeforeOffsetWithByteCount(filePath, endOffset, byteCount, limit) {
+    let file;
+    try {
+        const start = Math.max(0, endOffset - byteCount);
+        const buffer = Buffer.alloc(endOffset - start);
+        file = await openFile(filePath, "r");
+        await file.read(buffer, 0, buffer.length, start);
+        let parseStart = 0;
+        if (start > 0) {
+            const firstNewline = buffer.indexOf(10);
+            parseStart = firstNewline >= 0 ? firstNewline + 1 : buffer.length;
+        }
+        return selectLastSessionEntries(parseSessionEntryBufferLines(buffer.subarray(parseStart), start + parseStart), limit, start);
+    }
+    catch {
+        return { entries: [], startOffset: 0 };
+    }
+    finally {
+        await file?.close();
+    }
+}
+function selectLastSessionEntries(parsedEntries, limit, emptyStartOffset) {
+    const selected = parsedEntries.slice(-limit);
+    return {
+        entries: selected.map((item) => item.entry),
+        startOffset: selected[0]?.offset ?? emptyStartOffset,
+    };
+}
+function parseSessionEntryBufferLines(buffer, baseOffset) {
+    const entries = [];
+    let lineStart = 0;
+    for (let index = 0; index <= buffer.length; index += 1) {
+        if (index < buffer.length && buffer[index] !== 10)
+            continue;
+        const lineEnd = index > lineStart && buffer[index - 1] === 13 ? index - 1 : index;
+        const entry = parseSessionEntryLine(buffer.toString("utf8", lineStart, lineEnd));
+        if (entry)
+            entries.push({ entry, offset: baseOffset + lineStart });
+        lineStart = index + 1;
+    }
+    return entries;
+}
+function parseSessionEntryLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!isRecord(parsed) || parsed.type === "session" || typeof parsed.id !== "string")
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readAllSessionEntries(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    const entries = [];
+    const lines = createInterface({ input: createReadStream(filePath, { encoding: "utf8" }), crlfDelay: Infinity });
+    for await (const line of lines) {
+        const entry = parseSessionEntryLine(line);
+        if (entry)
+            entries.push(entry);
+    }
+    return entries;
+}
+function branchEntries(entries, leafId) {
+    if (!leafId)
+        return [...entries];
+    const byId = new Map(entries.map((entry) => [entry.id, entry]));
+    const branch = [];
+    const seen = new Set();
+    let cursor = leafId;
+    while (cursor && !seen.has(cursor)) {
+        seen.add(cursor);
+        const entry = byId.get(cursor);
+        if (!entry)
+            break;
+        branch.push(entry);
+        cursor = entry.parentId;
+    }
+    return branch.reverse();
+}
+function contextStartIndex(entries) {
+    const userIndex = entries.findIndex((entry) => entry.type === "message" && entry.message.role === "user");
+    if (userIndex < 0)
+        return 0;
+    let start = userIndex;
+    while (start > 0) {
+        const previous = entries[start - 1];
+        if (!previous || (previous.type !== "model_change" && previous.type !== "thinking_level_change" && previous.type !== "compaction" && previous.type !== "branch_summary" && previous.type !== "custom"))
+            break;
+        start -= 1;
+    }
+    return start;
+}