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

package/src/database.ts

@@ -1,685 +1,373 @@
 /**
- * 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 better-sqlite3 for reliable cross-platform native bindings.
  */
 
-import sqlite3 from 'sqlite3';
+import BetterSqlite3 from 'better-sqlite3';
 import { mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
-
-import { join } from 'node:path';
 import { createLogger } from './logger.js';
-import type { DevelopmentPhase } from './state-machine.js';
-import type {
-  ConversationState,
-  InteractionLog,
-  GitCommitConfig,
-} from './types.js';
+import type { ConversationState, InteractionLog } from './types.js';
 
 const logger = createLogger('Database');
 
-// SQLite parameter types
-type SqliteParam = string | number | boolean | null | undefined | Buffer;
-type SqliteRow = Record<string, SqliteParam>;
-type SqliteColumnInfo = {
-  cid: number;
-  name: string;
-  type: string;
-  notnull: number;
-  dflt_value: SqliteParam;
-  pk: number;
-};
-
-// Database row validation utilities
-function validateString(value: SqliteParam, fieldName: string): string {
-  if (typeof value === 'string') {
-    return value;
-  }
-  throw new Error(
-    `Database field '${fieldName}' expected string but got ${typeof value}: ${value}`
-  );
-}
-
-function parseJsonSafely(value: SqliteParam, fieldName: string): unknown {
-  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: SqliteRow): InteractionLog {
-  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 {
-  private db: sqlite3.Database | null = null;
+  private db: BetterSqlite3.Database | null = null;
   private dbPath: string;
 
-  constructor(projectPath: string) {
-    // 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: string) {
+    this.dbPath = dbPath;
   }
 
   /**
    * Initialize database connection and create tables
    */
   async initialize(): Promise<void> {
-    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),
-      });
+      const dbDir = dirname(this.dbPath);
+      await mkdir(dbDir, { recursive: true });
+      logger.debug('Database directory ensured', { dbDir });
 
       // Create database connection
-      this.db = new sqlite3.Database(this.dbPath);
+      this.db = new BetterSqlite3(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();
       logger.info('Database initialized successfully', { dbPath: this.dbPath });
     } catch (error) {
-      logger.error('Failed to initialize database', error as Error, {
-        dbPath: this.dbPath,
-      });
+      logger.error('Failed to initialize database', error as Error);
       throw error;
     }
   }
 
   /**
-   * Helper method to run queries with promises
+   * Create database tables if they don't exist
    */
