@stackmemoryai/stackmemory 0.2.9 → 0.3.0

package/dist/core/database/batch-operations.js

@@ -0,0 +1,329 @@
+import { logger } from "../monitoring/logger.js";
+import { trace } from "../trace/index.js";
+class BatchOperationsManager {
+  db;
+  preparedStatements = /* @__PURE__ */ new Map();
+  batchQueue = [];
+  isProcessing = false;
+  constructor(db) {
+    if (db) {
+      this.db = db;
+      this.initializePreparedStatements();
+    } else {
+      this.db = void 0;
+    }
+  }
+  /**
+   * Add events in bulk with optimized batching
+   */
+  async bulkInsertEvents(events, options = {}) {
+    const {
+      batchSize = 100,
+      onConflict = "ignore",
+      enableTransactions = true
+    } = options;
+    return this.performBulkInsert("events", events, {
+      batchSize,
+      onConflict,
+      enableTransactions,
+      preprocessor: (event) => ({
+        ...event,
+        event_id: `evt_${event.frame_id}_${event.seq}_${Date.now()}`,
+        payload: JSON.stringify(event.payload)
+      })
+    });
+  }
+  /**
+   * Add anchors in bulk
+   */
+  async bulkInsertAnchors(anchors, options = {}) {
+    return this.performBulkInsert("anchors", anchors, {
+      ...options,
+      preprocessor: (anchor) => ({
+        ...anchor,
+        anchor_id: `anc_${anchor.frame_id}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        metadata: JSON.stringify(anchor.metadata),
+        created_at: Date.now()
+      })
+    });
+  }
+  /**
+   * Bulk update frame digests
+   */
+  async bulkUpdateFrameDigests(updates, options = {}) {
+    const {
+      batchSize = 50,
+      enableTransactions = true
+    } = options;
+    return trace.traceAsync("function", "bulkUpdateFrameDigests", { count: updates.length }, async () => {
+      const startTime = performance.now();
+      const stats = {
+        totalRecords: updates.length,
+        batchesProcessed: 0,
+        successfulInserts: 0,
+        failedInserts: 0,
+        totalTimeMs: 0,
+        avgBatchTimeMs: 0
+      };
+      if (updates.length === 0) return stats;
+      const stmt = this.db.prepare(`
+        UPDATE frames 
+        SET digest_text = ?, 
+            digest_json = ?, 
+            closed_at = COALESCE(?, closed_at),
+            state = CASE WHEN ? IS NOT NULL THEN 'closed' ELSE state END
+        WHERE frame_id = ?
+      `);
+      const updateFn = (batch) => {
+        for (const update of batch) {
+          try {
+            const result = stmt.run(
+              update.digest_text,
+              JSON.stringify(update.digest_json),
+              update.closed_at,
+              update.closed_at,
+              update.frame_id
+            );
+            stats.successfulInserts += result.changes;
+          } catch (error) {
+            stats.failedInserts++;
+            logger.warn("Failed to update frame digest", {
+              frameId: update.frame_id,
+              error: error.message
+            });
+          }
+        }
+      };
+      if (enableTransactions) {
+        const transaction = this.db.transaction(updateFn);
+        await this.processBatches(updates, batchSize, transaction, stats);
+      } else {
+        await this.processBatches(updates, batchSize, updateFn, stats);
+      }
+      stats.totalTimeMs = performance.now() - startTime;
+      stats.avgBatchTimeMs = stats.batchesProcessed > 0 ? stats.totalTimeMs / stats.batchesProcessed : 0;
+      logger.info("Bulk frame digest update completed", stats);
+      return stats;
+    });
+  }
+  /**
+   * Generic bulk insert with preprocessing
+   */
+  async performBulkInsert(table, records, options = {}) {
+    const {
+      batchSize = 100,
+      onConflict = "ignore",
+      enableTransactions = true,
+      preprocessor
+    } = options;
+    return trace.traceAsync("function", `bulkInsert${table}`, { count: records.length }, async () => {
+      const startTime = performance.now();
+      const stats = {
+        totalRecords: records.length,
+        batchesProcessed: 0,
+        successfulInserts: 0,
+        failedInserts: 0,
+        totalTimeMs: 0,
+        avgBatchTimeMs: 0
+      };
+      if (records.length === 0) return stats;
+      const processedRecords = preprocessor ? records.map(preprocessor) : records;
+      const firstRecord = processedRecords[0];
+      const columns = Object.keys(firstRecord);
+      const placeholders = columns.map(() => "?").join(", ");
+      const conflictClause = this.getConflictClause(onConflict);
+      const insertSql = `INSERT ${conflictClause} INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
+      const stmt = this.db.prepare(insertSql);
+      const insertFn = (batch) => {
+        for (const record of batch) {
+          try {
+            const values = columns.map((col) => record[col]);
+            const result = stmt.run(...values);
+            stats.successfulInserts += result.changes;
+          } catch (error) {
+            stats.failedInserts++;
+            logger.warn(`Failed to insert ${table} record`, {
+              record,
+              error: error.message
+            });
+          }
+        }
+      };
+      if (enableTransactions) {
+        const transaction = this.db.transaction(insertFn);
+        await this.processBatches(processedRecords, batchSize, transaction, stats);
+      } else {
+        await this.processBatches(processedRecords, batchSize, insertFn, stats);
+      }
+      stats.totalTimeMs = performance.now() - startTime;
+      stats.avgBatchTimeMs = stats.batchesProcessed > 0 ? stats.totalTimeMs / stats.batchesProcessed : 0;
+      logger.info(`Bulk ${table} insert completed`, stats);
+      return stats;
+    });
+  }
+  /**
+   * Process records in batches
+   */
+  async processBatches(records, batchSize, processFn, stats) {
+    for (let i = 0; i < records.length; i += batchSize) {
+      const batch = records.slice(i, i + batchSize);
+      const batchStart = performance.now();
+      try {
+        processFn(batch);
+        stats.batchesProcessed++;
+        const batchTime = performance.now() - batchStart;
+        logger.debug("Batch processed", {
+          batchNumber: stats.batchesProcessed,
+          records: batch.length,
+          timeMs: batchTime.toFixed(2)
+        });
+        if (stats.batchesProcessed % 10 === 0) {
+          await new Promise((resolve) => setImmediate(resolve));
+        }
+      } catch (error) {
+        stats.failedInserts += batch.length;
+        logger.error("Batch processing failed", error, {
+          batchNumber: stats.batchesProcessed + 1,
+          batchSize: batch.length
+        });
+      }
+    }
+  }
+  /**
+   * Queue batch operation for later processing
+   */
+  queueBatchOperation(operation) {
+    this.batchQueue.push(operation);
+    if (this.batchQueue.length >= 10 && !this.isProcessing) {
+      setImmediate(() => this.processBatchQueue());
+    }
+  }
+  /**
+   * Process queued batch operations
+   */
+  async processBatchQueue() {
+    if (this.isProcessing || this.batchQueue.length === 0) {
+      return;
+    }
+    this.isProcessing = true;
+    const operations = [...this.batchQueue];
+    this.batchQueue = [];
+    try {
+      const groupedOps = this.groupOperationsByTable(operations);
+      for (const [table, tableOps] of groupedOps) {
+        await this.processTableOperations(table, tableOps);
+      }
+      logger.info("Batch queue processed", {
+        operations: operations.length,
+        tables: groupedOps.size
+      });
+    } catch (error) {
+      logger.error("Batch queue processing failed", error);
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+  /**
+   * Flush any remaining queued operations
+   */
+  async flush() {
+    if (this.batchQueue.length > 0) {
+      await this.processBatchQueue();
+    }
+  }
+  /**
+   * Get SQL conflict clause
+   */
+  getConflictClause(onConflict) {
+    switch (onConflict) {
+      case "ignore":
+        return "OR IGNORE";
+      case "replace":
+        return "OR REPLACE";
+      case "update":
+        return "ON CONFLICT DO UPDATE SET";
+      default:
+        return "";
+    }
+  }
+  /**
+   * Group operations by table for efficient processing
+   */
+  groupOperationsByTable(operations) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const op of operations) {
+      if (!grouped.has(op.table)) {
+        grouped.set(op.table, []);
+      }
+      grouped.get(op.table).push(op);
+    }
+    return grouped;
+  }
+  /**
+   * Process all operations for a specific table
+   */
+  async processTableOperations(table, operations) {
+    for (const op of operations) {
+      switch (op.operation) {
+        case "insert":
+          await this.performBulkInsert(table, op.data, {
+            onConflict: op.onConflict
+          });
+          break;
+        // Add update and delete operations as needed
+        default:
+          logger.warn("Unsupported batch operation", { table, operation: op.operation });
+      }
+    }
+  }
+  /**
+   * Initialize commonly used prepared statements
+   */
+  initializePreparedStatements() {
+    this.preparedStatements.set(
+      "insert_event",
+      this.db.prepare(`
+        INSERT OR IGNORE INTO events 
+        (event_id, frame_id, run_id, seq, event_type, payload, ts) 
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `)
+    );
+    this.preparedStatements.set(
+      "insert_anchor",
+      this.db.prepare(`
+        INSERT OR IGNORE INTO anchors 
+        (anchor_id, frame_id, type, text, priority, metadata, created_at) 
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+      `)
+    );
+    logger.info("Batch operations prepared statements initialized");
+  }
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    this.preparedStatements.clear();
+  }
+}
+let globalBatchManager = null;
+function getBatchManager(db) {
+  if (!globalBatchManager) {
+    globalBatchManager = new BatchOperationsManager(db);
+  }
+  return globalBatchManager;
+}
+async function bulkInsertEvents(events, options) {
+  const manager = getBatchManager();
+  return manager.bulkInsertEvents(events, options);
+}
+async function bulkInsertAnchors(anchors, options) {
+  const manager = getBatchManager();
+  return manager.bulkInsertAnchors(anchors, options);
+}
+export {
+  BatchOperationsManager,
+  bulkInsertAnchors,
+  bulkInsertEvents,
+  getBatchManager
+};
+//# sourceMappingURL=batch-operations.js.map

package/dist/core/database/batch-operations.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/database/batch-operations.ts"],
+  "sourcesContent": ["/**\n * Batch Database Operations\n * High-performance bulk operations with transaction management\n */\n\nimport Database from 'better-sqlite3';\nimport { getConnectionPool } from './connection-pool.js';\nimport { logger } from '../monitoring/logger.js';\nimport { trace } from '../trace/index.js';\n\nexport interface BatchOperation {\n  table: string;\n  operation: 'insert' | 'update' | 'delete';\n  data: Record<string, any>[];\n  onConflict?: 'ignore' | 'replace' | 'update';\n}\n\nexport interface BulkInsertOptions {\n  batchSize?: number;\n  onConflict?: 'ignore' | 'replace' | 'update';\n  enableTransactions?: boolean;\n  parallelTables?: boolean;\n}\n\nexport interface BatchStats {\n  totalRecords: number;\n  batchesProcessed: number;\n  successfulInserts: number;\n  failedInserts: number;\n  totalTimeMs: number;\n  avgBatchTimeMs: number;\n}\n\n/**\n * High-performance batch operations manager\n */\nexport class BatchOperationsManager {\n  private db: Database.Database;\n  private preparedStatements = new Map<string, Database.Statement>();\n  private batchQueue: BatchOperation[] = [];\n  private isProcessing = false;\n\n  constructor(db?: Database.Database) {\n    if (db) {\n      this.db = db;\n      this.initializePreparedStatements();\n    } else {\n      // Will be initialized when used with getConnectionPool().withConnection()\n      this.db = undefined as any;\n    }\n  }\n\n  /**\n   * Add events in bulk with optimized batching\n   */\n  async bulkInsertEvents(\n    events: Array<{\n      frame_id: string;\n      run_id: string;\n      seq: number;\n      event_type: string;\n      payload: any;\n      ts: number;\n    }>,\n    options: BulkInsertOptions = {}\n  ): Promise<BatchStats> {\n    const {\n      batchSize = 100,\n      onConflict = 'ignore',\n      enableTransactions = true,\n    } = options;\n\n    return this.performBulkInsert('events', events, {\n      batchSize,\n      onConflict,\n      enableTransactions,\n      preprocessor: (event) => ({\n        ...event,\n        event_id: `evt_${event.frame_id}_${event.seq}_${Date.now()}`,\n        payload: JSON.stringify(event.payload),\n      }),\n    });\n  }\n\n  /**\n   * Add anchors in bulk\n   */\n  async bulkInsertAnchors(\n    anchors: Array<{\n      frame_id: string;\n      type: string;\n      text: string;\n      priority: number;\n      metadata: any;\n    }>,\n    options: BulkInsertOptions = {}\n  ): Promise<BatchStats> {\n    return this.performBulkInsert('anchors', anchors, {\n      ...options,\n      preprocessor: (anchor) => ({\n        ...anchor,\n        anchor_id: `anc_${anchor.frame_id}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,\n        metadata: JSON.stringify(anchor.metadata),\n        created_at: Date.now(),\n      }),\n    });\n  }\n\n  /**\n   * Bulk update frame digests\n   */\n  async bulkUpdateFrameDigests(\n    updates: Array<{\n      frame_id: string;\n      digest_text: string;\n      digest_json: any;\n      closed_at?: number;\n    }>,\n    options: BulkInsertOptions = {}\n  ): Promise<BatchStats> {\n    const {\n      batchSize = 50,\n      enableTransactions = true,\n    } = options;\n\n    return trace.traceAsync('function', 'bulkUpdateFrameDigests', { count: updates.length }, async () => {\n      const startTime = performance.now();\n      const stats: BatchStats = {\n        totalRecords: updates.length,\n        batchesProcessed: 0,\n        successfulInserts: 0,\n        failedInserts: 0,\n        totalTimeMs: 0,\n        avgBatchTimeMs: 0,\n      };\n\n      if (updates.length === 0) return stats;\n\n      const stmt = this.db.prepare(`\n        UPDATE frames \n        SET digest_text = ?, \n            digest_json = ?, \n            closed_at = COALESCE(?, closed_at),\n            state = CASE WHEN ? IS NOT NULL THEN 'closed' ELSE state END\n        WHERE frame_id = ?\n      `);\n\n      const updateFn = (batch: typeof updates) => {\n        for (const update of batch) {\n          try {\n            const result = stmt.run(\n              update.digest_text,\n              JSON.stringify(update.digest_json),\n              update.closed_at,\n              update.closed_at,\n              update.frame_id\n            );\n            stats.successfulInserts += result.changes;\n          } catch (error) {\n            stats.failedInserts++;\n            logger.warn('Failed to update frame digest', {\n              frameId: update.frame_id,\n              error: (error as Error).message,\n            });\n          }\n        }\n      };\n\n      if (enableTransactions) {\n        const transaction = this.db.transaction(updateFn);\n        await this.processBatches(updates, batchSize, transaction, stats);\n      } else {\n        await this.processBatches(updates, batchSize, updateFn, stats);\n      }\n\n      stats.totalTimeMs = performance.now() - startTime;\n      stats.avgBatchTimeMs = stats.batchesProcessed > 0 \n        ? stats.totalTimeMs / stats.batchesProcessed \n        : 0;\n\n      logger.info('Bulk frame digest update completed', stats as unknown as Record<string, unknown>);\n      return stats;\n    });\n  }\n\n  /**\n   * Generic bulk insert with preprocessing\n   */\n  private async performBulkInsert<T extends Record<string, any>>(\n    table: string,\n    records: T[],\n    options: BulkInsertOptions & {\n      preprocessor?: (record: T) => Record<string, any>;\n    } = {}\n  ): Promise<BatchStats> {\n    const {\n      batchSize = 100,\n      onConflict = 'ignore',\n      enableTransactions = true,\n      preprocessor,\n    } = options;\n\n    return trace.traceAsync('function', `bulkInsert${table}`, { count: records.length }, async () => {\n      const startTime = performance.now();\n      const stats: BatchStats = {\n        totalRecords: records.length,\n        batchesProcessed: 0,\n        successfulInserts: 0,\n        failedInserts: 0,\n        totalTimeMs: 0,\n        avgBatchTimeMs: 0,\n      };\n\n      if (records.length === 0) return stats;\n\n      // Preprocess records if needed\n      const processedRecords = preprocessor \n        ? records.map(preprocessor)\n        : records;\n\n      // Build dynamic insert statement\n      const firstRecord = processedRecords[0];\n      const columns = Object.keys(firstRecord);\n      const placeholders = columns.map(() => '?').join(', ');\n      const conflictClause = this.getConflictClause(onConflict);\n      \n      const insertSql = `INSERT ${conflictClause} INTO ${table} (${columns.join(', ')}) VALUES (${placeholders})`;\n      const stmt = this.db.prepare(insertSql);\n\n      const insertFn = (batch: typeof processedRecords) => {\n        for (const record of batch) {\n          try {\n            const values = columns.map(col => record[col]);\n            const result = stmt.run(...values);\n            stats.successfulInserts += result.changes;\n          } catch (error) {\n            stats.failedInserts++;\n            logger.warn(`Failed to insert ${table} record`, {\n              record,\n              error: (error as Error).message,\n            });\n          }\n        }\n      };\n\n      if (enableTransactions) {\n        const transaction = this.db.transaction(insertFn);\n        await this.processBatches(processedRecords, batchSize, transaction, stats);\n      } else {\n        await this.processBatches(processedRecords, batchSize, insertFn, stats);\n      }\n\n      stats.totalTimeMs = performance.now() - startTime;\n      stats.avgBatchTimeMs = stats.batchesProcessed > 0 \n        ? stats.totalTimeMs / stats.batchesProcessed \n        : 0;\n\n      logger.info(`Bulk ${table} insert completed`, stats as unknown as Record<string, unknown>);\n      return stats;\n    });\n  }\n\n  /**\n   * Process records in batches\n   */\n  private async processBatches<T>(\n    records: T[],\n    batchSize: number,\n    processFn: (batch: T[]) => void,\n    stats: BatchStats\n  ): Promise<void> {\n    for (let i = 0; i < records.length; i += batchSize) {\n      const batch = records.slice(i, i + batchSize);\n      const batchStart = performance.now();\n      \n      try {\n        processFn(batch);\n        stats.batchesProcessed++;\n        \n        const batchTime = performance.now() - batchStart;\n        logger.debug('Batch processed', {\n          batchNumber: stats.batchesProcessed,\n          records: batch.length,\n          timeMs: batchTime.toFixed(2),\n        });\n\n        // Yield control to prevent blocking\n        if (stats.batchesProcessed % 10 === 0) {\n          await new Promise(resolve => setImmediate(resolve));\n        }\n\n      } catch (error) {\n        stats.failedInserts += batch.length;\n        logger.error('Batch processing failed', error as Error, {\n          batchNumber: stats.batchesProcessed + 1,\n          batchSize: batch.length,\n        });\n      }\n    }\n  }\n\n  /**\n   * Queue batch operation for later processing\n   */\n  queueBatchOperation(operation: BatchOperation): void {\n    this.batchQueue.push(operation);\n    \n    if (this.batchQueue.length >= 10 && !this.isProcessing) {\n      setImmediate(() => this.processBatchQueue());\n    }\n  }\n\n  /**\n   * Process queued batch operations\n   */\n  async processBatchQueue(): Promise<void> {\n    if (this.isProcessing || this.batchQueue.length === 0) {\n      return;\n    }\n\n    this.isProcessing = true;\n    const operations = [...this.batchQueue];\n    this.batchQueue = [];\n\n    try {\n      const groupedOps = this.groupOperationsByTable(operations);\n      \n      for (const [table, tableOps] of groupedOps) {\n        await this.processTableOperations(table, tableOps);\n      }\n\n      logger.info('Batch queue processed', {\n        operations: operations.length,\n        tables: groupedOps.size,\n      });\n\n    } catch (error) {\n      logger.error('Batch queue processing failed', error as Error);\n    } finally {\n      this.isProcessing = false;\n    }\n  }\n\n  /**\n   * Flush any remaining queued operations\n   */\n  async flush(): Promise<void> {\n    if (this.batchQueue.length > 0) {\n      await this.processBatchQueue();\n    }\n  }\n\n  /**\n   * Get SQL conflict clause\n   */\n  private getConflictClause(onConflict: string): string {\n    switch (onConflict) {\n      case 'ignore':\n        return 'OR IGNORE';\n      case 'replace':\n        return 'OR REPLACE';\n      case 'update':\n        return 'ON CONFLICT DO UPDATE SET';\n      default:\n        return '';\n    }\n  }\n\n  /**\n   * Group operations by table for efficient processing\n   */\n  private groupOperationsByTable(operations: BatchOperation[]): Map<string, BatchOperation[]> {\n    const grouped = new Map<string, BatchOperation[]>();\n    \n    for (const op of operations) {\n      if (!grouped.has(op.table)) {\n        grouped.set(op.table, []);\n      }\n      grouped.get(op.table)!.push(op);\n    }\n    \n    return grouped;\n  }\n\n  /**\n   * Process all operations for a specific table\n   */\n  private async processTableOperations(table: string, operations: BatchOperation[]): Promise<void> {\n    for (const op of operations) {\n      switch (op.operation) {\n        case 'insert':\n          await this.performBulkInsert(table, op.data, {\n            onConflict: op.onConflict,\n          });\n          break;\n        // Add update and delete operations as needed\n        default:\n          logger.warn('Unsupported batch operation', { table, operation: op.operation });\n      }\n    }\n  }\n\n  /**\n   * Initialize commonly used prepared statements\n   */\n  private initializePreparedStatements(): void {\n    // Event insertion\n    this.preparedStatements.set('insert_event', \n      this.db.prepare(`\n        INSERT OR IGNORE INTO events \n        (event_id, frame_id, run_id, seq, event_type, payload, ts) \n        VALUES (?, ?, ?, ?, ?, ?, ?)\n      `)\n    );\n\n    // Anchor insertion\n    this.preparedStatements.set('insert_anchor',\n      this.db.prepare(`\n        INSERT OR IGNORE INTO anchors \n        (anchor_id, frame_id, type, text, priority, metadata, created_at) \n        VALUES (?, ?, ?, ?, ?, ?, ?)\n      `)\n    );\n\n    logger.info('Batch operations prepared statements initialized');\n  }\n\n  /**\n   * Cleanup resources\n   */\n  cleanup(): void {\n    // Modern better-sqlite3 automatically handles cleanup\n    this.preparedStatements.clear();\n  }\n}\n\n// Global batch operations manager\nlet globalBatchManager: BatchOperationsManager | null = null;\n\n/**\n * Get or create global batch operations manager\n */\nexport function getBatchManager(db?: Database.Database): BatchOperationsManager {\n  if (!globalBatchManager) {\n    globalBatchManager = new BatchOperationsManager(db);\n  }\n  return globalBatchManager;\n}\n\n/**\n * Convenience function for bulk event insertion\n */\nexport async function bulkInsertEvents(\n  events: any[],\n  options?: BulkInsertOptions\n): Promise<BatchStats> {\n  const manager = getBatchManager();\n  return manager.bulkInsertEvents(events, options);\n}\n\n/**\n * Convenience function for bulk anchor insertion\n */\nexport async function bulkInsertAnchors(\n  anchors: any[],\n  options?: BulkInsertOptions\n): Promise<BatchStats> {\n  const manager = getBatchManager();\n  return manager.bulkInsertAnchors(anchors, options);\n}"],
+  "mappings": "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",
+  "names": []
+}

