pi-fast-resume 1.2.0 → 1.3.0

package/fast-resume.ts

@@ -72,6 +72,8 @@ import {
   scanAllSessionDirs,
   scanSessionDir,
   loadSessionHeaders,
+  loadSessionHeadersForward,
+  resolveSessionName,
   sortByModified,
   sortByModifiedDesc,
   filterByCwd,
@@ -133,7 +135,7 @@ function loadCurrentSessionsImmediate(
 ): SessionHeader[] {
   if (!sessionDir) return [];
   const metas = sortByModifiedDesc(scanSessionDir(sessionDir));
-  let headers = loadSessionHeaders(metas);
+  let headers = loadSessionHeadersForward(metas);
   if (!usesDefaultSessionDir) {
     // Custom session dirs may contain sessions from multiple cwds; filter to
     // the current one, matching SessionManager.list behavior.
@@ -675,6 +677,17 @@ class FastResumePicker extends Container {
   private loadingAbort: AbortController | null = null;
   private allLoadSeq = 0;
 
+  // Deferred rename-name resolution. The picker displays rows immediately
+  // with forward-only headers (fast: ~80ms for 2.5k sessions); the latest rename
+  // name (which pi appends at EOF, past the forward stop) is resolved per file
+  // in the background and applied in-place, so a row's name pops in without
+  // blocking the initial render. See resolveSessionName in scanner.ts.
+  private metaByPath = new Map<string, SessionFileMeta>();
+  private nameResolveQueue: SessionFileMeta[] = [];
+  private nameResolveScheduled = false;
+  private nameResolveSeq = 0;
+  private nameResolvedPaths = new Set<string>();
+
   private mode: "list" | "rename" = "list";
   private renameTargetPath: string | null = null;
 
@@ -757,16 +770,19 @@ class FastResumePicker extends Container {
     this.sessionList.onSelect = (sessionPath) => {
       this.header.clearStatusTimeout();
       this.loadingAbort?.abort();
+      this.nameResolveSeq++; // cancel any pending name-resolution ticks
       this.done({ sessionPath, cancelled: false });
     };
     this.sessionList.onCancel = () => {
       this.header.clearStatusTimeout();
       this.loadingAbort?.abort();
+      this.nameResolveSeq++;
       this.done({ cancelled: true });
     };
     this.sessionList.onExit = () => {
       this.header.clearStatusTimeout();
       this.loadingAbort?.abort();
+      this.nameResolveSeq++;
       this.done({ cancelled: true });
     };
     this.sessionList.onToggleScope = () => this.toggleScope();
@@ -818,6 +834,17 @@ class FastResumePicker extends Container {
     // Build layout
     this.buildBaseLayout(this.sessionList);
 
+    // Build the path → meta lookup from allMetas (which is a superset of the
+    // current-scope metas both for the default and custom-dir cases), then
+    // enqueue the current-scope sessions for background rename-name resolution.
+    // Rows are already visible with the correct firstMessage; names populate
+    // in-place as their tails resolve.
+    for (const m of allMetas) this.metaByPath.set(m.path, m);
+    const currentMetas = initialCurrentSessions
+      .map((s) => this.metaByPath.get(s.path))
+      .filter((m): m is SessionFileMeta => !!m);
+    this.enqueueNameResolution(currentMetas);
+
     // Start loading current sessions (mark as loaded since we already have them)
     this.currentLoading = false;
     this.header.loading = false;
@@ -957,7 +984,10 @@ class FastResumePicker extends Container {
 
       let headers: SessionHeader[];
       try {
-        headers = loadSessionHeaders(batch);
+        // Forward-only: the rename name will resolve in the background via
+        // resolveSessionName (enqueued below), so rows appear with the correct
+        // firstMessage immediately and names populate in-place.
+        headers = loadSessionHeadersForward(batch);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         this.allLoading = false;
@@ -970,6 +1000,10 @@ class FastResumePicker extends Container {
       }
 
       allParsed.push(...headers);
+      // Enqueue this batch's metas for background rename-name resolution.
+      // Names will be applied in-place as they resolve; if the user is viewing
+      // "all" scope, newly-named rows also reflect in the active list.
+      this.enqueueNameResolution(batch);
 
       // If we're currently showing "all" scope, update progress
       if (this.scope === "all") {
@@ -986,6 +1020,76 @@ class FastResumePicker extends Container {
     setImmediate(loadBatch);
   }
 
+  // Enqueue session file metas for background rename-name resolution. Each
+  // path is resolved at most once (deduped via nameResolvedPaths); repeated
+  // enqueues for the same path are no-ops. Safe to call for the current-scope
+  // sessions at construction and for each batch of the all-scope background load.
+  private enqueueNameResolution(metas: SessionFileMeta[]): void {
+    for (const m of metas) {
+      if (this.nameResolvedPaths.has(m.path)) continue;
+      this.nameResolvedPaths.add(m.path);
+      this.nameResolveQueue.push(m);
+    }
+    this.scheduleNameResolution();
+  }
+
+  private scheduleNameResolution(): void {
+    if (this.nameResolveScheduled) return;
+    this.nameResolveScheduled = true;
+    setImmediate(() => this.drainNameResolution());
+  }
+
+  // Resolve one cooperative batch of rename names (up to 50 per tick), apply
+  // any found names in-place, and re-render once for the whole batch. Yields
+  // between batches so input stays responsive even while thousands of tail
+  // reads resolve. Aborts cleanly on select/cancel/exit via nameResolveSeq.
+  private drainNameResolution(): void {
+    this.nameResolveScheduled = false;
+    if (this.loadingAbort?.signal.aborted) return;
+    const seq = this.nameResolveSeq;
+    const BATCH = 50;
+    const batch = this.nameResolveQueue.splice(0, BATCH);
+    if (batch.length === 0) return;
+
+    let updatedAny = false;
+    for (const meta of batch) {
+      if (seq !== this.nameResolveSeq) return; // stale — picker exited/aborted
+      const result = resolveSessionName(meta);
+      if (result.found && this.applyNameUpdate(meta.path, result.name)) {
+        updatedAny = true;
+      }
+    }
+
+    if (updatedAny) {
+      const sessions = this.scope === "all" ? (this.allSessions ?? []) : (this.currentSessions ?? []);
+      const showCwd = this.scope === "all";
+      this.sessionList.setSessions(sessions, showCwd);
+      this.tuiRequestRender();
+    }
+
+    if (this.nameResolveQueue.length > 0) this.scheduleNameResolution();
+  }
+
+  // Apply a resolved name to the session with the given path in both the
+  // current- and all-scope caches. The same logical session may appear as
+  // distinct objects in the two caches, so both are updated. Returns whether a
+  // session was found and updated (so the caller can batch re-renders).
+  private applyNameUpdate(path: string, name: string | undefined): boolean {
+    let updated = false;
+    const updateArr = (arr: SessionHeader[] | null) => {
+      if (!arr) return;
+      for (const s of arr) {
+        if (s.path === path) {
+          s.name = name;
+          updated = true;
+        }
+      }
+    };
+    updateArr(this.currentSessions);
+    updateArr(this.allSessions);
+    return updated;
+  }
+
   private toggleScope(): void {
     if (this.scope === "current") {
       this.scope = "all";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fast-resume",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Fast session picker for pi — reads headers + first messages from 16KB partial reads instead of full-file parsing",
   "type": "module",
   "author": "Tom X Nguyen",

package/src/index.ts

@@ -1,5 +1,20 @@
-export { parseSessionFromBuffer, loadSessionHeader, loadSessionHeaders, scanAllSessionDirs, scanSessionDir, sortByModified, sortByModifiedDesc, filterByCwd, matchQuery, canonicalizePath } from "./scanner.js";
-export type { SessionHeader, SessionFileMeta } from "./scanner.js";
+export {
+  parseSessionFromBuffer,
+  scanTailForSessionInfo,
+  loadSessionHeader,
+  loadSessionHeaderForward,
+  loadSessionHeaders,
+  loadSessionHeadersForward,
+  resolveSessionName,
+  scanAllSessionDirs,
+  scanSessionDir,
+  sortByModified,
+  sortByModifiedDesc,
+  filterByCwd,
+  matchQuery,
+  canonicalizePath,
+} from "./scanner.js";
+export type { SessionHeader, SessionFileMeta, TailSessionInfo } from "./scanner.js";
 export {
   parseSearchQuery,
   matchSession,

package/src/scanner.ts

@@ -397,20 +397,72 @@ export function scanSessionDir(
   return results;
 }
 
-// Load a session header from disk using a streaming forward read plus a bounded
-// tail read — no fixed head window.
+// Forward-only load: reads complete lines from the start and stops at the
+// first user message (which is all the title row needs). This reads exactly as
+// many bytes as the first user message requires — a few KB for a normal
+// session, ~19KB for a <skill> injection, more for a base64 image — and never
+// truncates a line mid-JSON the way a fixed byte window would. So oversized
+// first user messages (the cases that used to show "(no messages)") are parsed
+// correctly.
 //
-// Forward pass: reads complete lines from the start and stops at the first user
-// message (which is all the title row needs). This reads exactly as many bytes
-// as the first user message requires — a few KB for a normal session, ~19KB
-// for a <skill> injection, more for a base64 image — and never truncates a line
-// mid-JSON the way a fixed byte window would. So oversized first user messages
-// (the cases that used to show "(no messages)") are now parsed correctly.
+// No tail read — the returned header's name reflects only session_info entries
+// seen within the forward window. For sessions whose latest rename lives past
+// the forward stop point (the common case for renamed large sessions), pair
+// this with resolveSessionName() run in the background; the name then populates
+// in-place without blocking the picker's initial render.
+export function loadSessionHeaderForward(
+  meta: SessionFileMeta,
+): SessionHeader | null {
+  let fd: number | undefined;
+  try {
+    fd = openSync(meta.path, "r");
+    const acc = newAccumulator();
+    const { reachedEof } = forEachLineForward(fd, meta.size, (line) => {
+      processEntry(acc, line);
+      if (acc.header && acc.foundFirstUser) return false;
+      return true;
+    });
+    return buildHeader(acc, meta.path, meta.mtimeMs, reachedEof);
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+// Resolve the latest session_info (the rename name) from a bounded tail at EOF,
+// independent of any forward pass. Returns found:false when no session_info
+// lives in the tail region (keep whatever name the forward pass produced);
+// found:true means a session_info was seen — its name (or explicit clear)
+// overrides the forward name (it is later in file order).
 //
-// Tail pass (only when the forward pass stopped before EOF): reads up to
-// TAIL_READ_SIZE bytes from EOF and recovers the latest session_info (the
-// rename name), bounded below by the forward stop offset so it never re-reads
-// covered bytes. See TAIL_READ_SIZE for the documented tradeoff.
+// This is the deferred half of loadSessionHeader, exposed so callers can show
+// a row immediately with the forward name and resolve the rename name in the
+// background. Reading up to TAIL_READ_SIZE bytes from EOF may overlap the
+// forward region for small files; that is a redundant re-read of a small range
+// (no correctness impact — the latest session_info wins either way).
+export function resolveSessionName(meta: SessionFileMeta): TailSessionInfo {
+  if (meta.size <= 0) return { found: false };
+  let fd: number | undefined;
+  try {
+    fd = openSync(meta.path, "r");
+    const tailReadSize = Math.min(TAIL_READ_SIZE, meta.size);
+    const tailBuf = Buffer.alloc(tailReadSize);
+    const tailOffset = meta.size - tailReadSize;
+    const tailBytesRead = readSync(fd, tailBuf, 0, tailReadSize, tailOffset);
+    return scanTailForSessionInfo(tailBuf, tailBytesRead);
+  } catch {
+    return { found: false };
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+// Load a session header using a streaming forward read plus a bounded tail read
+// — forward + tail in one shared fd. Equivalent to loadSessionHeaderForward
+// followed by resolveSessionName, but bounds the tail below by the forward stop
+// offset so it never re-reads already-covered bytes. Use this when the full
+// header (including rename name) is needed synchronously.
 export function loadSessionHeader(
   meta: SessionFileMeta,
 ): SessionHeader | null {
@@ -466,6 +518,20 @@ export function loadSessionHeaders(
   return results;
 }
 
+// Forward-only batch load — see loadSessionHeaderForward. Use for the picker's
+// immediate display path: rows appear instantly with the correct firstMessage,
+// and rename names resolve in the background via resolveSessionName().
+export function loadSessionHeadersForward(
+  metas: SessionFileMeta[],
+): SessionHeader[] {
+  const results: SessionHeader[] = [];
+  for (const meta of metas) {
+    const header = loadSessionHeaderForward(meta);
+    if (header) results.push(header);
+  }
+  return results;
+}
+
 export function sortByModified(sessions: SessionHeader[]): SessionHeader[] {
   return sessions.sort(
     (a, b) => b.modified.getTime() - a.modified.getTime(),