memorix 1.2.2 → 1.2.4

package/src/store/bun-sqlite-compat.ts

@@ -1,21 +1,120 @@
 /**
  * Bun SQLite Compatibility Layer
  *
- * Provides a better-sqlite3 compatible API using bun:sqlite when running under Bun.
- * Falls back to better-sqlite3 when running under Node.js.
+ * Provides a small better-sqlite3 compatibility layer for the available local
+ * SQLite implementation. Node 22 ships node:sqlite, which keeps Memorix
+ * usable when an optional better-sqlite3 native binary is unavailable.
  */
 
 import { createRequire } from 'node:module';
 
 let Database: any;
+let driver: 'better-sqlite3' | 'node:sqlite' | 'bun:sqlite' | undefined;
 const requireFromHere = createRequire(import.meta.url);
 
+function loadNodeSqlite(): any {
+  const nodeSqlite = requireFromHere('node:sqlite');
+  return nodeSqlite.DatabaseSync;
+}
+
+function isNativeBindingFailure(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /could not locate the bindings file|better_sqlite3\.node|module did not self-register/i.test(message);
+}
+
+function addCompatibility(db: any): any {
+  // Bun and node:sqlite do not expose better-sqlite3's pragma helper.
+  if (!db.pragma) {
+    db.pragma = function (pragma: string, options?: { simple?: boolean }) {
+      const statement = db.prepare(`PRAGMA ${pragma}`);
+      if (options?.simple) {
+        const result = statement.get();
+        return result ? Object.values(result)[0] : undefined;
+      }
+      return statement.all();
+    };
+  }
+
+  // Stores use better-sqlite3's synchronous transaction factory. Keep nested
+  // calls correct with savepoints instead of silently committing inner work.
+  if (!db.transaction) {
+    let depth = 0;
+    let sequence = 0;
+    db.transaction = function <T>(fn: (...args: any[]) => T) {
+      return (...args: any[]): T => {
+        const outermost = depth === 0;
+        const savepoint = `memorix_tx_${++sequence}`;
+        if (outermost) {
+          db.exec('BEGIN IMMEDIATE');
+        } else {
+          db.exec(`SAVEPOINT ${savepoint}`);
+        }
+        depth += 1;
+        try {
+          const result = fn(...args);
+          if (result && typeof (result as any).then === 'function') {
+            throw new Error('[memorix] SQLite transactions must be synchronous');
+          }
+          depth -= 1;
+          if (outermost) {
+            db.exec('COMMIT');
+          } else {
+            db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+          }
+          return result;
+        } catch (error) {
+          depth -= 1;
+          try {
+            if (outermost) {
+              db.exec('ROLLBACK');
+            } else {
+              db.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+              db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+            }
+          } catch {
+            // Preserve the original application failure when rollback itself fails.
+          }
+          throw error;
+        }
+      };
+    };
+  }
+
+  return db;
+}
+
+function instantiateDatabase(Sqlite: any, filePath: string, options?: any): any {
+  // DatabaseSync validates that an explicitly supplied second argument is an
+  // object, unlike better-sqlite3 which accepts undefined.
+  return driver === 'node:sqlite' && options === undefined
+    ? new Sqlite(filePath)
+    : new Sqlite(filePath, options);
+}
+
 export function loadSqlite(): any {
   if (Database) return Database;
 
+  // Kept as an operational escape hatch and a regression-test seam. Node 22
+  // is the supported minimum runtime, so this does not expand the platform
+  // contract beyond package.json's existing engine requirement.
+  if (process.env.MEMORIX_SQLITE_DRIVER === 'node') {
+    Database = loadNodeSqlite();
+    driver = 'node:sqlite';
+    return Database;
+  }
+
   // Try better-sqlite3 first (Node.js)
   try {
     Database = requireFromHere('better-sqlite3');
+    driver = 'better-sqlite3';
+    return Database;
+  } catch {
+    // Fall through to node:sqlite, then Bun's runtime implementation.
+  }
+
+  try {
+    Database = loadNodeSqlite();
+    driver = 'node:sqlite';
     return Database;
   } catch {
     // Fall through to bun:sqlite
@@ -26,9 +125,10 @@ export function loadSqlite(): any {
     // bun:sqlite is a Bun built-in
     const bunSqlite = requireFromHere('bun:sqlite');
     Database = bunSqlite.Database;
+    driver = 'bun:sqlite';
     return Database;
   } catch {
-    throw new Error('[memorix] Neither better-sqlite3 nor bun:sqlite is available');
+    throw new Error('[memorix] SQLite is unavailable (better-sqlite3, node:sqlite, and bun:sqlite failed)');
   }
 }
 
@@ -38,18 +138,21 @@ export function loadSqlite(): any {
  */
 export function createDatabase(path: string, options?: any): any {
   const Sqlite = loadSqlite();
-  const db = new Sqlite(path, options);
-
-  // Bun's sqlite doesn't have .pragma() method, add compatibility
-  if (!db.pragma) {
-    db.pragma = function (pragma: string, options?: any) {
-      if (options && options.simple) {
-        const result = db.prepare(`PRAGMA ${pragma}`).get();
-        return result ? Object.values(result)[0] : undefined;
-      }
-      return db.prepare(`PRAGMA ${pragma}`).all();
-    };
+  try {
+    return addCompatibility(instantiateDatabase(Sqlite, path, options));
+  } catch (error) {
+    // require('better-sqlite3') can succeed even when npm had no prebuild and
+    // no local compiler. Fall back to Node's built-in SQLite for that one
+    // recoverable case; real open/corruption errors still surface unchanged.
+    if (driver !== 'better-sqlite3' || !isNativeBindingFailure(error)) throw error;
+    Database = loadNodeSqlite();
+    driver = 'node:sqlite';
+    return addCompatibility(instantiateDatabase(Database, path, options));
   }
+}
 
-  return db;
+/** Test-only reset for the driver cache used by the forced node:sqlite path. */
+export function resetSqliteDriverForTests(): void {
+  Database = undefined;
+  driver = undefined;
 }

package/src/store/chat-store.ts

@@ -1,119 +1,119 @@
-/**
- * ChatTranscriptStore — persistence for TUI chat history.
- *
- * Backed by the shared SQLite database (chat_transcript table).
- * Supports multiple threads (thread_id), so /new creates a new thread
- * and /resume reloads the most recent one.
- */
-
-import { getDatabase } from './sqlite-db.js';
-import type { ChatTranscriptMessage } from '../cli/tui/ChatView.js';
-
-export interface ChatThreadInfo {
-  threadId: string;
-  messageCount: number;
-  lastActivity: string;
-}
-
-function safeJsonParse(text: string, fallback: any): any {
-  try { return JSON.parse(text); } catch { return fallback; }
-}
-
-export class ChatTranscriptStore {
-  private db: any = null;
-
-  async init(dataDir: string): Promise<void> {
-    this.db = getDatabase(dataDir);
-  }
-
-  /** Append a message to a thread */
-  append(projectId: string, threadId: string, message: ChatTranscriptMessage): void {
-    if (!this.db) return;
-    const now = new Date().toISOString();
-    this.db.prepare(`
-      INSERT INTO chat_transcript (project_id, thread_id, role, content, sources_json, meta_json, error, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      projectId,
-      threadId,
-      message.role,
-      message.content,
-      JSON.stringify(message.sources || []),
-      JSON.stringify(message.meta || {}),
-      message.error ? 1 : 0,
-      message.timestamp || now,
-    );
-  }
-
-  /** Load all messages for a thread, oldest first */
-  load(projectId: string, threadId: string): ChatTranscriptMessage[] {
-    if (!this.db) return [];
-    const rows = this.db.prepare(`
-      SELECT role, content, sources_json, meta_json, error, created_at
-      FROM chat_transcript
-      WHERE project_id = ? AND thread_id = ?
-      ORDER BY id ASC
-    `).all(projectId, threadId);
-
-    return rows.map((row: any) => ({
-      role: row.role as 'user' | 'assistant',
-      content: row.content,
-      sources: safeJsonParse(row.sources_json, []),
-      meta: safeJsonParse(row.meta_json, {}),
-      error: row.error === 1,
-      timestamp: row.created_at,
-    }));
-  }
-
-  /** Delete all messages for a thread */
-  clear(projectId: string, threadId: string): void {
-    if (!this.db) return;
-    this.db.prepare(`
-      DELETE FROM chat_transcript
-      WHERE project_id = ? AND thread_id = ?
-    `).run(projectId, threadId);
-  }
-
-  /** List all threads for a project, most recently active first */
-  listThreads(projectId: string): ChatThreadInfo[] {
-    if (!this.db) return [];
-    const rows = this.db.prepare(`
-      SELECT thread_id, COUNT(*) as message_count, MAX(created_at) as last_activity
-      FROM chat_transcript
-      WHERE project_id = ?
-      GROUP BY thread_id
-      ORDER BY last_activity DESC
-    `).all(projectId);
-
-    return rows.map((row: any) => ({
-      threadId: row.thread_id,
-      messageCount: row.message_count,
-      lastActivity: row.last_activity,
-    }));
-  }
-
-  /** Get the most recent thread_id for a project */
-  getLatestThreadId(projectId: string): string | null {
-    if (!this.db) return null;
-    const row = this.db.prepare(`
-      SELECT thread_id FROM chat_transcript
-      WHERE project_id = ?
-      ORDER BY created_at DESC
-      LIMIT 1
-    `).get(projectId);
-    return row?.thread_id ?? null;
-  }
-
-  /** Generate a new thread ID (timestamp-based) */
-  newThreadId(): string {
-    return `t${Date.now().toString(36)}`;
-  }
-}
-
-// Singleton
-let _store: ChatTranscriptStore | null = null;
-
-export function getChatStore(): ChatTranscriptStore {
-  if (!_store) _store = new ChatTranscriptStore();
-  return _store;
-}
+/**
+ * ChatTranscriptStore — persistence for TUI chat history.
+ *
+ * Backed by the shared SQLite database (chat_transcript table).
+ * Supports multiple threads (thread_id), so /new creates a new thread
+ * and /resume reloads the most recent one.
+ */
+
+import { getDatabase } from './sqlite-db.js';
+import type { ChatTranscriptMessage } from '../cli/tui/ChatView.js';
+
+export interface ChatThreadInfo {
+  threadId: string;
+  messageCount: number;
+  lastActivity: string;
+}
+
+function safeJsonParse(text: string, fallback: any): any {
+  try { return JSON.parse(text); } catch { return fallback; }
+}
+
+export class ChatTranscriptStore {
+  private db: any = null;
+
+  async init(dataDir: string): Promise<void> {
+    this.db = getDatabase(dataDir);
+  }
+
+  /** Append a message to a thread */
+  append(projectId: string, threadId: string, message: ChatTranscriptMessage): void {
+    if (!this.db) return;
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      INSERT INTO chat_transcript (project_id, thread_id, role, content, sources_json, meta_json, error, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      projectId,
+      threadId,
+      message.role,
+      message.content,
+      JSON.stringify(message.sources || []),
+      JSON.stringify(message.meta || {}),
+      message.error ? 1 : 0,
+      message.timestamp || now,
+    );
+  }
+
+  /** Load all messages for a thread, oldest first */
+  load(projectId: string, threadId: string): ChatTranscriptMessage[] {
+    if (!this.db) return [];
+    const rows = this.db.prepare(`
+      SELECT role, content, sources_json, meta_json, error, created_at
+      FROM chat_transcript
+      WHERE project_id = ? AND thread_id = ?
+      ORDER BY id ASC
+    `).all(projectId, threadId);
+
+    return rows.map((row: any) => ({
+      role: row.role as 'user' | 'assistant',
+      content: row.content,
+      sources: safeJsonParse(row.sources_json, []),
+      meta: safeJsonParse(row.meta_json, {}),
+      error: row.error === 1,
+      timestamp: row.created_at,
+    }));
+  }
+
+  /** Delete all messages for a thread */
+  clear(projectId: string, threadId: string): void {
+    if (!this.db) return;
+    this.db.prepare(`
+      DELETE FROM chat_transcript
+      WHERE project_id = ? AND thread_id = ?
+    `).run(projectId, threadId);
+  }
+
+  /** List all threads for a project, most recently active first */
+  listThreads(projectId: string): ChatThreadInfo[] {
+    if (!this.db) return [];
+    const rows = this.db.prepare(`
+      SELECT thread_id, COUNT(*) as message_count, MAX(created_at) as last_activity
+      FROM chat_transcript
+      WHERE project_id = ?
+      GROUP BY thread_id
+      ORDER BY last_activity DESC
+    `).all(projectId);
+
+    return rows.map((row: any) => ({
+      threadId: row.thread_id,
+      messageCount: row.message_count,
+      lastActivity: row.last_activity,
+    }));
+  }
+
+  /** Get the most recent thread_id for a project */
+  getLatestThreadId(projectId: string): string | null {
+    if (!this.db) return null;
+    const row = this.db.prepare(`
+      SELECT thread_id FROM chat_transcript
+      WHERE project_id = ?
+      ORDER BY created_at DESC
+      LIMIT 1
+    `).get(projectId);
+    return row?.thread_id ?? null;
+  }
+
+  /** Generate a new thread ID (timestamp-based) */
+  newThreadId(): string {
+    return `t${Date.now().toString(36)}`;
+  }
+}
+
+// Singleton
+let _store: ChatTranscriptStore | null = null;
+
+export function getChatStore(): ChatTranscriptStore {
+  if (!_store) _store = new ChatTranscriptStore();
+  return _store;
+}