pi-fast-resume 1.1.1 → 1.1.3

package/README.md

@@ -4,7 +4,7 @@
 
 **Instant session picker for [pi](https://github.com/earendil-works/pi-coding-agent)**
 
-_Reads 16KB per file instead of the full JSONL — first results in **6ms**._
+_Reads the head + tail of each file instead of the full JSONL — first results in **6ms**._
 
 [![pi extension](https://img.shields.io/badge/pi-extension-blueviolet)](https://github.com/earendil-works/pi-coding-agent)
 [![license](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
@@ -16,7 +16,7 @@ _Reads 16KB per file instead of the full JSONL — first results in **6ms**._
 > **`/resume` takes 5.6 seconds** when you have 1,700+ sessions.
 > pi-fast-resume's `/fast-resume` takes **6 milliseconds**.
 
-Same picker UI and keybindings as `/resume`. The difference is pi-fast-resume never reads beyond the first 16KB of any session file. Headers, names, first messages — they all live in the first few lines. Everything after that is full message history the picker never shows. Search matches against the first message only (see [Known Limitations](#known-limitations)).
+Same picker UI and keybindings as `/resume`. The difference is pi-fast-resume reads at most ~24KB of each file (a 16KB head + up to 8KB tail) instead of the full JSONL. The head carries the header and first user message; the tail recovers the latest session name, which pi appends at EOF on `/rename`. Everything between is full message history the picker never shows. Search matches against the first message only (see [Known Limitations](#known-limitations)).
 
 ```
 ──────────────────────────────────────────────────────────
@@ -180,7 +180,7 @@ stat() all .jsonl files ──────► sort by mtime ──────
 
 1. **`stat()` all session files** — collect paths and mtimes (~100 ms for 1,700 files)
 2. **Sort by mtime descending** — most recent sessions first
-3. **Read first 16KB** of the top 30 files — extract header, name, first user message (~6 ms)
+3. **Read head (16KB) + tail (≤8KB)** of the top 30 files — extract header, first user message, and latest session name (~6 ms)
 4. **Show picker** — user can navigate, filter, and select immediately
 5. **Background load** — remaining sessions stream in batches of 50, non-blocking
 6. **Tab to switch scope** — filter to current project or show everything

package/fast-resume.ts

@@ -73,6 +73,7 @@ import {
   loadSessionHeaders,
   sortByModified,
   sortByModifiedDesc,
+  filterByCwd,
   canonicalizePath,
   type SessionHeader,
   type SessionFileMeta,
@@ -88,8 +89,8 @@ import {
   type FlatSessionNode,
   type SortMode,
   type NameFilter,
+  type PickerScope,
 } from "./src/search.js";
-import type { PickerScope } from "./src/picker-state.js";
 
 const HOME = homedir();
 
@@ -121,6 +122,43 @@ export interface FastResumeResult {
 
 type StatusMessage = { type: "info" | "error"; message: string };
 
+// Session loading helpers — mirror SessionManager.list / listAll behavior
+// while keeping partial reads.
+
+function loadCurrentSessionsImmediate(
+  cwd: string,
+  sessionDir: string | undefined,
+  usesDefaultSessionDir: boolean,
+): SessionHeader[] {
+  if (!sessionDir) return [];
+  const metas = sortByModifiedDesc(scanSessionDir(sessionDir));
+  let headers = loadSessionHeaders(metas);
+  if (!usesDefaultSessionDir) {
+    // Custom session dirs may contain sessions from multiple cwds; filter to
+    // the current one, matching SessionManager.list behavior.
+    headers = filterByCwd(headers, cwd);
+  }
+  return sortByModified(headers);
+}
+
+function loadAllSessionMetas(
+  sessionDir: string | undefined,
+  usesDefaultSessionDir: boolean,
+): SessionFileMeta[] {
+  if (usesDefaultSessionDir) {
+    return scanAllSessionDirs();
+  }
+  if (!sessionDir) return [];
+  return sortByModifiedDesc(scanSessionDir(sessionDir));
+}
+
+// ReadonlySessionManager doesn't declare usesDefaultSessionDir, but the
+// runtime SessionManager has it. Default to true so old pi versions behave
+// like the original default-dir-only fast-resume.
+function getUsesDefaultSessionDir(sessionManager: ExtensionCommandContext["sessionManager"]): boolean {
+  return (sessionManager as any).usesDefaultSessionDir?.() ?? true;
+}
+
 // Helpers
 
 function shortenPath(path: string): string {
@@ -639,6 +677,10 @@ class FastResumePicker extends Container {
   private mode: "list" | "rename" = "list";
   private renameTargetPath: string | null = null;
 
+  private cwd: string;
+  private sessionDir: string | undefined;
+  private usesDefaultSessionDir: boolean;
+
   // Focusable — propagate to sessionList or renameInput
   private _focused = false;
   get focused() { return this._focused; }
@@ -668,18 +710,24 @@ class FastResumePicker extends Container {
   constructor(
     theme: Theme,
     currentCwd: string,
+    sessionDir: string | undefined,
+    usesDefaultSessionDir: boolean,
     currentSessionPath: string | undefined,
     initialCurrentSessions: SessionHeader[],
     allMetas: SessionFileMeta[],
     allSessions: SessionHeader[] | null,
     done: (result: FastResumeResult) => void,
     tuiRequestRender: () => void,
+    initialQuery?: string,
   ) {
     super();
     this.theme = theme;
     this.done = done;
     this.tuiRequestRender = tuiRequestRender;
     this.allMetas = allMetas;
+    this.cwd = currentCwd;
+    this.sessionDir = sessionDir;
+    this.usesDefaultSessionDir = usesDefaultSessionDir;
 
     // Create header
     this.header = new FastResumeHeader(theme, tuiRequestRender);
@@ -698,6 +746,12 @@ class FastResumePicker extends Container {
     // Set initial data into the list
     this.sessionList.setSessions(initialCurrentSessions, false);
 
+    // Seed an optional initial query from /fast-resume <query>
+    if (initialQuery !== undefined && initialQuery !== "") {
+      this.sessionList.searchInput.setValue(initialQuery);
+      this.sessionList.filterSessions(initialQuery);
+    }
+
     // Wire session list events
     this.sessionList.onSelect = (sessionPath) => {
       this.header.clearStatusTimeout();
@@ -819,12 +873,54 @@ class FastResumePicker extends Container {
     }
   }
 
+  private rescanCurrentScope(): SessionHeader[] {
+    if (!this.sessionDir) return [];
+    const metas = sortByModifiedDesc(scanSessionDir(this.sessionDir));
+    let headers = loadSessionHeaders(metas);
+    if (!this.usesDefaultSessionDir) {
+      headers = filterByCwd(headers, this.cwd);
+    }
+    return sortByModified(headers);
+  }
+
+  private rescanAllScope(): SessionHeader[] {
+    if (this.usesDefaultSessionDir) {
+      const metas = scanAllSessionDirs();
+      const headers = loadSessionHeaders(metas);
+      return sortByModified(headers);
+    }
+    if (!this.sessionDir) return [];
+    const metas = sortByModifiedDesc(scanSessionDir(this.sessionDir));
+    const headers = loadSessionHeaders(metas);
+    return sortByModified(headers);
+  }
+
   private async refreshSessionsAfterMutation(): Promise<void> {
-    // After delete/rename, the in-memory arrays are already updated (filtered above).
-    // Just re-apply them to the session list.
-    const sessions = this.scope === "all" ? (this.allSessions ?? []) : (this.currentSessions ?? []);
-    const showCwd = this.scope === "all";
-    this.sessionList.setSessions(sessions, showCwd);
+    // Rescan from disk so renames, deletes, and newly created sessions are
+    // reflected in the list. This mirrors upstream's loadScope(scope, "refresh").
+    // Bump the sequence number first so any in-progress background all-load
+    // stops before it can overwrite the rescanned data.
+    this.allLoadSeq++;
+    try {
+      if (this.scope === "current") {
+        this.currentSessions = this.rescanCurrentScope();
+        this.sessionList.setSessions(this.currentSessions, false);
+      } else {
+        this.allLoading = true;
+        this.allSessions = this.rescanAllScope();
+        this.allLoading = false;
+        this.sessionList.setSessions(this.allSessions, true);
+      }
+      this.header.loading = false;
+      this.header.loadProgress = null;
+    } catch (err) {
+      this.currentLoading = false;
+      this.allLoading = false;
+      this.header.loading = false;
+      this.header.loadProgress = null;
+      const message = err instanceof Error ? err.message : String(err);
+      this.header.setStatusMessage({ type: "error", message: `Failed to refresh: ${message}` }, 4000);
+    }
   }
 
   private startAllLoadBackground(): void {
@@ -951,19 +1047,14 @@ async function showFastResumePicker(
 ): Promise<void> {
   const cwd = ctx.cwd;
   const sessionDir = ctx.sessionManager.getSessionDir();
+  const usesDefaultSessionDir = getUsesDefaultSessionDir(ctx.sessionManager);
 
   const t0 = Date.now();
 
-  // Phase 1: stat all session files
-  const currentMetas = sessionDir ? scanSessionDir(sessionDir) : [];
-  const allMetas = scanAllSessionDirs();
-
-  // Phase 2: quickly parse the first 30 for instant display
-  const INITIAL_BATCH = 30;
-  const sortedCurrent = sortByModifiedDesc(currentMetas);
-  const quickMetas = sortedCurrent.slice(0, INITIAL_BATCH);
-  const quickHeaders = loadSessionHeaders(quickMetas);
-  const currentSessions = sortByModified(quickHeaders);
+  // Load the current-scope sessions immediately, and collect metadata for the
+  // incremental "all" scope load that happens in the background.
+  const currentSessions = loadCurrentSessionsImmediate(cwd, sessionDir, usesDefaultSessionDir);
+  const allMetas = loadAllSessionMetas(sessionDir, usesDefaultSessionDir);
 
   const loadTime = Date.now() - t0;
 
@@ -977,12 +1068,15 @@ async function showFastResumePicker(
       const picker = new FastResumePicker(
         theme,
         cwd,
+        sessionDir,
+        usesDefaultSessionDir,
         ctx.sessionManager.getSessionFile(),
         currentSessions,
         allMetas,
         null, // allSessions not yet loaded — will load in background
         (result) => done(result),
         () => _tui.requestRender(),
+        initialQuery,
       );
 
       return picker;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-fast-resume",
-  "version": "1.1.1",
-  "description": "Fast session picker for pi \u2014 reads headers + first messages from 16KB partial reads instead of full-file parsing",
+  "version": "1.1.3",
+  "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",
   "license": "MIT",
@@ -29,13 +29,6 @@
     "src/",
     "README.md"
   ],
-  "scripts": {
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint:dead": "knip --no-gitignore"
-  },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "0.79.4",
     "@earendil-works/pi-tui": "0.79.4",
@@ -52,5 +45,12 @@
   },
   "overrides": {
     "brace-expansion": "5.0.6"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint:dead": "knip --no-gitignore"
   }
-}
+}

package/src/index.ts

@@ -1,7 +1,5 @@
 export { parseSessionFromBuffer, loadSessionHeader, loadSessionHeaders, scanAllSessionDirs, scanSessionDir, sortByModified, sortByModifiedDesc, filterByCwd, matchQuery, canonicalizePath } from "./scanner.js";
 export type { SessionHeader, SessionFileMeta } from "./scanner.js";
-export { createInitialState, setScope, setSessions, setFilter, moveSelection } from "./picker-state.js";
-export type { PickerScope, PickerState } from "./picker-state.js";
 export {
   parseSearchQuery,
   matchSession,
@@ -18,6 +16,7 @@ export type {
   MatchResult,
   SortMode,
   NameFilter,
+  PickerScope,
   SessionTreeNode,
   FlatSessionNode,
 } from "./search.js";

package/src/scanner.ts

@@ -23,6 +23,25 @@ export interface SessionFileMeta {
 
 const PARTIAL_READ_SIZE = 16_384;
 
+// Size of the trailing read used to recover session_info entries (session
+// names set via /rename or programmatically). These are appended at EOF by
+// SessionManager.appendSessionInfo, so for any session larger than the head
+// window the latest name lands past the partial read and would be invisible —
+// showing "(no messages)" for renamed large sessions. The tail read recovers
+// it, matching pi-core's getSessionName() semantics (latest session_info wins,
+// including explicit name clears).
+const TAIL_READ_SIZE = 8_192;
+
+// Result of scanning a file tail for session_info entries.
+//   found: false  → no session_info seen in the tail; fall back to the head's name.
+//   found: true   → a session_info was seen (later in file order than anything
+//                   in the head, since the tail starts past the head window);
+//                   name is undefined if that entry explicitly cleared the name.
+export interface TailSessionInfo {
+  found: boolean;
+  name?: string;
+}
+
 function extractTextFromContent(
   content: string | Array<{ type: string; text?: string }>,
 ): string {
@@ -39,6 +58,7 @@ export function parseSessionFromBuffer(
   filePath: string,
   mtimeMs: number,
   partial = false,
+  tailInfo?: TailSessionInfo,
 ): SessionHeader | null {
   const decoder = new StringDecoder("utf8");
   const text = decoder.write(buf.subarray(0, bytesRead)) + decoder.end();
@@ -46,7 +66,7 @@ export function parseSessionFromBuffer(
 
   let header: { id: string; timestamp: string; cwd?: string; parentSession?: string } | null = null;
   let firstUserMsg = "";
-  let name = "";
+  let name: string | undefined;
   let msgCount = 0;
   let lastActivityTime: number | undefined;
 
@@ -60,8 +80,7 @@ export function parseSessionFromBuffer(
         continue;
       }
       if (entry.type === "session_info") {
-        const n = entry.name?.trim();
-        if (n) name = n;
+        name = entry.name?.trim() || undefined;
       }
       if (entry.type === "message") {
         msgCount++;
@@ -118,6 +137,11 @@ export function parseSessionFromBuffer(
           : new Date(mtimeMs);
   }
 
+  // The tail scan (if any) sees session_info entries at EOF, which are later
+  // in file order than anything in the head window — so it wins over the
+  // head-derived name, including explicit clears (empty name → undefined).
+  const finalName = tailInfo?.found ? tailInfo.name : name;
+
   return {
     path: filePath,
     id: header.id,
@@ -126,11 +150,41 @@ export function parseSessionFromBuffer(
     created: new Date(header.timestamp),
     modified,
     messageCount: msgCount,
-    firstMessage: firstUserMsg || "",
-    name: name || undefined,
+    firstMessage: firstUserMsg || "(no messages)",
+    name: finalName,
   };
 }
 
+// Scan a tail chunk (read from near EOF) for session_info entries and return
+// the latest name, matching pi-core's getSessionName() semantics: the latest
+// session_info in file order wins, including explicit clears (empty name).
+// The tail's first line may be a partial line cut off at the read-start
+// boundary — it is skipped naturally when JSON.parse fails.
+export function scanTailForSessionInfo(
+  buf: Buffer,
+  bytesRead: number,
+): TailSessionInfo {
+  const decoder = new StringDecoder("utf8");
+  const text = decoder.write(buf.subarray(0, bytesRead)) + decoder.end();
+  const lines = text.split("\n");
+  let found = false;
+  let name: string | undefined;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const entry = JSON.parse(trimmed);
+      if (entry.type === "session_info") {
+        found = true;
+        name = entry.name?.trim() || undefined;
+      }
+    } catch {
+      // Partial line at tail boundary — skip
+    }
+  }
+  return { found, name };
+}
+
 const HOME = homedir();
 const DEFAULT_SESSIONS_DIR = join(HOME, ".pi", "agent", "sessions");
 
@@ -222,7 +276,35 @@ export function loadSessionHeader(
     const readSize = Math.min(PARTIAL_READ_SIZE, meta.size);
     const buf = Buffer.alloc(readSize);
     const bytesRead = readSync(fd, buf, 0, readSize, 0);
-    return parseSessionFromBuffer(buf, bytesRead, meta.path, meta.mtimeMs, meta.size > PARTIAL_READ_SIZE);
+
+    // Recover the latest session name from EOF. session_info entries are
+    // appended at EOF by SessionManager.appendSessionInfo, so for any session
+    // larger than the head window they live past the 16KB read and would be
+    // invisible. The tail read covers `meta.size - PARTIAL_READ_SIZE` bytes
+    // (capped at TAIL_READ_SIZE), starting past the head window so it never
+    // overlaps. A failure here must not lose the whole header — fall back to
+    // head-only parsing by leaving tailInfo undefined.
+    let tailInfo: TailSessionInfo | undefined;
+    if (meta.size > PARTIAL_READ_SIZE) {
+      try {
+        const tailReadSize = Math.min(TAIL_READ_SIZE, meta.size - PARTIAL_READ_SIZE);
+        const tailBuf = Buffer.alloc(tailReadSize);
+        const tailOffset = meta.size - tailReadSize;
+        const tailBytesRead = readSync(fd, tailBuf, 0, tailReadSize, tailOffset);
+        tailInfo = scanTailForSessionInfo(tailBuf, tailBytesRead);
+      } catch {
+        // Tail read failed — fall back to head-only parse
+      }
+    }
+
+    return parseSessionFromBuffer(
+      buf,
+      bytesRead,
+      meta.path,
+      meta.mtimeMs,
+      meta.size > PARTIAL_READ_SIZE,
+      tailInfo,
+    );
   } catch {
     return null;
   } finally {

package/src/search.ts

@@ -12,6 +12,8 @@
 import { fuzzyMatch } from "@earendil-works/pi-tui";
 import { canonicalizePath, type SessionHeader } from "./scanner.js";
 
+export type PickerScope = "current" | "all";
+
 // Search query parsing
 
 export type SearchTokenKind = "fuzzy" | "phrase";

package/src/picker-state.ts

@@ -1,95 +0,0 @@
-import type { SessionHeader } from "./scanner.js";
-
-export type PickerScope = "current" | "all";
-
-export interface PickerState {
-  scope: PickerScope;
-  sessions: SessionHeader[];
-  filteredSessions: SessionHeader[];
-  selectedIndex: number;
-  filterQuery: string;
-  loadingDone: boolean;
-  loadedCount: number;
-  totalCount: number;
-}
-
-export function createInitialState(
-  initialSessions: SessionHeader[],
-  totalCount: number,
-  loadingDone: boolean,
-): PickerState {
-  return {
-    scope: "current",
-    sessions: initialSessions,
-    filteredSessions: initialSessions,
-    selectedIndex: 0,
-    filterQuery: "",
-    loadingDone,
-    loadedCount: initialSessions.length,
-    totalCount,
-  };
-}
-
-export function setScope(state: PickerState, scope: PickerScope): PickerState {
-  return {
-    ...state,
-    scope,
-    filterQuery: "",
-    selectedIndex: 0,
-  };
-}
-
-export function setSessions(
-  state: PickerState,
-  sessions: SessionHeader[],
-  loadingDone: boolean,
-): PickerState {
-  const filtered = applyFilter(sessions, state.filterQuery);
-  return {
-    ...state,
-    sessions,
-    filteredSessions: filtered,
-    loadingDone,
-    loadedCount: sessions.length,
-    selectedIndex: Math.min(state.selectedIndex, Math.max(0, filtered.length - 1)),
-  };
-}
-
-export function setFilter(
-  state: PickerState,
-  query: string,
-): PickerState {
-  const filtered = applyFilter(state.sessions, query);
-  return {
-    ...state,
-    filterQuery: query,
-    filteredSessions: filtered,
-    selectedIndex: Math.min(state.selectedIndex, Math.max(0, filtered.length - 1)),
-  };
-}
-
-export function moveSelection(
-  state: PickerState,
-  delta: number,
-): PickerState {
-  const max = Math.max(0, state.filteredSessions.length - 1);
-  return {
-    ...state,
-    selectedIndex: Math.max(0, Math.min(max, state.selectedIndex + delta)),
-  };
-}
-
-function applyFilter(
-  sessions: SessionHeader[],
-  query: string,
-): SessionHeader[] {
-  if (!query) return sessions;
-  const q = query.toLowerCase();
-  return sessions.filter(
-    (s) =>
-      s.firstMessage.toLowerCase().includes(q) ||
-      (s.name?.toLowerCase().includes(q) ?? false) ||
-      s.cwd.toLowerCase().includes(q) ||
-      s.id.toLowerCase().includes(q),
-  );
-}