@stackmemoryai/stackmemory 0.3.1 → 0.3.3

package/dist/core/context/validation.js

@@ -0,0 +1,121 @@
+import { z } from "zod";
+const StackPermissionsSchema = z.object({
+  canRead: z.boolean(),
+  canWrite: z.boolean(),
+  canHandoff: z.boolean(),
+  canMerge: z.boolean(),
+  canAdminister: z.boolean()
+});
+const stackIdSchema = z.string().min(1).max(200);
+const userIdSchema = z.string().min(1).max(100);
+const frameIdSchema = z.string().min(1).max(100);
+const teamIdSchema = z.string().min(1).max(100);
+const CreateSharedStackSchema = z.object({
+  teamId: teamIdSchema,
+  name: z.string().min(1).max(200),
+  ownerId: userIdSchema,
+  permissions: StackPermissionsSchema.optional()
+});
+const SwitchStackSchema = z.object({
+  stackId: stackIdSchema
+});
+const FrameContextSchema = z.object({
+  totalFrames: z.number().min(1).max(1e4),
+  frameTypes: z.array(z.string()).min(1).max(50),
+  estimatedSize: z.number().min(0).max(1e6),
+  // Max 1MB
+  dependencies: z.array(z.string()).max(100)
+});
+const BusinessContextSchema = z.object({
+  milestone: z.string().max(100).optional(),
+  priority: z.enum(["low", "medium", "high", "critical"]).optional(),
+  deadline: z.date().optional(),
+  stakeholders: z.array(userIdSchema).max(20).optional()
+});
+const HandoffRequestSchema = z.object({
+  initiatedAt: z.date(),
+  initiatorId: userIdSchema,
+  frameContext: FrameContextSchema,
+  businessContext: BusinessContextSchema.optional()
+});
+const InitiateHandoffSchema = z.object({
+  targetStackId: stackIdSchema,
+  frameIds: z.array(frameIdSchema).min(1).max(1e3),
+  handoffRequest: HandoffRequestSchema,
+  reviewerId: userIdSchema.optional(),
+  description: z.string().max(1e3).optional()
+});
+const HandoffApprovalSchema = z.object({
+  reviewerId: userIdSchema,
+  decision: z.enum(["approved", "rejected", "needs_changes"]),
+  feedback: z.string().max(2e3).optional(),
+  suggestedChanges: z.array(
+    z.object({
+      frameId: frameIdSchema,
+      suggestion: z.string().max(500),
+      reason: z.string().max(300).optional()
+    })
+  ).max(50).optional()
+});
+const ConflictResolutionSchema = z.object({
+  strategy: z.enum(["source_wins", "target_wins", "merge_both", "manual"]),
+  resolvedBy: userIdSchema,
+  notes: z.string().max(1e3).optional()
+});
+const MergePolicyRuleSchema = z.object({
+  condition: z.string().min(1).max(500),
+  action: z.enum(["source_wins", "target_wins", "merge_both", "manual_review"]),
+  priority: z.number().min(1).max(10)
+});
+const CreateMergePolicySchema = z.object({
+  name: z.string().min(1).max(100),
+  description: z.string().max(500).optional(),
+  rules: z.array(MergePolicyRuleSchema).min(1).max(20),
+  autoApplyThreshold: z.enum(["low", "medium", "high"])
+});
+const StartMergeSessionSchema = z.object({
+  sourceStackId: stackIdSchema,
+  targetStackId: stackIdSchema,
+  frameIds: z.array(frameIdSchema).max(1e3).optional(),
+  policyName: z.string().max(100).optional()
+});
+function validateInput(schema, input) {
+  try {
+    return schema.parse(input);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const details = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+      throw new Error(`Validation failed: ${details}`);
+    }
+    throw error;
+  }
+}
+function validateInputSafe(schema, input) {
+  try {
+    const data = schema.parse(input);
+    return { success: true, data };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const details = error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+      return { success: false, error: `Validation failed: ${details}` };
+    }
+    return { success: false, error: "Unknown validation error" };
+  }
+}
+export {
+  BusinessContextSchema,
+  ConflictResolutionSchema,
+  CreateMergePolicySchema,
+  CreateSharedStackSchema,
+  FrameContextSchema,
+  HandoffApprovalSchema,
+  HandoffRequestSchema,
+  InitiateHandoffSchema,
+  MergePolicyRuleSchema,
+  StackPermissionsSchema,
+  StartMergeSessionSchema,
+  SwitchStackSchema,
+  validateInput,
+  validateInputSafe
+};
+//# sourceMappingURL=validation.js.map