-  private runQuery(sql: string, params: SqliteParam[] = []): Promise<void> {
-    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();
-        }
-      });
-    });
-  }
+  private async createTables(): Promise<void> {
+    if (!this.db) {
+      throw new Error('Database not initialized');
+    }
 
-  /**
-   * Helper method to get single row with promises
-   */
-  private getRow(
-    sql: string,
-    params: SqliteParam[] = []
-  ): Promise<SqliteRow | null> {
-    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 as SqliteRow | null);
-        }
-      });
-    });
+    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,
+        isReset INTEGER DEFAULT 0,
+        resetAt TEXT,
+        FOREIGN KEY (conversationId) REFERENCES conversation_state(conversationId)
+      )
+    `;
+
+    this.db.exec(createConversationStateTable);
+    this.db.exec(createInteractionLogTable);
+    logger.debug('Tables created successfully');
   }
 
   /**
-   * Helper method to get multiple rows with promises
+   * Save conversation state to database
    */
-  private getAllRows(
-    sql: string,
-    params: SqliteParam[] = []
-  ): Promise<SqliteRow[]> {
-    return new Promise((resolve, reject) => {
-      if (!this.db) {
-        reject(new Error('Database not initialized'));
-        return;
-      }
-
-      this.db.all(sql, params, (err, rows) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(rows as SqliteRow[]);
-        }
-      });
+  async saveConversationState(state: ConversationState): Promise<void> {
+    if (!this.db) {
+      throw new Error('Database not initialized');
+    }
+
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO conversation_state 
+      (conversationId, projectPath, gitBranch, currentPhase, planFilePath, workflowName, 
+       gitCommitConfig, requireReviewsBeforePhaseTransition, createdAt, updatedAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    stmt.run(
+      state.conversationId,
+      state.projectPath,
+      state.gitBranch,
+      state.currentPhase,
+      state.planFilePath,
+      state.workflowName,
+      state.gitCommitConfig ? JSON.stringify(state.gitCommitConfig) : null,
+      state.requireReviewsBeforePhaseTransition ? 1 : 0,
+      state.createdAt,
+      state.updatedAt
+    );
+
+    logger.debug('Conversation state saved', {
+      conversationId: state.conversationId,
+      workflowName: state.workflowName,
+      currentPhase: state.currentPhase,
     });
   }
 
   /**
-   * Get conversation state by ID
+   * Load conversation state from database
    */
-  async getConversationState(
+  async loadConversationState(
     conversationId: string
   ): Promise<ConversationState | null> {
-    logger.debug('Retrieving conversation state', { conversationId });
-
-    try {
-      const row = await this.getRow(
-        'SELECT * FROM conversation_states WHERE conversation_id = ?',
-        [conversationId]
-      );
+    if (!this.db) {
+      throw new Error('Database not initialized');
+    }
 
-      if (!row) {
-        logger.debug('Conversation state not found', { conversationId });
-        return null;
-      }
+    const stmt = this.db.prepare(
+      'SELECT * FROM conversation_state WHERE conversationId = ?'
+    );
+    const row = stmt.get(conversationId) as
+      | {
+          conversationId: string;
+          projectPath: string;
+          gitBranch: string;
+          currentPhase: string;
+          planFilePath: string;
+          workflowName: string;
+          gitCommitConfig: string;
+          requireReviewsBeforePhaseTransition: number;
+          createdAt: string;
+          updatedAt: string;
+        }
+      | undefined;
 
+    if (row) {
       const state: ConversationState = {
-        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'
-        ) as DevelopmentPhase,
-        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'
-        ) as GitCommitConfig | undefined,
-        requireReviewsBeforePhaseTransition: Boolean(
-          row.require_reviews_before_phase_transition
-        ),
-        createdAt: validateString(row.created_at, 'created_at'),
-        updatedAt: validateString(row.updated_at, 'updated_at'),
+        conversationId: row.conversationId,
+        projectPath: row.projectPath,
+        gitBranch: row.gitBranch,
+        currentPhase: row.currentPhase,
+        planFilePath: row.planFilePath,
+        workflowName: row.workflowName,
+        gitCommitConfig: row.gitCommitConfig
+          ? JSON.parse(row.gitCommitConfig)
+          : undefined,
+        requireReviewsBeforePhaseTransition:
+          row.requireReviewsBeforePhaseTransition === 1,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
       };
 
-      logger.debug('Conversation state retrieved', {
+      logger.debug('Conversation state loaded', {
         conversationId,
+        workflowName: state.workflowName,
         currentPhase: state.currentPhase,
-        projectPath: state.projectPath,
       });
-
       return state;
-    } catch (error) {
-      logger.error('Failed to retrieve conversation state', error as Error, {
-        conversationId,
-      });
-      throw error;
     }
+
+    logger.debug('No conversation state found', { conversationId });
+    return null;
   }
 
   /**
-   * Save or update conversation state
+   * Get conversation state by ID (alias for loadConversationState)
    */
-  async saveConversationState(state: ConversationState): Promise<void> {
-    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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        [
-          state.conversationId,
-          state.projectPath,
-          state.gitBranch,
-          state.currentPhase,
-          state.planFilePath,
-          state.workflowName,
-          state.gitCommitConfig ? JSON.stringify(state.gitCommitConfig) : null,
-          state.requireReviewsBeforePhaseTransition,
-          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 as Error, {
-        conversationId: state.conversationId,
-      });
-      throw error;
-    }
+  async getConversationState(
+    conversationId: string
+  ): Promise<ConversationState | null> {
+    return this.loadConversationState(conversationId);
   }
 
   /**
-   * Find conversation by project path and git branch
+   * List all conversation states
    */
-  async findConversationByProject(
-    projectPath: string,
-    gitBranch: string
-  ): Promise<ConversationState | null> {
-    const row = await this.getRow(
-      'SELECT * FROM conversation_states WHERE project_path = ? AND git_branch = ?',
-      [projectPath, gitBranch]
-    );
-
-    if (!row) {
-      return null;
+  async listConversationStates(): Promise<ConversationState[]> {
+    if (!this.db) {
+      throw new Error('Database not initialized');
     }
 
-    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'
-      ) as DevelopmentPhase,
-      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'
-      ) as GitCommitConfig | undefined,
-      requireReviewsBeforePhaseTransition: Boolean(
-        row.require_reviews_before_phase_transition
-      ),
-      createdAt: validateString(row.created_at, 'created_at'),
-      updatedAt: validateString(row.updated_at, 'updated_at'),
-    };
+    const stmt = this.db.prepare(
+      'SELECT * FROM conversation_state ORDER BY updatedAt DESC'
+    );
+    const rows = stmt.all() as {
+      conversationId: string;
+      projectPath: string;
+      gitBranch: string;
+      currentPhase: string;
+      planFilePath: string;
+      workflowName: string;
+      gitCommitConfig: string;
+      requireReviewsBeforePhaseTransition: number;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+
+    const states = rows.map(row => ({
+      conversationId: row.conversationId,
+      projectPath: row.projectPath,
+      gitBranch: row.gitBranch,
+      currentPhase: row.currentPhase,
+      planFilePath: row.planFilePath,
+      workflowName: row.workflowName,
+      gitCommitConfig: row.gitCommitConfig
+        ? JSON.parse(row.gitCommitConfig)
+        : undefined,
+      requireReviewsBeforePhaseTransition:
+        row.requireReviewsBeforePhaseTransition === 1,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    }));
+
+    logger.debug('Listed conversation states', { count: states.length });
+    return states;
   }
 
   /**
    * Delete conversation state
    */
-  async deleteConversationState(conversationId: string): Promise<void> {
-    await this.runQuery(
-      'DELETE FROM conversation_states WHERE conversation_id = ?',
-      [conversationId]
+  async deleteConversationState(conversationId: string): Promise<boolean> {
+    if (!this.db) {
+      throw new Error('Database not initialized');
+    }
+
+    const stmt = this.db.prepare(
+      'DELETE FROM conversation_state WHERE conversationId = ?'
     );
+    const result = stmt.run(conversationId);
+
+    const deleted = result.changes > 0;
+    logger.debug('Conversation state deletion', { conversationId, deleted });
+    return deleted;
   }
 
   /**
    * Log an interaction to the database
    */
   async logInteraction(log: InteractionLog): Promise<void> {
-    logger.debug('Logging interaction to database', {
+    if (!this.db) {
+      throw new Error('Database not initialized');
+    }
+
+    const stmt = this.db.prepare(`
+      INSERT INTO interaction_log 
+      (conversationId, toolName, inputParams, responseData, currentPhase, timestamp, isReset, resetAt)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    stmt.run(
+      log.conversationId,
+      log.toolName,
+      log.inputParams,
+      log.responseData,
+      log.currentPhase,
+      log.timestamp,
+      log.isReset ? 1 : 0,
+      log.resetAt || null
+    );
+
+    logger.debug('Interaction logged', {
       conversationId: log.conversationId,
       toolName: log.toolName,
+      timestamp: log.timestamp,
     });
