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

package/src/swarm/memory.ts

@@ -1,4 +1,3 @@
-import { getErrorMessage } from '../utils/error-handler.js';
 /**
  * Distributed Memory System with Cross-Agent Sharing
  */
@@ -10,8 +9,16 @@ import * as crypto from 'node:crypto';
 import { Logger } from '../core/logger.js';
 import { generateId } from '../utils/helpers.js';
 import {
-  MemoryEntry, MemoryPartition, SwarmMemory, AccessLevel, ConsistencyLevel,
-  MemoryType, MemoryPermissions, AgentId, SwarmEvent, SWARM_CONSTANTS
+  MemoryEntry,
+  MemoryPartition,
+  SwarmMemory,
+  AccessLevel,
+  ConsistencyLevel,
+  MemoryType,
+  MemoryPermissions,
+  AgentId,
+  SwarmEvent,
+  SWARM_CONSTANTS,
 } from './types.js';
 
 export interface MemoryQuery {
@@ -94,7 +101,7 @@ export class SwarmMemoryManager extends EventEmitter {
   private persistence: MemoryPersistence;
   private encryption: MemoryEncryption;
   private isInitialized = false;
-  
+
   // Background processes
   private syncTimer?: NodeJS.Timeout;
   private backupTimer?: NodeJS.Timeout;
@@ -102,18 +109,18 @@ export class SwarmMemoryManager extends EventEmitter {
 
   constructor(config: Partial<MemoryConfig & { logging?: any }> = {}) {
     super();
-    
+
     // Configure logger based on config or default to quiet mode
     const logLevel = config.logging?.level || 'error';
     const logFormat = config.logging?.format || 'text';
     const logDestination = config.logging?.destination || 'console';
-    
+
     this.logger = new Logger(
       { level: logLevel, format: logFormat, destination: logDestination },
-      { component: 'SwarmMemoryManager' }
+      { component: 'SwarmMemoryManager' },
     );
     this.config = this.mergeWithDefaults(config);
-    
+
     // Initialize memory structure
     this.memory = {
       namespace: this.config.namespace,
@@ -122,14 +129,14 @@ export class SwarmMemoryManager extends EventEmitter {
         read: 'swarm',
         write: 'team',
         delete: 'private',
-        share: 'team'
+        share: 'team',
       },
       persistent: true,
       backupEnabled: true,
       distributed: this.config.enableDistribution,
       consistency: this.config.consistencyLevel,
       cacheEnabled: this.config.enableCaching,
-      compressionEnabled: this.config.enableCompression
+      compressionEnabled: this.config.enableCompression,
     };
 
     // Initialize subsystems
@@ -138,7 +145,7 @@ export class SwarmMemoryManager extends EventEmitter {
     this.replication = new MemoryReplication(this.config);
     this.persistence = new MemoryPersistence(this.config);
     this.encryption = new MemoryEncryption(this.config);
-    
+
     this.setupEventHandlers();
   }
 
@@ -155,30 +162,29 @@ export class SwarmMemoryManager extends EventEmitter {
       await this.encryption.initialize();
       await this.replication.initialize();
       await this.index.initialize();
-      
+
       // Load existing data
       await this.loadMemoryState();
-      
+
       // Create default partitions
       await this.createDefaultPartitions();
-      
+
       // Start background processes
       this.startBackgroundProcesses();
-      
+
       this.isInitialized = true;
-      
+
       this.emit('memory:initialized', {
         namespace: this.config.namespace,
         entriesLoaded: this.entries.size,
-        partitionsLoaded: this.partitions.size
+        partitionsLoaded: this.partitions.size,
       });
-      
+
       this.logger.info('Swarm memory manager initialized', {
         namespace: this.config.namespace,
         entries: this.entries.size,
-        partitions: this.partitions.size
+        partitions: this.partitions.size,
       });
-
     } catch (error) {
       this.logger.error('Failed to initialize memory manager', { error });
       throw error;
@@ -195,20 +201,19 @@ export class SwarmMemoryManager extends EventEmitter {
     try {
       // Stop background processes
       this.stopBackgroundProcesses();
-      
+
       // Save final state
       await this.saveMemoryState();
-      
+
       // Shutdown subsystems
       await this.replication.shutdown();
       await this.persistence.shutdown();
       await this.encryption.shutdown();
-      
+
       this.isInitialized = false;
-      
+
       this.emit('memory:shutdown');
       this.logger.info('Swarm memory manager shut down');
-
     } catch (error) {
       this.logger.error('Error during memory manager shutdown', { error });
     }
@@ -227,13 +232,13 @@ export class SwarmMemoryManager extends EventEmitter {
       accessLevel: AccessLevel;
       ttl: number;
       metadata: Record<string, any>;
-    }> = {}
+    }> = {},
   ): Promise<string> {
     this.ensureInitialized();
 
     const entryId = generateId('mem');
     const now = new Date();
-    
+
     // Validate access permissions
     if (options.owner) {
       await this.validateAccess(options.owner, 'write', options.partition);
@@ -257,7 +262,7 @@ export class SwarmMemoryManager extends EventEmitter {
       expiresAt: options.ttl ? new Date(now.getTime() + options.ttl) : undefined,
       version: 1,
       references: [],
-      dependencies: []
+      dependencies: [],
     };
 
     // Validate entry size
@@ -292,7 +297,7 @@ export class SwarmMemoryManager extends EventEmitter {
       key,
       partition: partitionName,
       type: entry.type,
-      size: entrySize
+      size: entrySize,
     });
 
     this.logger.debug('Stored memory entry', {
@@ -300,7 +305,7 @@ export class SwarmMemoryManager extends EventEmitter {
       key,
       partition: partitionName,
       type: entry.type,
-      size: entrySize
+      size: entrySize,
     });
 
     return entryId;
@@ -312,7 +317,7 @@ export class SwarmMemoryManager extends EventEmitter {
       partition: string;
       requester: AgentId;
       includeMetadata: boolean;
-    }> = {}
+    }> = {},
   ): Promise<any> {
     this.ensureInitialized();
 
@@ -353,7 +358,7 @@ export class SwarmMemoryManager extends EventEmitter {
     this.emit('memory:retrieved', {
       entryId: entry.id,
       key,
-      requester: options.requester?.id
+      requester: options.requester?.id,
     });
 
     return options.includeMetadata ? entry : await this.deserializeValue(entry.value);
@@ -367,7 +372,7 @@ export class SwarmMemoryManager extends EventEmitter {
       updater: AgentId;
       metadata: Record<string, any>;
       incrementVersion: boolean;
-    }> = {}
+    }> = {},
   ): Promise<boolean> {
     this.ensureInitialized();
 
@@ -385,7 +390,7 @@ export class SwarmMemoryManager extends EventEmitter {
     if (options.incrementVersion !== false) {
       entry.previousVersions = entry.previousVersions || [];
       entry.previousVersions.push({ ...entry });
-      
+
       // Limit version history
       if (entry.previousVersions.length > 10) {
         entry.previousVersions = entry.previousVersions.slice(-10);
@@ -416,7 +421,7 @@ export class SwarmMemoryManager extends EventEmitter {
       entryId: entry.id,
       key,
       version: entry.version,
-      updater: options.updater?.id
+      updater: options.updater?.id,
     });
 
     return true;
@@ -428,7 +433,7 @@ export class SwarmMemoryManager extends EventEmitter {
       partition: string;
       deleter: AgentId;
       force: boolean;
-    }> = {}
+    }> = {},
   ): Promise<boolean> {
     this.ensureInitialized();
 
@@ -454,57 +459,53 @@ export class SwarmMemoryManager extends EventEmitter {
     if (query.partition) {
       const partition = this.partitions.get(query.partition);
       if (partition) {
-        const entryIds = new Set(partition.entries.map(e => e.id));
-        results = results.filter(e => entryIds.has(e.id));
+        const entryIds = new Set(partition.entries.map((e) => e.id));
+        results = results.filter((e) => entryIds.has(e.id));
       } else {
         return [];
       }
     }
 
     if (query.key) {
-      results = results.filter(e => e.key === query.key);
+      results = results.filter((e) => e.key === query.key);
     }
 
     if (query.type) {
-      results = results.filter(e => e.type === query.type);
+      results = results.filter((e) => e.type === query.type);
     }
 
     if (query.owner) {
-      results = results.filter(e => e.owner.id === query.owner!.id);
+      results = results.filter((e) => e.owner.id === query.owner!.id);
     }
 
     if (query.accessLevel) {
-      results = results.filter(e => e.accessLevel === query.accessLevel);
+      results = results.filter((e) => e.accessLevel === query.accessLevel);
     }
 
     if (query.tags && query.tags.length > 0) {
-      results = results.filter(e => 
-        query.tags!.some(tag => e.tags.includes(tag))
-      );
+      results = results.filter((e) => query.tags!.some((tag) => e.tags.includes(tag)));
     }
 
     if (query.createdAfter) {
-      results = results.filter(e => e.createdAt >= query.createdAfter!);
+      results = results.filter((e) => e.createdAt >= query.createdAfter!);
     }
 
     if (query.createdBefore) {
-      results = results.filter(e => e.createdAt <= query.createdBefore!);
+      results = results.filter((e) => e.createdAt <= query.createdBefore!);
     }
 
     if (query.expiresAfter) {
-      results = results.filter(e => 
-        e.expiresAt && e.expiresAt >= query.expiresAfter!
-      );
+      results = results.filter((e) => e.expiresAt && e.expiresAt >= query.expiresAfter!);
     }
 
     // Filter out expired entries
-    results = results.filter(e => !this.isExpired(e));
+    results = results.filter((e) => !this.isExpired(e));
 
     // Sort results
     if (query.sortBy) {
       results.sort((a, b) => {
         let compareValue = 0;
-        
+
         switch (query.sortBy) {
           case 'createdAt':
             compareValue = a.createdAt.getTime() - b.createdAt.getTime();
@@ -518,7 +519,7 @@ export class SwarmMemoryManager extends EventEmitter {
           default:
             compareValue = 0;
         }
-        
+
         return query.sortOrder === 'desc' ? -compareValue : compareValue;
       });
     }
@@ -546,7 +547,7 @@ export class SwarmMemoryManager extends EventEmitter {
       sharer: AgentId;
       accessLevel: AccessLevel;
       expiresAt: Date;
-    }> = {}
+    }> = {},
   ): Promise<string> {
     this.ensureInitialized();
 
@@ -570,7 +571,7 @@ export class SwarmMemoryManager extends EventEmitter {
       createdAt: new Date(),
       updatedAt: new Date(),
       expiresAt: options.expiresAt,
-      references: [...entry.references, entry.id]
+      references: [...entry.references, entry.id],
     };
 
     // Store shared entry
@@ -586,14 +587,14 @@ export class SwarmMemoryManager extends EventEmitter {
       sharedId: sharedEntryId,
       key,
       sharer: options.sharer?.id,
-      target: targetAgent.id
+      target: targetAgent.id,
     });
 
     this.logger.info('Shared memory entry', {
       key,
       from: options.sharer?.id,
       to: targetAgent.id,
-      sharedId: sharedEntryId
+      sharedId: sharedEntryId,
     });
 
     return sharedEntryId;
@@ -606,7 +607,7 @@ export class SwarmMemoryManager extends EventEmitter {
       partition: string;
       broadcaster: AgentId;
       accessLevel: AccessLevel;
-    }> = {}
+    }> = {},
   ): Promise<string[]> {
     this.ensureInitialized();
 
@@ -616,14 +617,14 @@ export class SwarmMemoryManager extends EventEmitter {
       try {
         const sharedId = await this.shareMemory(key, targetAgent, {
           ...options,
-          sharer: options.broadcaster
+          sharer: options.broadcaster,
         });
         sharedIds.push(sharedId);
       } catch (error) {
         this.logger.warn('Failed to share memory with agent', {
           key,
           targetAgent: targetAgent.id,
-          error: (error instanceof Error ? error.message : String(error))
+          error: error instanceof Error ? error.message : String(error),
         });
       }
     }
@@ -631,8 +632,8 @@ export class SwarmMemoryManager extends EventEmitter {
     this.emit('memory:broadcasted', {
       key,
       broadcaster: options.broadcaster?.id,
-      targets: targetAgents.map(a => a.id),
-      sharedCount: sharedIds.length
+      targets: targetAgents.map((a) => a.id),
+      sharedCount: sharedIds.length,
     });
 
     return sharedIds;
@@ -644,7 +645,7 @@ export class SwarmMemoryManager extends EventEmitter {
       partition: string;
       direction: 'pull' | 'push' | 'bidirectional';
       filter: MemoryQuery;
-    }> = {}
+    }> = {},
   ): Promise<void> {
     this.ensureInitialized();
 
@@ -657,7 +658,7 @@ export class SwarmMemoryManager extends EventEmitter {
     this.emit('memory:synchronized', {
       targetNode,
       direction: options.direction || 'bidirectional',
-      partition: options.partition
+      partition: options.partition,
     });
   }
 
@@ -674,7 +675,7 @@ export class SwarmMemoryManager extends EventEmitter {
       indexed: boolean;
       compressed: boolean;
     }> = {},
-    skipInitCheck: boolean = false
+    skipInitCheck: boolean = false,
   ): Promise<string> {
     if (!skipInitCheck) {
       this.ensureInitialized();
@@ -694,7 +695,7 @@ export class SwarmMemoryManager extends EventEmitter {
       readOnly: options.readOnly || false,
       shared: options.shared || true,
       indexed: options.indexed !== false,
-      compressed: options.compressed || this.config.enableCompression
+      compressed: options.compressed || this.config.enableCompression,
     };
 
     this.partitions.set(name, partition);
@@ -703,13 +704,13 @@ export class SwarmMemoryManager extends EventEmitter {
     this.emit('memory:partition-created', {
       partitionId: partition.id,
       name,
-      type: partition.type
+      type: partition.type,
     });
 
     this.logger.info('Created memory partition', {
       name,
       type: partition.type,
-      maxSize: partition.maxSize
+      maxSize: partition.maxSize,
     });
 
     return partition.id;
@@ -733,11 +734,11 @@ export class SwarmMemoryManager extends EventEmitter {
     }
 
     this.partitions.delete(name);
-    this.memory.partitions = this.memory.partitions.filter(p => p.id !== partition.id);
+    this.memory.partitions = this.memory.partitions.filter((p) => p.id !== partition.id);
 
     this.emit('memory:partition-deleted', {
       partitionId: partition.id,
-      name
+      name,
     });
 
     return true;
@@ -763,10 +764,10 @@ export class SwarmMemoryManager extends EventEmitter {
       metadata: {
         namespace: this.config.namespace,
         entryCount: this.entries.size,
-        partitionCount: this.partitions.size
+        partitionCount: this.partitions.size,
       },
       entries: Array.from(this.entries.values()),
-      partitions: Array.from(this.partitions.values())
+      partitions: Array.from(this.partitions.values()),
     };
 
     // Calculate checksum
@@ -778,7 +779,7 @@ export class SwarmMemoryManager extends EventEmitter {
     this.emit('memory:backup-created', {
       backupId,
       entryCount: backup.entries.length,
-      size: JSON.stringify(backup).length
+      size: JSON.stringify(backup).length,
     });
 
     return backupId;
@@ -819,13 +820,13 @@ export class SwarmMemoryManager extends EventEmitter {
     this.emit('memory:backup-restored', {
       backupId,
       entryCount: backup.entries.length,
-      partitionCount: backup.partitions.length
+      partitionCount: backup.partitions.length,
     });
 
     this.logger.info('Restored from backup', {
       backupId,
       entries: backup.entries.length,
-      partitions: backup.partitions.length
+      partitions: backup.partitions.length,
     });
   }
 
@@ -833,7 +834,7 @@ export class SwarmMemoryManager extends EventEmitter {
 
   getStatistics(): MemoryStatistics {
     const entries = Array.from(this.entries.values());
-    const validEntries = entries.filter(e => !this.isExpired(e));
+    const validEntries = entries.filter((e) => !this.isExpired(e));
 
     const entriesByType: Record<MemoryType, number> = {
       knowledge: 0,
@@ -843,7 +844,7 @@ export class SwarmMemoryManager extends EventEmitter {
       results: 0,
       communication: 0,
       configuration: 0,
-      metrics: 0
+      metrics: 0,
     };
 
     const entriesByAccess: Record<AccessLevel, number> = {
@@ -851,7 +852,7 @@ export class SwarmMemoryManager extends EventEmitter {
       team: 0,
       swarm: 0,
       public: 0,
-      system: 0
+      system: 0,
     };
 
     let totalSize = 0;
@@ -862,7 +863,7 @@ export class SwarmMemoryManager extends EventEmitter {
     for (const entry of validEntries) {
       entriesByType[entry.type]++;
       entriesByAccess[entry.accessLevel]++;
-      
+
       const entrySize = this.calculateEntrySize(entry);
       totalSize += entrySize;
 
@@ -888,7 +889,7 @@ export class SwarmMemoryManager extends EventEmitter {
       averageSize: validEntries.length > 0 ? totalSize / validEntries.length : 0,
       oldestEntry,
       newestEntry,
-      expiringEntries
+      expiringEntries,
     };
   }
 
@@ -897,34 +898,38 @@ export class SwarmMemoryManager extends EventEmitter {
       format: 'json' | 'csv';
       includeExpired: boolean;
       filter: MemoryQuery;
-    }> = {}
+    }> = {},
   ): Promise<string> {
     this.ensureInitialized();
 
     let entries = Array.from(this.entries.values());
 
     if (!options.includeExpired) {
-      entries = entries.filter(e => !this.isExpired(e));
+      entries = entries.filter((e) => !this.isExpired(e));
     }
 
     if (options.filter) {
       const filteredResults = await this.query(options.filter);
-      const filteredIds = new Set(filteredResults.map(e => e.id));
-      entries = entries.filter(e => filteredIds.has(e.id));
+      const filteredIds = new Set(filteredResults.map((e) => e.id));
+      entries = entries.filter((e) => filteredIds.has(e.id));
     }
 
     if (options.format === 'csv') {
       return this.entriesToCSV(entries);
     } else {
-      return JSON.stringify({
-        exported: new Date().toISOString(),
-        namespace: this.config.namespace,
-        entryCount: entries.length,
-        entries: entries.map(e => ({
-          ...e,
-          value: e.value // Value is already serialized
-        }))
-      }, null, 2);
+      return JSON.stringify(
+        {
+          exported: new Date().toISOString(),
+          namespace: this.config.namespace,
+          entryCount: entries.length,
+          entries: entries.map((e) => ({
+            ...e,
+            value: e.value, // Value is already serialized
+          })),
+        },
+        null,
+        2,
+      );
     }
   }
 
@@ -941,7 +946,7 @@ export class SwarmMemoryManager extends EventEmitter {
       if (entry.key === key) {
         if (partition) {
           const part = this.partitions.get(partition);
-          if (part && part.entries.find(e => e.id === entry.id)) {
+          if (part && part.entries.find((e) => e.id === entry.id)) {
             return entry;
           }
         } else {
@@ -963,7 +968,7 @@ export class SwarmMemoryManager extends EventEmitter {
 
     // Remove from partitions
     for (const partition of this.partitions.values()) {
-      partition.entries = partition.entries.filter(e => e.id !== entryId);
+      partition.entries = partition.entries.filter((e) => e.id !== entryId);
     }
 
     // Remove from index
@@ -976,7 +981,7 @@ export class SwarmMemoryManager extends EventEmitter {
 
     this.emit('memory:deleted', {
       entryId,
-      key: entry.key
+      key: entry.key,
     });
 
     return true;
@@ -989,7 +994,7 @@ export class SwarmMemoryManager extends EventEmitter {
   private async validateAccess(
     agent: AgentId,
     operation: 'read' | 'write' | 'delete' | 'share',
-    partition?: string
+    partition?: string,
   ): Promise<void> {
     // Implement access control logic here
     // For now, allow all operations
@@ -1008,31 +1013,31 @@ export class SwarmMemoryManager extends EventEmitter {
   private async serializeValue(value: any): Promise<any> {
     // Apply compression and encryption if enabled
     let serialized = JSON.stringify(value);
-    
+
     if (this.config.enableCompression) {
       // Compression would be implemented here
       // For now, just return the serialized value
     }
-    
+
     if (this.config.enableEncryption) {
       serialized = await this.encryption.encrypt(serialized);
     }
-    
+
     return serialized;
   }
 
   private async deserializeValue(value: any): Promise<any> {
     let deserialized = value;
-    
+
     if (this.config.enableEncryption) {
       deserialized = await this.encryption.decrypt(deserialized);
     }
-    
+
     if (this.config.enableCompression) {
       // Decompression would be implemented here
       // For now, just use the deserialized value
     }
-    
+
     return JSON.parse(deserialized);
   }
 
@@ -1043,11 +1048,11 @@ export class SwarmMemoryManager extends EventEmitter {
   private async enforceMemoryLimits(newEntrySize: number): Promise<void> {
     const stats = this.getStatistics();
     const projectedSize = stats.totalSize + newEntrySize;
-    
+
     if (projectedSize > this.config.maxMemorySize) {
       // Remove expired entries first
       await this.cleanupExpiredEntries();
-      
+
       // If still over limit, remove oldest entries
       const updatedStats = this.getStatistics();
       if (updatedStats.totalSize + newEntrySize > this.config.maxMemorySize) {
@@ -1057,13 +1062,12 @@ export class SwarmMemoryManager extends EventEmitter {
   }
 
   private async cleanupExpiredEntries(): Promise<void> {
-    const expiredEntries = Array.from(this.entries.values())
-      .filter(e => this.isExpired(e));
-    
+    const expiredEntries = Array.from(this.entries.values()).filter((e) => this.isExpired(e));
+
     for (const entry of expiredEntries) {
       await this.deleteEntry(entry.id);
     }
-    
+
     if (expiredEntries.length > 0) {
       this.logger.info('Cleaned up expired entries', { count: expiredEntries.length });
     }
@@ -1071,43 +1075,44 @@ export class SwarmMemoryManager extends EventEmitter {
 
   private async evictOldEntries(requiredSpace: number): Promise<void> {
     const entries = Array.from(this.entries.values())
-      .filter(e => !this.isExpired(e))
+      .filter((e) => !this.isExpired(e))
       .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-    
+
     let freedSpace = 0;
     let evictedCount = 0;
-    
+
     for (const entry of entries) {
       if (freedSpace >= requiredSpace) {
         break;
       }
-      
-      if (entry.accessLevel !== 'system') { // Don't evict system entries
+
+      if (entry.accessLevel !== 'system') {
+        // Don't evict system entries
         const entrySize = this.calculateEntrySize(entry);
         await this.deleteEntry(entry.id);
         freedSpace += entrySize;
         evictedCount++;
       }
     }
-    
+
     this.logger.warn('Evicted old entries for space', {
       evictedCount,
       freedSpace,
-      requiredSpace
+      requiredSpace,
     });
   }
 
   private calculateChecksum(backup: MemoryBackup): string {
     const content = JSON.stringify({
       entries: backup.entries,
-      partitions: backup.partitions
+      partitions: backup.partitions,
     });
     return crypto.createHash('sha256').update(content).digest('hex');
   }
 
   private entriesToCSV(entries: MemoryEntry[]): string {
     const headers = ['id', 'key', 'type', 'accessLevel', 'createdAt', 'updatedAt', 'owner', 'tags'];
-    const rows = entries.map(entry => [
+    const rows = entries.map((entry) => [
       entry.id,
       entry.key,
       entry.type,
@@ -1115,10 +1120,10 @@ export class SwarmMemoryManager extends EventEmitter {
       entry.createdAt.toISOString(),
       entry.updatedAt.toISOString(),
       entry.owner.id,
-      entry.tags.join(';')
+      entry.tags.join(';'),
     ]);
-    
-    return [headers, ...rows].map(row => row.join(',')).join('\n');
+
+    return [headers, ...rows].map((row) => row.join(',')).join('\n');
   }
 
   private async loadMemoryState(): Promise<void> {
@@ -1130,17 +1135,17 @@ export class SwarmMemoryManager extends EventEmitter {
           this.entries.set(entry.id, entry);
           await this.index.addEntry(entry);
         }
-        
+
         // Load partitions
         for (const partition of state.partitions || []) {
           this.partitions.set(partition.name, partition);
         }
-        
+
         this.memory.partitions = state.partitions || [];
-        
+
         this.logger.info('Loaded memory state', {
           entries: this.entries.size,
-          partitions: this.partitions.size
+          partitions: this.partitions.size,
         });
       }
     } catch (error) {
@@ -1154,9 +1159,9 @@ export class SwarmMemoryManager extends EventEmitter {
         namespace: this.config.namespace,
         timestamp: new Date(),
         entries: Array.from(this.entries.values()),
-        partitions: Array.from(this.partitions.values())
+        partitions: Array.from(this.partitions.values()),
       };
-      
+
       await this.persistence.saveState(state);
     } catch (error) {
       this.logger.error('Failed to save memory state', { error });
@@ -1168,9 +1173,9 @@ export class SwarmMemoryManager extends EventEmitter {
       { name: 'default', type: 'knowledge' as MemoryType },
       { name: 'system', type: 'configuration' as MemoryType },
       { name: 'cache', type: 'cache' as MemoryType },
-      { name: 'logs', type: 'logs' as MemoryType }
+      { name: 'logs', type: 'logs' as MemoryType },
     ];
-    
+
     for (const partition of defaultPartitions) {
       if (!this.partitions.has(partition.name)) {
         await this.createPartition(partition.name, { type: partition.type }, true);
@@ -1183,13 +1188,13 @@ export class SwarmMemoryManager extends EventEmitter {
       namespace: 'default',
       persistencePath: './swarm-memory',
       maxMemorySize: 100 * 1024 * 1024, // 100MB
-      maxEntrySize: 10 * 1024 * 1024,   // 10MB
-      defaultTtl: 24 * 60 * 60 * 1000,  // 24 hours
+      maxEntrySize: 10 * 1024 * 1024, // 10MB
+      defaultTtl: 24 * 60 * 60 * 1000, // 24 hours
       enableCompression: false,
       enableEncryption: false,
       consistencyLevel: 'eventual',
-      syncInterval: 60000,      // 1 minute
-      backupInterval: 3600000,  // 1 hour
+      syncInterval: 60000, // 1 minute
+      backupInterval: 3600000, // 1 hour
       maxBackups: 24,
       enableDistribution: false,
       distributionNodes: [],
@@ -1197,7 +1202,7 @@ export class SwarmMemoryManager extends EventEmitter {
       enableCaching: true,
       cacheSize: 1000,
       cacheTtl: 300000, // 5 minutes
-      ...config
+      ...config,
     };
   }
 
@@ -1208,16 +1213,16 @@ export class SwarmMemoryManager extends EventEmitter {
         this.performSync();
       }, this.config.syncInterval);
     }
-    
+
     // Backup process
     if (this.config.backupInterval > 0) {
       this.backupTimer = setInterval(() => {
-        this.createBackup().catch(error => {
+        this.createBackup().catch((error) => {
           this.logger.error('Background backup failed', { error });
         });
       }, this.config.backupInterval);
     }
-    
+
     // Cleanup process
     this.cleanupTimer = setInterval(() => {
       this.cleanupExpiredEntries();
@@ -1229,12 +1234,12 @@ export class SwarmMemoryManager extends EventEmitter {
       clearInterval(this.syncTimer);
       this.syncTimer = undefined;
     }
-    
+
     if (this.backupTimer) {
       clearInterval(this.backupTimer);
       this.backupTimer = undefined;
     }
-    
+
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = undefined;
@@ -1244,7 +1249,7 @@ export class SwarmMemoryManager extends EventEmitter {
   private async performSync(): Promise<void> {
     try {
       await this.saveMemoryState();
-      
+
       if (this.config.enableDistribution) {
         await this.replication.sync();
       }
@@ -1259,11 +1264,11 @@ export class SwarmMemoryManager extends EventEmitter {
       const entry = data.entry as MemoryEntry;
       this.entries.set(entry.id, entry);
       await this.index.addEntry(entry);
-      
+
       this.emit('memory:replicated', {
         entryId: entry.id,
         key: entry.key,
-        source: data.source
+        source: data.source,
       });
     });
   }
@@ -1331,10 +1336,10 @@ class MemoryCache {
       const oldestKey = this.cache.keys().next().value;
       this.cache.delete(oldestKey);
     }
-    
+
     this.cache.set(key, {
       entry,
-      expiry: Date.now() + this.ttl
+      expiry: Date.now() + this.ttl,
     });
   }
 
@@ -1343,12 +1348,12 @@ class MemoryCache {
     if (!cached) {
       return null;
     }
-    
+
     if (Date.now() > cached.expiry) {
       this.cache.delete(key);
       return null;
     }
-    
+
     return cached.entry;
   }
 
@@ -1459,4 +1464,4 @@ class MemoryEncryption {
   }
 }
 
-export default SwarmMemoryManager;
+export default SwarmMemoryManager;