squish-memory 1.0.0 → 1.0.2

package/dist/core/search/conversations.js

@@ -46,24 +46,24 @@ async function searchConversationsSqlite(input, limit) {
         params.push(input.role);
     }
     params.push(limit);
-    const statement = sqlite.prepare(`
-    SELECT DISTINCT
-      c.id as id,
-      c.project_id as projectId,
-      c.session_id as sessionId,
-      c.title as title,
-      c.summary as summary,
-      c.message_count as messageCount,
-      c.token_count as tokenCount,
-      c.started_at as startedAt,
-      c.ended_at as endedAt,
-      c.metadata as metadata
-    FROM conversations c
-    JOIN messages m ON m.conversation_id = c.id
-    JOIN messages_fts ON messages_fts.rowid = m.rowid
-    WHERE ${where}
-    ORDER BY c.started_at DESC
-    LIMIT ?
+    const statement = sqlite.prepare(`
+    SELECT DISTINCT
+      c.id as id,
+      c.project_id as projectId,
+      c.session_id as sessionId,
+      c.title as title,
+      c.summary as summary,
+      c.message_count as messageCount,
+      c.token_count as tokenCount,
+      c.started_at as startedAt,
+      c.ended_at as endedAt,
+      c.metadata as metadata
+    FROM conversations c
+    JOIN messages m ON m.conversation_id = c.id
+    JOIN messages_fts ON messages_fts.rowid = m.rowid
+    WHERE ${where}
+    ORDER BY c.started_at DESC
+    LIMIT ?
   `);
     const rows = statement.all(...params);
     return rows.map((row) => normalizeConversation(row));
@@ -77,21 +77,21 @@ async function searchConversationsPostgres(input, limit) {
         whereParts.push(`m.role = $${values.length}`);
     }
     values.push(limit);
-    const rows = await db.$client.query(`SELECT DISTINCT ON (c.id)
-      c.id as "id",
-      c.project_id as "projectId",
-      c.session_id as "sessionId",
-      c.title as "title",
-      c.summary as "summary",
-      c.message_count as "messageCount",
-      c.token_count as "tokenCount",
-      c.started_at as "startedAt",
-      c.ended_at as "endedAt",
-      c.metadata as "metadata"
-    FROM conversations c
-    JOIN messages m ON m.conversation_id = c.id
-    WHERE ${whereParts.join(' AND ')}
-    ORDER BY c.id, c.started_at DESC
+    const rows = await db.$client.query(`SELECT DISTINCT ON (c.id)
+      c.id as "id",
+      c.project_id as "projectId",
+      c.session_id as "sessionId",
+      c.title as "title",
+      c.summary as "summary",
+      c.message_count as "messageCount",
+      c.token_count as "tokenCount",
+      c.started_at as "startedAt",
+      c.ended_at as "endedAt",
+      c.metadata as "metadata"
+    FROM conversations c
+    JOIN messages m ON m.conversation_id = c.id
+    WHERE ${whereParts.join(' AND ')}
+    ORDER BY c.id, c.started_at DESC
     LIMIT $${values.length}`, values);
     return rows.rows.map((row) => normalizeConversation(row));
 }

package/dist/core/session-hooks/self-iteration-job.js

