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

package/src/memory/fallback-store.js

@@ -23,18 +23,27 @@ class FallbackMemoryStore {
     try {
       this.primaryStore = new SqliteMemoryStore(this.options);
       await this.primaryStore.initialize();
-      console.error(`[${new Date().toISOString()}] INFO [fallback-store] Successfully initialized SQLite store`);
+      console.error(
+        `[${new Date().toISOString()}] INFO [fallback-store] Successfully initialized SQLite store`,
+      );
       this.useFallback = false;
     } catch (error) {
-      console.error(`[${new Date().toISOString()}] WARN [fallback-store] SQLite initialization failed, falling back to in-memory store:`, error.message);
-      
+      console.error(
+        `[${new Date().toISOString()}] WARN [fallback-store] SQLite initialization failed, falling back to in-memory store:`,
+        error.message,
+      );
+
       // Fall back to in-memory store
       this.fallbackStore = new InMemoryStore(this.options);
       await this.fallbackStore.initialize();
       this.useFallback = true;
-      
-      console.error(`[${new Date().toISOString()}] INFO [fallback-store] Using in-memory store (data will not persist across sessions)`);
-      console.error(`[${new Date().toISOString()}] INFO [fallback-store] To enable persistent storage, install the package locally: npm install claude-flow@alpha`);
+
+      console.error(
+        `[${new Date().toISOString()}] INFO [fallback-store] Using in-memory store (data will not persist across sessions)`,
+      );
+      console.error(
+        `[${new Date().toISOString()}] INFO [fallback-store] To enable persistent storage, install the package locally: npm install claude-flow@alpha`,
+      );
     }
   }
 
