pi-hashline-edit-pro 0.17.13 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.17.13",
+  "version": "0.18.0",
   "type": "module",
   "description": "Strict hashline read/replace tool for pi-coding-agent with hash-anchored edits (3-char, 18-bit, perfect hashing)",
   "main": "index.ts",
@@ -24,8 +24,7 @@
     "src",
     "prompts",
     "README.md",
-    "LICENSE",
-    "scripts"
+    "LICENSE"
   ],
   "pi": {
     "extensions": [
@@ -33,10 +32,8 @@
     ]
   },
   "dependencies": {
-    "better-sqlite3": "^13.0.1",
     "diff": "^8.0.2",
     "file-type": "^21.3.0",
-    "sql.js": "1.11",
     "xxhash-wasm": "^1.1.0"
   },
   "peerDependencies": {
@@ -47,23 +44,18 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "eslint 'src/**/*.ts' 'index.ts'",
-    "typecheck": "tsc --noEmit",
-    "postinstall": "node scripts/ensure-better-sqlite3.cjs",
-    "preuninstall": "node scripts/cleanup-better-sqlite3.cjs"
+    "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.74.0",
     "@eslint/js": "^10.0.1",
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/node": "^22.0.0",
-    "@types/sql.js": "^1.4.11",
+    "@types/node": "^24.0.0",
     "eslint": "^10.7.0",
     "typescript": "^5.8.0",
     "typescript-eslint": "^8.65.0",
     "vitest": "^4.1.8"
   },
   "allowScripts": {
-    "better-sqlite3@13.0.1": true,
     "@google/genai@1.52.0": true,
     "koffi@2.16.2": true,
     "protobufjs@7.6.4": true

package/src/hash-store.ts

@@ -1,10 +1,10 @@
-import { readFileSync, writeFileSync, existsSync } from "fs";
+import { existsSync } from "fs";
 import { readFile, rename, mkdir, stat } from "fs/promises";
+import { DatabaseSync } from "node:sqlite";
 import { hashStorePath, hashStoreDir, legacyHashStorePath } from "./paths";
 import { errCode } from "./utils";
 import { initHasher, contentChecksum } from "./hashline/hasher";
 import { HASH_STORE_VERSION, HASH_STORE_BUSY_TIMEOUT } from "./constants";
-import initSqlJs from "sql.js";
 
 type SqlParams = (string | number)[];
 
@@ -17,7 +17,7 @@ interface Prepared {
 
 export interface HashStore {
   readonly stmts: Prepared;
-  readonly engine: "better-sqlite3" | "sql.js";
+  readonly engine: "node:sqlite";
 }
 
 interface LegacySnapshot {
@@ -36,38 +36,15 @@ function isValidSnapshot(value: unknown): value is LegacySnapshot {
   return true;
 }
 
+let cachedDb: { path: string; db: DatabaseSync; stmts: Prepared } | null = null;
 
-
-interface BackendHandle {
-  store: HashStore;
-  close: () => void;
-  transact: (fn: () => void) => void;
-  prepare: (sql: string) => { run: (...params: unknown[]) => void; free: () => void };
-}
-
-let cachedHandle: { path: string; handle: BackendHandle } | null = null;
-
-
-
-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 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}`);
+function openDb(storePath: string): { db: DatabaseSync; stmts: Prepared } {
+  const db = new DatabaseSync(storePath, {
+    timeout: HASH_STORE_BUSY_TIMEOUT,
+    defensive: false,
+  } as any);
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA synchronous = NORMAL");
   db.exec(
     "CREATE TABLE IF NOT EXISTS snapshots (" +
       "path TEXT PRIMARY KEY, " +
@@ -93,169 +70,54 @@ function openBetterDb(storePath: string): BackendHandle {
     upsert: (...params) => { upsertStmt.run(...params); },
   };
 
-  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: () => {} };
-    },
-  };
-}
-
-
-
-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 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 (" +
-      "path TEXT PRIMARY KEY, " +
-      "checksum TEXT NOT NULL, " +
-      "line_count INTEGER NOT NULL, " +
-      "hashes TEXT NOT NULL, " +
-      "updated_at INTEGER NOT NULL" +
-    ")"
-  );
-
-  function save() {
-    writeFileSync(storePath, Buffer.from(db.export()));
-  }
-
-  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(); },
-      };
-    },
-  };
+  return { db, stmts };
 }
 
-
-
-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;
-}
-
-
-
 export async function loadHashStore(): Promise<HashStore> {
   const storePath = hashStorePath();
-  if (cachedHandle && cachedHandle.path === storePath) {
-    return cachedHandle.handle.store;
+  if (cachedDb && cachedDb.path === storePath && cachedDb.db.isOpen) {
+    return { stmts: cachedDb.stmts, engine: "node:sqlite" };
   }
 
   shutdownHashStore();
 
   await initHasher();
   await mkdir(hashStoreDir(), { recursive: true });
-  await initBackend();
 
   const existed = existsSync(storePath);
-
-  let handle: BackendHandle;
-  if (BetterDatabase) {
-    try {
-      handle = openBetterDb(storePath);
-    } catch {
-      const debug = process.env.PI_HASHLINE_DEBUG === "1" || process.env.PI_HASHLINE_DEBUG === "true";
-      if (debug) {
-        console.error('better-sqlite3 native binding failed, falling back to sql.js');
-      }
-      BetterDatabase = null;
-      await ensureSqlJs();
-      handle = openSqlJsDb(storePath);
-    }
-  } else {
-    await ensureSqlJs();
-    handle = openSqlJsDb(storePath);
-  }
+  const { db, stmts } = openDb(storePath);
 
   if (!existed) {
-    await migrateLegacy(handle);
+    await migrateLegacy(db);
   }
 
-  cachedHandle = { path: storePath, handle };
-  return handle.store;
+  cachedDb = { path: storePath, db, stmts };
+  return { stmts, engine: "node:sqlite" };
 }
 
 export function shutdownHashStore(): void {
-  if (cachedHandle) {
-    cachedHandle.handle.close();
-    cachedHandle = null;
+  if (cachedDb) {
+    cachedDb.db.close();
+    cachedDb = null;
   }
 }
 
-
-
-function withStore(store: HashStore, fn: () => void): void {
-  const h = cachedHandle?.handle;
-  if (h && h.store === store) {
-    h.transact(fn);
+function withStore(fn: () => void): void {
+  if (cachedDb) {
+    cachedDb.db.exec("BEGIN IMMEDIATE");
+    try {
+      fn();
+      cachedDb.db.exec("COMMIT");
+    } catch (e) {
+      cachedDb.db.exec("ROLLBACK");
+      throw e;
+    }
   } else {
     fn();
   }
 }
 
-async function migrateLegacy(handle: BackendHandle): Promise<void> {
+async function migrateLegacy(db: DatabaseSync): Promise<void> {
   const legacyPath = legacyHashStorePath();
   let content: string;
   try {
@@ -290,13 +152,17 @@ async function migrateLegacy(handle: BackendHandle): Promise<void> {
   }
 
   if (rows.length > 0) {
-    handle.transact(() => {
-      const stmt = handle.prepare(
+    db.exec("BEGIN IMMEDIATE");
+    try {
+      const stmt = db.prepare(
         "INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?)"
       );
       for (const row of rows) stmt.run(...row);
-      stmt.free();
-    });
+      db.exec("COMMIT");
+    } catch (e) {
+      db.exec("ROLLBACK");
+      throw e;
+    }
   }
 
   try {
@@ -306,8 +172,6 @@ async function migrateLegacy(handle: BackendHandle): Promise<void> {
   }
 }
 
-
-
 export function getSnapshot(
   store: HashStore,
   path: string,
@@ -327,13 +191,13 @@ export function upsertSnapshot(
   hashes: string[],
 ): void {
   const hashesJson = JSON.stringify(hashes);
-  withStore(store, () => {
+  withStore(() => {
     store.stmts.upsert(path, checksum, lineCount, hashesJson, Date.now());
   });
 }
 
 export function deleteSnapshot(store: HashStore, path: string): void {
-  withStore(store, () => {
+  withStore(() => {
     store.stmts.deleteOne(path);
   });
 }
@@ -349,7 +213,7 @@ export async function pruneMissing(store: HashStore): Promise<void> {
     }
   }
   if (missing.length === 0) return;
-  withStore(store, () => {
+  withStore(() => {
     for (const path of missing) store.stmts.deleteOne(path);
   });
 }

package/scripts/cleanup-better-sqlite3.cjs

@@ -1,21 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-
-function cleanNodeModules(nm) {
-  if (!fs.existsSync(nm)) return;
-  const entries = fs.readdirSync(nm, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name.startsWith(".better-sqlite3-")) {
-      const full = path.join(nm, entry.name);
-      try {
-        fs.rmSync(full, { recursive: true, force: true });
-        console.error("Cleaned up stale better-sqlite3 build artifact:", entry.name);
-      } catch {
-      }
-    }
-  }
-}
-
-const pkgDir = path.resolve(__dirname, "..");
-cleanNodeModules(path.resolve(pkgDir, "node_modules"));
-cleanNodeModules(path.resolve(pkgDir, "..", "node_modules"));

package/scripts/ensure-better-sqlite3.cjs

@@ -1,60 +0,0 @@
-const { execSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-
-const root = path.resolve(__dirname, "..");
-const bsqlDir = path.join(root, "node_modules", "better-sqlite3");
-
-function removeStaleArtifacts() {
-  for (const dir of [root, bsqlDir]) {
-    if (!fs.existsSync(dir)) continue;
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.name.startsWith(".better-sqlite3-")) {
-        const full = path.join(dir, entry.name);
-        try {
-          fs.rmSync(full, { recursive: true, force: true });
-          console.error("Removed stale artifact:", entry.name);
-        } catch {
-        }
-      }
-    }
-  }
-  const buildDir = path.join(bsqlDir, "build");
-  if (fs.existsSync(buildDir)) {
-    fs.rmSync(buildDir, { recursive: true, force: true });
-  }
-}
-
-try {
-  require(bsqlDir);
-  process.exit(0);
-} catch (e) {
-  const msg = e && typeof e.message === "string" ? e.message : String(e);
-  if (/GLIBC|Cannot find module|dlo|not found/i.test(msg)) {
-    console.error("better-sqlite3 prebuilt incompatible, rebuilding from source...");
-    removeStaleArtifacts();
-    const prebuildDir = path.join(bsqlDir, "prebuilds");
-    if (fs.existsSync(prebuildDir)) {
-      const platform = process.platform + "-" + process.arch;
-      const prebuilt = path.join(prebuildDir, platform + ".node");
-      if (fs.existsSync(prebuilt)) {
-        fs.unlinkSync(prebuilt);
-        console.error("Removed incompatible prebuilt:", platform + ".node");
-      }
-    }
-
-    try {
-      execSync("npx --yes node-gyp rebuild", {
-        cwd: bsqlDir,
-        stdio: "inherit",
-        timeout: 300000,
-      });
-      console.error("better-sqlite3 rebuilt successfully from source.");
-    } catch (rebuildErr) {
-      console.error("better-sqlite3 rebuild failed:", rebuildErr.message);
-      console.error("Will fall back to sql.js at runtime.");
-      process.exit(0);
-    }
-  }
-}