claude-flow 2.7.0 → 2.7.2

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

@@ -1,399 +1,480 @@
-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 {
-    logger;
-    config;
-    baseMemory;
-    entries;
-    knowledgeBases;
-    agentMemories;
-    syncTimer;
-    isInitialized = false;
-    constructor(config = {}){
-        super();
-        this.logger = new Logger('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',
-            namespace: this.config.namespace,
-            cacheSizeMB: 50,
-            syncOnExit: true,
-            maxEntries: this.config.maxEntries,
-            ttlMinutes: 60
-        }, eventBus, this.logger);
+import { SharedMemory } from './shared-memory.js';
+const SWARM_NAMESPACES = {
+    AGENTS: 'swarm:agents',
+    TASKS: 'swarm:tasks',
+    COMMUNICATIONS: 'swarm:communications',
+    CONSENSUS: 'swarm:consensus',
+    PATTERNS: 'swarm:patterns',
+    METRICS: 'swarm:metrics',
+    COORDINATION: 'swarm:coordination'
+};
+export class SwarmMemory extends SharedMemory {
+    constructor(options = {}){
+        super({
+            directory: options.directory || '.swarm',
+            filename: options.filename || 'swarm-memory.db',
+            ...options
+        });
+        this.swarmId = options.swarmId || 'default';
+        this.mcpMode = options.mcpMode !== false;
+        this.agentCache = new Map();
+        this.taskCache = new Map();
+        this.patternCache = new Map();
     }
     async initialize() {
-        if (this.isInitialized) return;
-        this.logger.info('Initializing swarm memory manager...');
-        await this.baseMemory.initialize();
-        await fs.mkdir(this.config.persistencePath, {
-            recursive: true
+        await super.initialize();
+        await this._initializeSwarmNamespaces();
+        await this._loadSwarmState();
+        this.emit('swarm:initialized', {
+            swarmId: this.swarmId
         });
-        await this.loadMemoryState();
-        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...');
-        if (this.syncTimer) {
-            clearInterval(this.syncTimer);
-            this.syncTimer = undefined;
-        }
-        await this.saveMemoryState();
-        this.isInitialized = false;
-        this.emit('memory:shutdown');
-    }
-    async remember(agentId, type, content, metadata = {}) {
-        const entryId = generateId('mem');
-        const entry = {
-            id: entryId,
-            agentId,
-            type,
-            content,
-            timestamp: new Date(),
+    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: {
-                shareLevel: 'team',
-                priority: 1,
-                ...metadata
+                swarmId: this.swarmId,
+                agentType: agentData.type
             }
+        });
+        this.agentCache.set(agentId, enrichedData);
+        this.emit('swarm:agentStored', {
+            agentId,
+            type: agentData.type
+        });
+        return {
+            agentId,
+            stored: true
         };
-        this.entries.set(entryId, entry);
-        if (!this.agentMemories.has(agentId)) {
-            this.agentMemories.set(agentId, new Set());
+    }
+    async getAgent(agentId) {
+        if (this.agentCache.has(agentId)) {
+            return this.agentCache.get(agentId);
         }
-        this.agentMemories.get(agentId).add(entryId);
-        await this.baseMemory.remember({
-            namespace: this.config.namespace,
-            key: `entry:${entryId}`,
-            content: JSON.stringify(entry),
+        const key = `agent:${agentId}`;
+        const agent = await this.retrieve(key, SWARM_NAMESPACES.AGENTS);
+        if (agent) {
+            this.agentCache.set(agentId, agent);
+        }
+        return agent;
+    }
+    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;
+        });
+    }
+    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: {
-                type: 'swarm-memory',
-                agentId,
-                entryType: type,
-                shareLevel: entry.metadata.shareLevel
+                swarmId: this.swarmId,
+                assignedAgents: taskData.assignedAgents || []
             }
         });
-        this.logger.debug(`Agent ${agentId} remembered: ${type} - ${entryId}`);
-        this.emit('memory:added', entry);
-        if (type === 'knowledge' && this.config.enableKnowledgeBase) {
-            await this.updateKnowledgeBase(entry);
-        }
-        await this.enforceMemoryLimits();
-        return entryId;
+        this.taskCache.set(taskId, enrichedData);
+        this.emit('swarm:taskStored', {
+            taskId,
+            status: taskData.status
+        });
+        return {
+            taskId,
+            stored: true
+        };
     }