-
-    try {
-      await this.runQuery(
-        `INSERT INTO interaction_logs (
-          conversation_id, tool_name, input_params, response_data,
-          current_phase, timestamp
-        ) VALUES (?, ?, ?, ?, ?, ?)`,
-        [
-          log.conversationId,
-          log.toolName,
-          log.inputParams,
-          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 as Error, {
-        conversationId: log.conversationId,
-      });
-      throw error;
-    }
   }
 
   /**
-   * Get all interactions for a specific conversation
+   * Get interactions by conversation ID
    */
   async getInteractionsByConversationId(
     conversationId: string
   ): Promise<InteractionLog[]> {
-    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: InteractionLog[] = 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'
-        ) as DevelopmentPhase,
-        timestamp: validateString(row.timestamp, 'timestamp'),
-      }));
-
-      logger.debug('Retrieved interaction logs', {
-        conversationId,
-        count: logs.length,
-      });
-
-      return logs;
-    } catch (error) {
-      logger.error('Failed to get interaction logs', error as Error, {
-        conversationId,
-      });
-      throw error;
+    if (!this.db) {
+      throw new Error('Database not initialized');
     }
-  }
-
-  /**
-   * Run database migrations to add new columns
-   */
-  private async runMigrations(): Promise<void> {
-    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 as unknown as SqliteColumnInfo[]).some(
-          (col: SqliteColumnInfo) => col.name === 'is_reset'
-        );
-        const hasResetAt = (tableInfo as unknown as SqliteColumnInfo[]).some(
-          (col: SqliteColumnInfo) => 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)'
-        )) as SqliteColumnInfo[];
-        const hasWorkflowName = conversationTableInfo.some(
-          (col: SqliteColumnInfo) => col.name === 'workflow_name'
-        );
-        const hasGitCommitConfig = conversationTableInfo.some(
-          (col: SqliteColumnInfo) => col.name === 'git_commit_config'
-        );
-        const hasRequireReviews = conversationTableInfo.some(
-          (col: SqliteColumnInfo) =>
-            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 as Error);
-      throw error;
-    }
+    const stmt = this.db.prepare(`
+      SELECT * FROM interaction_log 
+      WHERE conversationId = ? AND (isReset = 0 OR isReset IS NULL)
+      ORDER BY timestamp ASC
+    `);
+    const rows = stmt.all(conversationId) as {
+      id: number;
+      conversationId: string;
+      toolName: string;
+      inputParams: string;
+      responseData: string;
+      currentPhase: string;
+      timestamp: string;
+      isReset: number;
+      resetAt: string;
+    }[];
+
+    const logs = rows.map(row => ({
+      id: row.id,
+      conversationId: row.conversationId,
+      toolName: row.toolName,
+      inputParams: row.inputParams,
+      responseData: row.responseData,
+      currentPhase: row.currentPhase,
+      timestamp: row.timestamp,
+      isReset: row.isReset === 1,
+      resetAt: row.resetAt,
+    }));
+
+    logger.debug('Retrieved interaction logs', {
+      conversationId,
+      count: logs.length,
+    });
+    return logs;
   }
 
   /**
-   * Soft delete interaction logs for a conversation
+   * Soft delete interaction logs by marking them as reset
    */