@@ -20,31 +20,31 @@ const DEFAULT_CONFIG = {
  */
 function buildFactExtractionPrompt(messages) {
     const messagesText = messages.map(m => `[${m.role}]: ${m.content}`).join('\n\n');
-    return `Extract key facts, decisions, and user preferences from this conversation.
-
-Format your response as JSON:
-{
-  "extractedFacts": [
-    {
-      "content": "specific fact text",
-      "type": "fact|decision|preference|observation",
-      "confidence": 0-100
-    }
-  ]
-}
-
-Only extract truly meaningful information that should be remembered:
-- Facts that are useful for future work or decisions
-- User preferences and choices
-- Important decisions made
-- Patterns or behaviors observed
-
-Do NOT extract:
-- Temporary conversational details
-- Greetings or pleasantries
-- Unless they indicate something significant
-
-Conversation messages:
+    return `Extract key facts, decisions, and user preferences from this conversation.
+
+Format your response as JSON:
+{
+  "extractedFacts": [
+    {
+      "content": "specific fact text",
+      "type": "fact|decision|preference|observation",
+      "confidence": 0-100
+    }
+  ]
+}
+
+Only extract truly meaningful information that should be remembered:
+- Facts that are useful for future work or decisions
+- User preferences and choices
+- Important decisions made
+- Patterns or behaviors observed
+
+Do NOT extract:
+- Temporary conversational details
+- Greetings or pleasantries
+- Unless they indicate something significant
+
+Conversation messages:
 ${messagesText}`;
 }
 /**
@@ -52,14 +52,14 @@ ${messagesText}`;
  */
 function buildSummaryPrompt(messages) {
     const messagesText = messages.map(m => `[${m.role}]: ${m.content}`).join('\n\n');
-    return `Generate a concise summary of this conversation (2-3 sentences, under 300 characters).
-
-Focus on:
-- What was accomplished
-- Key decisions made
-- Important context established
-
-Conversation messages:
+    return `Generate a concise summary of this conversation (2-3 sentences, under 300 characters).
+
+Focus on:
+- What was accomplished
+- Key decisions made
+- Important context established
+
+Conversation messages:
 ${messagesText}`;
 }
 /**
@@ -86,14 +86,15 @@ async function getConversationsForIteration(maxMessages) {
     if (!db)
         return [];
     const schema = await getSchema();
+    const sqliteDb = db;
     // Get conversations that:
     // 1. Have ended (endedAt is not null)
     // 2. Haven't been processed yet (metadata.selfIterationProcessed is not set)
     // 3. Have enough messages (messageCount >= minMessageCount)
-    const conversations = await db.select()
+    const conversations = await sqliteDb.select()
         .from(schema.conversations)
-        .where(sql `${schema.conversations.endedAt} IS NOT NULL
-      AND (${schema.conversations.metadata}->>'selfIterationProcessed') IS NULL
+        .where(sql `${schema.conversations.endedAt} IS NOT NULL
+      AND (${schema.conversations.metadata}->>'selfIterationProcessed') IS NULL
       AND ${schema.conversations.messageCount} >= ?`)
         .limit(10);
     return conversations;
@@ -106,7 +107,8 @@ async function getConversationMessages(conversationId) {
     if (!db)
         return [];
     const schema = await getSchema();
-    const messages = await db.select()
+    const sqliteDb = db;
+    const messages = await sqliteDb.select()
         .from(schema.messages)
         .where(eq(schema.messages.conversationId, conversationId))
         .orderBy(schema.messages.createdAt);
@@ -126,7 +128,8 @@ async function markConversationProcessed(conversationId) {
     if (!db)
         return;
     const schema = await getSchema();
-    await db.update(schema.conversations)
+    const sqliteDb = db;
+    await sqliteDb.update(schema.conversations)
         .set({
         metadata: sql `json_set(${schema.conversations.metadata}, 'selfIterationProcessed', true)`,
     })
@@ -208,7 +211,8 @@ async function processConversation(conversation, config) {
         // Update conversation with summary
         const db = await getDb();
         const schema = await getSchema();
-        await db.update(schema.conversations)
+        const sqliteDb = db;
+        await sqliteDb.update(schema.conversations)
             .set({ summary })
             .where(eq(schema.conversations.id, conversation.id));
         summariesCreated++;

package/dist/core/session-hooks/session-hooks.js

@@ -18,8 +18,9 @@ export async function onSessionEnd(sessionId) {
         return;
     }
     const schema = await getSchema();
+    const sqliteDb = db;
     // Mark conversation as ended
-    await db.update(schema.conversations)
+    await sqliteDb.update(schema.conversations)
         .set({ endedAt: new Date() })
         .where(eq(schema.conversations.sessionId, sessionId));
     logger.info(`[SessionHooks] Session ${sessionId} marked as ended`);
@@ -32,7 +33,8 @@ export async function getActiveSessions(projectId) {
     if (!db)
         return [];
     const schema = await getSchema();
-    const sessions = await db.select()
+    const sqliteDb = db;
+    const sessions = await sqliteDb.select()
         .from(schema.conversations)
         .where(eq(schema.conversations.projectId, projectId))
         .where(sql `${schema.conversations.endedAt} IS NULL`);
@@ -46,7 +48,8 @@ export async function endAllProjectSessions(projectId) {
     if (!db)
         return 0;
     const schema = await getSchema();
-    const result = await db.update(schema.conversations)
+    const sqliteDb = db;
+    const result = await sqliteDb.update(schema.conversations)
         .set({ endedAt: new Date() })
         .where(eq(schema.conversations.projectId, projectId));
     logger.info(`[SessionHooks] Ended ${result.rowCount} sessions for project ${projectId}`);

package/dist/core/tracing/collector.js

@@ -17,10 +17,11 @@ export async function startTrace(sessionId, query) {
         return '';
     }
     const schema = await getSchema();
+    const sqliteDb = db;
     const traceId = crypto.randomUUID();
     const timestamp = new Date();
     // Create trace record
-    await db.insert(schema.searchTraces).values({
+    await sqliteDb.insert(schema.searchTraces).values({
         id: traceId,
         sessionId,
         query,
@@ -39,8 +40,9 @@ export async function addQueryRewriteStage(traceId, stage) {
     if (!db)
         return;
     const schema = await getSchema();
+    const sqliteDb = db;
     const data = JSON.stringify(stage);
-    await db.update(schema.searchTraces)
+    await sqliteDb.update(schema.searchTraces)
         .set({
         queryRewrite: sql `CAST(? AS jsonb)`,
     })
@@ -56,8 +58,9 @@ export async function addCandidateRetrievalStage(traceId, stage) {
     if (!db)
         return;
     const schema = await getSchema();
+    const sqliteDb = db;
     const data = JSON.stringify(stage);
-    await db.update(schema.searchTraces)
+    await sqliteDb.update(schema.searchTraces)
         .set({ candidateRetrieval: data })
         .where(eq(schema.searchTraces.id, traceId));
     logger.debug(`[Tracing] Added candidateRetrieval stage to trace ${traceId}`);
@@ -70,8 +73,9 @@ export async function addEntityFilteringStage(traceId, stage) {
     if (!db)
         return;
     const schema = await getSchema();
+    const sqliteDb = db;
     const data = JSON.stringify(stage);
-    await db.update(schema.searchTraces)
+    await sqliteDb.update(schema.searchTraces)
         .set({ entityFiltering: data })
         .where(eq(schema.searchTraces.id, traceId));
     logger.debug(`[Tracing] Added entityFiltering stage to trace ${traceId}`);
@@ -84,8 +88,9 @@ export async function addHybridScoringStage(traceId, stage) {
     if (!db)
         return;
     const schema = await getSchema();
+    const sqliteDb = db;
     const data = JSON.stringify(stage);
-    await db.update(schema.searchTraces)
+    await sqliteDb.update(schema.searchTraces)
         .set({ hybridScoring: data })
         .where(eq(schema.searchTraces.id, traceId));
     logger.debug(`[Tracing] Added hybridScoring stage to trace ${traceId}`);
@@ -98,8 +103,9 @@ export async function addRerankingStage(traceId, stage) {
     if (!db)
         return;
     const schema = await getSchema();
+    const sqliteDb = db;
     const data = JSON.stringify(stage);
-    await db.update(schema.searchTraces)
+    await sqliteDb.update(schema.searchTraces)
         .set({ reranking: data })
         .where(eq(schema.searchTraces.id, traceId));
     logger.debug(`[Tracing] Added reranking stage to trace ${traceId}`);
@@ -112,8 +118,9 @@ export async function completeTrace(traceId, results) {
     if (!db)
         return;
     const schema = await getSchema();
+    const sqliteDb = db;
     // Get trace
-    const rows = await db.select()
+    const rows = await sqliteDb.select()
         .from(schema.searchTraces)
         .where(eq(schema.searchTraces.id, traceId))
         .limit(1);
@@ -127,7 +134,7 @@ export async function completeTrace(traceId, results) {
     const totalDurationMs = endTime - startTime;
     const resultCount = results.length;
     const topResults = results.slice(0, 10);
-    await db.update(schema.searchTraces)
+    await sqliteDb.update(schema.searchTraces)
         .set({
         resultCount,
         topResults: JSON.stringify(topResults),
@@ -144,6 +151,7 @@ export async function getTraces(options = {}) {
     if (!db)
         return [];
     const schema = await getSchema();
+    const sqliteDb = db;
     let conditions = [];
     if (options.sessionId) {
         conditions.push(eq(schema.searchTraces.sessionId, options.sessionId));
@@ -151,7 +159,7 @@ export async function getTraces(options = {}) {
     if (options.session && options.session.length > 0) {
         conditions.push(eq(schema.searchTraces.sessionId, options.session));
     }
-    const query = db.select()
+    const query = sqliteDb.select()
         .from(schema.searchTraces)
         .where(conditions.length > 0 ? eq(schema.searchTraces.sessionId, options.sessionId || options.session || '') : undefined)
         .orderBy(desc(schema.searchTraces.timestamp));
@@ -183,7 +191,8 @@ export async function getTraceById(traceId) {
     if (!db)
         return null;
     const schema = await getSchema();
-    const rows = await db.select()
+    const sqliteDb = db;
+    const rows = await sqliteDb.select()
         .from(schema.searchTraces)
         .where(eq(schema.searchTraces.id, traceId))
         .limit(1);
@@ -214,7 +223,8 @@ export async function getRecentTraces(limit = 10) {
     if (!db)
         return [];
     const schema = await getSchema();
-    const traces = await db.select()
+    const sqliteDb = db;
+    const traces = await sqliteDb.select()
         .from(schema.searchTraces)
         .orderBy(desc(schema.searchTraces.timestamp))
         .limit(limit);
@@ -242,8 +252,9 @@ export async function getSessionTraces(sessionId) {
     if (!db)
         return [];
     const schema = await getSchema();
+    const sqliteDb = db;
     // Get all traces for this session
-    const traces = await db.select()
+    const traces = await sqliteDb.select()
         .from(schema.searchTraces)
         .where(eq(schema.searchTraces.sessionId, sessionId))
         .orderBy(desc(schema.searchTraces.timestamp));
@@ -318,7 +329,8 @@ export async function getTraceStats() {
         };
     }
     const schema = await getSchema();
-    const traces = await db.select()
+    const sqliteDb = db;
+    const traces = await sqliteDb.select()
         .from(schema.searchTraces)
         .limit(100);
     const totalTraces = traces.length;

package/dist/db/adapter.d.ts

@@ -1,2 +1,7 @@
-export declare function createDb(): Promise<any>;
+export declare function createDb(): Promise<(import("drizzle-orm/node-postgres").NodePgDatabase<typeof import("../drizzle/schema.js")> & {
+    $client: import("pg").Pool;
+}) | (import("drizzle-orm/better-sqlite3").BetterSQLite3Database<typeof import("../drizzle/schema-sqlite.js")> & {
+    $client: import("better-sqlite3").Database;
+}) | import("drizzle-orm/sql-js").SQLJsDatabase<typeof import("../drizzle/schema-sqlite.js")>>;
+export default createDb;
 //# sourceMappingURL=adapter.d.ts.map

package/dist/db/adapter.js

@@ -1,8 +1,19 @@
 import { config, getDataDir } from '../config.js';
 import { ensurePostgresSchema, ensureSqliteSchema } from './bootstrap.js';
 import { logger } from '../core/logger.js';
-// Runtime detection - check if running in Bun
-const isBun = typeof globalThis.Bun !== 'undefined';
+async function createBunSqliteDb(dbPath) {
+    // @ts-ignore - bun:sqlite module not found in types but works at runtime
+    const { drizzle } = await import('drizzle-orm/bun-sqlite');
+    const schemaModule = await import('../drizzle/schema-sqlite.js');
+    // Bun SQLite doesn't need file path for in-memory, but we'll use file path for persistence
+    // @ts-ignore - bun:sqlite module not found in types but works at runtime
+    const sqlite = new (await import('bun:sqlite')).default(dbPath);
+    // Enable foreign keys
+    sqlite.exec('PRAGMA foreign_keys = ON');
+    await ensureSqliteSchema(sqlite);
+    logger.info('SQLite initialized with bun:sqlite');
+    return drizzle(sqlite, { schema: schemaModule });
+}
 export async function createDb() {
     if (config.isTeamMode) {
         return createPostgresDb();
@@ -24,145 +35,130 @@ async function createPostgresDb() {
 }
 async function createSqliteDb() {
     const dbPath = `${getDataDir()}/squish.db`;
-    // Try Bun's built-in SQLite first if running in Bun
-    if (isBun) {
+    // Try bun:sqlite first (Bun's built-in SQLite)
+    try {
+        return await createBunSqliteDb(dbPath);
+    }
+    catch (bunSqliteError) {
+        logger.warn('bun:sqlite failed, trying better-sqlite3', {
+            error: bunSqliteError.message
+        });
+        // Try better-sqlite3 second (best performance)
         try {
-            return await createBunSqliteDb(dbPath);
+            return await createBetterSqliteDb(dbPath);
         }
-        catch (error) {
-            logger.warn('Bun SQLite failed, trying better-sqlite3 fallback', { error: String(error) });
+        catch (betterSqliteError) {
+            logger.warn('better-sqlite3 failed, trying sql.js fallback', {
+                error: betterSqliteError.message
+            });
+            // Fallback to sql.js (pure JavaScript, no native module)
+            try {
+                return await createSqlJsDb(dbPath);
+            }
+            catch (sqlJsError) {
+                // All failed - this is critical, Squish cannot work without DB
+                logger.error('CRITICAL: SQLite database initialization failed', {
+                    bunSqliteError: bunSqliteError.message,
+                    betterSqliteError: betterSqliteError.message,
+                    sqlJsError: sqlJsError.message
+                });
+                throw new Error(`Squish requires SQLite to function. Database initialization failed.\n` +
+                    `Primary error (bun:sqlite): ${bunSqliteError.message}\n` +
+                    `Secondary error (better-sqlite3): ${betterSqliteError.message}\n` +
+                    `Fallback error (sql.js): ${sqlJsError.message}\n\n` +
+                    `Solutions:\n` +
+                    `1. Install build tools: npm install -g windows-build-tools (Windows)\n` +
+                    `2. Or use PostgreSQL instead by setting DATABASE_URL environment variable`);
+            }
         }
     }
-    // Fallback to better-sqlite3 for Node.js
-    try {
-        return await createBetterSqliteDb(dbPath);
-    }
-    catch (error) {
-        logger.error('SQLite initialization failed', error);
-        throw new Error(`SQLite database unavailable: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-}
-async function createBunSqliteDb(dbPath) {
-    // Dynamic import for Bun runtime - wrapped to avoid TS issues
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - bun:sqlite is only available in Bun runtime
-    const { Database } = await import('bun:sqlite');
-    const { drizzle } = await import('drizzle-orm/bun-sqlite');
-    const schemaModule = await import('../drizzle/schema-sqlite.js');
-    const sqlite = new Database(dbPath);
-    // Enable foreign keys
-    sqlite.run('PRAGMA foreign_keys = ON');
-    // Run full schema bootstrap from bootstrap.ts (includes ALL tables)
-    await ensureSqliteSchema(sqlite);
-    return drizzle(sqlite, { schema: schemaModule });
 }
 async function createBetterSqliteDb(dbPath) {
     const DatabaseModule = await import('better-sqlite3');
     const Database = DatabaseModule.default;
     const { drizzle } = await import('drizzle-orm/better-sqlite3');
     const schemaModule = await import('../drizzle/schema-sqlite.js');
-    let sqlite;
-    try {
-        sqlite = new Database(dbPath);
-    }
-    catch (error) {
-        // Check if it's a Win32 native module error
-        if (error.message?.includes('not a valid Win32 application')) {
-            logger.error('better-sqlite3 native module not compiled for this platform');
-            logger.error('Solution: Run "npm run web:bun" to use Bun instead, or rebuild with "npm rebuild better-sqlite3"');
-            throw new Error('SQLite native module unavailable. Use "npm run web:bun" or rebuild better-sqlite3 for your platform.');
-        }
-        throw error;
-    }
+    const sqlite = new Database(dbPath);
     // Enable foreign keys
     sqlite.pragma('foreign_keys = ON');
     await ensureSqliteSchema(sqlite);
+    logger.info('SQLite initialized with better-sqlite3');
     return drizzle(sqlite, { schema: schemaModule });
 }
-// Bun-specific schema bootstrap
-function ensureSqliteSchemaForBun(sqlite) {
-    const createMemoriesTable = `
-    CREATE TABLE IF NOT EXISTS memories (
-      id TEXT PRIMARY KEY,
-      project_id TEXT,
-      type TEXT NOT NULL DEFAULT 'observation',
-      content TEXT NOT NULL,
-      summary TEXT,
-      tags TEXT,
-      metadata TEXT,
-      embedding BLOB,
-      embedding_json TEXT,
-      source TEXT DEFAULT 'mcp',
-      tier TEXT DEFAULT 'warm',
-      status TEXT DEFAULT 'active',
-      importance_score REAL DEFAULT 50,
-      relevance_score REAL,
-      coactivation_score INTEGER DEFAULT 0,
-      access_count INTEGER DEFAULT 0,
-      retrieval_count INTEGER DEFAULT 0,
-      echo_count INTEGER DEFAULT 0,
-      fizzle_count INTEGER DEFAULT 0,
-      is_pinned INTEGER DEFAULT 0,
-      is_protected INTEGER DEFAULT 0,
-      is_immutable INTEGER DEFAULT 0,
-      is_mergeable INTEGER DEFAULT 0,
-      is_merged INTEGER DEFAULT 0,
-      merged_into TEXT,
-      merged_at TEXT,
-      superseded_by TEXT,
-      superseded_at TEXT,
-      valid_from TEXT,
-      valid_to TEXT,
-      expired_at TEXT,
-      last_accessed_at TEXT,
-      last_retrieved_at TEXT,
-      last_echoed_at TEXT,
-      last_importance_recalc TEXT,
-      created_at TEXT DEFAULT CURRENT_TIMESTAMP,
-      updated_at TEXT DEFAULT CURRENT_TIMESTAMP
-    )
-  `;
-    const createProjectsTable = `
-    CREATE TABLE IF NOT EXISTS projects (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      path TEXT UNIQUE,
-      description TEXT,
-      metadata TEXT,
-      created_at TEXT DEFAULT CURRENT_TIMESTAMP,
-      updated_at TEXT DEFAULT CURRENT_TIMESTAMP
-    )
-  `;
-    const createAssociationsTable = `
-    CREATE TABLE IF NOT EXISTS memory_associations (
-      id TEXT PRIMARY KEY,
-      from_memory_id TEXT NOT NULL,
-      to_memory_id TEXT NOT NULL,
-      association_type TEXT NOT NULL,
-      weight REAL DEFAULT 1,
-      coactivation_count INTEGER DEFAULT 1,
-      last_coactivated_at TEXT,
-      created_at TEXT DEFAULT CURRENT_TIMESTAMP,
-      UNIQUE(from_memory_id, to_memory_id)
-    )
-  `;
-    sqlite.run(createMemoriesTable);
-    sqlite.run(createProjectsTable);
-    sqlite.run(createAssociationsTable);
-    // FTS is optional - don't fail if it doesn't work
-    try {
-        sqlite.run(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-        content,
-        summary,
-        content='memories',
-        content_rowid='rowid'
-      )
-    `);
-    }
-    catch (e) {
-        logger.debug('FTS5 table creation skipped', { error: e?.message || String(e) });
+async function createSqlJsDb(dbPath) {
+    // @ts-ignore - sql.js has no types but works fine
+    const initSqlJs = await import('sql.js');
+    const { drizzle } = await import('drizzle-orm/sql-js');
+    const schemaModule = await import('../drizzle/schema-sqlite.js');
+    const fs = await import('fs');
+    const path = await import('path');
+    const SQL = await initSqlJs.default();
+    let data;
+    // Try to load existing database
+    if (fs.existsSync(dbPath)) {
+        data = fs.readFileSync(dbPath);
     }
-    logger.info('SQLite schema initialized (Bun runtime)');
+    const sqlite = new SQL.Database(data);
+    // Enable foreign keys
+    sqlite.exec('PRAGMA foreign_keys = ON');
+    // Schema bootstrap
+    await ensureSqliteSchema(sqlite);
+    // Persist database on changes (sql.js is in-memory by default)
+    const originalExec = sqlite.exec.bind(sqlite);
+    sqlite.exec = function (...args) {
+        const result = originalExec(...args);
+        // Save after each exec
+        const data = sqlite.export();
+        fs.writeFileSync(dbPath, Buffer.from(data));
+        return result;
+    };
+    // Add prepare method for compatibility with drizzle-orm/sql-js
+    sqlite.prepare = (query) => {
+        const stmt = sqlite.prepare(query);
+        const preparedStatement = {};
+        preparedStatement.bind = (bindParams) => {
+            bindParams.forEach((param, index) => {
+                stmt.bind(param, index + 1);
+            });
+            return preparedStatement;
+        };
+        preparedStatement.step = () => {
+            return stmt.step();
+        };
+        preparedStatement.getAsObject = () => {
+            return stmt.getAsObject();
+        };
+        preparedStatement.free = () => {
+            stmt.free();
+        };
+        preparedStatement.run = () => {
+            const result = stmt.step() ? { changes: sqlite.changes() } : { changes: 0 };
+            stmt.reset();
+            return result;
+        };
+        preparedStatement.get = (bindParams = []) => {
+            if (bindParams.length > 0) {
+                preparedStatement.bind(bindParams);
+            }
+            const row = stmt.step() ? stmt.getAsObject() : undefined;
+            stmt.reset();
+            return row;
+        };
+        preparedStatement.all = (bindParams = []) => {
+            if (bindParams.length > 0) {
+                preparedStatement.bind(bindParams);
+            }
+            const rows = [];
+            while (stmt.step()) {
+                rows.push(stmt.getAsObject());
+            }
+            stmt.reset();
+            return rows;
+        };
+        return preparedStatement;
+    };
+    logger.info('SQLite initialized with sql.js (pure JavaScript fallback)');
+    return drizzle(sqlite, { schema: schemaModule });
 }
+export default createDb;
 //# sourceMappingURL=adapter.js.map