pi-fast-resume 1.0.0

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "pi-fast-resume",
+  "version": "1.0.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",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/monotykamary/pi-fast-resume.git"
+  },
+  "homepage": "https://github.com/monotykamary/pi-fast-resume#readme",
+  "bugs": {
+    "url": "https://github.com/monotykamary/pi-fast-resume/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "extension",
+    "resume",
+    "session",
+    "fast",
+    "picker",
+    "performance"
+  ],
+  "files": [
+    "*.ts",
+    "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.75.4",
+    "@earendil-works/pi-tui": "0.75.4",
+    "@types/node": "25.9.1",
+    "@vitest/coverage-v8": "4.1.7",
+    "knip": "6.14.1",
+    "typescript": "6.0.3",
+    "vitest": "4.1.7"
+  },
+  "pi": {
+    "extensions": [
+      "./fast-resume.ts"
+    ]
+  },
+  "overrides": {
+    "brace-expansion": "5.0.6"
+  }
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+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,
+  hasSessionName,
+  filterAndSortSessions,
+  buildSessionTree,
+  flattenSessionTree,
+  buildTreePrefix,
+} from "./search.js";
+export type {
+  SearchToken,
+  SearchTokenKind,
+  ParsedSearch,
+  MatchResult,
+  SortMode,
+  NameFilter,
+  SessionTreeNode,
+  FlatSessionNode,
+} from "./search.js";

package/src/picker-state.ts

@@ -0,0 +1,95 @@
+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),
+  );
+}

package/src/scanner.ts