-    async recall(query) {
-        let results = Array.from(this.entries.values());
-        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);
+    async updateTaskStatus(taskId, status, result = null) {
+        const task = await this.getTask(taskId);
+        if (!task) {
+            throw new Error(`Task ${taskId} not found`);
         }
-        if (query.objectiveId) {
-            results = results.filter((e)=>e.metadata.objectiveId === query.objectiveId);
+        task.status = status;
+        task.updatedAt = new Date().toISOString();
+        if (result) {
+            task.result = result;
         }
-        if (query.tags && query.tags.length > 0) {
-            results = results.filter((e)=>e.metadata.tags && query.tags.some((tag)=>e.metadata.tags.includes(tag)));
+        if (status === 'completed') {
+            task.completedAt = new Date().toISOString();
         }
-        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);
-        }
-        results.sort((a, b)=>b.timestamp.getTime() - a.timestamp.getTime());
-        if (query.limit) {
-            results = results.slice(0, query.limit);
-        }
-        this.logger.debug(`Recalled ${results.length} memories for query`);
-        return results;
+        await this.storeTask(taskId, task);
+        this.emit('swarm:taskStatusUpdated', {
+            taskId,
+            status
+        });
+        return {
+            taskId,
+            status,
+            updated: true
+        };
     }
-    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');
+    async getTask(taskId) {
+        if (this.taskCache.has(taskId)) {
+            return this.taskCache.get(taskId);
         }
-        if (entry.metadata.shareLevel === 'private') {
-            throw new Error('Memory entry is private and cannot be shared');
+        const key = `task:${taskId}`;
+        const task = await this.retrieve(key, SWARM_NAMESPACES.TASKS);
+        if (task) {
+            this.taskCache.set(taskId, task);
         }
-        const sharedEntry = {
-            ...entry,
-            id: generateId('mem'),
+        return task;
+    }
+    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,
+            tags: [
+                'communication',
+                message.type
+            ],
             metadata: {
-                ...entry.metadata,
-                originalId: entryId,
-                sharedFrom: entry.agentId,
-                sharedTo: targetAgentId,
-                sharedAt: new Date()
+                fromAgent,
+                toAgent,
+                messageType: message.type
             }
-        };
-        this.entries.set(sharedEntry.id, sharedEntry);
-        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
         });
+        this.emit('swarm:communication', {
+            fromAgent,
+            toAgent,
+            type: message.type
+        });
+        return {
+            id: commId,
+            stored: true
+        };
     }
-    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);
+    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.logger.info(`Broadcasted memory ${entryId} to ${targets.length} agents`);
+        });
+        this.emit('swarm:consensus', {
+            consensusId,
+            status: decision.status
+        });
+        return {
+            consensusId,
+            stored: true
+        };
     }
-    async createKnowledgeBase(name, description, domain, expertise) {
-        const kbId = generateId('kb');
-        const knowledgeBase = {
-            id: kbId,
-            name,
-            description,
-            entries: [],
+    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: {
-                domain,
-                expertise,
-                contributors: [],
-                lastUpdated: new Date()
+                swarmId: this.swarmId,
+                patternType: pattern.type,
+                confidence: pattern.confidence || 0
             }
+        });
+        if (pattern.type === 'coordination' || pattern.type === 'optimization') {
+            this.patternCache.set(patternId, patternData);
+        }
+        this.emit('swarm:patternStored', {
+            patternId,
+            type: pattern.type
+        });
+        return {
+            patternId,
+            stored: true
         };
