pi-sessions 0.3.2 → 0.4.0

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

@@ -1,5 +1,4 @@
 import { existsSync, mkdirSync } from "node:fs";
-import path from "node:path";
 import { parseTypeBoxValue } from "../typebox.js";
 import {
   INDEX_SCHEMA_VERSION,
@@ -17,13 +16,6 @@ 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 },
@@ -55,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
@@ -97,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,

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

@@ -3,6 +3,8 @@ 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 {
@@ -16,13 +18,17 @@ export interface SqliteStatement {
   run(...params: SqliteBindValue[]): SqliteRunResult;
 }
 
+export interface SqliteTransaction<Args extends unknown[], Result> {
+  (...args: Args): Result;
+  immediate(...args: Args): Result;
+}
+
 export interface SqliteDatabase {
-  readonly inTransaction: boolean;
   prepare(sql: string): SqliteStatement;
   exec(sql: string): void;
   transaction<Args extends unknown[], Result>(
     fn: (...args: Args) => Result,
-  ): (...args: Args) => Result;
+  ): SqliteTransaction<Args, Result>;
   close(): void;
 }
 
@@ -47,19 +53,46 @@ export function openSqlite(
   const Database = loadDatabaseConstructor();
   const db = isBun
     ? new Database(dbPath, { create: options.create, readwrite: true })
-    : new Database(
-        dbPath,
-        options.timeoutMs === undefined
-          ? { fileMustExist: !options.create }
-          : { fileMustExist: !options.create, timeout: options.timeoutMs },
-      );
+    : 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");
-  if (isBun && options.timeoutMs !== undefined) {
-    db.exec(`PRAGMA busy_timeout = ${options.timeoutMs}`);
-  }
 
-  return db;
+  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.2",
+  "version": "0.4.0",
   "type": "module",
   "description": "Pi session search, ask, handoff, auto-titling, and indexing tools",
   "license": "MIT",