@tt-a1i/openpi 0.4.0 → 0.5.0

package/extensions/sessions/index.ts

@@ -22,7 +22,19 @@ import {
   wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
 import { hintLine } from "../shared/screen-chrome.ts";
-import { createSessionStatsLoader, type SessionStats } from "./git-stats.js";
+import {
+  createSessionStatsLoader,
+  type SessionStatsState,
+} from "./git-stats.js";
+import {
+  createSessionPreviewCache,
+  measureSessionPreviewBytes,
+  previewCacheKey,
+} from "./preview-cache.js";
+import {
+  loadSessionPreviewData,
+  readPreviewFileIdentity,
+} from "./preview-loader.js";
 import {
   buildPreviewError,
   buildSessionDescription,
@@ -33,7 +45,9 @@ import {
   formatRelativeTime,
   getSessionPaneLayout,
   type PreviewBlock,
+  type PreviewMessageLike,
   parseLimit,
+  selectSessionStatsWindow,
   type SessionInfoLike,
   type SessionPreview,
 } from "./sessions.js";
@@ -291,20 +305,16 @@ const renderPreviewBlock = (
   return renderTextBlock(`◇ ${block.label}`, block.text, width, theme, "muted");
 };
 
-/** Cached across picker openings, while the loader bounds process-wide Git work. */
-const statsLoader = createSessionStatsLoader();
-const statsCache = statsLoader.cache;
-
 const formatItemLabel = (
   session: SessionInfoLike,
   width: number,
   theme: any,
-  statsCache: Map<string, SessionStats>,
+  statsState: SessionStatsState | undefined,
 ): string => {
   const itemWidth = width - 4;
   const timeStr = formatRelativeTime(session.modified);
 
-  const stats = statsCache.get(session.path);
+  const stats = statsState?.status === "ready" ? statsState.stats : undefined;
   let statsStr = "";
   let statsLen = 0;
   if (stats && (stats.add > 0 || stats.mod > 0 || stats.del > 0)) {
@@ -319,6 +329,12 @@ const formatItemLabel = (
       (stats.del > 0 ? `${stats.del}`.length + 1 : 0) +
       parts.length -
       1;
+  } else if (statsState?.status === "pending") {
+    statsStr = theme.fg("dim", "…");
+    statsLen = 1;
+  } else if (statsState?.status === "unavailable") {
+    statsStr = theme.fg("warning", "?");
+    statsLen = 1;
   }
 
   const title = buildSessionLabel(session);
@@ -442,14 +458,28 @@ const renderPreview = (
 
 const loadSessionPreview = async (
   session: SessionInfoLike,
+  cache: ReturnType<typeof createSessionPreviewCache>,
+  signal: AbortSignal,
 ): Promise<SessionPreview> => {
-  try {
-    const manager = SessionManager.open(session.path);
-    const context = manager.buildSessionContext();
-    return buildSessionPreview(session, context.messages as any[]);
-  } catch (error) {
-    return buildPreviewError(session, error);
-  }
+  const initialIdentity = await readPreviewFileIdentity(session.path);
+  const cached = cache.get(previewCacheKey(initialIdentity));
+  if (cached) return cached;
+
+  const data = await loadSessionPreviewData(session.path, { signal });
+  const preview = buildSessionPreview(
+    session,
+    data.messages as PreviewMessageLike[],
+    {
+      totalMessages: data.totalMessages,
+      truncatedBytes: data.truncatedBytes,
+    },
+  );
+  cache.set(
+    previewCacheKey(data.identity),
+    preview,
+    measureSessionPreviewBytes(preview),
+  );
+  return preview;
 };
 
 async function listSessions(
@@ -551,12 +581,17 @@ async function showSessionPicker(
       let previewScrollOffset = 0;
       let toolsExpanded = false;
       let thinkingVisible = false;
-      const previewCache = new Map<string, SessionPreview>();
+      const previewCache = createSessionPreviewCache();
       let activePreview: SessionPreview | undefined;
       let previewTimer: ReturnType<typeof setTimeout> | undefined;
+      let previewController: AbortController | undefined;
       let previewSeq = 0;
-      let statsController = new AbortController();
-      let statsGeneration = 0;
+      // Stats use a picker-scoped, per-query first-observation cache. Rows that
+      // become visible later may observe later repository state; reopening the
+      // picker refreshes every row without polling repositories while idle.
+      const statsLoader = createSessionStatsLoader();
+      let statsUniverseVersion = 0;
+      let statsWindowSignature = "";
       let workspaceLoadSeq = 0;
       let disposed = false;
       let settled = false;
@@ -565,14 +600,22 @@ async function showSessionPicker(
       let showAllWorkspaces = false;
       let isLoading = false;
 
+      const cancelPreviewLoad = () => {
+        previewSeq++;
+        if (previewTimer) clearTimeout(previewTimer);
+        previewTimer = undefined;
+        previewController?.abort();
+        previewController = undefined;
+      };
+
       const disposePicker = () => {
         if (disposed) return;
         disposed = true;
         workspaceLoadSeq++;
-        statsGeneration++;
-        statsController.abort();
-        previewSeq++;
-        if (previewTimer) clearTimeout(previewTimer);
+        statsLoader.cancel();
+        cancelPreviewLoad();
+        previewCache.clear();
+        activePreview = undefined;
       };
       const finishPicker = (result: SessionInfoLike | null) => {
         if (settled) return;
@@ -580,30 +623,29 @@ async function showSessionPicker(
         disposePicker();
         done(result);
       };
-      const previewKey = (session: SessionInfoLike): string =>
-        `${session.path}:${session.modified.getTime()}`;
-
-      const cancelStatsLoad = () => {
-        statsGeneration++;
-        statsController.abort();
-      };
-      const triggerStatsLoad = (list: SessionInfoLike[]) => {
-        cancelStatsLoad();
-        statsController = new AbortController();
-        const generation = statsGeneration;
-        const signal = statsController.signal;
-        void statsLoader.load(list, signal, () => {
-          if (disposed || signal.aborted || generation !== statsGeneration)
-            return;
-          tui.requestRender();
+      const ensureStatsWindowLoad = (visibleCount: number) => {
+        const targets = selectSessionStatsWindow(
+          filteredEntries.map((entry) => entry.session),
+          selectedPath,
+          visibleCount,
+        );
+        const signature = `${statsUniverseVersion}:${targets
+          .map((session) => session.path)
+          .join("\0")}`;
+        if (signature === statsWindowSignature) return;
+        statsWindowSignature = signature;
+        void statsLoader.reconcile(targets, sorted, () => {
+          if (!disposed) tui.requestRender();
         });
       };
 
-      triggerStatsLoad(sorted);
-
       const loadWorkspaceSessions = async (allWorkspaces: boolean) => {
         const loadSeq = ++workspaceLoadSeq;
-        cancelStatsLoad();
+        statsLoader.cancel();
+        statsWindowSignature = "";
+        cancelPreviewLoad();
+        previewCache.clear();
+        activePreview = undefined;
         isLoading = true;
         tui.requestRender();
         try {
@@ -616,11 +658,11 @@ async function showSessionPicker(
           if (disposed || loadSeq !== workspaceLoadSeq) return;
 
           sorted = sortSessions(results);
+          statsUniverseVersion++;
           for (const s of sorted) {
             sessionByPath.set(s.path, s);
           }
           entries = buildSessionSearchEntries(sorted);
-          triggerStatsLoad(sorted);
 
           filteredEntries = filterSessionEntries(entries, filter);
           const matchedIndex = filteredEntries.findIndex(
@@ -648,6 +690,7 @@ async function showSessionPicker(
       };
 
       const schedulePreviewLoad = () => {
+        cancelPreviewLoad();
         previewScrollOffset = 0;
         const session = sessionByPath.get(selectedPath);
         if (!session) {
@@ -655,28 +698,45 @@ async function showSessionPicker(
           return;
         }
 
-        const key = previewKey(session);
-        const cached = previewCache.get(key);
-        if (cached) {
-          activePreview = cached;
-          return;
-        }
-
         activePreview = {
           title: buildSessionLabel(session),
           subtitle: `${session.modified.toLocaleString()} · loading preview`,
           blocks: [{ kind: "notice", text: "Loading selected session…" }],
         };
 
-        if (previewTimer) clearTimeout(previewTimer);
-        const seq = ++previewSeq;
+        const seq = previewSeq;
         previewTimer = setTimeout(() => {
-          void loadSessionPreview(session).then((preview) => {
-            if (seq !== previewSeq || selectedPath !== session.path) return;
-            previewCache.set(key, preview);
-            activePreview = preview;
-            tui.requestRender();
-          });
+          previewTimer = undefined;
+          const controller = new AbortController();
+          previewController = controller;
+          void loadSessionPreview(session, previewCache, controller.signal)
+            .then((preview) => {
+              if (
+                controller.signal.aborted ||
+                seq !== previewSeq ||
+                selectedPath !== session.path
+              ) {
+                return;
+              }
+              activePreview = preview;
+              tui.requestRender();
+            })
+            .catch((error) => {
+              if (
+                controller.signal.aborted ||
+                seq !== previewSeq ||
+                selectedPath !== session.path
+              ) {
+                return;
+              }
+              activePreview = buildPreviewError(session, error);
+              tui.requestRender();
+            })
+            .finally(() => {
+              if (previewController === controller) {
+                previewController = undefined;
+              }
+            });
         }, PREVIEW_LOAD_DEBOUNCE_MS);
       };
 
@@ -692,7 +752,12 @@ async function showSessionPicker(
       ): SelectItem[] =>
         current.map((entry) => ({
           value: entry.session.path,
-          label: formatItemLabel(entry.session, listWidth, theme, statsCache),
+          label: formatItemLabel(
+            entry.session,
+            listWidth,
+            theme,
+            statsLoader.get(entry.session),
+          ),
         }));
 
       const rebuild = () => {
@@ -728,20 +793,21 @@ async function showSessionPicker(
           );
           container.addChild(new Spacer(1));
         } else {
-          const items = buildItems(filteredEntries, width);
-          selectList = new SelectList(
-            items,
-            Math.max(1, Math.min(maxVisible, Math.max(items.length, 1))),
-            {
-              selectedPrefix: (text) =>
-                theme.fg(focus === "list" ? "accent" : "muted", text),
-              selectedText: (text) =>
-                theme.fg(focus === "list" ? "accent" : "muted", text),
-              description: (text) => theme.fg("muted", text),
-              scrollInfo: (text) => theme.fg("dim", text),
-              noMatch: () => theme.fg("warning", "  No matching sessions"),
-            },
+          const effectiveVisible = Math.max(
+            1,
+            Math.min(maxVisible, Math.max(filteredEntries.length, 1)),
           );
+          ensureStatsWindowLoad(effectiveVisible);
+          const items = buildItems(filteredEntries, width);
+          selectList = new SelectList(items, effectiveVisible, {
+            selectedPrefix: (text) =>
+              theme.fg(focus === "list" ? "accent" : "muted", text),
+            selectedText: (text) =>
+              theme.fg(focus === "list" ? "accent" : "muted", text),
+            description: (text) => theme.fg("muted", text),
+            scrollInfo: (text) => theme.fg("dim", text),
+            noMatch: () => theme.fg("warning", "  No matching sessions"),
+          });
           const selectedIndex = filteredEntries.findIndex(
             (entry) => entry.session.path === selectedPath,
           );
@@ -811,23 +877,21 @@ async function showSessionPicker(
           leftLines.push("");
           leftLines.push(theme.fg("muted", "  Loading sessions..."));
         } else {
-          const items = buildItems(filteredEntries, layout.listWidth);
-          selectList = new SelectList(
-            items,
-            Math.max(
-              listHeight,
-              Math.min(maxVisible, Math.max(items.length, 1)),
-            ),
-            {
-              selectedPrefix: (text) =>
-                theme.fg(focus === "list" ? "accent" : "muted", text),
-              selectedText: (text) =>
-                theme.fg(focus === "list" ? "accent" : "muted", text),
-              description: (text) => theme.fg("muted", text),
-              scrollInfo: (text) => theme.fg("dim", text),
-              noMatch: () => theme.fg("warning", "  No matching sessions"),
-            },
+          const effectiveVisible = Math.max(
+            listHeight,
+            Math.min(maxVisible, Math.max(filteredEntries.length, 1)),
           );
+          ensureStatsWindowLoad(effectiveVisible);
+          const items = buildItems(filteredEntries, layout.listWidth);
+          selectList = new SelectList(items, effectiveVisible, {
+            selectedPrefix: (text) =>
+              theme.fg(focus === "list" ? "accent" : "muted", text),
+            selectedText: (text) =>
+              theme.fg(focus === "list" ? "accent" : "muted", text),
+            description: (text) => theme.fg("muted", text),
+            scrollInfo: (text) => theme.fg("dim", text),
+            noMatch: () => theme.fg("warning", "  No matching sessions"),
+          });
           const selectedIndex = filteredEntries.findIndex(
             (entry) => entry.session.path === selectedPath,
           );
@@ -909,8 +973,11 @@ async function showSessionPicker(
           return renderSplitPane(width);
         },
         invalidate: () => {
+          cancelPreviewLoad();
           previewCache.clear();
+          activePreview = undefined;
           rebuild();
+          schedulePreviewLoad();
         },
         dispose: disposePicker,
         handleInput: (data) => {

package/extensions/sessions/preview-cache.ts

@@ -0,0 +1,104 @@
+import type { PreviewFileIdentity } from "./preview-loader.ts";
+import type { SessionPreview } from "./sessions.ts";
+
+export const PREVIEW_CACHE_MAX_ENTRIES = 16;
+export const PREVIEW_CACHE_MAX_BYTES = 4 * 1024 * 1024;
+
+interface PreviewCacheOptions {
+  maxEntries?: number;
+  maxBytes?: number;
+}
+
+interface CacheEntry {
+  preview: SessionPreview;
+  bytes: number;
+}
+
+export function measureSessionPreviewBytes(value: unknown): number {
+  if (typeof value === "string") return Buffer.byteLength(value, "utf8");
+  if (Array.isArray(value)) {
+    return value.reduce(
+      (total, nested) => total + measureSessionPreviewBytes(nested),
+      0,
+    );
+  }
+  if (typeof value !== "object" || value === null) return 0;
+  return Object.entries(value).reduce(
+    (total, [key, nested]) =>
+      total +
+      Buffer.byteLength(key, "utf8") +
+      measureSessionPreviewBytes(nested),
+    0,
+  );
+}
+
+export function previewCacheKey(identity: PreviewFileIdentity) {
+  return [
+    identity.path,
+    identity.device,
+    identity.inode,
+    identity.size,
+    identity.mtimeNs,
+  ].join(":");
+}
+
+export function createSessionPreviewCache(options: PreviewCacheOptions = {}) {
+  const maxEntries = Math.max(
+    1,
+    options.maxEntries ?? PREVIEW_CACHE_MAX_ENTRIES,
+  );
+  const maxBytes = Math.max(1, options.maxBytes ?? PREVIEW_CACHE_MAX_BYTES);
+  const cache = new Map<string, CacheEntry>();
+  let totalBytes = 0;
+  let evictionCount = 0;
+
+  const remove = (key: string) => {
+    const entry = cache.get(key);
+    if (!entry) return false;
+    cache.delete(key);
+    totalBytes -= entry.bytes;
+    return true;
+  };
+
+  const get = (key: string) => {
+    const entry = cache.get(key);
+    if (!entry) return undefined;
+    cache.delete(key);
+    cache.set(key, entry);
+    return entry.preview;
+  };
+
+  const set = (key: string, preview: SessionPreview, bytes: number) => {
+    remove(key);
+    if (!Number.isFinite(bytes) || bytes < 0 || bytes > maxBytes) return false;
+
+    cache.set(key, { preview, bytes });
+    totalBytes += bytes;
+    while (cache.size > maxEntries || totalBytes > maxBytes) {
+      const oldest = cache.keys().next().value;
+      if (oldest === undefined || !remove(oldest)) break;
+      evictionCount++;
+    }
+    return cache.has(key);
+  };
+
+  const clear = () => {
+    cache.clear();
+    totalBytes = 0;
+  };
+
+  return {
+    get,
+    set,
+    clear,
+    get entries() {
+      return cache.size;
+    },
+    get bytes() {
+      return totalBytes;
+    },
+    get evictions() {
+      return evictionCount;
+    },
+  };
+}