-        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;
-        const relevantKBs = Array.from(this.knowledgeBases.values()).filter((kb)=>{
-            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){
-            kb.entries.push(entry);
-            kb.metadata.lastUpdated = new Date();
-            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 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();
+        const alpha = 0.1;
+        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
+        };
     }
-    async searchKnowledge(query, domain, expertise) {
-        const allEntries = [];
-        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);
+    async getPattern(patternId) {
+        if (this.patternCache.has(patternId)) {
+            return this.patternCache.get(patternId);
         }
-        const queryLower = query.toLowerCase();
-        const results = allEntries.filter((entry)=>{
-            const contentStr = JSON.stringify(entry.content).toLowerCase();
-            return contentStr.includes(queryLower);
+        const key = `pattern:${patternId}`;
+        return await this.retrieve(key, SWARM_NAMESPACES.PATTERNS);
+    }
+    async findBestPatterns(context, limit = 5) {
+        const patterns = await this.search({
+            namespace: SWARM_NAMESPACES.PATTERNS,
+            tags: context.tags,
+            limit: 100
+        });
+        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
+            };
         });
-        return results.slice(0, 50);
+        return scored.sort((a, b)=>b.score - a.score).slice(0, limit);
     }
-    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;
+    async storeCoordination(key, state) {
+        await this.store(key, state, {
+            namespace: SWARM_NAMESPACES.COORDINATION,
+            ttl: 3600,
+            metadata: {
+                swarmId: this.swarmId,
+                timestamp: new Date().toISOString()
+            }
+        });
         return {
-            totalEntries: agentEntries.length,
-            recentEntries,
-            knowledgeContributions,
-            sharedEntries
+            key,
+            stored: true
         };
     }
-    async loadMemoryState() {
-        try {
-            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)
-                    });
-                    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');
-            }
-            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');
+    async getCoordination(key) {
+        return await this.retrieve(key, SWARM_NAMESPACES.COORDINATION);
+    }
+    async storeMetrics(metricsId, metrics) {
+        const key = `metrics:${metricsId}`;
+        await this.store(key, metrics, {
+            namespace: SWARM_NAMESPACES.METRICS,
+            ttl: 86400 * 7,
+            tags: [
+                'metrics',
+                metrics.type
+            ],
+            metadata: {
+                swarmId: this.swarmId,
+                agentId: metrics.agentId,
+                timestamp: new Date().toISOString()
             }
-        } catch (error) {
-            this.logger.error('Error loading memory state:', error);
-        }
+        });
+        this.emit('swarm:metricsStored', {
+            metricsId,
+            type: metrics.type
+        });
+        return {
+            metricsId,
+            stored: true
+        };
     }
-    async saveMemoryState() {
-        try {
-            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));
-            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 getSwarmStats() {
+        const baseStats = await this.getStats();
+        const agentCount = await this._countNamespace(SWARM_NAMESPACES.AGENTS);
+        const taskCount = await this._countNamespace(SWARM_NAMESPACES.TASKS);
+        const patternCount = await this._countNamespace(SWARM_NAMESPACES.PATTERNS);
+        const activeAgents = Array.from(this.agentCache.values()).filter((agent)=>agent.status === 'active' || agent.status === 'busy').length;
+        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)
+            }
+        };
     }
-    async syncMemoryState() {
-        try {
-            await this.saveMemoryState();
-            this.emit('memory:synced');
-        } catch (error) {
-            this.logger.error('Error syncing memory state:', error);
+    async cleanupSwarmData(options = {}) {
+        const { maxAge = 86400 * 7, keepPatterns = true, keepConsensus = true } = options;
+        const cutoffTime = Date.now() - maxAge * 1000;
+        let cleaned = 0;
+        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++;
+            }
         }
-    }
-    async enforceMemoryLimits() {
-        if (this.entries.size <= this.config.maxEntries) return;
-        this.logger.info('Enforcing memory limits...');
-        const entries = Array.from(this.entries.values()).filter((e)=>(e.metadata.priority || 1) <= 1).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);
-            const agentEntries = this.agentMemories.get(entry.agentId);
-            if (agentEntries) {
-                agentEntries.delete(entry.id);
+        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++;
             }