-  async softDeleteInteractionLogs(
-    conversationId: string,
-    reason?: string
-  ): Promise<void> {
-    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 as Error, {
-        conversationId,
-      });
-      throw error;
+  async softDeleteInteractionLogs(conversationId: string): Promise<void> {
+    if (!this.db) {
+      throw new Error('Database not initialized');
     }
-  }
 
-  /**
-   * Get active (non-reset) interaction logs for a conversation
-   */
-  async getActiveInteractionLogs(
-    conversationId: string
-  ): Promise<InteractionLog[]> {
-    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: InteractionLog[] = 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,
-      });
+    const resetAt = new Date().toISOString();
+    const stmt = this.db.prepare(`
+      UPDATE interaction_log 
+      SET isReset = 1, resetAt = ?
+      WHERE conversationId = ? AND (isReset = 0 OR isReset IS NULL)
+    `);
 
-      return logs;
-    } catch (error) {
-      logger.error('Failed to get active interaction logs', error as Error, {
-        conversationId,
-      });
-      throw error;
-    }
+    const result = stmt.run(resetAt, conversationId);
+    logger.debug('Soft deleted interaction logs', {
+      conversationId,
+      affectedRows: result.changes,
+    });
   }
 
   /**
-   * Get all interaction logs including reset ones for a conversation
+   * Close database connection
    */
-  async getAllInteractionLogsIncludingReset(
-    conversationId: string
-  ): Promise<InteractionLog[]> {
-    logger.debug('Getting all interaction logs including reset', {
-      conversationId,
-    });
-
-    try {
-      const rows = await this.getAllRows(
-        'SELECT * FROM interaction_logs WHERE conversation_id = ? ORDER BY timestamp ASC',
-        [conversationId]
-      );
-
-      const logs: InteractionLog[] = 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 as Error,
-        { conversationId }
-      );
-      throw error;
+  async close(): Promise<void> {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      logger.debug('Database connection closed');
     }
   }
 
   /**
-   * Close database connection
+   * Check if database is initialized
    */
-  async close(): Promise<void> {
-    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();
-      }
-    });
+  isInitialized(): boolean {
+    return this.db !== null;
   }
 }