@@ -90,4 +99,4 @@ class FallbackMemoryStore {
 export const memoryStore = new FallbackMemoryStore();
 
 export { FallbackMemoryStore };
-export default FallbackMemoryStore;
+export default FallbackMemoryStore;

package/src/memory/in-memory-store.js

@@ -16,16 +16,18 @@ class InMemoryStore {
 
     // Initialize default namespace
     this.data.set('default', new Map());
-    
+
     // Start cleanup interval for expired entries
     this.cleanupInterval = setInterval(() => {
-      this.cleanup().catch(err => 
-        console.error(`[${new Date().toISOString()}] ERROR [in-memory-store] Cleanup failed:`, err)
+      this.cleanup().catch((err) =>
+        console.error(`[${new Date().toISOString()}] ERROR [in-memory-store] Cleanup failed:`, err),
       );
     }, 60000); // Run cleanup every minute
 
     this.isInitialized = true;
-    console.error(`[${new Date().toISOString()}] INFO [in-memory-store] Initialized in-memory store`);
+    console.error(
+      `[${new Date().toISOString()}] INFO [in-memory-store] Initialized in-memory store`,
+    );
   }
 
   _getNamespaceMap(namespace) {
@@ -37,15 +39,15 @@ class InMemoryStore {
 
   async store(key, value, options = {}) {
     await this.initialize();
-    
+
     const namespace = options.namespace || 'default';
     const namespaceMap = this._getNamespaceMap(namespace);
-    
+
     const now = Date.now();
     const ttl = options.ttl || null;
-    const expiresAt = ttl ? now + (ttl * 1000) : null;
+    const expiresAt = ttl ? now + ttl * 1000 : null;
     const valueStr = typeof value === 'string' ? value : JSON.stringify(value);
-    
+
     const entry = {
       key,
       value: valueStr,
@@ -56,7 +58,7 @@ class InMemoryStore {
       accessedAt: now,
       accessCount: namespaceMap.has(key) ? namespaceMap.get(key).accessCount + 1 : 1,
       ttl,
-      expiresAt
+      expiresAt,
     };
 
     namespaceMap.set(key, entry);
@@ -64,18 +66,18 @@ class InMemoryStore {
     return {
       success: true,
       id: `${namespace}:${key}`,
-      size: valueStr.length
+      size: valueStr.length,
     };
   }
 
   async retrieve(key, options = {}) {
     await this.initialize();
-    
+
     const namespace = options.namespace || 'default';
     const namespaceMap = this._getNamespaceMap(namespace);
-    
+
     const entry = namespaceMap.get(key);
-    
+
     if (!entry) {
       return null;
     }
@@ -100,43 +102,43 @@ class InMemoryStore {
 
   async list(options = {}) {
     await this.initialize();
-    
+
     const namespace = options.namespace || 'default';
     const limit = options.limit || 100;
     const namespaceMap = this._getNamespaceMap(namespace);
-    
+
     const entries = Array.from(namespaceMap.values())
-      .filter(entry => !entry.expiresAt || entry.expiresAt > Date.now())
+      .filter((entry) => !entry.expiresAt || entry.expiresAt > Date.now())
       .sort((a, b) => b.updatedAt - a.updatedAt)
       .slice(0, limit);
 
-    return entries.map(entry => ({
+    return entries.map((entry) => ({
       key: entry.key,
       value: this._tryParseJson(entry.value),
       namespace: entry.namespace,
       metadata: entry.metadata,
       createdAt: new Date(entry.createdAt),
       updatedAt: new Date(entry.updatedAt),
-      accessCount: entry.accessCount
+      accessCount: entry.accessCount,
     }));
   }
 
   async delete(key, options = {}) {
     await this.initialize();
-    
+
     const namespace = options.namespace || 'default';
     const namespaceMap = this._getNamespaceMap(namespace);
-    
+
     return namespaceMap.delete(key);
   }
 
   async search(pattern, options = {}) {
     await this.initialize();
-    
+
     const namespace = options.namespace || 'default';
     const limit = options.limit || 50;
     const namespaceMap = this._getNamespaceMap(namespace);
-    
+
     const searchLower = pattern.toLowerCase();
     const results = [];
 
@@ -147,14 +149,16 @@ class InMemoryStore {
       }
 
       // Search in key and value
-      if (key.toLowerCase().includes(searchLower) || 
-          entry.value.toLowerCase().includes(searchLower)) {
+      if (
+        key.toLowerCase().includes(searchLower) ||
+        entry.value.toLowerCase().includes(searchLower)
+      ) {
         results.push({
           key: entry.key,
           value: this._tryParseJson(entry.value),
           namespace: entry.namespace,
           score: entry.accessCount,
-          updatedAt: new Date(entry.updatedAt)
+          updatedAt: new Date(entry.updatedAt),
         });
       }
 
@@ -172,7 +176,7 @@ class InMemoryStore {
 
   async cleanup() {
     await this.initialize();
-    
+
     let cleaned = 0;
     const now = Date.now();
 
@@ -207,4 +211,4 @@ class InMemoryStore {
 }
 
 export { InMemoryStore };
-export default InMemoryStore;
+export default InMemoryStore;

package/src/memory/index.js

@@ -1,8 +1,8 @@
 /**
  * Memory Module - Unified memory persistence for ruv-swarm
- * 
+ *
  * Provides both generic SharedMemory and MCP-specific SwarmMemory implementations
- * 
+ *
  * @module memory
  */
 
@@ -19,7 +19,7 @@ export const SWARM_NAMESPACES = {
   CONSENSUS: 'swarm:consensus',
   PATTERNS: 'swarm:patterns',
   METRICS: 'swarm:metrics',
-  COORDINATION: 'swarm:coordination'
+  COORDINATION: 'swarm:coordination',
 };
 
 /**
@@ -35,4 +35,4 @@ export function createMemory(options = {}) {
 }
 
 // Default export for backwards compatibility
-export default { SharedMemory, SwarmMemory, createMemory, SWARM_NAMESPACES };
+export default { SharedMemory, SwarmMemory, createMemory, SWARM_NAMESPACES };

package/src/memory/indexer.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * Memory indexer for fast querying
  */
@@ -74,7 +73,7 @@ export class MemoryIndexer {
       this.addEntry(entry);
     }
 
-    this.logger.info('Memory index built', { 
+    this.logger.info('Memory index built', {
       totalEntries: this.entries.size,
       agents: this.agentIndex.keys().length,
       sessions: this.sessionIndex.keys().length,
@@ -94,7 +93,7 @@ export class MemoryIndexer {
     this.agentIndex.add(entry.agentId, entry.id);
     this.sessionIndex.add(entry.sessionId, entry.id);
     this.typeIndex.add(entry.type, entry.id);
-    
+
     for (const tag of entry.tags) {
       this.tagIndex.add(tag, entry.id);
     }
@@ -126,7 +125,7 @@ export class MemoryIndexer {
     this.agentIndex.remove(entry.agentId, id);
     this.sessionIndex.remove(entry.sessionId, id);
     this.typeIndex.remove(entry.type, id);
-    
+
     for (const tag of entry.tags) {
       this.tagIndex.remove(tag, id);
     }
@@ -155,7 +154,7 @@ export class MemoryIndexer {
     }
 
     if (query.tags && query.tags.length > 0) {
-      const tagSets = query.tags.map(tag => this.tagIndex.get(tag));
+      const tagSets = query.tags.map((tag) => this.tagIndex.get(tag));
       const unionSet = this.unionSets(...tagSets);
       resultIds = this.intersectSets(resultIds, unionSet);
     }
@@ -210,10 +209,7 @@ export class MemoryIndexer {
     this.timeIndex.clear();
   }
 
-  private intersectSets(
-    set1: Set<string> | undefined,
-    set2: Set<string>,
-  ): Set<string> {
+  private intersectSets(set1: Set<string> | undefined, set2: Set<string>): Set<string> {
     if (!set1) {
       return new Set(set2);
     }
@@ -236,4 +232,4 @@ export class MemoryIndexer {
     }
     return result;
   }
-}
+}

package/src/memory/manager.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * Memory manager interface and implementation
  */
@@ -23,7 +22,11 @@ export interface IMemoryManager {
   query(query: MemoryQuery): Promise<MemoryEntry[]>;
   update(id: string, updates: Partial<MemoryEntry>): Promise<void>;
   delete(id: string): Promise<void>;
-  getHealthStatus(): Promise<{ healthy: boolean; error?: string; metrics?: Record<string, number> }>;
+  getHealthStatus(): Promise<{
+    healthy: boolean;
+    error?: string;
+    metrics?: Record<string, number>;
+  }>;
   performMaintenance(): Promise<void>;
 }
 
@@ -56,7 +59,7 @@ export class MemoryManager implements IMemoryManager {
   ) {
     // Initialize backend based on configuration
     this.backend = this.createBackend();
-    
+
     // Initialize cache
     this.cache = new MemoryCache(
       this.config.cacheSizeMB * 1024 * 1024, // Convert MB to bytes
@@ -111,7 +114,7 @@ export class MemoryManager implements IMemoryManager {
 
       // Close all banks
       const bankIds = Array.from(this.banks.keys());
-      await Promise.all(bankIds.map(id => this.closeBank(id)));
+      await Promise.all(bankIds.map((id) => this.closeBank(id)));
 
       // Shutdown backend
       await this.backend.shutdown();
@@ -138,9 +141,9 @@ export class MemoryManager implements IMemoryManager {
     };
 
     this.banks.set(bank.id, bank);
-    
+
     this.logger.info('Memory bank created', { bankId: bank.id, agentId });
-    
+
     return bank.id;
   }
 
@@ -157,7 +160,7 @@ export class MemoryManager implements IMemoryManager {
     }
 
     this.banks.delete(bankId);
-    
+
     this.logger.info('Memory bank closed', { bankId });
   }
 
@@ -166,7 +169,7 @@ export class MemoryManager implements IMemoryManager {
       throw new MemoryError('Memory manager not initialized');
     }
 
-    this.logger.debug('Storing memory entry', { 
+    this.logger.debug('Storing memory entry', {
       id: entry.id,
       type: entry.type,
       agentId: entry.agentId,
@@ -180,15 +183,15 @@ export class MemoryManager implements IMemoryManager {
       this.indexer.addEntry(entry);
 
       // Store in backend (async, don't wait)
-      this.backend.store(entry).catch(error => {
-        this.logger.error('Failed to store entry in backend', { 
+      this.backend.store(entry).catch((error) => {
+        this.logger.error('Failed to store entry in backend', {
           id: entry.id,
           error,
         });
       });
 
       // Update bank stats
-      const bank = Array.from(this.banks.values()).find(b => b.agentId === entry.agentId);
+      const bank = Array.from(this.banks.values()).find((b) => b.agentId === entry.agentId);
       if (bank) {
         bank.entryCount++;
         bank.lastAccessed = new Date();
@@ -236,15 +239,16 @@ export class MemoryManager implements IMemoryManager {
 
       // Apply additional filters if needed
       if (query.search) {
-        results = results.filter(entry => 
-          entry.content.toLowerCase().includes(query.search!.toLowerCase()) ||
-          entry.tags.some(tag => tag.toLowerCase().includes(query.search!.toLowerCase())),
+        results = results.filter(
+          (entry) =>
+            entry.content.toLowerCase().includes(query.search!.toLowerCase()) ||
+            entry.tags.some((tag) => tag.toLowerCase().includes(query.search!.toLowerCase())),
         );
       }
 
       // Apply time range filter
       if (query.startTime || query.endTime) {
-        results = results.filter(entry => {
+        results = results.filter((entry) => {
           const timestamp = entry.timestamp.getTime();
           if (query.startTime && timestamp < query.startTime.getTime()) {
             return false;
@@ -297,7 +301,7 @@ export class MemoryManager implements IMemoryManager {
     await this.backend.update(id, updated);
 
     // Emit event
-    this.eventBus.emit('memory:updated', { 
+    this.eventBus.emit('memory:updated', {
       entry: updated,
       previousVersion: existing.version,
     });
@@ -321,9 +325,9 @@ export class MemoryManager implements IMemoryManager {
     this.eventBus.emit('memory:deleted', { entryId: id });
   }
 
-  async getHealthStatus(): Promise<{ 
-    healthy: boolean; 
-    error?: string; 
+  async getHealthStatus(): Promise<{
+    healthy: boolean;
+    error?: string;
     metrics?: Record<string, number>;
   }> {
     try {
@@ -364,7 +368,7 @@ export class MemoryManager implements IMemoryManager {
       if (this.config.retentionDays > 0) {
         const cutoffDate = new Date();
         cutoffDate.setDate(cutoffDate.getDate() - this.config.retentionDays);
-        
+
         const oldEntries = await this.query({
           endTime: cutoffDate,
         });
@@ -372,7 +376,7 @@ export class MemoryManager implements IMemoryManager {
         for (const entry of oldEntries) {
           await this.delete(entry.id);
         }
-        
+
         this.logger.info(`Cleaned up ${oldEntries.length} old memory entries`);
       }
 
@@ -400,26 +404,14 @@ export class MemoryManager implements IMemoryManager {
   private createBackend(): IMemoryBackend {
     switch (this.config.backend) {
       case 'sqlite':
-        return new SQLiteBackend(
-          this.config.sqlitePath || './claude-flow.db',
-          this.logger,
-        );
+        return new SQLiteBackend(this.config.sqlitePath || './claude-flow.db', this.logger);
       case 'markdown':
-        return new MarkdownBackend(
-          this.config.markdownDir || './memory',
-          this.logger,
-        );
+        return new MarkdownBackend(this.config.markdownDir || './memory', this.logger);
       case 'hybrid':
         // Use SQLite for structured data and Markdown for human-readable backup
         return new HybridBackend(
-          new SQLiteBackend(
-            this.config.sqlitePath || './claude-flow.db',
-            this.logger,
-          ),
-          new MarkdownBackend(
-            this.config.markdownDir || './memory',
-            this.logger,
-          ),
+          new SQLiteBackend(this.config.sqlitePath || './claude-flow.db', this.logger),
+          new MarkdownBackend(this.config.markdownDir || './memory', this.logger),
           this.logger,
         );
       default:
@@ -439,21 +431,21 @@ export class MemoryManager implements IMemoryManager {
 
   private async syncCache(): Promise<void> {
     const dirtyEntries = this.cache.getDirtyEntries();
-    
+
     if (dirtyEntries.length === 0) {
       return;
     }
 
     this.logger.debug('Syncing cache to backend', { count: dirtyEntries.length });
 
-    const promises = dirtyEntries.map(entry => 
-      this.backend.store(entry).catch(error => {
+    const promises = dirtyEntries.map((entry) =>
+      this.backend.store(entry).catch((error) => {
         this.logger.error('Failed to sync entry', { id: entry.id, error });
       }),
     );
 
     await Promise.all(promises);
-    this.cache.markClean(dirtyEntries.map(e => e.id));
+    this.cache.markClean(dirtyEntries.map((e) => e.id));
 
     // Emit sync event
     this.eventBus.emit('memory:synced', { entries: dirtyEntries });
@@ -461,15 +453,15 @@ export class MemoryManager implements IMemoryManager {
 
   private async flushCache(): Promise<void> {
     const allEntries = this.cache.getAllEntries();
-    
+
     if (allEntries.length === 0) {
       return;
     }
 
     this.logger.info('Flushing cache to backend', { count: allEntries.length });
 
-    const promises = allEntries.map(entry => 
-      this.backend.store(entry).catch(error => {
+    const promises = allEntries.map((entry) =>
+      this.backend.store(entry).catch((error) => {
         this.logger.error('Failed to flush entry', { id: entry.id, error });
       }),
     );
@@ -489,24 +481,18 @@ class HybridBackend implements IMemoryBackend {
   ) {}
 
   async initialize(): Promise<void> {
-    await Promise.all([
-      this.primary.initialize(),
-      this.secondary.initialize(),
-    ]);
+    await Promise.all([this.primary.initialize(), this.secondary.initialize()]);
   }
 
   async shutdown(): Promise<void> {
-    await Promise.all([
-      this.primary.shutdown(),
-      this.secondary.shutdown(),
-    ]);
+    await Promise.all([this.primary.shutdown(), this.secondary.shutdown()]);
   }
 
   async store(entry: MemoryEntry): Promise<void> {
     // Store in both backends
     await Promise.all([
       this.primary.store(entry),
-      this.secondary.store(entry).catch(error => {
+      this.secondary.store(entry).catch((error) => {
         this.logger.warn('Failed to store in secondary backend', { error });
       }),
     ]);
@@ -526,7 +512,7 @@ class HybridBackend implements IMemoryBackend {
   async update(id: string, entry: MemoryEntry): Promise<void> {
     await Promise.all([
       this.primary.update(id, entry),
-      this.secondary.update(id, entry).catch(error => {
+      this.secondary.update(id, entry).catch((error) => {
         this.logger.warn('Failed to update in secondary backend', { error });
       }),
     ]);
@@ -535,7 +521,7 @@ class HybridBackend implements IMemoryBackend {
   async delete(id: string): Promise<void> {
     await Promise.all([
       this.primary.delete(id),
-      this.secondary.delete(id).catch(error => {
+      this.secondary.delete(id).catch((error) => {
         this.logger.warn('Failed to delete from secondary backend', { error });
       }),
     ]);
@@ -550,9 +536,9 @@ class HybridBackend implements IMemoryBackend {
     return await this.primary.getAllEntries();
   }
 
-  async getHealthStatus(): Promise<{ 
-    healthy: boolean; 
-    error?: string; 
+  async getHealthStatus(): Promise<{
+    healthy: boolean;
+    error?: string;
     metrics?: Record<string, number>;
   }> {
     const [primaryHealth, secondaryHealth] = await Promise.all([
@@ -570,4 +556,4 @@ class HybridBackend implements IMemoryBackend {
       },
     };
   }
-}
+}