claude-flow 2.7.38 → 2.7.40

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

@@ -1,477 +1,409 @@
-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();
+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);
     }
     async initialize() {
-        await super.initialize();
-        await this._initializeSwarmNamespaces();
-        await this._loadSwarmState();
-        this.emit('swarm:initialized', {
-            swarmId: this.swarmId
+        if (this.isInitialized) return;
+        this.logger.info('Initializing swarm memory manager...');
+        await this.baseMemory.initialize();
+        await fs.mkdir(this.config.persistencePath, {
+            recursive: true
         });
+        await this.loadMemoryState();
+        if (this.config.syncInterval > 0) {
+            this.syncTimer = setInterval(()=>{
+                this.syncMemoryState();
+            }, this.config.syncInterval);
+        }
+        this.isInitialized = true;
+        this.emit('memory:initialized');
     }
-    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
-            ],
+    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(),
             metadata: {
-                swarmId: this.swarmId,
-                agentType: agentData.type
+                shareLevel: 'team',
+                priority: 1,
+                ...metadata
             }
-        });
-        this.agentCache.set(agentId, enrichedData);
-        this.emit('swarm:agentStored', {
-            agentId,
-            type: agentData.type
-        });
-        return {
-            agentId,
-            stored: true
         };
-    }
-    async getAgent(agentId) {
-        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);
+        this.entries.set(entryId, entry);
+        if (!this.agentMemories.has(agentId)) {
+            this.agentMemories.set(agentId, new Set());
         }
-        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
-            ],
+        this.agentMemories.get(agentId).add(entryId);
+        await this.baseMemory.remember({
+            namespace: this.config.namespace,
+            key: `entry:${entryId}`,
+            content: JSON.stringify(entry),
             metadata: {
-                swarmId: this.swarmId,
-                assignedAgents: taskData.assignedAgents || []
+                type: 'swarm-memory',
+                agentId,
+                entryType: type,
+                shareLevel: entry.metadata.shareLevel
             }
         });
-        this.taskCache.set(taskId, enrichedData);
-        this.emit('swarm:taskStored', {
-            taskId,
-            status: taskData.status
-        });
-        return {
-            taskId,
-            stored: true
-        };
+        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;
     }
-    async updateTaskStatus(taskId, status, result = null) {
-        const task = await this.getTask(taskId);
-        if (!task) {
-            throw new Error(`Task ${taskId} not found`);
+    async recall(query) {
+        let results = Array.from(this.entries.values());
+        if (query.agentId) {
+            results = results.filter((e)=>e.agentId === query.agentId);
         }
-        task.status = status;
-        task.updatedAt = new Date().toISOString();
-        if (result) {
-            task.result = result;
+        if (query.type) {
+            results = results.filter((e)=>e.type === query.type);
         }
-        if (status === 'completed') {
-            task.completedAt = new Date().toISOString();
+        if (query.taskId) {
+            results = results.filter((e)=>e.metadata.taskId === query.taskId);
         }
-        await this.storeTask(taskId, task);
-        this.emit('swarm:taskStatusUpdated', {
-            taskId,
-            status
-        });
-        return {
-            taskId,
-            status,
-            updated: true
-        };
-    }
-    async getTask(taskId) {
-        if (this.taskCache.has(taskId)) {
-            return this.taskCache.get(taskId);
+        if (query.objectiveId) {
+            results = results.filter((e)=>e.metadata.objectiveId === query.objectiveId);
         }
-        const key = `task:${taskId}`;
-        const task = await this.retrieve(key, SWARM_NAMESPACES.TASKS);
-        if (task) {
-            this.taskCache.set(taskId, task);
+        if (query.tags && query.tags.length > 0) {
+            results = results.filter((e)=>e.metadata.tags && query.tags.some((tag)=>e.metadata.tags.includes(tag)));
         }
-        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: {
-                fromAgent,
-                toAgent,
-                messageType: message.type
-            }
-        });
-        this.emit('swarm:communication', {
-            fromAgent,
-            toAgent,
-            type: message.type
-        });
-        return {
-            id: commId,
-            stored: true
-        };
+        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;
     }
-    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
-            ],
+    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');
+        }
+        if (entry.metadata.shareLevel === 'private') {
+            throw new Error('Memory entry is private and cannot be shared');
+        }
+        const sharedEntry = {
+            ...entry,
+            id: generateId('mem'),
             metadata: {
-                swarmId: this.swarmId,
-                taskId: decision.taskId,
-                threshold: decision.threshold
+                ...entry.metadata,
+                originalId: entryId,
+                sharedFrom: entry.agentId,
+                sharedTo: targetAgentId,
+                sharedAt: new Date()
             }
-        });
-        this.emit('swarm:consensus', {
-            consensusId,
-            status: decision.status
-        });
-        return {
-            consensusId,
-            stored: true
-        };
-    }
-    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
-            }
-        });
-        if (pattern.type === 'coordination' || pattern.type === 'optimization') {
-            this.patternCache.set(patternId, patternData);
+        this.entries.set(sharedEntry.id, sharedEntry);
+        if (!this.agentMemories.has(targetAgentId)) {
+            this.agentMemories.set(targetAgentId, new Set());
         }
-        this.emit('swarm:patternStored', {
-            patternId,
-            type: pattern.type
+        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
         });
-        return {
-            patternId,
-            stored: true
-        };
     }