@@ -0,0 +1,291 @@
+import { openSync, readSync, closeSync, readdirSync, statSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+import { StringDecoder } from "node:string_decoder";
+
+export interface SessionHeader {
+  path: string;
+  id: string;
+  cwd: string;
+  parentSessionPath?: string;
+  created: Date;
+  modified: Date;
+  messageCount: number;
+  firstMessage: string;
+  name?: string;
+}
+
+export interface SessionFileMeta {
+  path: string;
+  mtimeMs: number;
+  size: number;
+}
+
+const PARTIAL_READ_SIZE = 16_384;
+
+function extractTextFromContent(
+  content: string | Array<{ type: string; text?: string }>,
+): string {
+  if (typeof content === "string") return content;
+  return content
+    .filter((b) => b.type === "text" && b.text)
+    .map((b) => b.text!)
+    .join(" ");
+}
+
+export function parseSessionFromBuffer(
+  buf: Buffer,
+  bytesRead: number,
+  filePath: string,
+  mtimeMs: number,
+  partial = false,
+): SessionHeader | null {
+  const decoder = new StringDecoder("utf8");
+  const text = decoder.write(buf.subarray(0, bytesRead)) + decoder.end();
+  const lines = text.split("\n");
+
+  let header: { id: string; timestamp: string; cwd?: string; parentSession?: string } | null = null;
+  let firstUserMsg = "";
+  let name = "";
+  let msgCount = 0;
+  let lastActivityTime: number | undefined;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const entry = JSON.parse(trimmed);
+      if (entry.type === "session") {
+        header = entry;
+        continue;
+      }
+      if (entry.type === "session_info") {
+        const n = entry.name?.trim();
+        if (n) name = n;
+      }
+      if (entry.type === "message") {
+        msgCount++;
+
+        // Track last activity time from user/assistant messages
+        // Matches pi-core's getMessageActivityTime priority:
+        //   message.timestamp (number) > entry.timestamp (date string)
+        const msg = entry.message;
+        if (msg?.role === "user" || msg?.role === "assistant") {
+          const msgTimestamp = msg.timestamp;
+          if (typeof msgTimestamp === "number" && msgTimestamp > 0) {
+            lastActivityTime = Math.max(lastActivityTime ?? 0, msgTimestamp);
+          } else if (typeof entry.timestamp === "string") {
+            const t = new Date(entry.timestamp).getTime();
+            if (!Number.isNaN(t)) {
+              lastActivityTime = Math.max(lastActivityTime ?? 0, t);
+            }
+          }
+        }
+
+        if (!firstUserMsg && msg?.role === "user") {
+          try {
+            firstUserMsg = extractTextFromContent(msg.content);
+          } catch {
+            // Malformed content, skip
+          }
+        }
+      }
+    } catch {
+      // Incomplete/truncated JSON at buffer boundary, skip
+    }
+  }
+
+  if (!header) return null;
+
+  // Determine modified time:
+  //   - Full read: use pi-core's priority (message timestamp > header timestamp > stat mtime).
+  //     lastActivityTime is accurate since we saw every message.
+  //   - Partial read: stat mtime is more reliable than a partial lastActivityTime,
+  //     which only reflects messages in the first 16KB and may severely underestimate
+  //     the true last activity for large sessions.
+  const headerTime = typeof header.timestamp === "string" ? new Date(header.timestamp).getTime() : NaN;
+  let modified: Date;
+  if (partial) {
+    // Partial read — stat mtime is the most reliable signal
+    modified = new Date(mtimeMs);
+  } else {
+    // Full read — pi-core's priority chain
+    modified =
+      typeof lastActivityTime === "number" && lastActivityTime > 0
+        ? new Date(lastActivityTime)
+        : !Number.isNaN(headerTime)
+          ? new Date(headerTime)
+          : new Date(mtimeMs);
+  }
+
+  return {
+    path: filePath,
+    id: header.id,
+    cwd: header.cwd ?? "",
+    parentSessionPath: header.parentSession || undefined,
+    created: new Date(header.timestamp),
+    modified,
+    messageCount: msgCount,
+    firstMessage: firstUserMsg || "",
+    name: name || undefined,
+  };
+}
+
+const HOME = homedir();
+const DEFAULT_SESSIONS_DIR = join(HOME, ".pi", "agent", "sessions");
+
+/**
+ * Scan ALL session directories under the root (~/.pi/agent/sessions/).
+ * Each subdirectory contains .jsonl files for a specific cwd.
+ */
+export function scanAllSessionDirs(
+  sessionsDir: string = DEFAULT_SESSIONS_DIR,
+): SessionFileMeta[] {
+  const results: SessionFileMeta[] = [];
+  let dirs: string[];
+
+  try {
+    dirs = readdirSync(sessionsDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return results;
+  }
+
+  for (const dir of dirs) {
+    const subDir = join(sessionsDir, dir);
+    let files: string[];
+    try {
+      files = readdirSync(subDir);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".jsonl")) continue;
+      const path = join(subDir, file);
+      try {
+        const stat = statSync(path);
+        results.push({
+          path,
+          mtimeMs: stat.mtimeMs,
+          size: stat.size,
+        });
+      } catch {
+        // File disappeared between readdir and stat, skip
+      }
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Scan only the session directory that corresponds to a given cwd.
+ * Matches pi's built-in SessionManager.list() behavior.
+ */
+export function scanSessionDir(
+  sessionDir: string,
+): SessionFileMeta[] {
+  const results: SessionFileMeta[] = [];
+
+  let files: string[];
+  try {
+    files = readdirSync(sessionDir);
+  } catch {
+    return results;
+  }
+
+  for (const file of files) {
+    if (!file.endsWith(".jsonl")) continue;
+    const path = join(sessionDir, file);
+    try {
+      const stat = statSync(path);
+      results.push({
+        path,
+        mtimeMs: stat.mtimeMs,
+        size: stat.size,
+      });
+    } catch {
+      // File disappeared
+    }
+  }
+
+  return results;
+}
+
+export function loadSessionHeader(
+  meta: SessionFileMeta,
+): SessionHeader | null {
+  let fd: number | undefined;
+  try {
+    fd = openSync(meta.path, "r");
+    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);
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+export function loadSessionHeaders(
+  metas: SessionFileMeta[],
+): SessionHeader[] {
+  const results: SessionHeader[] = [];
+  for (const meta of metas) {
+    const header = loadSessionHeader(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(),
+  );
+}
+
+export function sortByModifiedDesc(metas: SessionFileMeta[]): SessionFileMeta[] {
+  return metas.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+
+/**
+ * Filter sessions by cwd, matching pi's sessionCwdMatches behavior:
+ * resolves both paths before comparing so symlinks don't cause mismatches.
+ */
+export function filterByCwd(
+  sessions: SessionHeader[],
+  cwd: string,
+): SessionHeader[] {
+  const resolvedCwd = resolve(cwd);
+  return sessions.filter((s) => {
+    if (!s.cwd) return false;
+    return resolve(s.cwd) === resolvedCwd;
+  });
+}
+
+/**
+ * Canonicalize a file path by resolving symlinks.
+ * Matches pi-core's canonicalizePath behavior (realpathSync with fallback).
+ */
+export function canonicalizePath(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+
+export function matchQuery(
+  session: SessionHeader,
+  query: string,
+): boolean {
+  const q = query.toLowerCase();
+  if (session.firstMessage.toLowerCase().includes(q)) return true;
+  if (session.name?.toLowerCase().includes(q)) return true;
+  if (session.cwd.toLowerCase().includes(q)) return true;
+  if (session.id.toLowerCase().includes(q)) return true;
+  return false;
+}