package/dist/core/context/validation.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/context/validation.ts"],
+  "sourcesContent": ["/**\n * Input validation schemas for collaboration layer\n */\n\nimport { z } from 'zod';\n\n// Permission validation\nexport const StackPermissionsSchema = z.object({\n  canRead: z.boolean(),\n  canWrite: z.boolean(),\n  canHandoff: z.boolean(),\n  canMerge: z.boolean(),\n  canAdminister: z.boolean(),\n});\n\n// Common string validations\nconst stackIdSchema = z.string().min(1).max(200);\nconst userIdSchema = z.string().min(1).max(100);\nconst frameIdSchema = z.string().min(1).max(100);\nconst teamIdSchema = z.string().min(1).max(100);\n\n// Dual Stack Manager validation\nexport const CreateSharedStackSchema = z.object({\n  teamId: teamIdSchema,\n  name: z.string().min(1).max(200),\n  ownerId: userIdSchema,\n  permissions: StackPermissionsSchema.optional(),\n});\n\nexport const SwitchStackSchema = z.object({\n  stackId: stackIdSchema,\n});\n\n// Frame Handoff validation\nexport const FrameContextSchema = z.object({\n  totalFrames: z.number().min(1).max(10000),\n  frameTypes: z.array(z.string()).min(1).max(50),\n  estimatedSize: z.number().min(0).max(1000000), // Max 1MB\n  dependencies: z.array(z.string()).max(100),\n});\n\nexport const BusinessContextSchema = z.object({\n  milestone: z.string().max(100).optional(),\n  priority: z.enum(['low', 'medium', 'high', 'critical']).optional(),\n  deadline: z.date().optional(),\n  stakeholders: z.array(userIdSchema).max(20).optional(),\n});\n\nexport const HandoffRequestSchema = z.object({\n  initiatedAt: z.date(),\n  initiatorId: userIdSchema,\n  frameContext: FrameContextSchema,\n  businessContext: BusinessContextSchema.optional(),\n});\n\nexport const InitiateHandoffSchema = z.object({\n  targetStackId: stackIdSchema,\n  frameIds: z.array(frameIdSchema).min(1).max(1000),\n  handoffRequest: HandoffRequestSchema,\n  reviewerId: userIdSchema.optional(),\n  description: z.string().max(1000).optional(),\n});\n\nexport const HandoffApprovalSchema = z.object({\n  reviewerId: userIdSchema,\n  decision: z.enum(['approved', 'rejected', 'needs_changes']),\n  feedback: z.string().max(2000).optional(),\n  suggestedChanges: z\n    .array(\n      z.object({\n        frameId: frameIdSchema,\n        suggestion: z.string().max(500),\n        reason: z.string().max(300).optional(),\n      })\n    )\n    .max(50)\n    .optional(),\n});\n\n// Merge Resolution validation\nexport const ConflictResolutionSchema = z.object({\n  strategy: z.enum(['source_wins', 'target_wins', 'merge_both', 'manual']),\n  resolvedBy: userIdSchema,\n  notes: z.string().max(1000).optional(),\n});\n\nexport const MergePolicyRuleSchema = z.object({\n  condition: z.string().min(1).max(500),\n  action: z.enum(['source_wins', 'target_wins', 'merge_both', 'manual_review']),\n  priority: z.number().min(1).max(10),\n});\n\nexport const CreateMergePolicySchema = z.object({\n  name: z.string().min(1).max(100),\n  description: z.string().max(500).optional(),\n  rules: z.array(MergePolicyRuleSchema).min(1).max(20),\n  autoApplyThreshold: z.enum(['low', 'medium', 'high']),\n});\n\nexport const StartMergeSessionSchema = z.object({\n  sourceStackId: stackIdSchema,\n  targetStackId: stackIdSchema,\n  frameIds: z.array(frameIdSchema).max(1000).optional(),\n  policyName: z.string().max(100).optional(),\n});\n\n// Type exports for use in implementation\nexport type StackPermissions = z.infer<typeof StackPermissionsSchema>;\nexport type CreateSharedStackInput = z.infer<typeof CreateSharedStackSchema>;\nexport type SwitchStackInput = z.infer<typeof SwitchStackSchema>;\nexport type FrameContext = z.infer<typeof FrameContextSchema>;\nexport type BusinessContext = z.infer<typeof BusinessContextSchema>;\nexport type HandoffRequest = z.infer<typeof HandoffRequestSchema>;\nexport type InitiateHandoffInput = z.infer<typeof InitiateHandoffSchema>;\nexport type HandoffApprovalInput = z.infer<typeof HandoffApprovalSchema>;\nexport type ConflictResolutionInput = z.infer<typeof ConflictResolutionSchema>;\nexport type MergePolicyRule = z.infer<typeof MergePolicyRuleSchema>;\nexport type CreateMergePolicyInput = z.infer<typeof CreateMergePolicySchema>;\nexport type StartMergeSessionInput = z.infer<typeof StartMergeSessionSchema>;\n\n// Validation helper functions\nexport function validateInput<T>(schema: z.ZodSchema<T>, input: unknown): T {\n  try {\n    return schema.parse(input);\n  } catch (error) {\n    if (error instanceof z.ZodError) {\n      const details = error.errors\n        .map((e) => `${e.path.join('.')}: ${e.message}`)\n        .join(', ');\n      throw new Error(`Validation failed: ${details}`);\n    }\n    throw error;\n  }\n}\n\nexport function validateInputSafe<T>(\n  schema: z.ZodSchema<T>,\n  input: unknown\n): { success: true; data: T } | { success: false; error: string } {\n  try {\n    const data = schema.parse(input);\n    return { success: true, data };\n  } catch (error) {\n    if (error instanceof z.ZodError) {\n      const details = error.errors\n        .map((e) => `${e.path.join('.')}: ${e.message}`)\n        .join(', ');\n      return { success: false, error: `Validation failed: ${details}` };\n    }\n    return { success: false, error: 'Unknown validation error' };\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -1,224 +1,315 @@
-import { createTracedDatabase } from "../trace/db-trace-wrapper.js";
+import { Pool } from "pg";
+import { EventEmitter } from "events";
 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
-      );
+class ConnectionPool extends EventEmitter {
+  pool;
+  config;
+  metrics;
+  health;
+  healthCheckTimer;
+  metricsTimer;
+  startTime;
+  badConnections = /* @__PURE__ */ new Set();
+  acquireTimes = [];
+  constructor(config) {
+    super();
+    this.config = this.normalizeConfig(config);
+    this.startTime = /* @__PURE__ */ new Date();
+    this.metrics = {
+      totalConnections: 0,
+      idleConnections: 0,
+      activeConnections: 0,
+      waitingRequests: 0,
+      totalAcquired: 0,
+      totalReleased: 0,
+      totalErrors: 0,
+      averageAcquireTime: 0,
+      peakConnections: 0,
+      uptime: 0
+    };
+    this.health = {
+      isHealthy: false,
+      lastCheck: /* @__PURE__ */ new Date(),
+      consecutiveFailures: 0,
+      totalChecks: 0,
+      totalFailures: 0,
+      averageResponseTime: 0
+    };
+    this.pool = new Pool(this.config);
+    this.setupPoolEvents();
+    if (this.config.enableMetrics) {
+      this.startMonitoring();
+    }
+  }
+  normalizeConfig(config) {
+    return {
+      ...config,
+      min: config.min ?? 2,
+      max: config.max ?? 10,
+      idleTimeoutMillis: config.idleTimeoutMillis ?? 3e4,
+      connectionTimeoutMillis: config.connectionTimeoutMillis ?? 5e3,
+      healthCheckInterval: config.healthCheckInterval ?? 3e4,
+      healthCheckQuery: config.healthCheckQuery ?? "SELECT 1",
+      retryOnFailure: config.retryOnFailure ?? true,
+      maxRetries: config.maxRetries ?? 3,
+      retryDelayMs: config.retryDelayMs ?? 1e3,
+      enableMetrics: config.enableMetrics ?? true,
+      metricsInterval: config.metricsInterval ?? 6e4
+    };
+  }
+  setupPoolEvents() {
+    this.pool.on("connect", (client) => {
+      logger.debug("New database connection established");
+      this.metrics.totalConnections++;
+      this.updatePeakConnections();
+      this.emit("connect", client);
+    });
+    this.pool.on("acquire", (client) => {
+      this.metrics.totalAcquired++;
+      this.emit("acquire", client);
+    });
+    this.pool.on("release", (client) => {
+      this.metrics.totalReleased++;
+      this.emit("release", client);
+    });
+    this.pool.on("remove", (client) => {
+      logger.debug("Database connection removed from pool");
+      this.metrics.totalConnections--;
+      this.emit("remove", client);
+    });
+    this.pool.on("error", (error) => {
+      logger.error("Database pool error:", error);
+      this.metrics.totalErrors++;
+      this.emit("error", error);
+    });
+  }
+  updatePeakConnections() {
+    const current = this.pool.totalCount;
+    if (current > this.metrics.peakConnections) {
+      this.metrics.peakConnections = current;
+    }
+  }
+  startMonitoring() {
+    if (this.config.healthCheckInterval > 0) {
+      this.healthCheckTimer = setInterval(() => {
+        this.performHealthCheck().catch((error) => {
+          logger.error("Health check failed:", error);
+        });
+      }, this.config.healthCheckInterval);
+    }
+    if (this.config.metricsInterval > 0) {
+      this.metricsTimer = setInterval(() => {
+        this.updateMetrics();
+        this.emit("metrics", this.getMetrics());
+      }, this.config.metricsInterval);
     }
-    logger.info("SQLite connection pool initialized", {
-      filename,
-      maxConnections: this.maxConnections,
-      acquireTimeoutMs: this.acquireTimeoutMs,
-      idleTimeoutMs: this.idleTimeoutMs
+    this.performHealthCheck().catch((error) => {
+      logger.warn("Initial health check failed:", error);
     });
   }
+  async performHealthCheck() {
+    const startTime = Date.now();
+    let client;
+    try {
+      this.health.totalChecks++;
+      client = await this.pool.connect();
+      await client.query(this.config.healthCheckQuery);
+      const responseTime = Date.now() - startTime;
+      this.updateHealthMetrics(true, responseTime);
+      logger.debug(`Health check passed in ${responseTime}ms`);
+    } catch (error) {
+      const responseTime = Date.now() - startTime;
+      this.updateHealthMetrics(false, responseTime);
+      logger.warn(`Health check failed after ${responseTime}ms:`, error);
+      if (this.config.retryOnFailure && this.health.consecutiveFailures < this.config.maxRetries) {
+        setTimeout(() => {
+          this.performHealthCheck().catch(() => {
+          });
+        }, this.config.retryDelayMs);
+      }
+    } finally {
+      if (client) {
+        client.release();
+      }
+    }
+  }
+  updateHealthMetrics(success, responseTime) {
+    this.health.lastCheck = /* @__PURE__ */ new Date();
+    if (success) {
+      this.health.isHealthy = true;
+      this.health.consecutiveFailures = 0;
+    } else {
+      this.health.isHealthy = false;
+      this.health.consecutiveFailures++;
+      this.health.totalFailures++;
+    }
+    const weight = Math.min(this.health.totalChecks, 10);
+    this.health.averageResponseTime = (this.health.averageResponseTime * (weight - 1) + responseTime) / weight;
+  }
+  updateMetrics() {
+    this.metrics.idleConnections = this.pool.idleCount;
+    this.metrics.activeConnections = this.pool.totalCount - this.pool.idleCount;
+    this.metrics.waitingRequests = this.pool.waitingCount;
+    this.metrics.uptime = Date.now() - this.startTime.getTime();
+    if (this.acquireTimes.length > 0) {
+      this.metrics.averageAcquireTime = this.acquireTimes.reduce((sum, time) => sum + time, 0) / this.acquireTimes.length;
+      if (this.acquireTimes.length > 100) {
+        this.acquireTimes = this.acquireTimes.slice(-100);
+      }
+    }
+  }
   /**
    * 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();
+    try {
+      const client = await this.pool.connect();
+      const acquireTime = Date.now() - startTime;
+      this.acquireTimes.push(acquireTime);
+      if (this.badConnections.has(client)) {
+        this.badConnections.delete(client);
+        client.release(true);
+        return this.acquire();
       }
-      await new Promise((resolve) => setTimeout(resolve, 10));
+      return client;
+    } catch (error) {
+      this.metrics.totalErrors++;
+      logger.error("Failed to acquire connection:", error);
+      throw error;
     }
-    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 });
+  release(client, error) {
+    if (error) {
+      client.release(true);
+    } else {
+      client.release();
     }
   }
   /**
-   * Execute a function with a pooled connection
+   * Mark a connection as bad (will be removed on next acquire)
    */
-  async withConnection(fn) {
-    const connection = await this.acquire();
-    try {
-      return await fn(connection.db);
-    } finally {
-      this.release(connection);
-    }
+  markConnectionAsBad(client) {
+    this.badConnections.add(client);
+    logger.warn("Connection marked as bad and will be removed");
   }
   /**
-   * Execute a transaction with a pooled connection
+   * Get current connection metrics
    */
-  async withTransaction(fn) {
-    const connection = await this.acquire();
+  getMetrics() {
+    this.updateMetrics();
+    return { ...this.metrics };
+  }
+  /**
+   * Get current health status
+   */
+  getHealth() {
+    return { ...this.health };
+  }
+  /**
+   * Test connection to database
+   */
+  async ping() {
     try {
-      const transaction = connection.db.transaction(() => fn(connection.db));
-      return transaction();
-    } finally {
-      this.release(connection);
+      const client = await this.acquire();
+      await client.query("SELECT 1");
+      this.release(client);
+      return true;
+    } catch {
+      return false;
     }
   }
   /**
-   * Get pool statistics
+   * Get pool status information
    */
-  getStats() {
+  getStatus() {
     return {
-      ...this.stats,
-      totalConnections: this.connections.size,
-      maxConnections: this.maxConnections
+      totalCount: this.pool.totalCount,
+      idleCount: this.pool.idleCount,
+      waitingCount: this.pool.waitingCount,
+      config: {
+        min: this.config.min,
+        max: this.config.max,
+        idleTimeoutMillis: this.config.idleTimeoutMillis,
+        connectionTimeoutMillis: this.config.connectionTimeoutMillis
+      },
+      health: this.getHealth(),
+      metrics: this.getMetrics()
     };
   }
   /**
-   * Close all connections and cleanup
+   * Close all connections and clean up
    */
   async close() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
+    logger.info("Closing connection pool");
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
     }
-    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
-        });
-      }
+    if (this.metricsTimer) {
+      clearInterval(this.metricsTimer);
     }
-    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
-    });
+    await this.pool.end();
+    this.badConnections.clear();
+    this.emit("close");
+    logger.info("Connection pool closed");
   }
   /**
-   * Create a new connection
+   * Drain pool gracefully (wait for active connections to finish)
    */
