pi-sessions 0.3.1 → 0.4.0

package/extensions/shared/session-index/lineage.ts

@@ -113,7 +113,7 @@ export function getSessionById(
     )
     .get(sessionId);
 
-  if (row === undefined) {
+  if (row === undefined || row === null) {
     return undefined;
   }
 
@@ -140,7 +140,7 @@ export function getSessionByPath(
     )
     .get(sessionPath);
 
-  if (row === undefined) {
+  if (row === undefined || row === null) {
     return undefined;
   }
 
@@ -185,9 +185,39 @@ export function getSiblingSessions(
   return queryRelatedSessions(db, sessionId, ["sibling"]);
 }
 
+interface SessionGraph {
+  nodes: Map<string, SessionGraphNode>;
+  childrenByParent: Map<string, string[]>;
+}
+
 export function rebuildSessionLineageRelations(db: SessionIndexDatabase): void {
   db.prepare(`DELETE FROM session_lineage_relations`).run();
 
+  const graph = buildSessionGraph(db);
+  insertLineageRelationRows(db, graph.nodes.keys(), graph);
+}
+
+// Recomputes lineage for just the connected component(s) containing the seed
+// sessions. Lineage relations only ever link sessions connected through parent
+// edges, so the rest of the table is untouched.
+export function refreshSessionLineageRelationsFor(
+  db: SessionIndexDatabase,
+  seedSessionIds: Array<string | undefined>,
+): void {
+  const graph = buildSessionGraph(db);
+  const component = collectLineageComponent(seedSessionIds, graph);
+  if (component.size === 0) {
+    return;
+  }
+
+  const placeholders = [...component].map(() => "?").join(", ");
+  db.prepare(`DELETE FROM session_lineage_relations WHERE session_id IN (${placeholders})`).run(
+    ...component,
+  );
+  insertLineageRelationRows(db, component, graph);
+}
+
+function buildSessionGraph(db: SessionIndexDatabase): SessionGraph {
   const rows = parseTypeBoxRows(
     SESSION_GRAPH_ROW_SCHEMA,
     db
@@ -229,6 +259,40 @@ export function rebuildSessionLineageRelations(db: SessionIndexDatabase): void {
     childrenByParent.set(node.resolvedParentSessionId, children);
   }
 
+  return { nodes, childrenByParent };
+}
+
+function collectLineageComponent(
+  seedSessionIds: Array<string | undefined>,
+  graph: SessionGraph,
+): Set<string> {
+  const component = new Set<string>();
+  const queue = seedSessionIds.filter(
+    (sessionId): sessionId is string => sessionId !== undefined && graph.nodes.has(sessionId),
+  );
+
+  while (queue.length > 0) {
+    const sessionId = queue.pop();
+    if (!sessionId || component.has(sessionId)) {
+      continue;
+    }
+
+    component.add(sessionId);
+    const parentId = graph.nodes.get(sessionId)?.resolvedParentSessionId;
+    if (parentId) {
+      queue.push(parentId);
+    }
+    queue.push(...(graph.childrenByParent.get(sessionId) ?? []));
+  }
+
+  return component;
+}
+
+function insertLineageRelationRows(
+  db: SessionIndexDatabase,
+  sessionIds: Iterable<string>,
+  graph: SessionGraph,
+): void {
   const insertRelation = db.prepare(
     `
       INSERT INTO session_lineage_relations(session_id, related_session_id, relation, distance)
@@ -236,8 +300,12 @@ export function rebuildSessionLineageRelations(db: SessionIndexDatabase): void {
     `,
   );
 
-  for (const node of nodes.values()) {
-    const relations = collectMaterializedLineageRows(node.sessionId, nodes, childrenByParent);
+  for (const sessionId of sessionIds) {
+    const relations = collectMaterializedLineageRows(
+      sessionId,
+      graph.nodes,
+      graph.childrenByParent,
+    );
     for (const relation of relations.values()) {
       insertRelation.run(
         relation.sessionId,

package/extensions/shared/session-index/schema.ts

@@ -1,6 +1,4 @@
 import { existsSync, mkdirSync } from "node:fs";
-import path from "node:path";
-import Database from "better-sqlite3";
 import { parseTypeBoxValue } from "../typebox.js";
 import {
   INDEX_SCHEMA_VERSION,
@@ -9,6 +7,7 @@ import {
   type SessionIndexDatabase,
   type SessionIndexStatus,
 } from "./common.js";
+import { openSqlite } from "./sqlite.js";
 
 export function ensureIndexDir(dir: string): string {
   if (!existsSync(dir)) {
@@ -17,28 +16,12 @@ export function ensureIndexDir(dir: string): string {
   return dir;
 }
 
-export function createTempIndexPath(finalPath: string): string {
-  const dir = path.dirname(finalPath);
-  const baseName = path.basename(finalPath, path.extname(finalPath));
-  ensureIndexDir(dir);
-  return path.join(dir, `${baseName}.tmp-${process.pid}-${Date.now()}.sqlite`);
-}
-
 export function openIndexDatabase(
   dbPath: string,
   options?: { create?: boolean; timeoutMs?: number },
 ): SessionIndexDatabase {
   const create = options?.create ?? true;
-  const db = new Database(
-    dbPath,
-    options?.timeoutMs === undefined
-      ? { fileMustExist: !create }
-      : { fileMustExist: !create, timeout: options.timeoutMs },
-  );
-  db.pragma("journal_mode = WAL");
-  db.pragma("synchronous = NORMAL");
-  db.pragma("foreign_keys = ON");
-  return db;
+  return openSqlite(dbPath, { create, timeoutMs: options?.timeoutMs });
 }
 
 export function initializeSchema(db: SessionIndexDatabase): void {
@@ -64,6 +47,9 @@ export function initializeSchema(db: SessionIndexDatabase): void {
       session_origin TEXT,
       handoff_goal TEXT,
       handoff_next_task TEXT,
+      indexed_file_size INTEGER,
+      indexed_file_mtime_ms INTEGER,
+      indexed_file_anchor TEXT,
       index_version INTEGER NOT NULL,
       indexed_at_ts TEXT NOT NULL,
       index_source TEXT NOT NULL
@@ -106,11 +92,29 @@ export function initializeSchema(db: SessionIndexDatabase): void {
     CREATE INDEX IF NOT EXISTS session_text_chunks_ts_idx ON session_text_chunks(ts DESC);
 
     CREATE VIRTUAL TABLE IF NOT EXISTS session_text_chunks_fts USING fts5(
-      chunk_id UNINDEXED,
-      session_id UNINDEXED,
-      text
+      text,
+      content='session_text_chunks',
+      content_rowid='id'
     );
 
+    CREATE TRIGGER IF NOT EXISTS session_text_chunks_fts_ai
+    AFTER INSERT ON session_text_chunks BEGIN
+      INSERT INTO session_text_chunks_fts(rowid, text) VALUES (new.id, new.text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS session_text_chunks_fts_ad
+    AFTER DELETE ON session_text_chunks BEGIN
+      INSERT INTO session_text_chunks_fts(session_text_chunks_fts, rowid, text)
+      VALUES ('delete', old.id, old.text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS session_text_chunks_fts_au
+    AFTER UPDATE ON session_text_chunks BEGIN
+      INSERT INTO session_text_chunks_fts(session_text_chunks_fts, rowid, text)
+      VALUES ('delete', old.id, old.text);
+      INSERT INTO session_text_chunks_fts(rowid, text) VALUES (new.id, new.text);
+    END;
+
     CREATE TABLE IF NOT EXISTS session_file_touches (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       session_id TEXT NOT NULL,
@@ -148,7 +152,7 @@ export function setMetadata(db: SessionIndexDatabase, key: string, value: string
 
 export function getMetadata(db: SessionIndexDatabase, key: string): string | undefined {
   const row = db.prepare(`SELECT value FROM metadata WHERE key = ?`).get(key);
-  if (row === undefined) {
+  if (row === undefined || row === null) {
     return undefined;
   }
 

package/extensions/shared/session-index/search.ts

@@ -325,12 +325,12 @@ function getTextMatchRows(db: SessionIndexDatabase, filters: SearchFilters): Sea
           s.session_origin as sessionOrigin,
           s.handoff_goal as handoffGoal,
           s.handoff_next_task as handoffNextTask,
-          snippet(session_text_chunks_fts, 2, ?, ?, ?, 12) as snippet,
+          snippet(session_text_chunks_fts, 0, ?, ?, ?, 12) as snippet,
           bm25(session_text_chunks_fts) as rank,
           c.entry_id as entryId,
           c.source_kind as sourceKind
         FROM session_text_chunks_fts
-        JOIN session_text_chunks c ON c.id = CAST(session_text_chunks_fts.chunk_id AS INTEGER)
+        JOIN session_text_chunks c ON c.id = session_text_chunks_fts.rowid
         JOIN sessions s ON s.session_id = c.session_id
         WHERE session_text_chunks_fts MATCH ?
           AND (? IS NULL OR s.modified_ts >= ?)

package/extensions/shared/session-index/sqlite.ts

@@ -0,0 +1,98 @@
+import { createRequire } from "node:module";
+
+const requireModule = createRequire(import.meta.url);
+const isBun = Boolean(process.versions.bun);
+
+const DEFAULT_BUSY_TIMEOUT_MS = 5000;
+
+export type SqliteBindValue = string | number | bigint | null;
+
+export interface SqliteRunResult {
+  changes: number;
+  lastInsertRowid: number | bigint;
+}
+
+export interface SqliteStatement {
+  get(...params: SqliteBindValue[]): unknown;
+  all(...params: SqliteBindValue[]): unknown[];
+  run(...params: SqliteBindValue[]): SqliteRunResult;
+}
+
+export interface SqliteTransaction<Args extends unknown[], Result> {
+  (...args: Args): Result;
+  immediate(...args: Args): Result;
+}
+
+export interface SqliteDatabase {
+  prepare(sql: string): SqliteStatement;
+  exec(sql: string): void;
+  transaction<Args extends unknown[], Result>(
+    fn: (...args: Args) => Result,
+  ): SqliteTransaction<Args, Result>;
+  close(): void;
+}
+
+interface SqliteConstructor {
+  new (path: string, options?: Record<string, unknown>): SqliteDatabase;
+}
+
+// The driver is resolved at runtime so Bun never loads the native better-sqlite3
+// addon (unsupported) and Node never loads the bun:sqlite builtin. The require
+// result is untyped, so the cast to our structural contract is unavoidable here.
+function loadDatabaseConstructor(): SqliteConstructor {
+  if (isBun) {
+    return (requireModule("bun:sqlite") as { Database: SqliteConstructor }).Database;
+  }
+  return requireModule("better-sqlite3") as SqliteConstructor;
+}
+
+export function openSqlite(
+  dbPath: string,
+  options: { create: boolean; timeoutMs?: number | undefined },
+): SqliteDatabase {
+  const Database = loadDatabaseConstructor();
+  const db = isBun
+    ? new Database(dbPath, { create: options.create, readwrite: true })
+    : new Database(dbPath, { fileMustExist: !options.create });
+
+  // busy_timeout must be set before any other statement: the journal_mode
+  // pragma below is the connection's first lock acquisition (and may run WAL
+  // recovery), and immediate transactions rely on this timeout to queue behind
+  // concurrent writers instead of failing.
+  db.exec(`PRAGMA busy_timeout = ${options.timeoutMs ?? DEFAULT_BUSY_TIMEOUT_MS}`);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA synchronous = NORMAL");
+  db.exec("PRAGMA foreign_keys = ON");
+
+  return withStatementCache(db);
+}
+
+// Neither driver memoizes prepare(), and the write paths prepare the same
+// statements once per row. SQLite re-prepares cached statements transparently
+// when the schema changes, so reusing them across DDL is safe.
+function withStatementCache(db: SqliteDatabase): SqliteDatabase {
+  const statements = new Map<string, SqliteStatement>();
+
+  return {
+    prepare(sql) {
+      const cached = statements.get(sql);
+      if (cached) {
+        return cached;
+      }
+
+      const statement = db.prepare(sql);
+      statements.set(sql, statement);
+      return statement;
+    },
+    exec(sql) {
+      db.exec(sql);
+    },
+    transaction(fn) {
+      return db.transaction(fn);
+    },
+    close() {
+      statements.clear();
+      db.close();
+    },
+  };
+}

package/extensions/shared/session-index/store.ts

@@ -1,12 +1,38 @@
+import { type Static, Type } from "typebox";
+import { parseTypeBoxValue } from "../typebox.js";
 import {
   compactSessionId,
   INDEX_SCHEMA_VERSION,
+  NULLABLE_STRING_SCHEMA,
+  parseRepoRoots,
+  SESSION_ORIGIN_SCHEMA,
   type SessionFileTouchRow,
   type SessionIndexDatabase,
   type SessionRow,
   type SessionTextChunkRow,
 } from "./common.js";
 
+const SESSION_ROW_QUERY_SCHEMA = Type.Object({
+  sessionId: Type.String(),
+  sessionPath: Type.String(),
+  sessionName: Type.String(),
+  firstUserPrompt: NULLABLE_STRING_SCHEMA,
+  cwd: Type.String(),
+  repoRootsJson: Type.String(),
+  startedAt: Type.String(),
+  modifiedAt: Type.String(),
+  messageCount: Type.Number(),
+  entryCount: Type.Number(),
+  parentSessionPath: NULLABLE_STRING_SCHEMA,
+  parentSessionId: NULLABLE_STRING_SCHEMA,
+  sessionOrigin: Type.Union([SESSION_ORIGIN_SCHEMA, Type.Null()]),
+  handoffGoal: NULLABLE_STRING_SCHEMA,
+  handoffNextTask: NULLABLE_STRING_SCHEMA,
+  indexedFileSize: Type.Union([Type.Number(), Type.Null()]),
+  indexedFileMtimeMs: Type.Union([Type.Number(), Type.Null()]),
+  indexedFileAnchor: NULLABLE_STRING_SCHEMA,
+});
+
 function sessionRowBindings(row: SessionRow, indexSource: string) {
   return [
     row.sessionId,
@@ -24,6 +50,9 @@ function sessionRowBindings(row: SessionRow, indexSource: string) {
     row.sessionOrigin ?? null,
     row.handoffGoal ?? null,
     row.handoffNextTask ?? null,
+    row.indexedFileSize ?? null,
+    row.indexedFileMtimeMs ?? null,
+    row.indexedFileAnchor ?? null,
     INDEX_SCHEMA_VERSION,
     new Date().toISOString(),
     indexSource,
@@ -42,8 +71,9 @@ export function insertSession(
         created_ts, modified_ts, message_count, entry_count,
         parent_session_path, parent_session_id, session_origin,
         handoff_goal, handoff_next_task,
+        indexed_file_size, indexed_file_mtime_ms, indexed_file_anchor,
         index_version, indexed_at_ts, index_source
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `,
   ).run(...sessionRowBindings(row, indexSource));
   insertSessionIdChunk(db, row);
@@ -61,8 +91,9 @@ export function upsertSession(
         created_ts, modified_ts, message_count, entry_count,
         parent_session_path, parent_session_id, session_origin,
         handoff_goal, handoff_next_task,
+        indexed_file_size, indexed_file_mtime_ms, indexed_file_anchor,
         index_version, indexed_at_ts, index_source
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(session_id) DO UPDATE SET
         session_path = excluded.session_path,
         session_name = excluded.session_name,
@@ -78,6 +109,9 @@ export function upsertSession(
         session_origin = excluded.session_origin,
         handoff_goal = excluded.handoff_goal,
         handoff_next_task = excluded.handoff_next_task,
+        indexed_file_size = excluded.indexed_file_size,
+        indexed_file_mtime_ms = excluded.indexed_file_mtime_ms,
+        indexed_file_anchor = excluded.indexed_file_anchor,
         index_version = excluded.index_version,
         indexed_at_ts = excluded.indexed_at_ts,
         index_source = excluded.index_source
@@ -86,6 +120,72 @@ export function upsertSession(
   syncSessionIdChunk(db, row);
 }
 
+export function getSessionRowByPath(
+  db: SessionIndexDatabase,
+  sessionPath: string,
+): SessionRow | undefined {
+  const row = db
+    .prepare(
+      `
+        SELECT
+          session_id as sessionId,
+          session_path as sessionPath,
+          session_name as sessionName,
+          first_user_prompt as firstUserPrompt,
+          cwd,
+          repo_roots_json as repoRootsJson,
+          created_ts as startedAt,
+          modified_ts as modifiedAt,
+          message_count as messageCount,
+          entry_count as entryCount,
+          parent_session_path as parentSessionPath,
+          parent_session_id as parentSessionId,
+          session_origin as sessionOrigin,
+          handoff_goal as handoffGoal,
+          handoff_next_task as handoffNextTask,
+          indexed_file_size as indexedFileSize,
+          indexed_file_mtime_ms as indexedFileMtimeMs,
+          indexed_file_anchor as indexedFileAnchor
+        FROM sessions
+        WHERE session_path = ?
+        ORDER BY indexed_at_ts DESC
+        LIMIT 1
+      `,
+    )
+    .get(sessionPath);
+
+  if (row === undefined || row === null) {
+    return undefined;
+  }
+
+  return buildSessionRow(
+    parseTypeBoxValue(SESSION_ROW_QUERY_SCHEMA, row, `Invalid session row for path ${sessionPath}`),
+  );
+}
+
+function buildSessionRow(row: Static<typeof SESSION_ROW_QUERY_SCHEMA>): SessionRow {
+  return {
+    sessionId: row.sessionId,
+    sessionPath: row.sessionPath,
+    sessionName: row.sessionName,
+    firstUserPrompt: row.firstUserPrompt ?? undefined,
+    cwd: row.cwd,
+    repoRoots: parseRepoRoots(row.repoRootsJson),
+    startedAt: row.startedAt,
+    modifiedAt: row.modifiedAt,
+    messageCount: row.messageCount,
+    entryCount: row.entryCount,
+    parentSessionPath: row.parentSessionPath ?? undefined,
+    parentSessionId: row.parentSessionId ?? undefined,
+    sessionOrigin: row.sessionOrigin ?? undefined,
+    handoffGoal: row.handoffGoal ?? undefined,
+    handoffNextTask: row.handoffNextTask ?? undefined,
+    indexedFileSize: row.indexedFileSize ?? undefined,
+    indexedFileMtimeMs: row.indexedFileMtimeMs ?? undefined,
+    indexedFileAnchor: row.indexedFileAnchor ?? undefined,
+  };
+}
+
 function insertSessionIdChunk(db: SessionIndexDatabase, row: SessionRow): void {
   insertTextChunk(db, {
     sessionId: row.sessionId,
@@ -97,18 +197,7 @@ function insertSessionIdChunk(db: SessionIndexDatabase, row: SessionRow): void {
 }
 
 function syncSessionIdChunk(db: SessionIndexDatabase, row: SessionRow): void {
-  db.prepare(
-    `DELETE FROM session_text_chunks_fts
-     WHERE chunk_id IN (
-       SELECT CAST(id AS TEXT) FROM session_text_chunks
-       WHERE session_id = ? AND source_kind = 'session_id'
-     )`,
-  ).run(row.sessionId);
-
-  db.prepare(
-    `DELETE FROM session_text_chunks WHERE session_id = ? AND source_kind = 'session_id'`,
-  ).run(row.sessionId);
-
+  clearSessionChunksBySourceKind(db, row.sessionId, "session_id");
   insertSessionIdChunk(db, row);
 }
 
@@ -117,35 +206,38 @@ function buildSessionIdSearchText(sessionId: string): string {
   return compact === sessionId ? sessionId : `${sessionId} ${compact}`;
 }
 
+export function clearSessionChunksBySourceKind(
+  db: SessionIndexDatabase,
+  sessionId: string,
+  sourceKind: string,
+): void {
+  db.prepare(`DELETE FROM session_text_chunks WHERE session_id = ? AND source_kind = ?`).run(
+    sessionId,
+    sourceKind,
+  );
+}
+
 export function clearSessionIndexedData(db: SessionIndexDatabase, sessionId: string): void {
-  db.prepare(`DELETE FROM session_text_chunks_fts WHERE session_id = ?`).run(sessionId);
   db.prepare(`DELETE FROM session_text_chunks WHERE session_id = ?`).run(sessionId);
   db.prepare(`DELETE FROM session_file_touches WHERE session_id = ?`).run(sessionId);
 }
 
 export function insertTextChunk(db: SessionIndexDatabase, row: SessionTextChunkRow): void {
-  const result = db
-    .prepare(
-      `
+  db.prepare(
+    `
       INSERT INTO session_text_chunks(
         session_id, entry_id, entry_type, role, ts, source_kind, text
       ) VALUES (?, ?, ?, ?, ?, ?, ?)
     `,
-    )
-    .run(
-      row.sessionId,
-      row.entryId ?? null,
-      row.entryType,
-      row.role ?? null,
-      row.ts,
-      row.sourceKind,
-      row.text,
-    );
-
-  const chunkId = Number(result.lastInsertRowid);
-  db.prepare(
-    `INSERT INTO session_text_chunks_fts(chunk_id, session_id, text) VALUES (?, ?, ?)`,
-  ).run(chunkId, row.sessionId, row.text);
+  ).run(
+    row.sessionId,
+    row.entryId ?? null,
+    row.entryType,
+    row.role ?? null,
+    row.ts,
+    row.sourceKind,
+    row.text,
+  );
 }
 
 export function insertSessionFileTouch(db: SessionIndexDatabase, row: SessionFileTouchRow): void {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-sessions",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "description": "Pi session search, ask, handoff, auto-titling, and indexing tools",
   "license": "MIT",
@@ -38,7 +38,7 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "check": "biome check . && tsc --noEmit && vitest run",
-    "prepare": "husky"
+    "prepare": "husky || true"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.14",
@@ -46,7 +46,6 @@
     "@earendil-works/pi-ai": "^0.78.1",
     "@earendil-works/pi-coding-agent": "^0.78.1",
     "@earendil-works/pi-tui": "^0.78.1",
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^25.6.2",
     "husky": "^9.1.7",
     "lint-staged": "^17.0.3",
@@ -64,7 +63,7 @@
   "lint-staged": {
     "*.{js,cjs,mjs,jsx,ts,tsx,json,jsonc}": "biome check --write --no-errors-on-unmatched"
   },
-  "dependencies": {
+  "optionalDependencies": {
     "better-sqlite3": "^12.9.0"
   }
 }