@hivehub/rulebook 4.4.1 → 5.1.1

package/dist/memory/memory-store.js

@@ -1,18 +1,22 @@
 /**
- * SQLite Storage Layer using sql.js (WASM)
+ * SQLite Storage Layer using better-sqlite3 (native)
  *
  * Provides CRUD operations for memories and sessions,
  * with FTS5 full-text search (BM25 ranking).
+ *
+ * Replaced sql.js (WASM) in v5.0 to eliminate:
+ * - Full DB export() copies on every save (100-500MB allocations)
+ * - WASM JIT warmup delay (~300ms on init)
+ * - Event loop blocking on synchronous writeFileSync of entire DB
+ *
+ * better-sqlite3 writes directly to disk via SQLite's WAL journal.
+ * No export(), no manual saveToDisk(), no memory copies.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, mkdirSync, statSync, writeFileSync } from 'fs';
 import { join } from 'path';
-// Increase threshold to reduce blocking syncs during heavy write bursts
-// (db.export() + writeFileSync blocks the event loop for the full DB size)
-const AUTO_SAVE_THRESHOLD = 200;
 export class MemoryStore {
     db = null;
     dbPath;
-    writeCount = 0;
     initialized = false;
     constructor(dbPath) {
         this.dbPath = dbPath;
@@ -25,223 +29,217 @@ export class MemoryStore {
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
         }
-        // Dynamic import sql.js
-        const initSqlJs = (await import('sql.js')).default;
-        const SQL = await initSqlJs();
-        // Load existing DB or create new
-        if (existsSync(this.dbPath)) {
-            const fileData = readFileSync(this.dbPath);
-            this.db = new SQL.Database(fileData);
+        // Try better-sqlite3 (native, fast) first.
+        // Falls back to sql.js (WASM, portable) if native addon isn't available
+        // (e.g. no C++ build tools on Windows).
+        try {
+            const Database = (await import('better-sqlite3')).default;
+            this.db = new Database(this.dbPath);
+            this.db.pragma('journal_mode = WAL');
+            this.db.pragma('foreign_keys = ON');
         }
-        else {
-            this.db = new SQL.Database();
+        catch {
+            // better-sqlite3 not available — fall back to sql.js (WASM)
+            console.error('[MemoryStore] better-sqlite3 unavailable, falling back to sql.js (slower but portable)');
+            const { default: initSqlJs } = await import('sql.js');
+            const SQL = await initSqlJs();
+            let rawDb;
+            if (existsSync(this.dbPath)) {
+                const { readFileSync } = await import('fs');
+                rawDb = new SQL.Database(readFileSync(this.dbPath));
+            }
+            else {
+                rawDb = new SQL.Database();
+            }
+            // Wrap sql.js to match better-sqlite3 API surface used in this file
+            this.db = this.wrapSqlJs(rawDb);
         }
         this.createSchema();
         this.initialized = true;
-        // Force save to disk immediately after initialization to ensure the .db file exists.
-        // Without this, the DB only persists after AUTO_SAVE_THRESHOLD writes or explicit close(),
-        // which means sessions that end early never create the file on disk.
+        // For sql.js: force initial save so the .db file exists on disk
+        // (better-sqlite3 creates the file automatically on open)
         this.saveToDisk();
     }
     createSchema() {
         if (!this.db)
             throw new Error('Database not initialized');
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS memories (
-        id TEXT PRIMARY KEY,
-        type TEXT NOT NULL,
-        title TEXT NOT NULL,
-        content TEXT NOT NULL,
-        project TEXT NOT NULL DEFAULT '',
-        tags TEXT NOT NULL DEFAULT '[]',
-        session_id TEXT,
-        created_at INTEGER NOT NULL,
-        updated_at INTEGER NOT NULL,
-        accessed_at INTEGER NOT NULL
-      )
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        title TEXT NOT NULL,
+        content TEXT NOT NULL,
+        project TEXT NOT NULL DEFAULT '',
+        tags TEXT NOT NULL DEFAULT '[]',
+        session_id TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        accessed_at INTEGER NOT NULL
+      )
     `);
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS sessions (
-        id TEXT PRIMARY KEY,
-        project TEXT NOT NULL DEFAULT '',
-        status TEXT NOT NULL DEFAULT 'active',
-        started_at INTEGER NOT NULL,
-        ended_at INTEGER,
-        summary TEXT,
-        tool_calls INTEGER NOT NULL DEFAULT 0
-      )
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        project TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'active',
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER,
+        summary TEXT,
+        tool_calls INTEGER NOT NULL DEFAULT 0
+      )
     `);
         // --- Indexer Extensions ---
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS code_nodes (
-        id TEXT PRIMARY KEY,
-        type TEXT NOT NULL,
-        name TEXT NOT NULL,
-        file_path TEXT NOT NULL,
-        start_line INTEGER NOT NULL,
-        end_line INTEGER NOT NULL,
-        content TEXT NOT NULL,
-        summary TEXT,
-        hash TEXT NOT NULL,
-        updated_at INTEGER NOT NULL
-      )
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS code_nodes (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        name TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        start_line INTEGER NOT NULL,
+        end_line INTEGER NOT NULL,
+        content TEXT NOT NULL,
+        summary TEXT,
+        hash TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
     `);
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS code_edges (
-        id TEXT PRIMARY KEY,
-        source_id TEXT NOT NULL,
-        target_id TEXT NOT NULL,
-        type TEXT NOT NULL,
-        weight REAL NOT NULL DEFAULT 1.0,
-        FOREIGN KEY(source_id) REFERENCES code_nodes(id) ON DELETE CASCADE
-      )
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS code_edges (
+        id TEXT PRIMARY KEY,
+        source_id TEXT NOT NULL,
+        target_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        weight REAL NOT NULL DEFAULT 1.0,
+        FOREIGN KEY(source_id) REFERENCES code_nodes(id) ON DELETE CASCADE
+      )
     `);
         // FTS5 virtual table for BM25 search
-        // Use external content mode synced with memories table
         try {
-            this.db.run(`
-        CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
-          title, content, type,
-          content=memories,
-          content_rowid=rowid
-        )
+            this.db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS memory_fts USING fts5(
+          title, content, type,
+          content=memories,
+          content_rowid=rowid
+        )
       `);
             // Triggers to sync FTS with memories table
-            this.db.run(`
-        CREATE TRIGGER IF NOT EXISTS memory_fts_ai AFTER INSERT ON memories BEGIN
-          INSERT INTO memory_fts(rowid, title, content, type)
-            VALUES (new.rowid, new.title, new.content, new.type);
-        END
+            this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS memory_fts_ai AFTER INSERT ON memories BEGIN
+          INSERT INTO memory_fts(rowid, title, content, type)
+            VALUES (new.rowid, new.title, new.content, new.type);
+        END
       `);
-            this.db.run(`
-        CREATE TRIGGER IF NOT EXISTS memory_fts_ad AFTER DELETE ON memories BEGIN
-          INSERT INTO memory_fts(memory_fts, rowid, title, content, type)
-            VALUES ('delete', old.rowid, old.title, old.content, old.type);
-        END
+            this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS memory_fts_ad AFTER DELETE ON memories BEGIN
+          INSERT INTO memory_fts(memory_fts, rowid, title, content, type)
+            VALUES ('delete', old.rowid, old.title, old.content, old.type);
+        END
       `);
-            this.db.run(`
-        CREATE TRIGGER IF NOT EXISTS memory_fts_au AFTER UPDATE ON memories BEGIN
-          INSERT INTO memory_fts(memory_fts, rowid, title, content, type)
-            VALUES ('delete', old.rowid, old.title, old.content, old.type);
-          INSERT INTO memory_fts(rowid, title, content, type)
-            VALUES (new.rowid, new.title, new.content, new.type);
-        END
+            this.db.exec(`
+        CREATE TRIGGER IF NOT EXISTS memory_fts_au AFTER UPDATE ON memories BEGIN
+          INSERT INTO memory_fts(memory_fts, rowid, title, content, type)
+            VALUES ('delete', old.rowid, old.title, old.content, old.type);
+          INSERT INTO memory_fts(rowid, title, content, type)
+            VALUES (new.rowid, new.title, new.content, new.type);
+        END
       `);
         }
         catch {
             // FTS5 may not be available in some builds; continue without it
         }
         // Index for common queries
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type)');
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at)');
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_memories_accessed ON memories(accessed_at)');
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_memories_session ON memories(session_id)');
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_code_nodes_type ON code_nodes(type)');
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_code_nodes_path ON code_nodes(file_path)');
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_code_edges_source ON code_edges(source_id)');
-        this.db.run('CREATE INDEX IF NOT EXISTS idx_code_edges_target ON code_edges(target_id)');
-    }
-    trackWrite() {
-        this.writeCount++;
-        if (this.writeCount >= AUTO_SAVE_THRESHOLD) {
-            this.saveToDisk();
-            this.writeCount = 0;
-        }
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type)');
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_memories_created ON memories(created_at)');
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_memories_accessed ON memories(accessed_at)');
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_memories_session ON memories(session_id)');
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_code_nodes_type ON code_nodes(type)');
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_code_nodes_path ON code_nodes(file_path)');
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_code_edges_source ON code_edges(source_id)');
+        this.db.exec('CREATE INDEX IF NOT EXISTS idx_code_edges_target ON code_edges(target_id)');
     }
     // --- Memory CRUD ---
     saveMemory(memory) {
         if (!this.db)
             throw new Error('Database not initialized');
-        this.db.run(`INSERT OR REPLACE INTO memories (id, type, title, content, project, tags, session_id, created_at, updated_at, accessed_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
-            memory.id,
-            memory.type,
-            memory.title,
-            memory.content,
-            memory.project,
-            JSON.stringify(memory.tags),
-            memory.sessionId ?? null,
-            memory.createdAt,
-            memory.updatedAt,
-            memory.accessedAt,
-        ]);
-        this.trackWrite();
+        this.db.prepare(`INSERT OR REPLACE INTO memories (id, type, title, content, project, tags, session_id, created_at, updated_at, accessed_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(memory.id, memory.type, memory.title, memory.content, memory.project, JSON.stringify(memory.tags), memory.sessionId ?? null, memory.createdAt, memory.updatedAt, memory.accessedAt);
     }
     getMemory(id) {
         if (!this.db)
             throw new Error('Database not initialized');
-        const result = this.db.exec(`SELECT id, type, title, content, project, tags, session_id, created_at, updated_at, accessed_at
-       FROM memories WHERE id = '${id.replace(/'/g, "''")}'`);
-        if (result.length === 0 || result[0].values.length === 0)
+        const row = this.db.prepare(`SELECT id, type, title, content, project, tags, session_id, created_at, updated_at, accessed_at
+       FROM memories WHERE id = ?`).get(id);
+        if (!row)
             return null;
-        const row = result[0].values[0];
         return this.rowToMemory(row);
     }
     deleteMemory(id) {
         if (!this.db)
             throw new Error('Database not initialized');
-        this.db.run(`DELETE FROM memories WHERE id = ?`, [id]);
-        this.trackWrite();
+        this.db.prepare(`DELETE FROM memories WHERE id = ?`).run(id);
     }
     listMemories(options) {
         if (!this.db)
             throw new Error('Database not initialized');
         const conditions = [];
-        if (options?.type)
-            conditions.push(`type = '${options.type}'`);
-        if (options?.project)
-            conditions.push(`project = '${options.project.replace(/'/g, "''")}'`);
+        const params = [];
+        if (options?.type) {
+            conditions.push(`type = ?`);
+            params.push(options.type);
+        }
+        if (options?.project) {
+            conditions.push(`project = ?`);
+            params.push(options.project);
+        }
         const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const limit = options?.limit ? `LIMIT ${options.limit}` : 'LIMIT 100';
-        const offset = options?.offset ? `OFFSET ${options.offset}` : '';
-        const result = this.db.exec(`SELECT id, type, title, content, project, tags, session_id, created_at, updated_at, accessed_at
-       FROM memories ${where} ORDER BY created_at DESC ${limit} ${offset}`);
-        if (result.length === 0)
-            return [];
-        return result[0].values.map((row) => this.rowToMemory(row));
+        const limit = options?.limit ?? 100;
+        const offset = options?.offset ?? 0;
+        const rows = this.db.prepare(`SELECT id, type, title, content, project, tags, session_id, created_at, updated_at, accessed_at
+       FROM memories ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+        return rows.map((row) => this.rowToMemory(row));
     }
     updateAccessedAt(id) {
         if (!this.db)
             throw new Error('Database not initialized');
-        this.db.run(`UPDATE memories SET accessed_at = ? WHERE id = ?`, [Date.now(), id]);
-        this.trackWrite();
+        this.db.prepare(`UPDATE memories SET accessed_at = ? WHERE id = ?`).run(Date.now(), id);
     }
     getMemoryCount() {
         if (!this.db)
             throw new Error('Database not initialized');
-        const result = this.db.exec('SELECT COUNT(*) FROM memories');
-        if (result.length === 0)
-            return 0;
-        return Number(result[0].values[0][0]);
+        const row = this.db.prepare('SELECT COUNT(*) as count FROM memories').get();
+        return row.count;
     }
     // --- BM25 Search ---
     searchBM25(query, limit = 20, filters) {
         if (!this.db)
             throw new Error('Database not initialized');
         try {
-            // Escape FTS5 special characters
-            const escaped = query.replace(/['"]/g, ' ').trim();
+            // Escape FTS5 special characters — strip quotes and special operators
+            const escaped = query.replace(/['"*(){}[\]:^~!]/g, ' ').trim();
             if (!escaped)
                 return [];
-            let sql = `
-        SELECT m.id, bm25(memory_fts) as score
-        FROM memory_fts f
-        JOIN memories m ON m.rowid = f.rowid
-        WHERE memory_fts MATCH '${escaped}'
+            // Build FTS5 match query with proper term quoting
+            const terms = escaped.split(/\s+/).filter(t => t.length > 1);
+            if (terms.length === 0)
+                return [];
+            const ftsQuery = terms.map(t => `"${t}"`).join(' OR ');
+            let sql = `
+        SELECT m.id, bm25(memory_fts) as score
+        FROM memory_fts f
+        JOIN memories m ON m.rowid = f.rowid
+        WHERE memory_fts MATCH '${ftsQuery}'
       `;
             if (filters?.type) {
-                sql += ` AND m.type = '${filters.type}'`;
+                sql += ` AND m.type = '${filters.type.replace(/'/g, "''")}'`;
             }
             if (filters?.project) {
                 sql += ` AND m.project = '${filters.project.replace(/'/g, "''")}'`;
             }
             sql += ` ORDER BY score LIMIT ${limit}`;
-            const result = this.db.exec(sql);
-            if (result.length === 0)
-                return [];
-            return result[0].values.map((row) => ({
-                id: row[0],
-                score: Math.abs(row[1]), // BM25 returns negative scores
+            const rows = this.db.prepare(sql).all();
+            return rows.map((row) => ({
+                id: row.id,
+                score: Math.abs(row.score), // BM25 returns negative scores
             }));
         }
         catch {
@@ -265,91 +263,72 @@ export class MemoryStore {
         if (filters?.project)
             sql += ` AND project = '${filters.project.replace(/'/g, "''")}'`;
         sql += ` LIMIT ${limit}`;
-        const result = this.db.exec(sql);
-        if (result.length === 0)
-            return [];
-        return result[0].values.map((row, i) => ({
-            id: row[0],
-            score: 1 / (i + 1), // Simple rank-based score
+        const rows = this.db.prepare(sql).all();
+        return rows.map((row, i) => ({
+            id: row.id,
+            score: 1 / (i + 1),
         }));
     }
     // --- Sessions ---
     createSession(session) {
         if (!this.db)
             throw new Error('Database not initialized');
-        this.db.run(`INSERT INTO sessions (id, project, status, started_at, ended_at, summary, tool_calls)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`, [
-            session.id,
-            session.project,
-            session.status,
-            session.startedAt,
-            session.endedAt ?? null,
-            session.summary ?? null,
-            session.toolCalls,
-        ]);
-        this.trackWrite();
+        this.db.prepare(`INSERT INTO sessions (id, project, status, started_at, ended_at, summary, tool_calls)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`).run(session.id, session.project, session.status, session.startedAt, session.endedAt ?? null, session.summary ?? null, session.toolCalls);
     }
     endSession(id, summary) {
         if (!this.db)
             throw new Error('Database not initialized');
-        this.db.run(`UPDATE sessions SET status = 'completed', ended_at = ?, summary = ? WHERE id = ?`, [Date.now(), summary ?? null, id]);
-        this.trackWrite();
+        this.db.prepare(`UPDATE sessions SET status = 'completed', ended_at = ?, summary = ? WHERE id = ?`).run(Date.now(), summary ?? null, id);
     }
     getActiveSession() {
         if (!this.db)
             throw new Error('Database not initialized');
-        const result = this.db.exec(`SELECT id, project, status, started_at, ended_at, summary, tool_calls
-       FROM sessions WHERE status = 'active' ORDER BY started_at DESC LIMIT 1`);
-        if (result.length === 0 || result[0].values.length === 0)
+        const row = this.db.prepare(`SELECT id, project, status, started_at, ended_at, summary, tool_calls
+       FROM sessions WHERE status = 'active' ORDER BY started_at DESC LIMIT 1`).get();
+        if (!row)
             return null;
-        const row = result[0].values[0];
         return {
-            id: row[0],
-            project: row[1],
-            status: row[2],
-            startedAt: row[3],
-            endedAt: row[4],
-            summary: row[5],
-            toolCalls: row[6],
+            id: row.id,
+            project: row.project,
+            status: row.status,
+            startedAt: row.started_at,
+            endedAt: row.ended_at,
+            summary: row.summary,
+            toolCalls: row.tool_calls,
         };
     }
     getSessionCount() {
         if (!this.db)
             throw new Error('Database not initialized');
-        const result = this.db.exec('SELECT COUNT(*) FROM sessions');
-        if (result.length === 0)
-            return 0;
-        return Number(result[0].values[0][0]);
+        const row = this.db.prepare('SELECT COUNT(*) as count FROM sessions').get();
+        return row.count;
     }
     // --- Queries for cache/stats ---
     getOldestMemoryTimestamp() {
         if (!this.db)
             return undefined;
-        const result = this.db.exec('SELECT MIN(created_at) FROM memories');
-        if (result.length === 0 || result[0].values[0][0] === null)
-            return undefined;
-        return Number(result[0].values[0][0]);
+        const row = this.db.prepare('SELECT MIN(created_at) as ts FROM memories').get();
+        return row.ts ?? undefined;
     }
     getNewestMemoryTimestamp() {
         if (!this.db)
             return undefined;
-        const result = this.db.exec('SELECT MAX(created_at) FROM memories');
-        if (result.length === 0 || result[0].values[0][0] === null)
-            return undefined;
-        return Number(result[0].values[0][0]);
+        const row = this.db.prepare('SELECT MAX(created_at) as ts FROM memories').get();
+        return row.ts ?? undefined;
     }
     getEvictionCandidates(batchSize, activeSessionId) {
         if (!this.db)
             return [];
         let sql = `SELECT id FROM memories WHERE type != 'decision'`;
+        const params = [];
         if (activeSessionId) {
-            sql += ` AND (session_id IS NULL OR session_id != '${activeSessionId.replace(/'/g, "''")}')`;
+            sql += ` AND (session_id IS NULL OR session_id != ?)`;
+            params.push(activeSessionId);
         }
-        sql += ` ORDER BY accessed_at ASC, created_at ASC LIMIT ${batchSize}`;
-        const result = this.db.exec(sql);
-        if (result.length === 0)
-            return [];
-        return result[0].values.map((row) => ({ id: row[0] }));
+        sql += ` ORDER BY accessed_at ASC, created_at ASC LIMIT ?`;
+        params.push(batchSize);
+        return this.db.prepare(sql).all(...params);
     }
     /**
      * Get memories in chronological order around a given memory
@@ -358,126 +337,200 @@ export class MemoryStore {
         if (!this.db)
             return [];
         // Get anchor memory's timestamp
-        const anchorResult = this.db.exec(`SELECT created_at FROM memories WHERE id = '${memoryId.replace(/'/g, "''")}'`);
-        if (anchorResult.length === 0 || anchorResult[0].values.length === 0)
+        const anchor = this.db.prepare(`SELECT created_at FROM memories WHERE id = ?`).get(memoryId);
+        if (!anchor)
             return [];
-        const anchorTs = anchorResult[0].values[0][0];
+        const anchorTs = anchor.created_at;
         // Get before + anchor + after
-        const result = this.db.exec(`SELECT id, title, type, created_at FROM (
-         SELECT id, title, type, created_at FROM memories
-         WHERE created_at <= ${anchorTs}
-         ORDER BY created_at DESC LIMIT ${window + 1}
-       )
-       UNION ALL
-       SELECT id, title, type, created_at FROM (
-         SELECT id, title, type, created_at FROM memories
-         WHERE created_at > ${anchorTs}
-         ORDER BY created_at ASC LIMIT ${window}
-       )
-       ORDER BY created_at ASC`);
-        if (result.length === 0)
-            return [];
-        return result[0].values.map((row) => ({
-            id: row[0],
-            title: row[1],
-            type: row[2],
-            createdAt: row[3],
+        const rows = this.db.prepare(`SELECT id, title, type, created_at FROM (
+         SELECT id, title, type, created_at FROM memories
+         WHERE created_at <= ?
+         ORDER BY created_at DESC LIMIT ?
+       )
+       UNION ALL
+       SELECT id, title, type, created_at FROM (
+         SELECT id, title, type, created_at FROM memories
+         WHERE created_at > ?
+         ORDER BY created_at ASC LIMIT ?
+       )
+       ORDER BY created_at ASC`).all(anchorTs, window + 1, anchorTs, window);
+        return rows.map((row) => ({
+            id: row.id,
+            title: row.title,
+            type: row.type,
+            createdAt: row.created_at,
         }));
     }
     // --- Persistence ---
     getDbSizeBytes() {
         if (!this.db)
             return 0;
-        return this.db.export().byteLength;
+        // O(1) — reads page count and page size from SQLite internal state
+        // No memory allocation, no data copy (unlike sql.js db.export())
+        try {
+            const stat = statSync(this.dbPath);
+            return stat.size;
+        }
+        catch {
+            return 0;
+        }
     }
     saveToDisk() {
         if (!this.db)
             return;
-        const dir = join(this.dbPath, '..');
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (this.db._isSqlJs) {
+            // sql.js: export + writeFileSync
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.db._sqlJsSave();
+        }
+        else {
+            // better-sqlite3: WAL checkpoint
+            this.db.pragma('wal_checkpoint(TRUNCATE)');
         }
-        const data = this.db.export();
-        writeFileSync(this.dbPath, data);
     }
     close() {
         if (this.db) {
-            this.saveToDisk();
             this.db.close();
             this.db = null;
             this.initialized = false;
         }
     }
+    /**
+     * Wraps a sql.js database to expose the same API surface as better-sqlite3.
+     * This enables the rest of the class to use db.prepare().run/get/all uniformly.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    wrapSqlJs(rawDb) {
+        const dbPath = this.dbPath;
+        let writeCount = 0;
+        const saveToDisk = () => {
+            const data = rawDb.export();
+            const dir = join(dbPath, '..');
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            writeFileSync(dbPath, data);
+        };
+        const trackWrite = () => {
+            writeCount++;
+            if (writeCount >= 200) {
+                saveToDisk();
+                writeCount = 0;
+            }
+        };
+        return {
+            exec: (sql) => rawDb.run(sql),
+            pragma: () => { }, // No-op for sql.js
+            prepare: (sql) => ({
+                run: (...params) => {
+                    rawDb.run(sql, params.length === 1 && Array.isArray(params[0]) ? params[0] : params);
+                    trackWrite();
+                },
+                get: (...params) => {
+                    const result = rawDb.exec(sql.replace(/\?/g, () => {
+                        const p = params.shift();
+                        if (p === null || p === undefined)
+                            return 'NULL';
+                        if (typeof p === 'string')
+                            return `'${p.replace(/'/g, "''")}'`;
+                        return String(p);
+                    }));
+                    if (!result.length || !result[0].values.length)
+                        return undefined;
+                    const cols = result[0].columns;
+                    const row = result[0].values[0];
+                    const obj = {};
+                    cols.forEach((c, i) => { obj[c] = row[i]; });
+                    return obj;
+                },
+                all: (...params) => {
+                    let processed = sql;
+                    for (const p of params) {
+                        if (p === null || p === undefined) {
+                            processed = processed.replace('?', 'NULL');
+                        }
+                        else if (typeof p === 'string') {
+                            processed = processed.replace('?', `'${p.replace(/'/g, "''")}'`);
+                        }
+                        else {
+                            processed = processed.replace('?', String(p));
+                        }
+                    }
+                    const result = rawDb.exec(processed);
+                    if (!result.length)
+                        return [];
+                    const cols = result[0].columns;
+                    return result[0].values.map((row) => {
+                        const obj = {};
+                        cols.forEach((c, i) => { obj[c] = row[i]; });
+                        return obj;
+                    });
+                },
+            }),
+            close: () => { saveToDisk(); rawDb.close(); },
+            // For saveToDisk() compatibility
+            _sqlJsSave: saveToDisk,
+            _isSqlJs: true,
+        };
+    }
     rowToMemory(row) {
         return {
-            id: row[0],
-            type: row[1],
-            title: row[2],
-            content: row[3],
-            project: row[4],
-            tags: JSON.parse(row[5] || '[]'),
-            sessionId: row[6] || undefined,
-            createdAt: row[7],
-            updatedAt: row[8],
-            accessedAt: row[9],
+            id: row.id,
+            type: row.type,
+            title: row.title,
+            content: row.content,
+            project: row.project,
+            tags: JSON.parse(row.tags || '[]'),
+            sessionId: row.session_id || undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            accessedAt: row.accessed_at,
         };
     }
     // --- Background Indexer Graph Persistence ---
     saveCodeNode(node) {
         if (!this.db)
             throw new Error('Database not initialized');
-        this.db.run(`INSERT OR REPLACE INTO code_nodes (id, type, name, file_path, start_line, end_line, content, summary, hash, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
-            node.id,
-            node.type,
-            node.name,
-            node.filePath,
-            node.startLine,
-            node.endLine,
-            node.content,
-            node.summary ?? null,
-            node.hash,
-            node.updatedAt,
-        ]);
-        this.trackWrite();
+        this.db.prepare(`INSERT OR REPLACE INTO code_nodes (id, type, name, file_path, start_line, end_line, content, summary, hash, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(node.id, node.type, node.name, node.filePath, node.startLine, node.endLine, node.content, node.summary ?? null, node.hash, node.updatedAt);
     }
     saveCodeEdge(edge) {
         if (!this.db)
             throw new Error('Database not initialized');
-        this.db.run(`INSERT OR IGNORE INTO code_edges (id, source_id, target_id, type, weight)
-       VALUES (?, ?, ?, ?, ?)`, [edge.id, edge.sourceId, edge.targetId, edge.type, edge.weight]);
-        this.trackWrite();
+        this.db.prepare(`INSERT OR IGNORE INTO code_edges (id, source_id, target_id, type, weight)
+       VALUES (?, ?, ?, ?, ?)`).run(edge.id, edge.sourceId, edge.targetId, edge.type, edge.weight);
+    }
+    getCodeNodeIdsByFile(filePath) {
+        if (!this.db)
+            return [];
+        const rows = this.db.prepare(`SELECT id FROM code_nodes WHERE file_path = ?`).all(filePath);
+        return rows.map((row) => row.id);
     }
     deleteCodeNodesByFile(filePath) {
         if (!this.db)
             throw new Error('Database not initialized');
-        // Due to ON DELETE CASCADE, deleting the code_nodes will auto delete code_edges where source_id = node.id
-        this.db.run(`DELETE FROM code_nodes WHERE file_path = ?`, [filePath]);
-        this.trackWrite();
+        this.db.prepare(`DELETE FROM code_nodes WHERE file_path = ?`).run(filePath);
     }
     getCodeNodeByHash(id) {
         if (!this.db)
             throw new Error('Database not initialized');
-        const result = this.db.exec(`SELECT hash FROM code_nodes WHERE id = '${id.replace(/'/g, "''")}'`);
-        if (result.length === 0 || result[0].values.length === 0)
-            return null;
-        return result[0].values[0][0];
+        const row = this.db.prepare(`SELECT hash FROM code_nodes WHERE id = ?`).get(id);
+        return row?.hash ?? null;
     }
     getCodeNode(id) {
         if (!this.db)
             throw new Error('Database not initialized');
-        const result = this.db.exec(`SELECT id, type, name, file_path, content, hash, updated_at FROM code_nodes WHERE id = '${id.replace(/'/g, "''")}'`);
-        if (result.length === 0 || result[0].values.length === 0)
+        const row = this.db.prepare(`SELECT id, type, name, file_path, content, hash, updated_at FROM code_nodes WHERE id = ?`).get(id);
+        if (!row)
             return null;
-        const row = result[0].values[0];
         return {
-            id: row[0],
-            type: row[1],
-            name: row[2],
-            filePath: row[3],
-            content: row[4],
-            hash: row[5],
-            updatedAt: row[6],
+            id: row.id,
+            type: row.type,
+            name: row.name,
+            filePath: row.file_path,
+            content: row.content,
+            hash: row.hash,
+            updatedAt: row.updated_at,
         };
     }
 }