@codemcp/workflows-core 3.1.20 → 3.1.21-fix-build-after-monorepo.1

package/dist/database.js

@@ -1,233 +1,169 @@
 /**
- * Database module for persistent state storage
+ * Database Manager
  *
- * Manages SQLite database for conversation state persistence.
- * Stores minimal state information to survive server restarts.
- * Also stores interaction logs for auditing and debugging.
+ * Handles SQLite database operations for conversation state persistence.
+ * Uses @sqlite.org/sqlite-wasm for reliable cross-platform WebAssembly bindings.
  */
-import sqlite3 from 'sqlite3';
+import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
 import { mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
-import { join } from 'node:path';
 import { createLogger } from './logger.js';
 const logger = createLogger('Database');
-// Database row validation utilities
-function validateString(value, fieldName) {
-    if (typeof value === 'string') {
-        return value;
-    }
-    throw new Error(`Database field '${fieldName}' expected string but got ${typeof value}: ${value}`);
-}
-function parseJsonSafely(value, fieldName) {
-    if (!value) {
-        return undefined;
-    }
-    const stringValue = validateString(value, fieldName);
-    try {
-        return JSON.parse(stringValue);
-    }
-    catch (error) {
-        throw new Error(`Failed to parse JSON in field '${fieldName}': ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-function mapRowToInteractionLog(row) {
-    return {
-        id: typeof row.id === 'number' ? row.id : undefined,
-        conversationId: validateString(row.conversationId, 'conversationId'),
-        toolName: validateString(row.toolName, 'toolName'),
-        inputParams: validateString(row.inputParams, 'inputParams'),
-        responseData: validateString(row.responseData, 'responseData'),
-        currentPhase: validateString(row.currentPhase, 'currentPhase'),
-        timestamp: validateString(row.timestamp, 'timestamp'),
-        isReset: typeof row.isReset === 'number' ? Boolean(row.isReset) : undefined,
-        resetAt: row.resetAt ? validateString(row.resetAt, 'resetAt') : undefined,
-    };
-}
+/**
+ * Database connection and operations manager
+ */
 export class Database {
     db = null;
+    sqlite3 = null;
     dbPath;
-    constructor(projectPath) {
-        // Store database in .vibe subfolder of the project
-        const vibeDir = join(projectPath, '.vibe');
-        this.dbPath = join(vibeDir, 'conversation-state.sqlite');
-        logger.debug('Database path configured', {
-            projectPath,
-            dbPath: this.dbPath,
-        });
+    constructor(dbPath) {
+        this.dbPath = dbPath;
     }
     /**
      * Initialize database connection and create tables
      */
     async initialize() {
-        logger.debug('Initializing database', { dbPath: this.dbPath });
         try {
-            // Ensure directory exists
-            await mkdir(dirname(this.dbPath), { recursive: true });
-            logger.debug('Database directory ensured', {
-                directory: dirname(this.dbPath),
+            // Initialize SQLite WASM
+            this.sqlite3 = await sqlite3InitModule();
+            // Always use in-memory database (sqlite-wasm Node.js limitation)
+            this.db = new this.sqlite3.oo1.DB();
+            logger.debug('Database connection established (in-memory)', {
+                originalPath: this.dbPath,
             });
-            // Create database connection
-            this.db = new sqlite3.Database(this.dbPath);
-            logger.debug('Database connection established');
-            // Create conversation_states table
-            await this.runQuery(`
-        CREATE TABLE IF NOT EXISTS conversation_states (
-          conversation_id TEXT PRIMARY KEY,
-          project_path TEXT NOT NULL,
-          git_branch TEXT NOT NULL,
-          current_phase TEXT NOT NULL,
-          plan_file_path TEXT NOT NULL,
-          workflow_name TEXT DEFAULT 'waterfall',
-          git_commit_config TEXT, -- JSON string for GitCommitConfig
-          created_at TEXT NOT NULL,
-          updated_at TEXT NOT NULL
-        )
-      `);
-            // Create index for efficient lookups
-            await this.runQuery(`
-        CREATE INDEX IF NOT EXISTS idx_project_branch 
-        ON conversation_states(project_path, git_branch)
-      `);
-            // Create interaction_logs table
-            await this.runQuery(`
-        CREATE TABLE IF NOT EXISTS interaction_logs (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          conversation_id TEXT NOT NULL,
-          tool_name TEXT NOT NULL,
-          input_params TEXT NOT NULL,
-          response_data TEXT NOT NULL,
-          current_phase TEXT NOT NULL,
-          timestamp TEXT NOT NULL,
-          is_reset BOOLEAN DEFAULT FALSE,
-          reset_at TEXT,
-          FOREIGN KEY (conversation_id) REFERENCES conversation_states(conversation_id)
-        )
-      `);
-            // Create index for efficient lookups of interaction logs
-            await this.runQuery(`
-        CREATE INDEX IF NOT EXISTS idx_interaction_conversation_id 
-        ON interaction_logs(conversation_id)
-      `);
-            // Run migrations to add any missing columns
-            await this.runMigrations();
+            // Create tables
+            await this.createTables();
+            // Load existing data from file if it exists
+            if (this.dbPath !== ':memory:' && this.dbPath) {
+                await this.loadFromFile();
+            }
             logger.info('Database initialized successfully', { dbPath: this.dbPath });
         }
         catch (error) {
-            logger.error('Failed to initialize database', error, {
-                dbPath: this.dbPath,
-            });
+            logger.error('Failed to initialize database', error);
             throw error;
         }
     }
     /**
-     * Helper method to run queries with promises
-     */
-    runQuery(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            if (!this.db) {
-                reject(new Error('Database not initialized'));
-                return;
-            }
-            this.db.run(sql, params, function (err) {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    /**
-     * Helper method to get single row with promises
+     * Load database content from file
      */
-    getRow(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            if (!this.db) {
-                reject(new Error('Database not initialized'));
-                return;
-            }
-            this.db.get(sql, params, (err, row) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(row);
+    async loadFromFile() {
+        if (!this.db || !this.dbPath || this.dbPath === ':memory:') {
+            return;
+        }
+        try {
+            const { readFile, access } = await import('node:fs/promises');
+            await access(this.dbPath);
+            const data = await readFile(this.dbPath);
+            if (data.length > 0) {
+                // Close current in-memory DB and create new one from file data
+                this.db.close();
+                // Create new DB and deserialize data into it
+                //eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                this.db = new this.sqlite3.oo1.DB();
+                if (!this.db.pointer) {
+                    throw new Error('Failed to create database');
                 }
-            });
-        });
-    }
-    /**
-     * Helper method to get multiple rows with promises
-     */
-    getAllRows(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            if (!this.db) {
-                reject(new Error('Database not initialized'));
-                return;
+                // Convert Buffer to Uint8Array
+                const uint8Data = new Uint8Array(data);
+                //eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const wasmPtr = this.sqlite3.wasm.allocFromTypedArray(uint8Data);
+                //eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                this.sqlite3.capi.sqlite3_deserialize(this.db.pointer, 'main', wasmPtr, data.length, data.length, 0x01 // SQLITE_DESERIALIZE_FREEONCLOSE
+                );
+                logger.debug('Loaded database from file', {
+                    dbPath: this.dbPath,
+                    size: data.length,
+                });
             }
-            this.db.all(sql, params, (err, rows) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(rows);
-                }
+        }
+        catch {
+            // File doesn't exist - that's OK for new databases
+            logger.debug('No existing database file to load', {
+                dbPath: this.dbPath,
             });
-        });
+        }
     }
     /**
-     * Get conversation state by ID
+     * Save database content to file
      */
-    async getConversationState(conversationId) {
-        logger.debug('Retrieving conversation state', { conversationId });
+    async saveToFile() {
+        if (!this.db || !this.dbPath || this.dbPath === ':memory:') {
+            return;
+        }
         try {
-            const row = await this.getRow('SELECT * FROM conversation_states WHERE conversation_id = ?', [conversationId]);
-            if (!row) {
-                logger.debug('Conversation state not found', { conversationId });
-                return null;
+            const { writeFile } = await import('node:fs/promises');
+            const dbDir = dirname(this.dbPath);
+            await mkdir(dbDir, { recursive: true });
+            // Export database to Uint8Array and save to file
+            if (!this.db.pointer) {
+                throw new Error('Database pointer is invalid');
             }
-            const state = {
-                conversationId: validateString(row.conversation_id, 'conversation_id'),
-                projectPath: validateString(row.project_path, 'project_path'),
-                gitBranch: validateString(row.git_branch, 'git_branch'),
-                currentPhase: validateString(row.current_phase, 'current_phase'),
-                planFilePath: validateString(row.plan_file_path, 'plan_file_path'),
-                workflowName: validateString(row.workflow_name, 'workflow_name'),
-                gitCommitConfig: parseJsonSafely(row.git_commit_config, 'git_commit_config'),
-                requireReviewsBeforePhaseTransition: Boolean(row.require_reviews_before_phase_transition),
-                createdAt: validateString(row.created_at, 'created_at'),
-                updatedAt: validateString(row.updated_at, 'updated_at'),
-            };
-            logger.debug('Conversation state retrieved', {
-                conversationId,
-                currentPhase: state.currentPhase,
-                projectPath: state.projectPath,
+            //eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const data = this.sqlite3.capi.sqlite3_js_db_export(this.db.pointer);
+            await writeFile(this.dbPath, data);
+            logger.debug('Saved database to file', {
+                dbPath: this.dbPath,
+                size: data.length,
             });
-            return state;
         }
         catch (error) {
-            logger.error('Failed to retrieve conversation state', error, {
-                conversationId,
+            logger.warn('Failed to save database to file', {
+                error: error,
+                dbPath: this.dbPath,
             });
-            throw error;
         }
     }
     /**
-     * Save or update conversation state
+     * Create database tables if they don't exist
+     */
+    async createTables() {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        const createConversationStateTable = `
+      CREATE TABLE IF NOT EXISTS conversation_state (
+        conversationId TEXT PRIMARY KEY,
+        projectPath TEXT NOT NULL,
+        gitBranch TEXT NOT NULL,
+        currentPhase TEXT NOT NULL,
+        planFilePath TEXT NOT NULL,
+        workflowName TEXT NOT NULL,
+        gitCommitConfig TEXT,
+        requireReviewsBeforePhaseTransition INTEGER NOT NULL DEFAULT 0,
+        createdAt TEXT NOT NULL,
+        updatedAt TEXT NOT NULL
+      )
+    `;
+        const createInteractionLogTable = `
+      CREATE TABLE IF NOT EXISTS interaction_log (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        conversationId TEXT NOT NULL,
+        toolName TEXT NOT NULL,
+        inputParams TEXT NOT NULL,
+        responseData TEXT NOT NULL,
+        currentPhase TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        FOREIGN KEY (conversationId) REFERENCES conversation_state(conversationId)
+      )
+    `;
+        this.db.exec(createConversationStateTable);
+        this.db.exec(createInteractionLogTable);
+        logger.debug('Database tables created');
+    }
+    /**
+     * Save conversation state to database
      */
     async saveConversationState(state) {
-        logger.debug('Saving conversation state', {
-            conversationId: state.conversationId,
-            currentPhase: state.currentPhase,
-            projectPath: state.projectPath,
-            workflowName: state.workflowName,
-        });
-        try {
-            await this.runQuery(`INSERT OR REPLACE INTO conversation_states (
-          conversation_id, project_path, git_branch, current_phase,
-          plan_file_path, workflow_name, git_commit_config, require_reviews_before_phase_transition, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        this.db.exec({
+            sql: `INSERT OR REPLACE INTO conversation_state
+            (conversationId, projectPath, gitBranch, currentPhase, planFilePath, workflowName,
+             gitCommitConfig, requireReviewsBeforePhaseTransition, createdAt, updatedAt)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            bind: [
                 state.conversationId,
                 state.projectPath,
                 state.gitBranch,
@@ -235,266 +171,188 @@ export class Database {
                 state.planFilePath,
                 state.workflowName,
                 state.gitCommitConfig ? JSON.stringify(state.gitCommitConfig) : null,
-                state.requireReviewsBeforePhaseTransition,
+                state.requireReviewsBeforePhaseTransition ? 1 : 0,
                 state.createdAt,
                 state.updatedAt,
-            ]);
-            logger.info('Conversation state saved successfully', {
-                conversationId: state.conversationId,
-                currentPhase: state.currentPhase,
-            });
-        }
-        catch (error) {
-            logger.error('Failed to save conversation state', error, {
-                conversationId: state.conversationId,
-            });
-            throw error;
-        }
+            ],
+        });
+        // Persist to file
+        await this.saveToFile();
+        logger.debug('Conversation state saved', {
+            conversationId: state.conversationId,
+            currentPhase: state.currentPhase,
+        });
     }
     /**
-     * Find conversation by project path and git branch
+     * Get conversation state by ID
      */
-    async findConversationByProject(projectPath, gitBranch) {
-        const row = await this.getRow('SELECT * FROM conversation_states WHERE project_path = ? AND git_branch = ?', [projectPath, gitBranch]);
-        if (!row) {
+    async getConversationState(conversationId) {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        const result = this.db.exec({
+            sql: 'SELECT * FROM conversation_state WHERE conversationId = ?',
+            bind: [conversationId],
+            returnValue: 'resultRows',
+        });
+        if (!result || result.length === 0) {
             return null;
         }
+        const row = result[0];
         return {
-            conversationId: validateString(row.conversation_id, 'conversation_id'),
-            projectPath: validateString(row.project_path, 'project_path'),
-            gitBranch: validateString(row.git_branch, 'git_branch'),
-            currentPhase: validateString(row.current_phase, 'current_phase'),
-            planFilePath: validateString(row.plan_file_path, 'plan_file_path'),
-            workflowName: validateString(row.workflow_name, 'workflow_name'),
-            gitCommitConfig: parseJsonSafely(row.git_commit_config, 'git_commit_config'),
-            requireReviewsBeforePhaseTransition: Boolean(row.require_reviews_before_phase_transition),
-            createdAt: validateString(row.created_at, 'created_at'),
-            updatedAt: validateString(row.updated_at, 'updated_at'),
+            conversationId: row[0],
+            projectPath: row[1],
+            gitBranch: row[2],
+            currentPhase: row[3],
+            planFilePath: row[4],
+            workflowName: row[5],
+            gitCommitConfig: row[6] ? JSON.parse(row[6]) : null,
+            requireReviewsBeforePhaseTransition: Boolean(row[7]),
+            createdAt: row[8],
+            updatedAt: row[9],
         };
     }
+    /**
+     * Get all conversation states
+     */
+    async getAllConversationStates() {
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        const result = this.db.exec({
+            sql: 'SELECT * FROM conversation_state ORDER BY updatedAt DESC',
+            returnValue: 'resultRows',
+        });
+        if (!result) {
+            return [];
+        }
+        return result.map(row => ({
+            conversationId: row[0],
+            projectPath: row[1],
+            gitBranch: row[2],
+            currentPhase: row[3],
+            planFilePath: row[4],
+            workflowName: row[5],
+            gitCommitConfig: row[6] ? JSON.parse(row[6]) : null,
+            requireReviewsBeforePhaseTransition: Boolean(row[7]),
+            createdAt: row[8],
+            updatedAt: row[9],
+        }));
+    }
     /**
      * Delete conversation state
      */
     async deleteConversationState(conversationId) {
-        await this.runQuery('DELETE FROM conversation_states WHERE conversation_id = ?', [conversationId]);
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        this.db.exec({
+            sql: 'DELETE FROM conversation_state WHERE conversationId = ?',
+            bind: [conversationId],
+        });
+        // Persist to file
+        await this.saveToFile();
+        logger.debug('Conversation state deleted', { conversationId });
+        return true;
     }
     /**
-     * Log an interaction to the database
+     * Log interaction
      */
     async logInteraction(log) {
-        logger.debug('Logging interaction to database', {
-            conversationId: log.conversationId,
-            toolName: log.toolName,
-        });
-        try {
-            await this.runQuery(`INSERT INTO interaction_logs (
-          conversation_id, tool_name, input_params, response_data,
-          current_phase, timestamp
-        ) VALUES (?, ?, ?, ?, ?, ?)`, [
+        if (!this.db) {
+            throw new Error('Database not initialized');
+        }
+        this.db.exec({
+            sql: `INSERT INTO interaction_log
+            (conversationId, toolName, inputParams, responseData, currentPhase, timestamp)
+            VALUES (?, ?, ?, ?, ?, ?)`,
+            bind: [
                 log.conversationId,
                 log.toolName,
-                log.inputParams,
-                log.responseData,
+                JSON.stringify(log.inputParams),
+                JSON.stringify(log.responseData),
                 log.currentPhase,
                 log.timestamp,
-            ]);
-            logger.debug('Interaction logged successfully', {
-                conversationId: log.conversationId,
-                toolName: log.toolName,
-                timestamp: log.timestamp,
-            });
-        }
-        catch (error) {
-            logger.error('Failed to log interaction', error, {
-                conversationId: log.conversationId,
-            });
-            throw error;
-        }
+            ],
+        });
+        // Persist to file
+        await this.saveToFile();
+        logger.debug('Interaction logged', {
+            conversationId: log.conversationId,
+            toolName: log.toolName,
+        });
     }
     /**
-     * Get all interactions for a specific conversation
+     * Get interaction logs for a conversation
      */
-    async getInteractionsByConversationId(conversationId) {
-        logger.debug('Getting interactions by conversation ID', { conversationId });
-        try {
-            const rows = await this.getAllRows('SELECT * FROM interaction_logs WHERE conversation_id = ? ORDER BY timestamp ASC', [conversationId]);
-            const logs = rows.map(row => ({
-                id: typeof row.id === 'number' ? row.id : undefined,
-                conversationId: validateString(row.conversation_id, 'conversation_id'),
-                toolName: validateString(row.tool_name, 'tool_name'),
-                inputParams: validateString(row.input_params, 'input_params'),
-                responseData: validateString(row.response_data, 'response_data'),
-                currentPhase: validateString(row.current_phase, 'current_phase'),
-                timestamp: validateString(row.timestamp, 'timestamp'),
-            }));
-            logger.debug('Retrieved interaction logs', {
-                conversationId,
-                count: logs.length,
-            });
-            return logs;
+    async getInteractionLogs(conversationId) {
+        if (!this.db) {
+            throw new Error('Database not initialized');
         }
-        catch (error) {
-            logger.error('Failed to get interaction logs', error, {
-                conversationId,
-            });
-            throw error;
+        const result = this.db.exec({
+            sql: 'SELECT * FROM interaction_log WHERE conversationId = ? ORDER BY timestamp ASC',
+            bind: [conversationId],
+            returnValue: 'resultRows',
+        });
+        if (!result) {
+            return [];
         }
+        return result.map(row => ({
+            id: row[0],
+            conversationId: row[1],
+            toolName: row[2],
+            inputParams: JSON.parse(row[3]),
+            responseData: JSON.parse(row[4]),
+            currentPhase: row[5],
+            timestamp: row[6],
+        }));
     }
     /**
-     * Run database migrations to add new columns
+     * Get interaction logs for a conversation (alias for compatibility)
      */
-    async runMigrations() {
-        logger.debug('Running database migrations');
-        try {
-            // Check if interaction_logs table exists first
-            const tables = await this.getAllRows("SELECT name FROM sqlite_master WHERE type='table' AND name='interaction_logs'");
-            if (tables.length > 0) {
-                // Table exists, check for missing columns
-                const tableInfo = await this.getAllRows('PRAGMA table_info(interaction_logs)');
-                const hasIsReset = tableInfo.some((col) => col.name === 'is_reset');
-                const hasResetAt = tableInfo.some((col) => col.name === 'reset_at');
-                if (!hasIsReset) {
-                    logger.info('Adding is_reset column to interaction_logs table');
-                    await this.runQuery('ALTER TABLE interaction_logs ADD COLUMN is_reset BOOLEAN DEFAULT FALSE');
-                }
-                if (!hasResetAt) {
-                    logger.info('Adding reset_at column to interaction_logs table');
-                    await this.runQuery('ALTER TABLE interaction_logs ADD COLUMN reset_at TEXT');
-                }
-            }
-            // Check if conversation_states table exists and has workflow_name column
-            const conversationTables = await this.getAllRows("SELECT name FROM sqlite_master WHERE type='table' AND name='conversation_states'");
-            if (conversationTables.length > 0) {
-                const conversationTableInfo = (await this.getAllRows('PRAGMA table_info(conversation_states)'));
-                const hasWorkflowName = conversationTableInfo.some((col) => col.name === 'workflow_name');
-                const hasGitCommitConfig = conversationTableInfo.some((col) => col.name === 'git_commit_config');
-                const hasRequireReviews = conversationTableInfo.some((col) => col.name === 'require_reviews_before_phase_transition');
-                if (!hasWorkflowName) {
-                    logger.info('Adding workflow_name column to conversation_states table');
-                    await this.runQuery("ALTER TABLE conversation_states ADD COLUMN workflow_name TEXT DEFAULT 'waterfall'");
-                }
-                if (!hasGitCommitConfig) {
-                    logger.info('Adding git_commit_config column to conversation_states table');
-                    await this.runQuery('ALTER TABLE conversation_states ADD COLUMN git_commit_config TEXT');
-                }
-                if (!hasRequireReviews) {
-                    logger.info('Adding require_reviews_before_phase_transition column to conversation_states table');
-                    await this.runQuery('ALTER TABLE conversation_states ADD COLUMN require_reviews_before_phase_transition BOOLEAN DEFAULT FALSE');
-                }
-            }
-            logger.debug('Database migrations completed successfully');
-        }
-        catch (error) {
-            logger.error('Failed to run database migrations', error);
-            throw error;
-        }
+    async getInteractionsByConversationId(conversationId) {
+        return this.getInteractionLogs(conversationId);
     }
     /**
-     * Soft delete interaction logs for a conversation
+     * Soft delete interaction logs (for compatibility - actually deletes them)
      */
-    async softDeleteInteractionLogs(conversationId, reason) {
-        logger.debug('Soft deleting interaction logs', { conversationId, reason });
-        try {
-            const resetAt = new Date().toISOString();
-            await this.runQuery('UPDATE interaction_logs SET is_reset = TRUE, reset_at = ? WHERE conversation_id = ? AND is_reset = FALSE', [resetAt, conversationId]);
-            logger.info('Interaction logs soft deleted successfully', {
-                conversationId,
-                reason,
-                resetAt,
-            });
-        }
-        catch (error) {
-            logger.error('Failed to soft delete interaction logs', error, {
-                conversationId,
-            });
-            throw error;
+    async softDeleteInteractionLogs(conversationId) {
+        if (!this.db) {
+            throw new Error('Database not initialized');
         }
+        this.db.exec({
+            sql: 'DELETE FROM interaction_log WHERE conversationId = ?',
+            bind: [conversationId],
+        });
+        // Persist to file
+        await this.saveToFile();
+        logger.debug('Interaction logs deleted', { conversationId });
     }
     /**
-     * Get active (non-reset) interaction logs for a conversation
+     * Reset conversation state (for testing)
      */
-    async getActiveInteractionLogs(conversationId) {
-        logger.debug('Getting active interaction logs', { conversationId });
-        try {
-            const rows = await this.getAllRows('SELECT * FROM interaction_logs WHERE conversation_id = ? AND (is_reset = FALSE OR is_reset IS NULL) ORDER BY timestamp ASC', [conversationId]);
-            const logs = rows.map(row => mapRowToInteractionLog({
-                id: row.id,
-                conversationId: row.conversation_id,
-                toolName: row.tool_name,
-                inputParams: row.input_params,
-                responseData: row.response_data,
-                currentPhase: row.current_phase,
-                timestamp: row.timestamp,
-            }));
-            logger.debug('Retrieved active interaction logs', {
-                conversationId,
-                count: logs.length,
-            });
-            return logs;
-        }
-        catch (error) {
-            logger.error('Failed to get active interaction logs', error, {
-                conversationId,
-            });
-            throw error;
+    async resetConversationState(conversationId) {
+        if (!this.db) {
+            throw new Error('Database not initialized');
         }
-    }
-    /**
-     * Get all interaction logs including reset ones for a conversation
-     */
-    async getAllInteractionLogsIncludingReset(conversationId) {
-        logger.debug('Getting all interaction logs including reset', {
-            conversationId,
+        const resetAt = new Date().toISOString();
+        this.db.exec({
+            sql: 'UPDATE conversation_state SET updatedAt = ? WHERE conversationId = ?',
+            bind: [resetAt, conversationId],
         });
-        try {
-            const rows = await this.getAllRows('SELECT * FROM interaction_logs WHERE conversation_id = ? ORDER BY timestamp ASC', [conversationId]);
-            const logs = rows.map(row => mapRowToInteractionLog({
-                id: row.id,
-                conversationId: row.conversation_id,
-                toolName: row.tool_name,
-                inputParams: row.input_params,
-                responseData: row.response_data,
-                currentPhase: row.current_phase,
-                timestamp: row.timestamp,
-                isReset: row.is_reset,
-                resetAt: row.reset_at,
-            }));
-            logger.debug('Retrieved all interaction logs including reset', {
-                conversationId,
-                count: logs.length,
-                resetCount: logs.filter(log => log.isReset).length,
-            });
-            return logs;
-        }
-        catch (error) {
-            logger.error('Failed to get all interaction logs including reset', error, { conversationId });
-            throw error;
-        }
+        // Persist to file
+        await this.saveToFile();
+        logger.debug('Conversation state reset', { conversationId, resetAt });
     }
     /**
      * Close database connection
      */
     async close() {
-        logger.debug('Closing database connection');
-        return new Promise((resolve, reject) => {
-            if (this.db) {
-                this.db.close(err => {
-                    if (err) {
-                        logger.error('Failed to close database connection', err);
-                        reject(err);
-                    }
-                    else {
-                        this.db = null;
-                        logger.info('Database connection closed successfully');
-                        resolve();
-                    }
-                });
-            }
-            else {
-                logger.debug('Database connection already closed');
-                resolve();
-            }
-        });
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            logger.debug('Database connection closed');
+        }
     }
 }
 //# sourceMappingURL=database.js.map