-    async updatePatternMetrics(patternId, success = true) {
-        const pattern = await this.getPattern(patternId);
-        if (!pattern) {
-            throw new Error(`Pattern ${patternId} not found`);
+    async broadcastMemory(entryId, agentIds) {
+        const entry = this.entries.get(entryId);
+        if (!entry) {
+            throw new Error('Memory entry 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 getPattern(patternId) {
-        if (this.patternCache.has(patternId)) {
-            return this.patternCache.get(patternId);
+        if (entry.metadata.shareLevel === 'private') {
+            throw new Error('Cannot broadcast private memory');
         }
-        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 scored.sort((a, b)=>b.score - a.score).slice(0, limit);
+        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 storeCoordination(key, state) {
-        await this.store(key, state, {
-            namespace: SWARM_NAMESPACES.COORDINATION,
-            ttl: 3600,
+    async createKnowledgeBase(name, description, domain, expertise) {
+        const kbId = generateId('kb');
+        const knowledgeBase = {
+            id: kbId,
+            name,
+            description,
+            entries: [],
             metadata: {
-                swarmId: this.swarmId,
-                timestamp: new Date().toISOString()
+                domain,
+                expertise,
+                contributors: [],
+                lastUpdated: new Date()
             }
-        });
-        return {
-            key,
-            stored: true
         };
+        this.knowledgeBases.set(kbId, knowledgeBase);
+        this.logger.info(`Created knowledge base: ${name} (${kbId})`);
+        this.emit('knowledgebase:created', knowledgeBase);
+        return kbId;
     }
-    async getCoordination(key) {
-        return await this.retrieve(key, SWARM_NAMESPACES.COORDINATION);
+    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 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()
+    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);
+        }
+        const queryLower = query.toLowerCase();
+        const results = allEntries.filter((entry)=>{
+            const contentStr = JSON.stringify(entry.content).toLowerCase();
+            return contentStr.includes(queryLower);
         });
-        this.emit('swarm:metricsStored', {
-            metricsId,
-            type: metrics.type
-        });
-        return {
-            metricsId,
-            stored: true
-        };
+        return results.slice(0, 50);
     }
-    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
-        };
+    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 {
-            ...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)
-            }
+            totalEntries: agentEntries.length,
+            recentEntries,
+            knowledgeContributions,
+            sharedEntries
         };
     }
-    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 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 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++;
+            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 {
+            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 syncMemoryState() {
+        try {
+            await this.saveMemoryState();
+            this.emit('memory:synced');
+        } catch (error) {
+            this.logger.error('Error syncing memory state:', error);
         }
-        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++;
+    }
+    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);
             }
+            this.logger.debug(`Removed old memory entry: ${entry.id}`);
         }
-        this.emit('swarm:cleanup', {
-            cleaned,
-            maxAge
-        });
+        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 memoryUsage = JSON.stringify(entries).length;
         return {
-            cleaned
+            totalEntries: entries.length,
+            entriesByType,
+            entriesByAgent,
+            knowledgeBases: this.knowledgeBases.size,
+            memoryUsage
         };
     }
-    async exportSwarmState() {
-        const agents = await this.listAgents();
-        const tasks = Array.from(this.taskCache.values());
-        const patterns = await this.list(SWARM_NAMESPACES.PATTERNS);
+    async exportMemory(agentId) {
+        const entries = agentId ? await this.recall({
+            agentId
+        }) : Array.from(this.entries.values());
         return {
-            swarmId: this.swarmId,
-            exportedAt: new Date().toISOString(),
-            agents: agents,
-            tasks: tasks,
-            patterns: patterns.map((p)=>p.value),
-            statistics: await this.getSwarmStats()
+            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 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++;
+    async clearMemory(agentId) {
+        if (agentId) {
+            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 {
+            this.entries.clear();
+            this.agentMemories.clear();
+            this.knowledgeBases.clear();
+            this.logger.info('Cleared all swarm memory');
         }
-        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.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'
+        this.emit('memory:cleared', {
+            agentId
         });
     }
-    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,
+    async store(key, value) {
+        const parts = key.split('/');
+        const type = parts[0] || 'state';
+        const agentId = parts[1] || 'system';
+        await this.remember(agentId, type, value, {
             tags: [
-                '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
+                parts[0],
+                parts[1]
+            ].filter(Boolean),
+            shareLevel: 'team'
         });
-        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 search(pattern, limit = 10) {
+        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;
     }
-    async _countNamespace(namespace) {
-        const stats = await this.getStats();
-        return stats.namespaces[namespace]?.count || 0;
-    }
-}
-export function createSwarmMemory(options = {}) {
-    return new SwarmMemory(options);
 }
-export default SwarmMemory;
 
 //# sourceMappingURL=swarm-memory.js.map