pi-hashline-edit-pro 0.17.0 → 0.17.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "0.17.0",
+  "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": {
@@ -31,9 +31,9 @@
     ]
   },
   "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": {
@@ -43,16 +43,14 @@
   "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",
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.0.0",
+    "@types/sql.js": "^1.4.11",
     "typescript": "^5.8.0",
     "vitest": "^4.1.8"
-  },
-  "allowScripts": {
-    "better-sqlite3@13.0.1": true
   }
 }

package/src/constants.ts

@@ -5,9 +5,8 @@ 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_VERSION = 2;
 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.`
   + ` Do not serialize the array (e.g. '["line1", "line2"]') — pass it as a proper JSON array: ["line1", "line2"].`;

package/src/hash-store.ts

@@ -1,191 +1,347 @@
-import Database from "better-sqlite3";
-import type { Database as DatabaseType, Statement } from "better-sqlite3";
-import { existsSync } from "fs";
+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, HASH_STORE_BUSY_TIMEOUT } from "./constants";
+import initSqlJs from "sql.js";
+
+type SqlParams = (string | number)[];
 
 interface Prepared {
-	get: Statement<[string, string, number], { hashes: string }>;
-	allPaths: Statement<[], { path: string }>;
-	deleteOne: Statement<[string]>;
-	upsert: Statement<[string, string, number, string, number]>;
+  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 stmts: Prepared;
+  readonly engine: "better-sqlite3" | "sql.js";
 }
 
 interface LegacySnapshot {
-	content: string;
-	hashes: string[];
+  content: string;
+  hashes: string[];
 }
 
 function isValidSnapshot(value: unknown): value is LegacySnapshot {
-	if (typeof value !== "object" || value === null) return false;
-	const v = value as Record<string, unknown>;
-	if (typeof v.content !== "string") return false;
-	if (!Array.isArray(v.hashes)) return false;
-	for (const h of v.hashes) {
-		if (typeof h !== "string") return false;
-	}
-	return true;
-}
-
-let cachedStore: { path: string; store: HashStore } | null = null;
-
-function openDatabase(storePath: string): HashStore {
-	const db = new Database(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 stmts: Prepared = {
-		get: db.prepare<[string, string, number], { hashes: string }>(
-			"SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?",
-		),
-		allPaths: db.prepare<[], { path: string }>("SELECT path FROM snapshots"),
-		deleteOne: db.prepare<[string]>("DELETE FROM snapshots WHERE path = ?"),
-		upsert: db.prepare<[string, string, number, string, number]>(
-			"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",
-		),
-	};
-	return { db, stmts };
-}
-
-async function migrateLegacy(store: HashStore): Promise<void> {
-	const legacyPath = legacyHashStorePath();
-	let content: string;
-	try {
-		content = await readFile(legacyPath, "utf-8");
-	} catch (error: unknown) {
-		if (errCode(error) === "ENOENT") return;
-		console.error("Failed to read legacy hash store for migration:", error);
-		return;
-	}
-
-	let parsed: { snapshots?: Record<string, unknown> };
-	try {
-		parsed = JSON.parse(content) as typeof parsed;
-	} catch (error) {
-		console.error("Failed to parse legacy hash store, skipping migration:", error);
-		return;
-	}
-
-	const raw = parsed.snapshots;
-	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
-
-	const insert = store.db.prepare(
-		"INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?)",
-	);
-	const rows: [string, string, number, string, number][] = [];
-	for (const [key, value] of Object.entries(raw)) {
-		if (!isValidSnapshot(value)) continue;
-		rows.push([
-			key,
-			contentChecksum(value.content),
-			value.content.split("\n").length,
-			JSON.stringify(value.hashes),
-			Date.now(),
-		]);
-	}
-
-	if (rows.length > 0) {
-		store.db.transaction(() => {
-			for (const row of rows) insert.run(...row);
-		}).immediate();
-	}
-
-	try {
-		await rename(legacyPath, `${legacyPath}.bak`);
-	} catch (error) {
-		console.error("Failed to rename legacy hash store after migration:", error);
-	}
+  if (typeof value !== "object" || value === null) return false;
+  const v = value as Record<string, unknown>;
+  if (typeof v.content !== "string") return false;
+  if (!Array.isArray(v.hashes)) return false;
+  for (const h of v.hashes) {
+    if (typeof h !== "string") return false;
+  }
+  return true;
+}
+
+// ── Backend handle abstraction ──────────────────────────────────────
+
+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;
+
+// ── 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 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); },
+  };
+
+  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: () => {} };
+    },
+  };
+}
+
+// ── 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 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(); },
+      };
+    },
+  };
+}
+
+// ── 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 (cachedStore && cachedStore.path === storePath) {
-		return cachedStore.store;
-	}
+  const storePath = hashStorePath();
+  if (cachedHandle && cachedHandle.path === storePath) {
+    return cachedHandle.handle.store;
+  }
+
+  shutdownHashStore();
+
+  await initHasher();
+  await mkdir(hashStoreDir(), { recursive: true });
+  await initBackend();
 
-	shutdownHashStore();
+  const existed = existsSync(storePath);
 
-	await initHasher();
-	await mkdir(hashStoreDir(), { recursive: true });
+  let handle: BackendHandle;
+  if (BetterDatabase) {
+    handle = openBetterDb(storePath);
+  } else {
+    await ensureSqlJs();
+    handle = openSqlJsDb(storePath);
+  }
 
-	const existed = existsSync(storePath);
-	const store = openDatabase(storePath);
-	if (!existed) {
-		await migrateLegacy(store);
-	}
-	cachedStore = { path: storePath, store };
-	return store;
+  if (!existed) {
+    await migrateLegacy(handle);
+  }
+
+  cachedHandle = { path: storePath, handle };
+  return handle.store;
 }
 
 export function shutdownHashStore(): void {
-	if (cachedStore) {
-		cachedStore.store.db.close();
-		cachedStore = null;
-	}
+  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();
+  }
+}
+
+async function migrateLegacy(handle: BackendHandle): Promise<void> {
+  const legacyPath = legacyHashStorePath();
+  let content: string;
+  try {
+    content = await readFile(legacyPath, "utf-8");
+  } catch (error: unknown) {
+    if (errCode(error) === "ENOENT") return;
+    console.error("Failed to read legacy hash store for migration:", error);
+    return;
+  }
+
+  let parsed: { snapshots?: Record<string, unknown> };
+  try {
+    parsed = JSON.parse(content) as typeof parsed;
+  } catch (error) {
+    console.error("Failed to parse legacy hash store, skipping migration:", error);
+    return;
+  }
+
+  const raw = parsed.snapshots;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+
+  const rows: [string, string, number, string, number][] = [];
+  for (const [key, value] of Object.entries(raw)) {
+    if (!isValidSnapshot(value)) continue;
+    rows.push([
+      key,
+      contentChecksum(value.content),
+      value.content.split("\n").length,
+      JSON.stringify(value.hashes),
+      Date.now(),
+    ]);
+  }
+
+  if (rows.length > 0) {
+    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);
+      stmt.free();
+    });
+  }
+
+  try {
+    await rename(legacyPath, `${legacyPath}.bak`);
+  } catch (error) {
+    console.error("Failed to rename legacy hash store after migration:", error);
+  }
+}
+
+// ── Snapshot operations ─────────────────────────────────────────────
+
 export function getSnapshot(
-	store: HashStore,
-	path: string,
-	content: string,
+  store: HashStore,
+  path: string,
+  content: string,
 ): string[] | undefined {
-	const checksum = contentChecksum(content);
-	const lineCount = content.split("\n").length;
-	const row = store.stmts.get.get(path, checksum, lineCount);
-	return row ? (JSON.parse(row.hashes) as string[]) : undefined;
+  const checksum = contentChecksum(content);
+  const lineCount = content.split("\n").length;
+  const row = store.stmts.get(path, checksum, lineCount);
+  return row ? (JSON.parse(row.hashes as string) as string[]) : undefined;
 }
 
 export function upsertSnapshot(
-	store: HashStore,
-	path: string,
-	checksum: string,
-	lineCount: number,
-	hashes: string[],
+  store: HashStore,
+  path: string,
+  checksum: string,
+  lineCount: number,
+  hashes: string[],
 ): void {
-	const hashesJson = JSON.stringify(hashes);
-	store.db.transaction(() => {
-		store.stmts.upsert.run(path, checksum, lineCount, hashesJson, Date.now());
-	}).immediate();
+  const hashesJson = JSON.stringify(hashes);
+  withStore(store, () => {
+    store.stmts.upsert(path, checksum, lineCount, hashesJson, Date.now());
+  });
 }
 
 export function deleteSnapshot(store: HashStore, path: string): void {
-	store.db.transaction(() => {
-		store.stmts.deleteOne.run(path);
-	}).immediate();
+  withStore(store, () => {
+    store.stmts.deleteOne(path);
+  });
 }
 
 export async function pruneMissing(store: HashStore): Promise<void> {
-	const rows = store.stmts.allPaths.all();
-	const missing: string[] = [];
-	for (const row of rows) {
-		try {
-			await stat(row.path);
-		} catch {
-			missing.push(row.path);
-		}
-	}
-	if (missing.length === 0) return;
-	store.db.transaction(() => {
-		for (const path of missing) store.stmts.deleteOne.run(path);
-	}).immediate();
-}
-
-export { HASH_STORE_VERSION };
+  const rows = store.stmts.allPaths() as { path: string }[];
+  const missing: string[] = [];
+  for (const row of rows) {
+    try {
+      await stat(row.path);
+    } catch {
+      missing.push(row.path);
+    }
+  }
+  if (missing.length === 0) return;
+  withStore(store, () => {
+    for (const path of missing) store.stmts.deleteOne(path);
+  });
+}
+
+export { HASH_STORE_VERSION };