package/dist/core/database/connection-pool.js

@@ -0,0 +1,224 @@
+import { createTracedDatabase } from "../trace/db-trace-wrapper.js";
+import { logger } from "../monitoring/logger.js";
+class SQLiteConnectionPool {
+  connections = /* @__PURE__ */ new Map();
+  filename;
+  options;
+  maxConnections;
+  acquireTimeoutMs;
+  idleTimeoutMs;
+  cleanupInterval = null;
+  // Statistics
+  stats = {
+    totalCreated: 0,
+    totalAcquired: 0,
+    totalReleased: 0,
+    currentActive: 0,
+    currentIdle: 0
+  };
+  constructor(filename, options = {}) {
+    this.filename = filename;
+    this.options = options;
+    this.maxConnections = options.maxConnections ?? 5;
+    this.acquireTimeoutMs = options.acquireTimeoutMs ?? 5e3;
+    this.idleTimeoutMs = options.idleTimeoutMs ?? 3e5;
+    if (options.checkInterval !== 0) {
+      this.cleanupInterval = setInterval(
+        () => this.cleanup(),
+        options.checkInterval ?? 6e4
+        // 1 minute
+      );
+    }
+    logger.info("SQLite connection pool initialized", {
+      filename,
+      maxConnections: this.maxConnections,
+      acquireTimeoutMs: this.acquireTimeoutMs,
+      idleTimeoutMs: this.idleTimeoutMs
+    });
+  }
+  /**
+   * Acquire a connection from the pool
+   */
+  async acquire() {
+    const startTime = Date.now();
+    while (Date.now() - startTime < this.acquireTimeoutMs) {
+      for (const [id, connection] of this.connections) {
+        if (!connection.inUse) {
+          connection.inUse = true;
+          connection.lastUsed = Date.now();
+          this.stats.totalAcquired++;
+          this.stats.currentActive++;
+          this.stats.currentIdle--;
+          logger.debug("Reused connection from pool", { connectionId: id });
+          return connection;
+        }
+      }
+      if (this.connections.size < this.maxConnections) {
+        return this.createConnection();
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    throw new Error(`Failed to acquire connection within ${this.acquireTimeoutMs}ms timeout`);
+  }
+  /**
+   * Release a connection back to the pool
+   */
+  release(connection) {
+    if (this.connections.has(connection.id)) {
+      connection.inUse = false;
+      connection.lastUsed = Date.now();
+      this.stats.totalReleased++;
+      this.stats.currentActive--;
+      this.stats.currentIdle++;
+      logger.debug("Released connection to pool", { connectionId: connection.id });
+    }
+  }
+  /**
+   * Execute a function with a pooled connection
+   */
+  async withConnection(fn) {
+    const connection = await this.acquire();
+    try {
+      return await fn(connection.db);
+    } finally {
+      this.release(connection);
+    }
+  }
+  /**
+   * Execute a transaction with a pooled connection
+   */
+  async withTransaction(fn) {
+    const connection = await this.acquire();
+    try {
+      const transaction = connection.db.transaction(() => fn(connection.db));
+      return transaction();
+    } finally {
+      this.release(connection);
+    }
+  }
+  /**
+   * Get pool statistics
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      totalConnections: this.connections.size,
+      maxConnections: this.maxConnections
+    };
+  }
+  /**
+   * Close all connections and cleanup
+   */
+  async close() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    for (const [id, connection] of this.connections) {
+      try {
+        connection.db.close();
+        logger.debug("Closed connection", { connectionId: id });
+      } catch (error) {
+        logger.warn("Error closing connection", {
+          connectionId: id,
+          error: error.message
+        });
+      }
+    }
+    this.connections.clear();
+    this.stats.currentActive = 0;
+    this.stats.currentIdle = 0;
+    logger.info("Connection pool closed", {
+      totalCreated: this.stats.totalCreated,
+      totalAcquired: this.stats.totalAcquired,
+      totalReleased: this.stats.totalReleased
+    });
+  }
+  /**
+   * Create a new connection
+   */
+  createConnection() {
+    const id = `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const now = Date.now();
+    const db = createTracedDatabase(this.filename, this.options);
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    db.pragma("cache_size = 1000");
+    db.pragma("temp_store = MEMORY");
+    const connection = {
+      db,
+      id,
+      createdAt: now,
+      lastUsed: now,
+      inUse: true
+    };
+    this.connections.set(id, connection);
+    this.stats.totalCreated++;
+    this.stats.totalAcquired++;
+    this.stats.currentActive++;
+    logger.debug("Created new connection", {
+      connectionId: id,
+      totalConnections: this.connections.size
+    });
+    return connection;
+  }
+  /**
+   * Clean up idle connections
+   */
+  cleanup() {
+    const now = Date.now();
+    const toRemove = [];
+    for (const [id, connection] of this.connections) {
+      if (!connection.inUse && now - connection.lastUsed > this.idleTimeoutMs) {
+        toRemove.push(id);
+      }
+    }
+    for (const id of toRemove) {
+      const connection = this.connections.get(id);
+      if (connection) {
+        try {
+          connection.db.close();
+          this.connections.delete(id);
+          this.stats.currentIdle--;
+          logger.debug("Cleaned up idle connection", {
+            connectionId: id,
+            idleTime: now - connection.lastUsed
+          });
+        } catch (error) {
+          logger.warn("Error cleaning up connection", {
+            connectionId: id,
+            error: error.message
+          });
+        }
+      }
+    }
+    if (toRemove.length > 0) {
+      logger.info("Connection cleanup completed", {
+        removed: toRemove.length,
+        remaining: this.connections.size
+      });
+    }
+  }
+}
+let globalPool = null;
+function getConnectionPool(filename, options) {
+  if (!globalPool && filename) {
+    globalPool = new SQLiteConnectionPool(filename, options);
+  }
+  if (!globalPool) {
+    throw new Error("Connection pool not initialized. Call with filename first.");
+  }
+  return globalPool;
+}
+async function closeGlobalPool() {
+  if (globalPool) {
+    await globalPool.close();
+    globalPool = null;
+  }
+}
+export {
+  SQLiteConnectionPool,
+  closeGlobalPool,
+  getConnectionPool
+};
+//# sourceMappingURL=connection-pool.js.map

package/dist/core/database/connection-pool.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/database/connection-pool.ts"],
+  "sourcesContent": ["/**\n * SQLite Connection Pool\n * Manages a pool of SQLite database connections for performance optimization\n */\n\nimport Database from 'better-sqlite3';\nimport { createTracedDatabase, TracedDatabaseOptions } from '../trace/db-trace-wrapper.js';\nimport { logger } from '../monitoring/logger.js';\n\nexport interface ConnectionPoolOptions extends TracedDatabaseOptions {\n  maxConnections?: number;\n  acquireTimeoutMs?: number;\n  idleTimeoutMs?: number;\n  checkInterval?: number;\n}\n\nexport interface PooledConnection {\n  db: Database.Database;\n  id: string;\n  createdAt: number;\n  lastUsed: number;\n  inUse: boolean;\n}\n\nexport class SQLiteConnectionPool {\n  private connections: Map<string, PooledConnection> = new Map();\n  private filename: string;\n  private options: ConnectionPoolOptions;\n  private maxConnections: number;\n  private acquireTimeoutMs: number;\n  private idleTimeoutMs: number;\n  private cleanupInterval: NodeJS.Timeout | null = null;\n  \n  // Statistics\n  private stats = {\n    totalCreated: 0,\n    totalAcquired: 0,\n    totalReleased: 0,\n    currentActive: 0,\n    currentIdle: 0,\n  };\n\n  constructor(filename: string, options: ConnectionPoolOptions = {}) {\n    this.filename = filename;\n    this.options = options;\n    this.maxConnections = options.maxConnections ?? 5;\n    this.acquireTimeoutMs = options.acquireTimeoutMs ?? 5000;\n    this.idleTimeoutMs = options.idleTimeoutMs ?? 300000; // 5 minutes\n    \n    // Start cleanup interval\n    if (options.checkInterval !== 0) {\n      this.cleanupInterval = setInterval(\n        () => this.cleanup(),\n        options.checkInterval ?? 60000 // 1 minute\n      );\n    }\n\n    logger.info('SQLite connection pool initialized', {\n      filename,\n      maxConnections: this.maxConnections,\n      acquireTimeoutMs: this.acquireTimeoutMs,\n      idleTimeoutMs: this.idleTimeoutMs,\n    });\n  }\n\n  /**\n   * Acquire a connection from the pool\n   */\n  async acquire(): Promise<PooledConnection> {\n    const startTime = Date.now();\n    \n    while (Date.now() - startTime < this.acquireTimeoutMs) {\n      // Try to find an idle connection\n      for (const [id, connection] of this.connections) {\n        if (!connection.inUse) {\n          connection.inUse = true;\n          connection.lastUsed = Date.now();\n          this.stats.totalAcquired++;\n          this.stats.currentActive++;\n          this.stats.currentIdle--;\n          \n          logger.debug('Reused connection from pool', { connectionId: id });\n          return connection;\n        }\n      }\n\n      // Create new connection if under limit\n      if (this.connections.size < this.maxConnections) {\n        return this.createConnection();\n      }\n\n      // Wait briefly before retrying\n      await new Promise(resolve => setTimeout(resolve, 10));\n    }\n\n    throw new Error(`Failed to acquire connection within ${this.acquireTimeoutMs}ms timeout`);\n  }\n\n  /**\n   * Release a connection back to the pool\n   */\n  release(connection: PooledConnection): void {\n    if (this.connections.has(connection.id)) {\n      connection.inUse = false;\n      connection.lastUsed = Date.now();\n      this.stats.totalReleased++;\n      this.stats.currentActive--;\n      this.stats.currentIdle++;\n      \n      logger.debug('Released connection to pool', { connectionId: connection.id });\n    }\n  }\n\n  /**\n   * Execute a function with a pooled connection\n   */\n  async withConnection<T>(fn: (db: Database.Database) => T | Promise<T>): Promise<T> {\n    const connection = await this.acquire();\n    try {\n      return await fn(connection.db);\n    } finally {\n      this.release(connection);\n    }\n  }\n\n  /**\n   * Execute a transaction with a pooled connection\n   */\n  async withTransaction<T>(fn: (db: Database.Database) => T): Promise<T> {\n    const connection = await this.acquire();\n    try {\n      const transaction = connection.db.transaction(() => fn(connection.db));\n      return transaction();\n    } finally {\n      this.release(connection);\n    }\n  }\n\n  /**\n   * Get pool statistics\n   */\n  getStats() {\n    return {\n      ...this.stats,\n      totalConnections: this.connections.size,\n      maxConnections: this.maxConnections,\n    };\n  }\n\n  /**\n   * Close all connections and cleanup\n   */\n  async close(): Promise<void> {\n    if (this.cleanupInterval) {\n      clearInterval(this.cleanupInterval);\n      this.cleanupInterval = null;\n    }\n\n    for (const [id, connection] of this.connections) {\n      try {\n        connection.db.close();\n        logger.debug('Closed connection', { connectionId: id });\n      } catch (error) {\n        logger.warn('Error closing connection', {\n          connectionId: id,\n          error: (error as Error).message,\n        });\n      }\n    }\n\n    this.connections.clear();\n    this.stats.currentActive = 0;\n    this.stats.currentIdle = 0;\n    \n    logger.info('Connection pool closed', { \n      totalCreated: this.stats.totalCreated,\n      totalAcquired: this.stats.totalAcquired,\n      totalReleased: this.stats.totalReleased,\n    });\n  }\n\n  /**\n   * Create a new connection\n   */\n  private createConnection(): PooledConnection {\n    const id = `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;\n    const now = Date.now();\n    \n    const db = createTracedDatabase(this.filename, this.options);\n    \n    // Configure for performance\n    db.pragma('journal_mode = WAL');\n    db.pragma('synchronous = NORMAL');\n    db.pragma('cache_size = 1000');\n    db.pragma('temp_store = MEMORY');\n    \n    const connection: PooledConnection = {\n      db,\n      id,\n      createdAt: now,\n      lastUsed: now,\n      inUse: true,\n    };\n\n    this.connections.set(id, connection);\n    this.stats.totalCreated++;\n    this.stats.totalAcquired++;\n    this.stats.currentActive++;\n\n    logger.debug('Created new connection', { \n      connectionId: id,\n      totalConnections: this.connections.size,\n    });\n\n    return connection;\n  }\n\n  /**\n   * Clean up idle connections\n   */\n  private cleanup(): void {\n    const now = Date.now();\n    const toRemove: string[] = [];\n\n    for (const [id, connection] of this.connections) {\n      if (!connection.inUse && now - connection.lastUsed > this.idleTimeoutMs) {\n        toRemove.push(id);\n      }\n    }\n\n    for (const id of toRemove) {\n      const connection = this.connections.get(id);\n      if (connection) {\n        try {\n          connection.db.close();\n          this.connections.delete(id);\n          this.stats.currentIdle--;\n          \n          logger.debug('Cleaned up idle connection', { \n            connectionId: id,\n            idleTime: now - connection.lastUsed,\n          });\n        } catch (error) {\n          logger.warn('Error cleaning up connection', {\n            connectionId: id,\n            error: (error as Error).message,\n          });\n        }\n      }\n    }\n\n    if (toRemove.length > 0) {\n      logger.info('Connection cleanup completed', {\n        removed: toRemove.length,\n        remaining: this.connections.size,\n      });\n    }\n  }\n}\n\n// Global pool instance\nlet globalPool: SQLiteConnectionPool | null = null;\n\n/**\n * Get or create the global connection pool\n */\nexport function getConnectionPool(\n  filename?: string, \n  options?: ConnectionPoolOptions\n): SQLiteConnectionPool {\n  if (!globalPool && filename) {\n    globalPool = new SQLiteConnectionPool(filename, options);\n  }\n  \n  if (!globalPool) {\n    throw new Error('Connection pool not initialized. Call with filename first.');\n  }\n  \n  return globalPool;\n}\n\n/**\n * Close the global connection pool\n */\nexport async function closeGlobalPool(): Promise<void> {\n  if (globalPool) {\n    await globalPool.close();\n    globalPool = null;\n  }\n}"],
+  "mappings": "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",
+  "names": []
+}