-  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;
+  async drain(timeoutMs = 3e4) {
+    logger.info("Draining connection pool");
+    const startTime = Date.now();
+    while (this.pool.totalCount - this.pool.idleCount > 0) {
+      if (Date.now() - startTime > timeoutMs) {
+        logger.warn("Pool drain timeout reached, forcing close");
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    await this.close();
   }
   /**
-   * Clean up idle connections
+   * Execute a query using a pooled connection
    */
-  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);
-      }
+  async query(text, params) {
+    const client = await this.acquire();
+    try {
+      const result = await client.query(text, params);
+      return {
+        rows: result.rows,
+        rowCount: result.rowCount || 0
+      };
+    } finally {
+      this.release(client);
     }
-    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
-          });
-        }
+  }
+  /**
+   * Execute multiple queries in a transaction
+   */
+  async transaction(callback) {
+    const client = await this.acquire();
+    try {
+      await client.query("BEGIN");
+      const result = await callback(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      try {
+        await client.query("ROLLBACK");
+      } catch (rollbackError) {
+        logger.error("Transaction rollback failed:", rollbackError);
+        this.markConnectionAsBad(client);
       }
+      throw error;
+    } finally {
+      this.release(client);
     }
-    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
+  ConnectionPool
 };
 //# sourceMappingURL=connection-pool.js.map