pi-fast-resume 1.1.0 → 1.1.2

package/README.md

@@ -68,6 +68,12 @@ Tested with **1,771 sessions, 1.46 GB** of JSONL data on disk.
 
 **With `pi install`** (recommended):
 
+```bash
+pi install npm:pi-fast-resume
+```
+
+Or install from GitHub:
+
 ```bash
 pi install https://github.com/monotykamary/pi-fast-resume
 ```

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,6 +1,6 @@
 {
   "name": "pi-fast-resume",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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",
@@ -37,8 +37,8 @@
     "lint:dead": "knip --no-gitignore"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.75.4",
-    "@earendil-works/pi-tui": "0.75.4",
+    "@earendil-works/pi-coding-agent": "0.79.4",
+    "@earendil-works/pi-tui": "0.79.4",
     "@types/node": "25.9.1",
     "@vitest/coverage-v8": "4.1.7",
     "knip": "6.14.1",

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

@@ -46,7 +46,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 +60,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++;
@@ -126,8 +125,8 @@ export function parseSessionFromBuffer(
     created: new Date(header.timestamp),
     modified,
     messageCount: msgCount,
-    firstMessage: firstUserMsg || "",
-    name: name || undefined,
+    firstMessage: firstUserMsg || "(no messages)",
+    name,
   };
 }
 

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),
-  );
-}