claude-flow-novice 2.3.1 → 2.3.3

package/dist/src/memory/swarm-memory.js

@@ -1,604 +1,471 @@
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { EventEmitter } from "node:events";
+import { Logger } from "../core/logger.js";
+import { MemoryManager } from "./manager.js";
+import { EventBus } from "../core/event-bus.js";
+import { generateId } from "../utils/helpers.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+export class SwarmMemoryManager extends EventEmitter {
+    async initialize() {
+        if (this.isInitialized) return;
+        this.logger.info('Initializing swarm memory manager...');
+        // Initialize base memory
+        await this.baseMemory.initialize();
+        // Create persistence directory
+        await fs.mkdir(this.config.persistencePath, {
+            recursive: true
+        });
+        // Load existing memory
+        await this.loadMemoryState();
+        // Start sync timer
+        if (this.config.syncInterval > 0) {
+            this.syncTimer = setInterval(()=>{
+                this.syncMemoryState();
+            }, this.config.syncInterval);
+        }
+        this.isInitialized = true;
+        this.emit('memory:initialized');
+    }
+    async shutdown() {
+        if (!this.isInitialized) return;
+        this.logger.info('Shutting down swarm memory manager...');
+        // Stop sync timer
+        if (this.syncTimer) {
+            clearInterval(this.syncTimer);
+            this.syncTimer = undefined;
+        }
+        // Save final state
+        await this.saveMemoryState();
+        this.isInitialized = false;
+        this.emit('memory:shutdown');
+    }
+    /**
+   * Close database connections and cleanup resources
+   * Alias for shutdown() to match test expectations
+   */ async close() {
+        await this.shutdown();
+    }
+    async remember(agentId, type, content, metadata = {}) {
+        const entryId = generateId('mem');
+        const entry = {
+            id: entryId,
+            agentId,
+            type,
+            content,
+            timestamp: new Date(),
+            metadata: {
+                shareLevel: 'team',
+                priority: 1,
+                ...metadata
+            }
+        };
+        this.entries.set(entryId, entry);
+        // Associate with agent
+        if (!this.agentMemories.has(agentId)) {
+            this.agentMemories.set(agentId, new Set());
+        }
+        this.agentMemories.get(agentId).add(entryId);
+        // Store in base memory for persistence
+        await this.baseMemory.store({
+            id: `entry:${entryId}`,
+            agentId,
+            sessionId: metadata.taskId || 'swarm-session',
+            type: 'artifact',
+            content: JSON.stringify(entry),
+            context: {
+                entryType: type,
+                shareLevel: entry.metadata.shareLevel
+            },
+            timestamp: entry.timestamp,
+            tags: metadata.tags || [],
+            version: 1
+        });
+        this.logger.debug(`Agent ${agentId} remembered: ${type} - ${entryId}`);
+        this.emit('memory:added', entry);
+        // Update knowledge base if applicable
+        if (type === 'knowledge' && this.config.enableKnowledgeBase) {
+            await this.updateKnowledgeBase(entry);
+        }
+        // Check for memory limits
+        await this.enforceMemoryLimits();
+        return entryId;
+    }
+    async recall(query) {
+        let results = Array.from(this.entries.values());
+        // Apply filters
+        if (query.agentId) {
+            results = results.filter((e)=>e.agentId === query.agentId);
+        }
+        if (query.type) {
+            results = results.filter((e)=>e.type === query.type);
+        }
+        if (query.taskId) {
+            results = results.filter((e)=>e.metadata.taskId === query.taskId);
+        }
+        if (query.objectiveId) {
+            results = results.filter((e)=>e.metadata.objectiveId === query.objectiveId);
+        }
+        if (query.tags && query.tags.length > 0) {
+            results = results.filter((e)=>e.metadata.tags && query.tags.some((tag)=>e.metadata.tags.includes(tag)));
+        }
+        if (query.since) {
+            results = results.filter((e)=>e.timestamp >= query.since);
+        }
+        if (query.before) {
+            results = results.filter((e)=>e.timestamp <= query.before);
+        }
+        if (query.shareLevel) {
+            results = results.filter((e)=>e.metadata.shareLevel === query.shareLevel);
+        }
+        // Sort by timestamp (newest first)
+        results.sort((a, b)=>b.timestamp.getTime() - a.timestamp.getTime());
+        // Apply limit
+        if (query.limit) {
+            results = results.slice(0, query.limit);
+        }
+        this.logger.debug(`Recalled ${results.length} memories for query`);
+        return results;
+    }
+    async shareMemory(entryId, targetAgentId) {
+        const entry = this.entries.get(entryId);
+        if (!entry) {
+            throw new Error('Memory entry not found');
+        }
+        if (!this.config.enableCrossAgentSharing) {
+            throw new Error('Cross-agent sharing is disabled');
+        }
+        // Check share level permissions
+        if (entry.metadata.shareLevel === 'private') {
+            throw new Error('Memory entry is private and cannot be shared');
+        }
+        // Create a shared copy for the target agent
+        const sharedEntry = {
+            ...entry,
+            id: generateId('mem'),
+            metadata: {
+                ...entry.metadata,
+                originalId: entryId,
+                sharedFrom: entry.agentId,
+                sharedTo: targetAgentId,
+                sharedAt: new Date()
+            }
+        };
+        this.entries.set(sharedEntry.id, sharedEntry);
+        // Associate with target agent
+        if (!this.agentMemories.has(targetAgentId)) {
+            this.agentMemories.set(targetAgentId, new Set());
+        }
+        this.agentMemories.get(targetAgentId).add(sharedEntry.id);
+        this.logger.info(`Shared memory ${entryId} from ${entry.agentId} to ${targetAgentId}`);
+        this.emit('memory:shared', {
+            original: entry,
+            shared: sharedEntry
+        });
+    }
+    async broadcastMemory(entryId, agentIds) {
+        const entry = this.entries.get(entryId);
+        if (!entry) {
+            throw new Error('Memory entry not found');
+        }
+        if (entry.metadata.shareLevel === 'private') {
+            throw new Error('Cannot broadcast private memory');
+        }
+        const targets = agentIds || Array.from(this.agentMemories.keys()).filter((id)=>id !== entry.agentId);
+        for (const targetId of targets){
+            try {
+                await this.shareMemory(entryId, targetId);
+            } catch (error) {
+                this.logger.warn(`Failed to share memory to ${targetId}:`, error);
+            }
+        }
+        this.logger.info(`Broadcasted memory ${entryId} to ${targets.length} agents`);
+    }
+    async createKnowledgeBase(name, description, domain, expertise) {
+        const kbId = generateId('kb');
+        const knowledgeBase = {
+            id: kbId,
+            name,
+            description,
+            entries: [],
+            metadata: {
+                domain,
+                expertise,
+                contributors: [],
+                lastUpdated: new Date()
+            }
+        };
+        this.knowledgeBases.set(kbId, knowledgeBase);
+        this.logger.info(`Created knowledge base: ${name} (${kbId})`);
+        this.emit('knowledgebase:created', knowledgeBase);
+        return kbId;
+    }
+    async updateKnowledgeBase(entry) {
+        if (!this.config.enableKnowledgeBase) return;
+        // Find relevant knowledge bases
+        const relevantKBs = Array.from(this.knowledgeBases.values()).filter((kb)=>{
+            // Simple matching based on tags and content
+            const tags = entry.metadata.tags || [];
+            return tags.some((tag)=>kb.metadata.expertise.some((exp)=>exp.toLowerCase().includes(tag.toLowerCase()) || tag.toLowerCase().includes(exp.toLowerCase())));
+        });
+        for (const kb of relevantKBs){
+            // Add entry to knowledge base
+            kb.entries.push(entry);
+            kb.metadata.lastUpdated = new Date();
+            // Add contributor
+            if (!kb.metadata.contributors.includes(entry.agentId)) {
+                kb.metadata.contributors.push(entry.agentId);
+            }
+            this.logger.debug(`Updated knowledge base ${kb.id} with entry ${entry.id}`);
+        }
+    }
+    async searchKnowledge(query, domain, expertise) {
+        const allEntries = [];
+        // Search in knowledge bases
+        for (const kb of this.knowledgeBases.values()){
+            if (domain && kb.metadata.domain !== domain) continue;
+            if (expertise && !expertise.some((exp)=>kb.metadata.expertise.includes(exp))) {
+                continue;
+            }
+            allEntries.push(...kb.entries);
+        }
+        // Simple text search (in real implementation, use better search)
+        const queryLower = query.toLowerCase();
+        const results = allEntries.filter((entry)=>{
+            const contentStr = JSON.stringify(entry.content).toLowerCase();
+            return contentStr.includes(queryLower);
+        });
+        return results.slice(0, 50); // Limit results
+    }
+    async getAgentMemorySnapshot(agentId) {
+        const agentEntryIds = this.agentMemories.get(agentId) || new Set();
+        const agentEntries = Array.from(agentEntryIds).map((id)=>this.entries.get(id)).filter(Boolean);
+        const recentEntries = agentEntries.sort((a, b)=>b.timestamp.getTime() - a.timestamp.getTime()).slice(0, 10);
+        const knowledgeContributions = agentEntries.filter((e)=>e.type === 'knowledge').length;
+        const sharedEntries = agentEntries.filter((e)=>e.metadata.shareLevel === 'public' || e.metadata.shareLevel === 'team').length;
+        return {
+            totalEntries: agentEntries.length,
+            recentEntries,
+            knowledgeContributions,
+            sharedEntries
+        };
+    }
+    async loadMemoryState() {
+        try {
+            // Load entries
+            const entriesFile = path.join(this.config.persistencePath, 'entries.json');
+            try {
+                const entriesData = await fs.readFile(entriesFile, 'utf-8');
+                const entriesArray = JSON.parse(entriesData);
+                for (const entry of entriesArray){
+                    this.entries.set(entry.id, {
+                        ...entry,
+                        timestamp: new Date(entry.timestamp)
+                    });
+                    // Rebuild agent memory associations
+                    if (!this.agentMemories.has(entry.agentId)) {
+                        this.agentMemories.set(entry.agentId, new Set());
+                    }
+                    this.agentMemories.get(entry.agentId).add(entry.id);
+                }
+                this.logger.info(`Loaded ${entriesArray.length} memory entries`);
+            } catch (error) {
+                this.logger.warn('No existing memory entries found');
+            }
+            // Load knowledge bases
+            const kbFile = path.join(this.config.persistencePath, 'knowledge-bases.json');
+            try {
+                const kbData = await fs.readFile(kbFile, 'utf-8');
+                const kbArray = JSON.parse(kbData);
+                for (const kb of kbArray){
+                    this.knowledgeBases.set(kb.id, {
+                        ...kb,
+                        metadata: {
+                            ...kb.metadata,
+                            lastUpdated: new Date(kb.metadata.lastUpdated)
+                        },
+                        entries: kb.entries.map((e)=>({
+                                ...e,
+                                timestamp: new Date(e.timestamp)
+                            }))
+                    });
+                }
+                this.logger.info(`Loaded ${kbArray.length} knowledge bases`);
+            } catch (error) {
+                this.logger.warn('No existing knowledge bases found');
+            }
+        } catch (error) {
+            this.logger.error('Error loading memory state:', error);
+        }
+    }
+    async saveMemoryState() {
+        try {
+            // Save entries
+            const entriesArray = Array.from(this.entries.values());
+            const entriesFile = path.join(this.config.persistencePath, 'entries.json');
+            await fs.writeFile(entriesFile, JSON.stringify(entriesArray, null, 2));
+            // Save knowledge bases
+            const kbArray = Array.from(this.knowledgeBases.values());
+            const kbFile = path.join(this.config.persistencePath, 'knowledge-bases.json');
+            await fs.writeFile(kbFile, JSON.stringify(kbArray, null, 2));
+            this.logger.debug('Saved memory state to disk');
+        } catch (error) {
+            this.logger.error('Error saving memory state:', error);
+        }
+    }
+    async syncMemoryState() {
+        try {
+            await this.saveMemoryState();
+            this.emit('memory:synced');
+        } catch (error) {
+            this.logger.error('Error syncing memory state:', error);
+        }
+    }
+    async enforceMemoryLimits() {
+        if (this.entries.size <= this.config.maxEntries) return;
+        this.logger.info('Enforcing memory limits...');
+        // Remove oldest entries that are not marked as important
+        const entries = Array.from(this.entries.values()).filter((e)=>(e.metadata.priority || 1) <= 1) // Only remove low priority
+        .sort((a, b)=>a.timestamp.getTime() - b.timestamp.getTime());
+        const toRemove = entries.slice(0, this.entries.size - this.config.maxEntries);
+        for (const entry of toRemove){
+            this.entries.delete(entry.id);
+            // Remove from agent memory
+            const agentEntries = this.agentMemories.get(entry.agentId);
+            if (agentEntries) {
+                agentEntries.delete(entry.id);
+            }
+            this.logger.debug(`Removed old memory entry: ${entry.id}`);
+        }
+        this.emit('memory:cleaned', toRemove.length);
+    }
+    // Public API methods
+    getMemoryStats() {
+        const entries = Array.from(this.entries.values());
+        const entriesByType = {};
+        const entriesByAgent = {};
+        for (const entry of entries){
+            entriesByType[entry.type] = (entriesByType[entry.type] || 0) + 1;
+            entriesByAgent[entry.agentId] = (entriesByAgent[entry.agentId] || 0) + 1;
+        }
+        // Rough memory usage calculation
+        const memoryUsage = JSON.stringify(entries).length;
+        return {
+            totalEntries: entries.length,
+            entriesByType,
+            entriesByAgent,
+            knowledgeBases: this.knowledgeBases.size,
+            memoryUsage
+        };
+    }
+    async exportMemory(agentId) {
+        const entries = agentId ? await this.recall({
+            agentId
+        }) : Array.from(this.entries.values());
+        return {
+            entries,
+            knowledgeBases: agentId ? Array.from(this.knowledgeBases.values()).filter((kb)=>kb.metadata.contributors.includes(agentId)) : Array.from(this.knowledgeBases.values()),
+            exportedAt: new Date(),
+            stats: this.getMemoryStats()
+        };
+    }
+    async clearMemory(agentId) {
+        if (agentId) {
+            // Clear specific agent's memory
+            const entryIds = this.agentMemories.get(agentId) || new Set();
+            for (const entryId of entryIds){
+                this.entries.delete(entryId);
+            }
+            this.agentMemories.delete(agentId);
+            this.logger.info(`Cleared memory for agent ${agentId}`);
+        } else {
+            // Clear all memory
+            this.entries.clear();
+            this.agentMemories.clear();
+            this.knowledgeBases.clear();
+            this.logger.info('Cleared all swarm memory');
+        }
+        this.emit('memory:cleared', {
+            agentId
+        });
+    }
+    // Compatibility methods for hive.ts
+    async store(key, value) {
+        // Extract namespace and actual key from the path
+        const parts = key.split('/');
+        const type = parts[0] || 'state';
+        const agentId = parts[1] || 'system';
+        await this.remember(agentId, type, value, {
+            tags: [
+                parts[0],
+                parts[1]
+            ].filter(Boolean),
+            shareLevel: 'team'
+        });
+    }
+    async search(pattern, limit = 10) {
+        // Simple pattern matching on stored keys/content
+        const results = [];
+        for (const entry of this.entries.values()){
+            const entryString = JSON.stringify(entry);
+            if (entryString.includes(pattern.replace('*', ''))) {
+                results.push(entry.content);
+                if (results.length >= limit) break;
+            }
+        }
+        return results;
+    }
+    constructor(config = {}){
+        super(), _define_property(this, "logger", void 0), _define_property(this, "config", void 0), _define_property(this, "baseMemory", void 0), _define_property(this, "entries", void 0), _define_property(this, "knowledgeBases", void 0), _define_property(this, "agentMemories", void 0 // agentId -> set of entry IDs
+        ), _define_property(this, "syncTimer", void 0), _define_property(this, "isInitialized", false);
+        this.logger = new Logger({
+            level: 'info',
+            format: 'json',
+            destination: 'console'
+        }, {
+            component: 'SwarmMemoryManager'
+        });
+        this.config = {
+            namespace: 'swarm',
+            enableDistribution: true,
+            enableReplication: true,
+            syncInterval: 10000,
+            maxEntries: 10000,
+            compressionThreshold: 1000,
+            enableKnowledgeBase: true,
+            enableCrossAgentSharing: true,
+            persistencePath: './swarm-memory',
+            ...config
+        };
+        this.entries = new Map();
+        this.knowledgeBases = new Map();
+        this.agentMemories = new Map();
+        const eventBus = EventBus.getInstance();
+        this.baseMemory = new MemoryManager({
+            backend: 'sqlite',
+            cacheSizeMB: 50,
+            syncInterval: 5000,
+            conflictResolution: 'last-write',
+            retentionDays: 30,
+            sqlitePath: './swarm-memory.db'
+        }, eventBus, this.logger);
+    }
+}
 /**
- * SwarmMemory - MCP-specific memory persistence extending SharedMemory
- * Provides swarm-specific features like agent coordination, task tracking, and neural patterns
- *
- * @module swarm-memory
- */
-
-import { SharedMemory } from './shared-memory.js';
-import path from 'path';
-
-/**
- * Swarm-specific namespaces
- */
-const SWARM_NAMESPACES = {
-  AGENTS: 'swarm:agents',
-  TASKS: 'swarm:tasks',
-  COMMUNICATIONS: 'swarm:communications',
-  CONSENSUS: 'swarm:consensus',
-  PATTERNS: 'swarm:patterns',
-  METRICS: 'swarm:metrics',
-  COORDINATION: 'swarm:coordination',
-};
-
-/**
- * SwarmMemory class - Extends SharedMemory with MCP features
- */
-export class SwarmMemory extends SharedMemory {
-  constructor(options = {}) {
-    // Default to .swarm directory for MCP
-    super({
-      directory: options.directory || '.swarm',
-      filename: options.filename || 'swarm-memory.db',
-      ...options,
-    });
-
-    this.swarmId = options.swarmId || 'default';
-    this.mcpMode = options.mcpMode !== false;
-
-    // Additional swarm-specific caches
-    this.agentCache = new Map();
-    this.taskCache = new Map();
-    this.patternCache = new Map();
-  }
-
-  /**
-   * Initialize with swarm-specific setup
-   */
-  async initialize() {
-    await super.initialize();
-
-    // Initialize swarm-specific namespaces
-    await this._initializeSwarmNamespaces();
-
-    // Load active agents and tasks into cache
-    await this._loadSwarmState();
-
-    this.emit('swarm:initialized', { swarmId: this.swarmId });
-  }
-
-  /**
-   * Store agent information
-   */
-  async storeAgent(agentId, agentData) {
-    const key = `agent:${agentId}`;
-    const enrichedData = {
-      ...agentData,
-      swarmId: this.swarmId,
-      lastUpdated: new Date().toISOString(),
-    };
-
-    await this.store(key, enrichedData, {
-      namespace: SWARM_NAMESPACES.AGENTS,
-      tags: ['agent', agentData.type, agentData.status],
-      metadata: {
-        swarmId: this.swarmId,
-        agentType: agentData.type,
-      },
-    });
-
-    // Update agent cache
-    this.agentCache.set(agentId, enrichedData);
-
-    this.emit('swarm:agentStored', { agentId, type: agentData.type });
-
-    return { agentId, stored: true };
-  }
-
-  /**
-   * Retrieve agent information
-   */
-  async getAgent(agentId) {
-    // Check cache first
-    if (this.agentCache.has(agentId)) {
-      return this.agentCache.get(agentId);
-    }
-
-    const key = `agent:${agentId}`;
-    const agent = await this.retrieve(key, SWARM_NAMESPACES.AGENTS);
-
-    if (agent) {
-      this.agentCache.set(agentId, agent);
-    }
-
-    return agent;
-  }
-
-  /**
-   * List all agents in swarm
-   */
-  async listAgents(filter = {}) {
-    const agents = await this.list(SWARM_NAMESPACES.AGENTS, {
-      limit: filter.limit || 100,
-    });
-
-    return agents
-      .map((entry) => entry.value)
-      .filter((agent) => {
-        if (filter.type && agent.type !== filter.type) return false;
-        if (filter.status && agent.status !== filter.status) return false;
-        if (filter.swarmId && agent.swarmId !== filter.swarmId) return false;
-        return true;
-      });
-  }
-
-  /**
-   * Store task information
-   */
-  async storeTask(taskId, taskData) {
-    const key = `task:${taskId}`;
-    const enrichedData = {
-      ...taskData,
-      swarmId: this.swarmId,
-      createdAt: taskData.createdAt || new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-    };
-
-    await this.store(key, enrichedData, {
-      namespace: SWARM_NAMESPACES.TASKS,
-      tags: ['task', taskData.status, taskData.priority],
-      metadata: {
-        swarmId: this.swarmId,
-        assignedAgents: taskData.assignedAgents || [],
-      },
-    });
-
-    // Update task cache
-    this.taskCache.set(taskId, enrichedData);
-
-    this.emit('swarm:taskStored', { taskId, status: taskData.status });
-
-    return { taskId, stored: true };
-  }
-
-  /**
-   * Update task status
-   */
-  async updateTaskStatus(taskId, status, result = null) {
-    const task = await this.getTask(taskId);
-    if (!task) {
-      throw new Error(`Task ${taskId} not found`);
-    }
-
-    task.status = status;
-    task.updatedAt = new Date().toISOString();
-
-    if (result) {
-      task.result = result;
-    }
-
-    if (status === 'completed') {
-      task.completedAt = new Date().toISOString();
-    }
-
-    await this.storeTask(taskId, task);
-
-    this.emit('swarm:taskStatusUpdated', { taskId, status });
-
-    return { taskId, status, updated: true };
-  }
-
-  /**
-   * Get task information
-   */
-  async getTask(taskId) {
-    // Check cache first
-    if (this.taskCache.has(taskId)) {
-      return this.taskCache.get(taskId);
-    }
-
-    const key = `task:${taskId}`;
-    const task = await this.retrieve(key, SWARM_NAMESPACES.TASKS);
-
-    if (task) {
-      this.taskCache.set(taskId, task);
-    }
-
-    return task;
-  }
-
-  /**
-   * Store inter-agent communication
-   */
-  async storeCommunication(fromAgent, toAgent, message) {
-    const commId = `comm:${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    const communication = {
-      id: commId,
-      fromAgent,
-      toAgent,
-      message,
-      swarmId: this.swarmId,
-      timestamp: new Date().toISOString(),
-    };
-
-    await this.store(commId, communication, {
-      namespace: SWARM_NAMESPACES.COMMUNICATIONS,
-      ttl: 86400, // 24 hours
-      tags: ['communication', message.type],
-      metadata: {
-        fromAgent,
-        toAgent,
-        messageType: message.type,
-      },
-    });
-
-    this.emit('swarm:communication', { fromAgent, toAgent, type: message.type });
-
-    return { id: commId, stored: true };
-  }
-
-  /**
-   * Store consensus decision
-   */
-  async storeConsensus(consensusId, decision) {
-    const key = `consensus:${consensusId}`;
-    const consensusData = {
-      ...decision,
-      swarmId: this.swarmId,
-      timestamp: new Date().toISOString(),
-    };
-
-    await this.store(key, consensusData, {
-      namespace: SWARM_NAMESPACES.CONSENSUS,
-      tags: ['consensus', decision.status],
-      metadata: {
-        swarmId: this.swarmId,
-        taskId: decision.taskId,
-        threshold: decision.threshold,
-      },
-    });
-
-    this.emit('swarm:consensus', { consensusId, status: decision.status });
-
-    return { consensusId, stored: true };
-  }
-
-  /**
-   * Store neural pattern
-   */
-  async storePattern(patternId, pattern) {
-    const key = `pattern:${patternId}`;
-    const patternData = {
-      ...pattern,
-      swarmId: this.swarmId,
-      createdAt: new Date().toISOString(),
-      usageCount: 0,
-      successRate: 0,
-    };
-
-    await this.store(key, patternData, {
-      namespace: SWARM_NAMESPACES.PATTERNS,
-      tags: ['pattern', pattern.type],
-      metadata: {
-        swarmId: this.swarmId,
-        patternType: pattern.type,
-        confidence: pattern.confidence || 0,
-      },
-    });
-
-    // Cache frequently used patterns
-    if (pattern.type === 'coordination' || pattern.type === 'optimization') {
-      this.patternCache.set(patternId, patternData);
-    }
-
-    this.emit('swarm:patternStored', { patternId, type: pattern.type });
-
-    return { patternId, stored: true };
-  }
-
-  /**
-   * Update pattern usage and success metrics
-   */
-  async updatePatternMetrics(patternId, success = true) {
-    const pattern = await this.getPattern(patternId);
-    if (!pattern) {
-      throw new Error(`Pattern ${patternId} not found`);
-    }
-
-    pattern.usageCount++;
-    pattern.lastUsedAt = new Date().toISOString();
-
-    // Update success rate with exponential moving average
-    const alpha = 0.1; // Smoothing factor
-    const currentSuccess = success ? 1 : 0;
-    pattern.successRate = alpha * currentSuccess + (1 - alpha) * (pattern.successRate || 0);
-
-    await this.storePattern(patternId, pattern);
-
-    return { patternId, usageCount: pattern.usageCount, successRate: pattern.successRate };
-  }
-
-  /**
-   * Get pattern
-   */
-  async getPattern(patternId) {
-    // Check cache first
-    if (this.patternCache.has(patternId)) {
-      return this.patternCache.get(patternId);
-    }
-
-    const key = `pattern:${patternId}`;
-    return await this.retrieve(key, SWARM_NAMESPACES.PATTERNS);
-  }
-
-  /**
-   * Find best patterns for a given context
-   */
-  async findBestPatterns(context, limit = 5) {
-    const patterns = await this.search({
-      namespace: SWARM_NAMESPACES.PATTERNS,
-      tags: context.tags,
-      limit: 100,
-    });
-
-    // Score patterns based on success rate and relevance
-    const scored = patterns.map((entry) => {
-      const pattern = entry.value;
-      const score =
-        pattern.successRate * 0.7 +
-        (pattern.confidence || 0) * 0.2 +
-        (pattern.usageCount > 0 ? 0.1 : 0);
-
-      return { ...pattern, score };
-    });
-
-    // Sort by score and return top patterns
-    return scored.sort((a, b) => b.score - a.score).slice(0, limit);
-  }
-
-  /**
-   * Store coordination state
-   */
-  async storeCoordination(key, state) {
-    await this.store(key, state, {
-      namespace: SWARM_NAMESPACES.COORDINATION,
-      ttl: 3600, // 1 hour
-      metadata: {
-        swarmId: this.swarmId,
-        timestamp: new Date().toISOString(),
-      },
-    });
-
-    return { key, stored: true };
-  }
-
-  /**
-   * Get coordination state
-   */
-  async getCoordination(key) {
-    return await this.retrieve(key, SWARM_NAMESPACES.COORDINATION);
-  }
-
-  /**
-   * Store performance metrics
-   */
-  async storeMetrics(metricsId, metrics) {
-    const key = `metrics:${metricsId}`;
-    await this.store(key, metrics, {
-      namespace: SWARM_NAMESPACES.METRICS,
-      ttl: 86400 * 7, // 7 days
-      tags: ['metrics', metrics.type],
-      metadata: {
-        swarmId: this.swarmId,
-        agentId: metrics.agentId,
-        timestamp: new Date().toISOString(),
-      },
-    });
-
-    this.emit('swarm:metricsStored', { metricsId, type: metrics.type });
-
-    return { metricsId, stored: true };
-  }
-
-  /**
-   * Get swarm statistics
-   */
-  async getSwarmStats() {
-    const baseStats = await this.getStats();
-
-    // Add swarm-specific stats
-    const agentCount = await this._countNamespace(SWARM_NAMESPACES.AGENTS);
-    const taskCount = await this._countNamespace(SWARM_NAMESPACES.TASKS);
-    const patternCount = await this._countNamespace(SWARM_NAMESPACES.PATTERNS);
-
-    // Get active agents
-    const activeAgents = Array.from(this.agentCache.values()).filter(
-      (agent) => agent.status === 'active' || agent.status === 'busy',
-    ).length;
-
-    // Get task statistics
-    const tasks = Array.from(this.taskCache.values());
-    const taskStats = {
-      total: tasks.length,
-      pending: tasks.filter((t) => t.status === 'pending').length,
-      inProgress: tasks.filter((t) => t.status === 'in_progress').length,
-      completed: tasks.filter((t) => t.status === 'completed').length,
-      failed: tasks.filter((t) => t.status === 'failed').length,
-    };
-
-    return {
-      ...baseStats,
-      swarm: {
-        swarmId: this.swarmId,
-        agents: {
-          total: agentCount,
-          active: activeAgents,
-          cached: this.agentCache.size,
-        },
-        tasks: taskStats,
-        patterns: {
-          total: patternCount,
-          cached: this.patternCache.size,
-        },
-        namespaces: Object.values(SWARM_NAMESPACES),
-      },
-    };
-  }
-
-  /**
-   * Clean up old swarm data
-   */
-  async cleanupSwarmData(options = {}) {
-    const {
-      maxAge = 86400 * 7, // 7 days
-      keepPatterns = true,
-      keepConsensus = true,
-    } = options;
-
-    const cutoffTime = Date.now() - maxAge * 1000;
-    let cleaned = 0;
-
-    // Clean old communications
-    const comms = await this.list(SWARM_NAMESPACES.COMMUNICATIONS);
-    for (const comm of comms) {
-      if (new Date(comm.value.timestamp).getTime() < cutoffTime) {
-        await this.delete(comm.key, SWARM_NAMESPACES.COMMUNICATIONS);
-        cleaned++;
-      }
-    }
-
-    // Clean completed tasks
-    const tasks = await this.list(SWARM_NAMESPACES.TASKS);
-    for (const task of tasks) {
-      if (
-        task.value.status === 'completed' &&
-        new Date(task.value.completedAt).getTime() < cutoffTime
-      ) {
-        await this.delete(task.key, SWARM_NAMESPACES.TASKS);
-        this.taskCache.delete(task.value.id);
-        cleaned++;
-      }
-    }
-
-    // Clean old metrics
-    const metrics = await this.list(SWARM_NAMESPACES.METRICS);
-    for (const metric of metrics) {
-      if (new Date(metric.createdAt).getTime() < cutoffTime) {
-        await this.delete(metric.key, SWARM_NAMESPACES.METRICS);
-        cleaned++;
-      }
-    }
-
-    this.emit('swarm:cleanup', { cleaned, maxAge });
-
-    return { cleaned };
-  }
-
-  /**
-   * Export swarm state
-   */
-  async exportSwarmState() {
-    const agents = await this.listAgents();
-    const tasks = Array.from(this.taskCache.values());
-    const patterns = await this.list(SWARM_NAMESPACES.PATTERNS);
-
-    return {
-      swarmId: this.swarmId,
-      exportedAt: new Date().toISOString(),
-      agents: agents,
-      tasks: tasks,
-      patterns: patterns.map((p) => p.value),
-      statistics: await this.getSwarmStats(),
-    };
-  }
-
-  /**
-   * Import swarm state
-   */
-  async importSwarmState(state) {
-    let imported = {
-      agents: 0,
-      tasks: 0,
-      patterns: 0,
-    };
-
-    // Import agents
-    if (state.agents) {
-      for (const agent of state.agents) {
-        await this.storeAgent(agent.id, agent);
-        imported.agents++;
-      }
-    }
-
-    // Import tasks
-    if (state.tasks) {
-      for (const task of state.tasks) {
-        await this.storeTask(task.id, task);
-        imported.tasks++;
-      }
-    }
-
-    // Import patterns
-    if (state.patterns) {
-      for (const pattern of state.patterns) {
-        await this.storePattern(pattern.id, pattern);
-        imported.patterns++;
-      }
-    }
-
-    this.emit('swarm:imported', imported);
-
-    return imported;
-  }
-
-  /**
-   * Private helper methods
-   */
-
-  async _initializeSwarmNamespaces() {
-    // Create swarm metadata
-    await this.store(
-      'swarm:metadata',
-      {
-        swarmId: this.swarmId,
-        createdAt: new Date().toISOString(),
-        version: '1.0.0',
-        namespaces: Object.values(SWARM_NAMESPACES),
-      },
-      {
-        namespace: 'swarm:system',
-      },
-    );
-  }
-
-  async _loadSwarmState() {
-    // Load active agents
-    const agents = await this.list(SWARM_NAMESPACES.AGENTS, { limit: 100 });
-    for (const entry of agents) {
-      if (entry.value.status === 'active' || entry.value.status === 'busy') {
-        this.agentCache.set(entry.value.id, entry.value);
-      }
-    }
-
-    // Load in-progress tasks
-    const tasks = await this.search({
-      namespace: SWARM_NAMESPACES.TASKS,
-      tags: ['in_progress'],
-      limit: 100,
-    });
-    for (const entry of tasks) {
-      this.taskCache.set(entry.value.id, entry.value);
-    }
-
-    // Load high-confidence patterns
-    const patterns = await this.list(SWARM_NAMESPACES.PATTERNS, { limit: 50 });
-    for (const entry of patterns) {
-      if (entry.value.confidence > 0.7 || entry.value.successRate > 0.8) {
-        this.patternCache.set(entry.value.id, entry.value);
-      }
-    }
-  }
-
-  async _countNamespace(namespace) {
-    const stats = await this.getStats();
-    return stats.namespaces[namespace]?.count || 0;
-  }
-}
-
-// Export factory function for easy creation
-export function createSwarmMemory(options = {}) {
-  return new SwarmMemory(options);
-}
-
-// Export for backwards compatibility
-export default SwarmMemory;
+ * Factory function to create SwarmMemoryManager instance
+ * Provides backward compatibility with existing code that uses createSwarmMemory()
+ */ export function createSwarmMemory(options = {}) {
+    return new SwarmMemoryManager(options);
+}