-            this.logger.debug(`Removed old memory entry: ${entry.id}`);
         }
-        this.emit('memory:cleaned', toRemove.length);
-    }
-    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;
+        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++;
+            }
         }
-        const memoryUsage = JSON.stringify(entries).length;
+        this.emit('swarm:cleanup', {
+            cleaned,
+            maxAge
+        });
         return {
-            totalEntries: entries.length,
-            entriesByType,
-            entriesByAgent,
-            knowledgeBases: this.knowledgeBases.size,
-            memoryUsage
+            cleaned
         };
     }
-    async exportMemory(agentId) {
-        const entries = agentId ? await this.recall({
-            agentId
-        }) : Array.from(this.entries.values());
+    async exportSwarmState() {
+        const agents = await this.listAgents();
+        const tasks = Array.from(this.taskCache.values());
+        const patterns = await this.list(SWARM_NAMESPACES.PATTERNS);
         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()
+            swarmId: this.swarmId,
+            exportedAt: new Date().toISOString(),
+            agents: agents,
+            tasks: tasks,
+            patterns: patterns.map((p)=>p.value),
+            statistics: await this.getSwarmStats()
         };
     }
-    async clearMemory(agentId) {
-        if (agentId) {
-            const entryIds = this.agentMemories.get(agentId) || new Set();
-            for (const entryId of entryIds){
-                this.entries.delete(entryId);
+    async importSwarmState(state) {
+        let imported = {
+            agents: 0,
+            tasks: 0,
+            patterns: 0
+        };
+        if (state.agents) {
+            for (const agent of state.agents){
+                await this.storeAgent(agent.id, agent);
+                imported.agents++;
+            }
+        }
+        if (state.tasks) {
+            for (const task of state.tasks){
+                await this.storeTask(task.id, task);
+                imported.tasks++;
+            }
+        }
+        if (state.patterns) {
+            for (const pattern of state.patterns){
+                await this.storePattern(pattern.id, pattern);
+                imported.patterns++;
             }
-            this.agentMemories.delete(agentId);
-            this.logger.info(`Cleared memory for agent ${agentId}`);
-        } else {
-            this.entries.clear();
-            this.agentMemories.clear();
-            this.knowledgeBases.clear();
-            this.logger.info('Cleared all swarm memory');
         }
-        this.emit('memory:cleared', {
-            agentId
+        this.emit('swarm:imported', imported);
+        return imported;
+    }
+    async _initializeSwarmNamespaces() {
+        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 store(key, value) {
-        const parts = key.split('/');
-        const type = parts[0] || 'state';
-        const agentId = parts[1] || 'system';
-        await this.remember(agentId, type, value, {
+    async _loadSwarmState() {
+        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);
+            }
+        }
+        const tasks = await this.search({
+            namespace: SWARM_NAMESPACES.TASKS,
             tags: [
-                parts[0],
-                parts[1]
-            ].filter(Boolean),
-            shareLevel: 'team'
+                'in_progress'
+            ],
+            limit: 100
+        });
+        for (const entry of tasks){
+            this.taskCache.set(entry.value.id, entry.value);
+        }
+        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;
     }
-    async search(pattern, limit = 10) {
+}
+export function createSwarmMemory(options = {}) {
+    return new SwarmMemory(options);
+}
+export default SwarmMemory;
+
+//# sourceMappingURL=swarm-memory.js.maptern, limit = 10) {
         const results = [];
         for (const entry of this.entries.values()){
             const entryString = JSON.stringify(entry);