pi-hashline-edit-pro 0.17.1 → 0.17.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.17.1",
+  "version": "0.17.2",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 18-bit, perfect hashing)",
   "main": "index.ts",
   "repository": {
@@ -43,7 +43,8 @@
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "postinstall": "node scripts/ensure-better-sqlite3.js"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.74.0",

package/src/constants.ts

@@ -5,6 +5,7 @@ export const MAX_BYTES = 100 * 1024 * 1024;
 export const MAX_HASH_LINES = 1_000_000;
 export const MAX_HASH_RETRIES = 262_144;
 
+export const HASH_STORE_BUSY_TIMEOUT = 1000;
 export const HASH_STORE_VERSION = 2;
 export const CONTENT_LINES_NOT_STRING_MSG =
   `[E_BAD_SHAPE] "content_lines" must be a native JSON array of strings, not a JSON string.`

package/src/hash-store.ts

@@ -1,23 +1,23 @@
-import initSqlJs, { type Database as DatabaseType, type SqlValue } from "sql.js";
 import { readFileSync, writeFileSync, existsSync } from "fs";
 import { readFile, rename, mkdir, stat } from "fs/promises";
 import { hashStorePath, hashStoreDir, legacyHashStorePath } from "./paths";
 import { errCode } from "./utils";
 import { initHasher, contentChecksum } from "./hashline/hasher";
-import { HASH_STORE_VERSION } from "./constants";
+import { HASH_STORE_VERSION, HASH_STORE_BUSY_TIMEOUT } from "./constants";
+import initSqlJs from "sql.js";
 
-type SqlParams = SqlValue[];
+type SqlParams = (string | number)[];
 
 interface Prepared {
-  get: (...params: SqlParams) => Record<string, SqlValue> | undefined;
-  allPaths: (...params: SqlParams) => Record<string, SqlValue>[];
+  get: (...params: SqlParams) => Record<string, unknown> | undefined;
+  allPaths: (...params: SqlParams) => Record<string, unknown>[];
   deleteOne: (...params: SqlParams) => void;
   upsert: (...params: SqlParams) => void;
 }
 
 export interface HashStore {
-  readonly db: DatabaseType;
   readonly stmts: Prepared;
+  readonly engine: "better-sqlite3" | "sql.js";
 }
 
 interface LegacySnapshot {
@@ -36,60 +36,88 @@ function isValidSnapshot(value: unknown): value is LegacySnapshot {
   return true;
 }
 
-let cachedStore: { path: string; store: HashStore; filePath: string } | null = null;
+// ── Backend handle abstraction ──────────────────────────────────────
 
-let sqlJsInit: Promise<void> | null = null;
-let DatabaseCtor!: new (data?: ArrayLike<number> | null) => DatabaseType;
+interface BackendHandle {
+  store: HashStore;
+  close: () => void;
+  transact: (fn: () => void) => void;
+  prepare: (sql: string) => { run: (...params: unknown[]) => void; free: () => void };
+}
 
-function makeGetter(db: DatabaseType, sql: string) {
-  return (...params: SqlParams) => {
-    const stmt = db.prepare(sql);
-    if (params.length > 0) stmt.bind(params);
-    let result: Record<string, SqlValue> | undefined;
-    if (stmt.step()) {
-      result = stmt.getAsObject() as Record<string, SqlValue>;
-    }
-    stmt.free();
-    return result;
-  };
+let cachedHandle: { path: string; handle: BackendHandle } | null = null;
+
+// ── better-sqlite3 backend ──────────────────────────────────────────
+
+let BetterDatabase: any = undefined;
+
+async function tryLoadBetter(): Promise<boolean> {
+  if (BetterDatabase !== undefined) return BetterDatabase !== null;
+  try {
+    const mod = await import("better-sqlite3");
+    BetterDatabase = mod.default || mod;
+    return true;
+  } catch {
+    BetterDatabase = null;
+    return false;
+  }
 }
 
-function makeAll(db: DatabaseType, sql: string) {
-  return (...params: SqlParams) => {
-    const stmt = db.prepare(sql);
-    if (params.length > 0) stmt.bind(params);
-    const results: Record<string, SqlValue>[] = [];
-    while (stmt.step()) {
-      results.push(stmt.getAsObject() as Record<string, SqlValue>);
-    }
-    stmt.free();
-    return results;
+function openBetterDb(storePath: string): BackendHandle {
+  const db = new BetterDatabase(storePath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("synchronous = NORMAL");
+  db.pragma(`busy_timeout = ${HASH_STORE_BUSY_TIMEOUT}`);
+  db.exec(
+    "CREATE TABLE IF NOT EXISTS snapshots (" +
+      "path TEXT PRIMARY KEY, " +
+      "checksum TEXT NOT NULL, " +
+      "line_count INTEGER NOT NULL, " +
+      "hashes TEXT NOT NULL, " +
+      "updated_at INTEGER NOT NULL" +
+    ")"
+  );
+
+  const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
+  const allStmt = db.prepare("SELECT path FROM snapshots");
+  const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
+  const upsertStmt = db.prepare(
+    "INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) " +
+    "ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, updated_at = excluded.updated_at"
+  );
+
+  const stmts: Prepared = {
+    get: (...params) => getStmt.get(...params) as Record<string, unknown> | undefined,
+    allPaths: (...params) => allStmt.all(...params) as Record<string, unknown>[],
+    deleteOne: (...params) => { delStmt.run(...params); },
+    upsert: (...params) => { upsertStmt.run(...params); },
   };
-}
 
-function makeRun(db: DatabaseType, sql: string) {
-  return (...params: SqlParams) => {
-    if (params.length > 0) {
-      db.run(sql, params);
-    } else {
-      db.run(sql);
-    }
+  return {
+    store: { stmts, engine: "better-sqlite3" },
+    close: () => { db.close(); },
+    transact: (fn) => { db.transaction(fn).immediate(); },
+    prepare: (sql) => {
+      const stmt = db.prepare(sql);
+      return { run: (...params) => stmt.run(...params), free: () => {} };
+    },
   };
 }
 
-function saveDb(storePath: string, db: DatabaseType): void {
-  const data = db.export();
-  writeFileSync(storePath, Buffer.from(data));
+// ── sql.js backend ──────────────────────────────────────────────────
+
+let SqlJsDatabase: any = null;
+let sqlJsPromise: Promise<void> | null = null;
+
+async function ensureSqlJs(): Promise<void> {
+  if (sqlJsPromise) return sqlJsPromise;
+  sqlJsPromise = initSqlJs().then((SQL) => { SqlJsDatabase = SQL.Database; });
+  return sqlJsPromise;
 }
 
-function openDatabase(storePath: string): HashStore {
-  let db: DatabaseType;
-  if (existsSync(storePath)) {
-    const fileBuffer = readFileSync(storePath);
-    db = new DatabaseCtor(new Uint8Array(fileBuffer));
-  } else {
-    db = new DatabaseCtor();
-  }
+function openSqlJsDb(storePath: string): BackendHandle {
+  const data = existsSync(storePath) ? new Uint8Array(readFileSync(storePath)) : undefined;
+  const db = new SqlJsDatabase(data);
 
   db.run(
     "CREATE TABLE IF NOT EXISTS snapshots (" +
@@ -100,33 +128,124 @@ function openDatabase(storePath: string): HashStore {
       "updated_at INTEGER NOT NULL" +
     ")"
   );
-  saveDb(storePath, db);
 
-  const get = makeGetter(db, "SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
-  const allPaths = makeAll(db, "SELECT path FROM snapshots");
-  const deleteOne = makeRun(db, "DELETE FROM snapshots WHERE path = ?");
-  const upsert = makeRun(
-    db,
-    "INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) " +
-    "ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, updated_at = excluded.updated_at"
-  );
+  function save() {
+    writeFileSync(storePath, Buffer.from(db.export()));
+  }
 
-  const stmts: Prepared = { get, allPaths, deleteOne, upsert };
-  return { db, stmts };
+  save();
+
+  const stmts: Prepared = {
+    get: (...params) => {
+      const stmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
+      stmt.bind(params);
+      let result: Record<string, unknown> | undefined;
+      if (stmt.step()) result = stmt.getAsObject() as Record<string, unknown>;
+      stmt.free();
+      return result;
+    },
+    allPaths: (...params) => {
+      const stmt = db.prepare("SELECT path FROM snapshots");
+      if (params.length > 0) stmt.bind(params);
+      const results: Record<string, unknown>[] = [];
+      while (stmt.step()) results.push(stmt.getAsObject() as Record<string, unknown>);
+      stmt.free();
+      return results;
+    },
+    deleteOne: (...params) => {
+      if (params.length > 0) db.run("DELETE FROM snapshots WHERE path = ?", params);
+      else db.run("DELETE FROM snapshots WHERE path = ?");
+    },
+    upsert: (...params) => {
+      db.run(
+        "INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) " +
+        "ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, updated_at = excluded.updated_at",
+        params
+      );
+    },
+  };
+
+  return {
+    store: { stmts, engine: "sql.js" },
+    close: () => { db.close(); },
+    transact: (fn) => {
+      db.run("BEGIN IMMEDIATE");
+      try { fn(); db.run("COMMIT"); save(); } catch (e) { db.run("ROLLBACK"); throw e; }
+    },
+    prepare: (sql) => {
+      const stmt = db.prepare(sql);
+      return {
+        run: (...params) => { stmt.bind(params); stmt.step(); stmt.reset(); },
+        free: () => { stmt.free(); },
+      };
+    },
+  };
 }
 
-function withTransaction(db: DatabaseType, fn: () => void): void {
-  db.run("BEGIN IMMEDIATE");
-  try {
+// ── Init ────────────────────────────────────────────────────────────
+
+let backendPromise: Promise<void> | null = null;
+
+async function initBackend(): Promise<void> {
+  if (backendPromise) return backendPromise;
+  backendPromise = (async () => {
+    const hasBetter = await tryLoadBetter();
+    if (!hasBetter) await ensureSqlJs();
+  })();
+  return backendPromise;
+}
+
+// ── Public API ──────────────────────────────────────────────────────
+
+export async function loadHashStore(): Promise<HashStore> {
+  const storePath = hashStorePath();
+  if (cachedHandle && cachedHandle.path === storePath) {
+    return cachedHandle.handle.store;
+  }
+
+  shutdownHashStore();
+
+  await initHasher();
+  await mkdir(hashStoreDir(), { recursive: true });
+  await initBackend();
+
+  const existed = existsSync(storePath);
+
+  let handle: BackendHandle;
+  if (BetterDatabase) {
+    handle = openBetterDb(storePath);
+  } else {
+    await ensureSqlJs();
+    handle = openSqlJsDb(storePath);
+  }
+
+  if (!existed) {
+    await migrateLegacy(handle);
+  }
+
+  cachedHandle = { path: storePath, handle };
+  return handle.store;
+}
+
+export function shutdownHashStore(): void {
+  if (cachedHandle) {
+    cachedHandle.handle.close();
+    cachedHandle = null;
+  }
+}
+
+// ── Internal helpers ────────────────────────────────────────────────
+
+function withStore(store: HashStore, fn: () => void): void {
+  const h = cachedHandle?.handle;
+  if (h && h.store === store) {
+    h.transact(fn);
+  } else {
     fn();
-    db.run("COMMIT");
-  } catch (e) {
-    db.run("ROLLBACK");
-    throw e;
   }
 }
 
-async function migrateLegacy(store: HashStore, storePath: string): Promise<void> {
+async function migrateLegacy(handle: BackendHandle): Promise<void> {
   const legacyPath = legacyHashStorePath();
   let content: string;
   try {
@@ -161,16 +280,13 @@ async function migrateLegacy(store: HashStore, storePath: string): Promise<void>
   }
 
   if (rows.length > 0) {
-    withTransaction(store.db, () => {
-      const stmt = store.db.prepare(
+    handle.transact(() => {
+      const stmt = handle.prepare(
         "INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?)"
       );
-      for (const row of rows) {
-        stmt.run(row);
-      }
+      for (const row of rows) stmt.run(...row);
       stmt.free();
     });
-    saveDb(storePath, store.db);
   }
 
   try {
@@ -180,40 +296,7 @@ async function migrateLegacy(store: HashStore, storePath: string): Promise<void>
   }
 }
 
-export async function loadHashStore(): Promise<HashStore> {
-  const storePath = hashStorePath();
-  if (cachedStore && cachedStore.path === storePath) {
-    return cachedStore.store;
-  }
-
-  shutdownHashStore();
-
-  await initHasher();
-  await mkdir(hashStoreDir(), { recursive: true });
-
-  if (!sqlJsInit) {
-    sqlJsInit = initSqlJs().then((SQL) => {
-      DatabaseCtor = SQL.Database;
-    });
-  }
-  await sqlJsInit;
-
-  const existed = existsSync(storePath);
-  const store = openDatabase(storePath);
-  if (!existed) {
-    await migrateLegacy(store, storePath);
-  }
-
-  cachedStore = { path: storePath, store, filePath: storePath };
-  return store;
-}
-
-export function shutdownHashStore(): void {
-  if (cachedStore) {
-    cachedStore.store.db.close();
-    cachedStore = null;
-  }
-}
+// ── Snapshot operations ─────────────────────────────────────────────
 
 export function getSnapshot(
   store: HashStore,
@@ -234,17 +317,15 @@ export function upsertSnapshot(
   hashes: string[],
 ): void {
   const hashesJson = JSON.stringify(hashes);
-  withTransaction(store.db, () => {
+  withStore(store, () => {
     store.stmts.upsert(path, checksum, lineCount, hashesJson, Date.now());
   });
-  if (cachedStore) saveDb(cachedStore.filePath, store.db);
 }
 
 export function deleteSnapshot(store: HashStore, path: string): void {
-  withTransaction(store.db, () => {
+  withStore(store, () => {
     store.stmts.deleteOne(path);
   });
-  if (cachedStore) saveDb(cachedStore.filePath, store.db);
 }
 
 export async function pruneMissing(store: HashStore): Promise<void> {
@@ -258,12 +339,9 @@ export async function pruneMissing(store: HashStore): Promise<void> {
     }
   }
   if (missing.length === 0) return;
-  withTransaction(store.db, () => {
-    for (const path of missing) {
-      store.stmts.deleteOne(path);
-    }
+  withStore(store, () => {
+    for (const path of missing) store.stmts.deleteOne(path);
   });
-  if (cachedStore) saveDb(cachedStore.filePath, store.db);
 }
 
 export { HASH_STORE_VERSION };