claude-flow 2.0.0-alpha.60 → 2.0.0-alpha.62

package/src/memory/shared-memory.js

@@ -1,7 +1,7 @@
 /**
  * SharedMemory - Unified memory persistence module for ruv-swarm
  * Supports both .swarm/ and .hive-mind/ directories with SQLite backend
- * 
+ *
  * @module shared-memory
  */
 
@@ -62,7 +62,7 @@ const MIGRATIONS = [
       INSERT OR IGNORE INTO metadata (key, value) VALUES 
         ('version', '1.0.0'),
         ('created_at', strftime('%s', 'now'));
-    `
+    `,
   },
   {
     version: 2,
@@ -76,8 +76,8 @@ const MIGRATIONS = [
       
       -- Update version
       UPDATE metadata SET value = '1.1.0', updated_at = strftime('%s', 'now') WHERE key = 'version';
-    `
-  }
+    `,
+  },
 ];
 
 /**
@@ -112,17 +112,17 @@ class LRUCache {
     if (!size) {
       size = this._estimateSize(data);
     }
-    
+
     // Handle memory pressure
     while (this.currentMemory + size > this.maxMemory && this.cache.size > 0) {
       this._evictLRU();
     }
-    
+
     // Handle size limit
     while (this.cache.size >= this.maxSize) {
       this._evictLRU();
     }
-    
+
     this.cache.set(key, { data, size, timestamp: Date.now() });
     this.currentMemory += size;
   }
@@ -152,7 +152,7 @@ class LRUCache {
       memoryUsageMB: this.currentMemory / (1024 * 1024),
       hitRate: total > 0 ? (this.hits / total) * 100 : 0,
       evictions: this.evictions,
-      utilizationPercent: (this.currentMemory / this.maxMemory) * 100
+      utilizationPercent: (this.currentMemory / this.maxMemory) * 100,
     };
   }
 
@@ -181,7 +181,7 @@ class LRUCache {
 export class SharedMemory extends EventEmitter {
   constructor(options = {}) {
     super();
-    
+
     this.options = {
       directory: options.directory || '.hive-mind',
       filename: options.filename || 'memory.db',
@@ -191,20 +191,20 @@ export class SharedMemory extends EventEmitter {
       gcInterval: options.gcInterval || 300000, // 5 minutes
       enableWAL: options.enableWAL !== false,
       enableVacuum: options.enableVacuum !== false,
-      ...options
+      ...options,
     };
-    
+
     this.db = null;
     this.cache = new LRUCache(this.options.cacheSize, this.options.cacheMemoryMB);
     this.statements = new Map();
     this.gcTimer = null;
     this.isInitialized = false;
-    
+
     // Performance tracking
     this.metrics = {
       operations: new Map(),
       lastGC: Date.now(),
-      totalOperations: 0
+      totalOperations: 0,
     };
   }
 
@@ -213,36 +213,35 @@ export class SharedMemory extends EventEmitter {
    */
   async initialize() {
     if (this.isInitialized) return;
-    
+
     const startTime = performance.now();
-    
+
     try {
       // Ensure directory exists
       await fs.mkdir(path.join(process.cwd(), this.options.directory), { recursive: true });
-      
+
       // Open database
       const dbPath = path.join(process.cwd(), this.options.directory, this.options.filename);
       this.db = new Database(dbPath);
-      
+
       // Configure for performance
       this._configureDatabase();
-      
+
       // Run migrations
       await this._runMigrations();
-      
+
       // Prepare statements
       this._prepareStatements();
-      
+
       // Start garbage collection
       this._startGarbageCollection();
-      
+
       this.isInitialized = true;
-      
+
       const duration = performance.now() - startTime;
       this._recordMetric('initialize', duration);
-      
+
       this.emit('initialized', { dbPath, duration });
-      
     } catch (error) {
       this.emit('error', error);
       throw new Error(`Failed to initialize SharedMemory: ${error.message}`);
@@ -254,61 +253,51 @@ export class SharedMemory extends EventEmitter {
    */
   async store(key, value, options = {}) {
     this._ensureInitialized();
-    
+
     const startTime = performance.now();
-    
+
     try {
       const namespace = options.namespace || 'default';
       const ttl = options.ttl;
       const tags = options.tags ? JSON.stringify(options.tags) : null;
       const metadata = options.metadata ? JSON.stringify(options.metadata) : null;
-      
+
       // Serialize value
       let serialized = value;
       let type = 'string';
       let compressed = 0;
-      
+
       if (typeof value !== 'string') {
         serialized = JSON.stringify(value);
         type = 'json';
       }
-      
+
       const size = Buffer.byteLength(serialized);
-      
+
       // Compress if needed
       if (size > this.options.compressionThreshold) {
         // In production, use proper compression
         compressed = 1;
       }
-      
+
       // Calculate expiry
       const expiresAt = ttl ? Math.floor(Date.now() / 1000) + ttl : null;
-      
+
       // Store in database
-      this.statements.get('upsert').run(
-        key,
-        namespace,
-        serialized,
-        type,
-        metadata,
-        tags,
-        ttl,
-        expiresAt,
-        compressed,
-        size
-      );
-      
+      this.statements
+        .get('upsert')
+        .run(key, namespace, serialized, type, metadata, tags, ttl, expiresAt, compressed, size);
+
       // Update cache
       const cacheKey = this._getCacheKey(key, namespace);
       this.cache.set(cacheKey, value, size);
-      
+
       const duration = performance.now() - startTime;
       this._recordMetric('store', duration);
-      
+
       this.emit('stored', { key, namespace, size, compressed: !!compressed });
-      
+
       return { success: true, key, namespace, size };
-      
     } catch (error) {
       this.emit('error', error);
       throw error;
@@ -320,27 +309,27 @@ export class SharedMemory extends EventEmitter {
    */
   async retrieve(key, namespace = 'default') {
     this._ensureInitialized();
-    
+
     const startTime = performance.now();
-    
+
     try {
       // Check cache first
       const cacheKey = this._getCacheKey(key, namespace);
       const cached = this.cache.get(cacheKey);
-      
+
       if (cached !== null) {
         this._recordMetric('retrieve_cache', performance.now() - startTime);
         return cached;
       }
-      
+
       // Get from database
       const row = this.statements.get('select').get(key, namespace);
-      
+
       if (!row) {
         this._recordMetric('retrieve_miss', performance.now() - startTime);
         return null;
       }
-      
+
       // Check expiry
       if (row.expires_at && row.expires_at < Math.floor(Date.now() / 1000)) {
         // Delete expired entry
@@ -348,24 +337,23 @@ export class SharedMemory extends EventEmitter {
         this._recordMetric('retrieve_expired', performance.now() - startTime);
         return null;
       }
-      
+
       // Update access stats
       this.statements.get('updateAccess').run(key, namespace);
-      
+
       // Deserialize value
       let value = row.value;
       if (row.type === 'json') {
         value = JSON.parse(value);
       }
-      
+
       // Update cache
       this.cache.set(cacheKey, value, row.size);
-      
+
       const duration = performance.now() - startTime;
       this._recordMetric('retrieve_db', duration);
-      
+
       return value;
-      
     } catch (error) {
       this.emit('error', error);
       throw error;
@@ -377,14 +365,14 @@ export class SharedMemory extends EventEmitter {
    */
   async list(namespace = 'default', options = {}) {
     this._ensureInitialized();
-    
+
     const limit = options.limit || 100;
     const offset = options.offset || 0;
-    
+
     try {
       const rows = this.statements.get('list').all(namespace, limit, offset);
-      
-      return rows.map(row => ({
+
+      return rows.map((row) => ({
         key: row.key,
         namespace: row.namespace,
         type: row.type,
@@ -395,9 +383,8 @@ export class SharedMemory extends EventEmitter {
         updatedAt: new Date(row.updated_at * 1000),
         accessedAt: new Date(row.accessed_at * 1000),
         accessCount: row.access_count,
-        expiresAt: row.expires_at ? new Date(row.expires_at * 1000) : null
+        expiresAt: row.expires_at ? new Date(row.expires_at * 1000) : null,
       }));
-      
     } catch (error) {
       this.emit('error', error);
       throw error;
@@ -409,22 +396,21 @@ export class SharedMemory extends EventEmitter {
    */
   async delete(key, namespace = 'default') {
     this._ensureInitialized();
-    
+
     try {
       // Remove from cache
       const cacheKey = this._getCacheKey(key, namespace);
       this.cache.delete(cacheKey);
-      
+
       // Remove from database
       const result = this.statements.get('delete').run(key, namespace);
-      
+
       if (result.changes > 0) {
         this.emit('deleted', { key, namespace });
         return true;
       }
-      
+
       return false;
-      
     } catch (error) {
       this.emit('error', error);
       throw error;
@@ -436,7 +422,7 @@ export class SharedMemory extends EventEmitter {
    */
   async clear(namespace = 'default') {
     this._ensureInitialized();
-    
+
     try {
       // Clear cache entries for namespace
       for (const [key] of this.cache.cache) {
@@ -444,14 +430,13 @@ export class SharedMemory extends EventEmitter {
           this.cache.delete(key);
         }
       }
-      
+
       // Clear database entries
       const result = this.statements.get('clearNamespace').run(namespace);
-      
+
       this.emit('cleared', { namespace, count: result.changes });
-      
+
       return { cleared: result.changes };
-      
     } catch (error) {
       this.emit('error', error);
       throw error;
@@ -463,11 +448,11 @@ export class SharedMemory extends EventEmitter {
    */
   async getStats() {
     this._ensureInitialized();
-    
+
     try {
       const dbStats = this.statements.get('stats').all();
       const cacheStats = this.cache.getStats();
-      
+
       // Transform database stats
       const namespaceStats = {};
       for (const row of dbStats) {
@@ -475,20 +460,19 @@ export class SharedMemory extends EventEmitter {
           count: row.count,
           totalSize: row.total_size,
           avgSize: row.avg_size,
-          compressed: row.compressed_count
+          compressed: row.compressed_count,
         };
       }
-      
+
       return {
         namespaces: namespaceStats,
         cache: cacheStats,
         metrics: this._getMetricsSummary(),
         database: {
           totalEntries: Object.values(namespaceStats).reduce((sum, ns) => sum + ns.count, 0),
-          totalSize: Object.values(namespaceStats).reduce((sum, ns) => sum + ns.totalSize, 0)
-        }
+          totalSize: Object.values(namespaceStats).reduce((sum, ns) => sum + ns.totalSize, 0),
+        },
       };
-      
     } catch (error) {
       this.emit('error', error);
       throw error;
@@ -500,48 +484,41 @@ export class SharedMemory extends EventEmitter {
    */
   async search(options = {}) {
     this._ensureInitialized();
-    
-    const {
-      pattern,
-      namespace,
-      tags,
-      limit = 50,
-      offset = 0
-    } = options;
-    
+
+    const { pattern, namespace, tags, limit = 50, offset = 0 } = options;
+
     try {
       let query = 'SELECT * FROM memory_store WHERE 1=1';
       const params = [];
-      
+
       if (namespace) {
         query += ' AND namespace = ?';
         params.push(namespace);
       }
-      
+
       if (pattern) {
         query += ' AND key LIKE ?';
         params.push(`%${pattern}%`);
       }
-      
+
       if (tags && tags.length > 0) {
         // Simple tag search - in production, use JSON functions
         query += ' AND tags IS NOT NULL';
       }
-      
+
       query += ' ORDER BY accessed_at DESC LIMIT ? OFFSET ?';
       params.push(limit, offset);
-      
+
       const stmt = this.db.prepare(query);
       const rows = stmt.all(...params);
-      
-      return rows.map(row => ({
+
+      return rows.map((row) => ({
         key: row.key,
         namespace: row.namespace,
         value: row.type === 'json' ? JSON.parse(row.value) : row.value,
         metadata: row.metadata ? JSON.parse(row.metadata) : null,
-        tags: row.tags ? JSON.parse(row.tags) : []
+        tags: row.tags ? JSON.parse(row.tags) : [],
       }));
-      
     } catch (error) {
       this.emit('error', error);
       throw error;
@@ -553,7 +530,7 @@ export class SharedMemory extends EventEmitter {
    */
   async backup(filepath) {
     this._ensureInitialized();
-    
+
     try {
       await this.db.backup(filepath);
       this.emit('backup', { filepath });
@@ -569,36 +546,35 @@ export class SharedMemory extends EventEmitter {
    */
   async close() {
     if (!this.isInitialized) return;
-    
+
     try {
       // Stop garbage collection
       if (this.gcTimer) {
         clearInterval(this.gcTimer);
         this.gcTimer = null;
       }
-      
+
       // Final optimization
       if (this.options.enableVacuum) {
         this.db.pragma('optimize');
       }
-      
+
       // Close statements
       for (const stmt of this.statements.values()) {
         stmt.finalize();
       }
       this.statements.clear();
-      
+
       // Close database
       this.db.close();
       this.db = null;
-      
+
       // Clear cache
       this.cache.clear();
-      
+
       this.isInitialized = false;
-      
+
       this.emit('closed');
-      
     } catch (error) {
       this.emit('error', error);
       throw error;
@@ -608,7 +584,7 @@ export class SharedMemory extends EventEmitter {
   /**
    * Private helper methods
    */
-  
+
   _ensureInitialized() {
     if (!this.isInitialized) {
       throw new Error('SharedMemory not initialized. Call initialize() first.');
@@ -635,25 +611,24 @@ export class SharedMemory extends EventEmitter {
         applied_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
       )
     `);
-    
+
     // Get current version
-    const currentVersion = this.db.prepare(
-      'SELECT MAX(version) as version FROM migrations'
-    ).get().version || 0;
-    
+    const currentVersion =
+      this.db.prepare('SELECT MAX(version) as version FROM migrations').get().version || 0;
+
     // Run pending migrations
-    const pending = MIGRATIONS.filter(m => m.version > currentVersion);
-    
+    const pending = MIGRATIONS.filter((m) => m.version > currentVersion);
+
     if (pending.length > 0) {
       const transaction = this.db.transaction((migrations) => {
         for (const migration of migrations) {
           this.db.exec(migration.sql);
-          this.db.prepare(
-            'INSERT INTO migrations (version, description) VALUES (?, ?)'
-          ).run(migration.version, migration.description);
+          this.db
+            .prepare('INSERT INTO migrations (version, description) VALUES (?, ?)')
+            .run(migration.version, migration.description);
         }
       });
-      
+
       transaction(pending);
       this.emit('migrated', { from: currentVersion, to: pending[pending.length - 1].version });
     }
@@ -661,7 +636,9 @@ export class SharedMemory extends EventEmitter {
 
   _prepareStatements() {
     // Upsert statement
-    this.statements.set('upsert', this.db.prepare(`
+    this.statements.set(
+      'upsert',
+      this.db.prepare(`
       INSERT INTO memory_store (key, namespace, value, type, metadata, tags, ttl, expires_at, compressed, size)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(key, namespace) DO UPDATE SET
@@ -675,40 +652,58 @@ export class SharedMemory extends EventEmitter {
         size = excluded.size,
         updated_at = strftime('%s', 'now'),
         access_count = memory_store.access_count + 1
-    `));
-    
+    `),
+    );
+
     // Select statement
-    this.statements.set('select', this.db.prepare(`
+    this.statements.set(
+      'select',
+      this.db.prepare(`
       SELECT * FROM memory_store WHERE key = ? AND namespace = ?
-    `));
-    
+    `),
+    );
+
     // Update access statement
-    this.statements.set('updateAccess', this.db.prepare(`
+    this.statements.set(
+      'updateAccess',
+      this.db.prepare(`
       UPDATE memory_store 
       SET accessed_at = strftime('%s', 'now'), access_count = access_count + 1
       WHERE key = ? AND namespace = ?
-    `));
-    
+    `),
+    );
+
     // Delete statement
-    this.statements.set('delete', this.db.prepare(`
+    this.statements.set(
+      'delete',
+      this.db.prepare(`
       DELETE FROM memory_store WHERE key = ? AND namespace = ?
-    `));
-    
+    `),
+    );
+
     // List statement
-    this.statements.set('list', this.db.prepare(`
+    this.statements.set(
+      'list',
+      this.db.prepare(`
       SELECT * FROM memory_store 
       WHERE namespace = ? 
       ORDER BY accessed_at DESC 
       LIMIT ? OFFSET ?
-    `));
-    
+    `),
+    );
+
     // Clear namespace statement
-    this.statements.set('clearNamespace', this.db.prepare(`
+    this.statements.set(
+      'clearNamespace',
+      this.db.prepare(`
       DELETE FROM memory_store WHERE namespace = ?
-    `));
-    
+    `),
+    );
+
     // Stats statement
-    this.statements.set('stats', this.db.prepare(`
+    this.statements.set(
+      'stats',
+      this.db.prepare(`
       SELECT 
         namespace,
         COUNT(*) as count,
@@ -717,13 +712,17 @@ export class SharedMemory extends EventEmitter {
         SUM(compressed) as compressed_count
       FROM memory_store
       GROUP BY namespace
-    `));
-    
+    `),
+    );
+
     // Garbage collection statement
-    this.statements.set('gc', this.db.prepare(`
+    this.statements.set(
+      'gc',
+      this.db.prepare(`
       DELETE FROM memory_store 
       WHERE expires_at IS NOT NULL AND expires_at < strftime('%s', 'now')
-    `));
+    `),
+    );
   }
 
   _startGarbageCollection() {
@@ -735,13 +734,12 @@ export class SharedMemory extends EventEmitter {
   _runGarbageCollection() {
     try {
       const result = this.statements.get('gc').run();
-      
+
       if (result.changes > 0) {
         this.emit('gc', { expired: result.changes });
       }
-      
+
       this.metrics.lastGC = Date.now();
-      
     } catch (error) {
       this.emit('error', error);
     }
@@ -755,38 +753,38 @@ export class SharedMemory extends EventEmitter {
     if (!this.metrics.operations.has(operation)) {
       this.metrics.operations.set(operation, []);
     }
-    
+
     const metrics = this.metrics.operations.get(operation);
     metrics.push(duration);
-    
+
     // Keep only last 100 measurements
     if (metrics.length > 100) {
       metrics.shift();
     }
-    
+
     this.metrics.totalOperations++;
   }
 
   _getMetricsSummary() {
     const summary = {};
-    
+
     for (const [operation, durations] of this.metrics.operations) {
       if (durations.length > 0) {
         summary[operation] = {
           count: durations.length,
           avg: durations.reduce((a, b) => a + b, 0) / durations.length,
           min: Math.min(...durations),
-          max: Math.max(...durations)
+          max: Math.max(...durations),
         };
       }
     }
-    
+
     summary.totalOperations = this.metrics.totalOperations;
     summary.lastGC = new Date(this.metrics.lastGC).toISOString();
-    
+
     return summary;
   }
 }
 
 // Export for backwards compatibility
-export default SharedMemory;
+export default SharedMemory;