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

package/dist/cli/simple-commands/hive-mind/mcp-wrapper.js

@@ -8,47 +8,107 @@ import { spawn } from 'child_process';
  */
 const MCP_TOOLS = {
     swarm: [
-        'swarm_init', 'agent_spawn', 'task_orchestrate', 'swarm_status',
-        'agent_list', 'agent_metrics', 'swarm_monitor', 'topology_optimize',
-        'load_balance', 'coordination_sync', 'swarm_scale', 'swarm_destroy'
+        'swarm_init',
+        'agent_spawn',
+        'task_orchestrate',
+        'swarm_status',
+        'agent_list',
+        'agent_metrics',
+        'swarm_monitor',
+        'topology_optimize',
+        'load_balance',
+        'coordination_sync',
+        'swarm_scale',
+        'swarm_destroy',
     ],
     neural: [
-        'neural_status', 'neural_train', 'neural_patterns', 'neural_predict',
-        'model_load', 'model_save', 'wasm_optimize', 'inference_run',
-        'pattern_recognize', 'cognitive_analyze', 'learning_adapt',
-        'neural_compress', 'ensemble_create', 'transfer_learn', 'neural_explain'
+        'neural_status',
+        'neural_train',
+        'neural_patterns',
+        'neural_predict',
+        'model_load',
+        'model_save',
+        'wasm_optimize',
+        'inference_run',
+        'pattern_recognize',
+        'cognitive_analyze',
+        'learning_adapt',
+        'neural_compress',
+        'ensemble_create',
+        'transfer_learn',
+        'neural_explain',
     ],
     memory: [
-        'memory_usage', 'memory_search', 'memory_persist', 'memory_namespace',
-        'memory_backup', 'memory_restore', 'memory_compress', 'memory_sync',
-        'cache_manage', 'state_snapshot', 'context_restore', 'memory_analytics'
+        'memory_usage',
+        'memory_search',
+        'memory_persist',
+        'memory_namespace',
+        'memory_backup',
+        'memory_restore',
+        'memory_compress',
+        'memory_sync',
+        'cache_manage',
+        'state_snapshot',
+        'context_restore',
+        'memory_analytics',
     ],
     performance: [
-        'performance_report', 'bottleneck_analyze', 'token_usage', 'benchmark_run',
-        'metrics_collect', 'trend_analysis', 'cost_analysis', 'quality_assess',
-        'error_analysis', 'usage_stats', 'health_check'
+        'performance_report',
+        'bottleneck_analyze',
+        'token_usage',
+        'benchmark_run',
+        'metrics_collect',
+        'trend_analysis',
+        'cost_analysis',
+        'quality_assess',
+        'error_analysis',
+        'usage_stats',
+        'health_check',
     ],
     github: [
-        'github_repo_analyze', 'github_pr_manage', 'github_issue_track',
-        'github_release_coord', 'github_workflow_auto', 'github_code_review',
-        'github_sync_coord', 'github_metrics'
+        'github_repo_analyze',
+        'github_pr_manage',
+        'github_issue_track',
+        'github_release_coord',
+        'github_workflow_auto',
+        'github_code_review',
+        'github_sync_coord',
+        'github_metrics',
     ],
     workflow: [
-        'workflow_create', 'workflow_execute', 'workflow_export', 'automation_setup',
-        'pipeline_create', 'scheduler_manage', 'trigger_setup', 'workflow_template',
-        'batch_process', 'parallel_execute'
+        'workflow_create',
+        'workflow_execute',
+        'workflow_export',
+        'automation_setup',
+        'pipeline_create',
+        'scheduler_manage',
+        'trigger_setup',
+        'workflow_template',
+        'batch_process',
+        'parallel_execute',
     ],
     daa: [
-        'daa_agent_create', 'daa_capability_match', 'daa_resource_alloc',
-        'daa_lifecycle_manage', 'daa_communication', 'daa_consensus',
-        'daa_fault_tolerance', 'daa_optimization'
+        'daa_agent_create',
+        'daa_capability_match',
+        'daa_resource_alloc',
+        'daa_lifecycle_manage',
+        'daa_communication',
+        'daa_consensus',
+        'daa_fault_tolerance',
+        'daa_optimization',
     ],
     system: [
-        'terminal_execute', 'config_manage', 'features_detect', 'security_scan',
-        'backup_create', 'restore_system', 'log_analysis', 'diagnostic_run'
+        'terminal_execute',
+        'config_manage',
+        'features_detect',
+        'security_scan',
+        'backup_create',
+        'restore_system',
+        'log_analysis',
+        'diagnostic_run',
     ],
     sparc: ['sparc_mode'],
-    task: ['task_status', 'task_results']
+    task: ['task_status', 'task_results'],
 };
 /**
  * MCPToolWrapper class for unified MCP tool access
@@ -59,7 +119,7 @@ export class MCPToolWrapper {
             parallel: true,
             timeout: 60000,
             retryCount: 3,
-            ...config
+            ...config,
         };
         this.toolStats = new Map();
         this.parallelQueue = [];
@@ -124,7 +184,7 @@ export class MCPToolWrapper {
                 console.error(`Attempt ${attempt} failed for ${toolName}:`, error.message);
                 if (attempt < this.config.retryCount) {
                     // Exponential backoff
-                    await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
+                    await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1000));
                 }
             }
         }
@@ -160,7 +220,7 @@ export class MCPToolWrapper {
                 for (let i = 0; i < group.length; i += concurrencyLimit) {
                     const batch = group.slice(i, i + concurrencyLimit);
                     // Execute batch with timeout and retry logic
-                    const batchPromises = batch.map(call => this._executeWithTimeout(call, this.config.timeout));
+                    const batchPromises = batch.map((call) => this._executeWithTimeout(call, this.config.timeout));
                     const batchResults = await Promise.allSettled(batchPromises);
                     // Process results and handle failures
                     for (let j = 0; j < batchResults.length; j++) {
@@ -190,11 +250,11 @@ export class MCPToolWrapper {
      * Calculate optimal concurrency based on tool types
      */
     _calculateOptimalConcurrency(toolCalls) {
-        const toolTypes = toolCalls.map(call => this._getToolCategory(call.tool));
+        const toolTypes = toolCalls.map((call) => this._getToolCategory(call.tool));
         const uniqueTypes = new Set(toolTypes);
         // Heavy operations (neural, github) need lower concurrency
         const heavyTypes = ['neural', 'github', 'workflow'];
-        const hasHeavyOps = toolTypes.some(type => heavyTypes.includes(type));
+        const hasHeavyOps = toolTypes.some((type) => heavyTypes.includes(type));
         if (hasHeavyOps) {
             return Math.min(3, Math.max(1, Math.floor(toolCalls.length / 2)));
         }
@@ -209,9 +269,9 @@ export class MCPToolWrapper {
             critical: [], // swarm_init, swarm_destroy
             high: [], // agent_spawn, memory operations
             medium: [], // task operations, monitoring
-            low: [] // analytics, reporting
+            low: [], // analytics, reporting
         };
-        toolCalls.forEach(call => {
+        toolCalls.forEach((call) => {
             const category = this._getToolCategory(call.tool);
             const tool = call.tool;
             if (['swarm_init', 'swarm_destroy', 'memory_backup'].includes(tool)) {
@@ -228,8 +288,7 @@ export class MCPToolWrapper {
             }
         });
         // Return groups in priority order, filtering empty groups
-        return [priorities.critical, priorities.high, priorities.medium, priorities.low]
-            .filter(group => group.length > 0);
+        return [priorities.critical, priorities.high, priorities.medium, priorities.low].filter((group) => group.length > 0);
     }
     /**
      * Execute tool with timeout wrapper
@@ -240,11 +299,11 @@ export class MCPToolWrapper {
                 reject(new Error(`Tool ${call.tool} timed out after ${timeout}ms`));
             }, timeout);
             this.executeTool(call.tool, call.params)
-                .then(result => {
+                .then((result) => {
                 clearTimeout(timer);
                 resolve(result);
             })
-                .catch(error => {
+                .catch((error) => {
                 clearTimeout(timer);
                 reject(error);
             });
@@ -261,7 +320,7 @@ export class MCPToolWrapper {
                 totalTime: 0,
                 avgConcurrency: 0,
                 avgToolsPerBatch: 0,
-                avgTimePerTool: 0
+                avgTimePerTool: 0,
             };
         }
         this.batchStats.totalBatches++;
@@ -293,10 +352,13 @@ export class MCPToolWrapper {
         else if (toolName === 'memory_search') {
             return await this.searchMemory(params.namespace, params.pattern);
         }
+        else if (toolName === 'swarm_status') {
+            return await this.getSwarmStatus(params);
+        }
         // For other tools, use mock responses
         console.log(`Executing MCP tool: mcp__claude-flow__${toolName} with params:`, params);
         // Simulate async execution for non-memory tools
-        await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
+        await new Promise((resolve) => setTimeout(resolve, Math.random() * 500));
         // Mock response based on tool type
         const mockResponse = this._getMockResponse(toolName, params);
         return mockResponse;
@@ -321,28 +383,28 @@ export class MCPToolWrapper {
             swarm_init: {
                 swarmId: `swarm-${Date.now()}`,
                 topology: params.topology || 'hierarchical',
-                status: 'initialized'
+                status: 'initialized',
             },
             agent_spawn: {
                 agentId: `agent-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
                 type: params.type,
-                status: 'active'
+                status: 'active',
             },
             task_orchestrate: {
                 taskId: `task-${Date.now()}`,
                 status: 'orchestrated',
-                strategy: params.strategy || 'parallel'
+                strategy: params.strategy || 'parallel',
             },
             memory_usage: {
                 action: params.action,
                 result: params.action === 'store' ? 'stored' : 'retrieved',
-                data: params.value || null
+                data: params.value || null,
             },
             neural_status: {
                 status: 'ready',
                 models: 27,
-                accuracy: 0.848
-            }
+                accuracy: 0.848,
+            },
         };
         return mockResponses[toolName] || { status: 'success', toolName };
     }
@@ -356,7 +418,7 @@ export class MCPToolWrapper {
                 successes: 0,
                 failures: 0,
                 totalDuration: 0,
-                avgDuration: 0
+                avgDuration: 0,
             });
         }
         const stats = this.toolStats.get(toolName);
@@ -386,7 +448,7 @@ export class MCPToolWrapper {
                 totalTime: 0,
                 avgConcurrency: 0,
                 avgToolsPerBatch: 0,
-                avgTimePerTool: 0
+                avgTimePerTool: 0,
             },
             spawn: this.spawnStats || {
                 totalSpawns: 0,
@@ -394,31 +456,29 @@ export class MCPToolWrapper {
                 totalTime: 0,
                 avgTimePerAgent: 0,
                 bestTime: 0,
-                worstTime: 0
+                worstTime: 0,
             },
             performance: {
                 totalCalls: Array.from(this.toolStats.values()).reduce((sum, stat) => sum + stat.calls, 0),
                 successRate: this._calculateOverallSuccessRate(),
                 avgLatency: this._calculateAvgLatency(),
-                throughput: this._calculateThroughput()
-            }
+                throughput: this._calculateThroughput(),
+            },
         };
     }
     /**
      * Calculate overall success rate
      */
     _calculateOverallSuccessRate() {
-        const total = Array.from(this.toolStats.values())
-            .reduce((sum, stat) => sum + stat.calls, 0);
-        const successes = Array.from(this.toolStats.values())
-            .reduce((sum, stat) => sum + stat.successes, 0);
-        return total > 0 ? (successes / total * 100).toFixed(2) : 100;
+        const total = Array.from(this.toolStats.values()).reduce((sum, stat) => sum + stat.calls, 0);
+        const successes = Array.from(this.toolStats.values()).reduce((sum, stat) => sum + stat.successes, 0);
+        return total > 0 ? ((successes / total) * 100).toFixed(2) : 100;
     }
     /**
      * Calculate average latency
      */
     _calculateAvgLatency() {
-        const stats = Array.from(this.toolStats.values()).filter(stat => stat.calls > 0);
+        const stats = Array.from(this.toolStats.values()).filter((stat) => stat.calls > 0);
         if (stats.length === 0)
             return 0;
         const totalLatency = stats.reduce((sum, stat) => sum + stat.avgDuration, 0);
@@ -437,9 +497,9 @@ export class MCPToolWrapper {
      * Create batch of tool calls for parallel execution
      */
     createBatch(calls) {
-        return calls.map(call => ({
+        return calls.map((call) => ({
             tool: call.tool,
-            params: call.params || {}
+            params: call.params || {},
         }));
     }
     /**
@@ -451,34 +511,49 @@ export class MCPToolWrapper {
         try {
             // Phase 1: Critical initialization (sequential)
             const criticalOps = [
-                { tool: 'swarm_init', params: {
+                {
+                    tool: 'swarm_init',
+                    params: {
                         topology: config.topology || 'hierarchical',
                         maxAgents: config.maxAgents || 8,
                         strategy: 'auto',
-                        swarmId
-                    } }
+                        swarmId,
+                    },
+                },
             ];
             const [swarmInitResult] = await this.executeParallel(criticalOps);
             // Phase 2: Supporting services (parallel)
             const supportingOps = [
-                { tool: 'memory_namespace', params: {
+                {
+                    tool: 'memory_namespace',
+                    params: {
                         action: 'create',
                         namespace: swarmId,
-                        maxSize: config.memorySize || 100
-                    } },
+                        maxSize: config.memorySize || 100,
+                    },
+                },
                 { tool: 'neural_status', params: {} },
                 { tool: 'performance_report', params: { format: 'summary' } },
-                { tool: 'features_detect', params: { component: 'swarm' } }
+                { tool: 'features_detect', params: { component: 'swarm' } },
             ];
             const supportingResults = await this.executeParallel(supportingOps);
             // Store initialization metadata
             const initTime = Date.now() - startTime;
             await this.storeMemory(swarmId, 'init_performance', {
                 initTime,
-                topology: config.topology,
-                maxAgents: config.maxAgents,
-                timestamp: Date.now()
+                topology: config.topology || 'hierarchical',
+                maxAgents: config.maxAgents || 8,
+                timestamp: Date.now(),
             }, 'metrics');
+            // Store swarm status
+            await this.storeMemory(swarmId, 'status', 'active', 'status');
+            // Store swarm config
+            await this.storeMemory(swarmId, 'config', {
+                topology: config.topology || 'hierarchical',
+                maxAgents: config.maxAgents || 8,
+                strategy: config.strategy || 'auto',
+                createdAt: Date.now(),
+            }, 'config');
             return [swarmInitResult, ...supportingResults];
         }
         catch (error) {
@@ -500,14 +575,14 @@ export class MCPToolWrapper {
         try {
             // Spawn each group in parallel
             for (const group of groupedTypes) {
-                const batch = group.map(type => ({
+                const batch = group.map((type) => ({
                     tool: 'agent_spawn',
                     params: {
                         type,
                         swarmId,
                         timestamp: Date.now(),
-                        batchId: `batch-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
-                    }
+                        batchId: `batch-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                    },
                 }));
                 const groupResults = await this.executeParallel(batch);
                 allResults.push(...groupResults);
@@ -531,16 +606,16 @@ export class MCPToolWrapper {
             development: ['coder', 'architect', 'reviewer'],
             analysis: ['researcher', 'analyst', 'optimizer'],
             quality: ['tester', 'documenter'],
-            coordination: ['coordinator']
+            coordination: ['coordinator'],
         };
         const result = [];
         const remaining = [...types];
         // Create groups of complementary agents
-        Object.values(groups).forEach(groupTypes => {
-            const groupAgents = remaining.filter(type => groupTypes.includes(type));
+        Object.values(groups).forEach((groupTypes) => {
+            const groupAgents = remaining.filter((type) => groupTypes.includes(type));
             if (groupAgents.length > 0) {
                 result.push(groupAgents);
-                groupAgents.forEach(type => {
+                groupAgents.forEach((type) => {
                     const index = remaining.indexOf(type);
                     if (index > -1)
                         remaining.splice(index, 1);
@@ -548,7 +623,7 @@ export class MCPToolWrapper {
             }
         });
         // Add remaining agents as individual groups
-        remaining.forEach(type => result.push([type]));
+        remaining.forEach((type) => result.push([type]));
         return result;
     }
     /**
@@ -562,7 +637,7 @@ export class MCPToolWrapper {
                 totalTime: 0,
                 avgTimePerAgent: 0,
                 bestTime: Infinity,
-                worstTime: 0
+                worstTime: 0,
             };
         }
         this.spawnStats.totalSpawns++;
@@ -596,7 +671,7 @@ export class MCPToolWrapper {
                     key,
                     type,
                     timestamp,
-                    id: result.lastInsertRowid
+                    id: result.lastInsertRowid,
                 };
             }
             else {
@@ -607,7 +682,7 @@ export class MCPToolWrapper {
                     key,
                     value: valueStr,
                     type,
-                    timestamp
+                    timestamp,
                 });
                 return {
                     success: true,
@@ -615,7 +690,7 @@ export class MCPToolWrapper {
                     namespace: swarmId,
                     key,
                     type,
-                    timestamp
+                    timestamp,
                 };
             }
         }
@@ -642,7 +717,7 @@ export class MCPToolWrapper {
                     try {
                         return {
                             ...row,
-                            value: JSON.parse(row.value)
+                            value: JSON.parse(row.value),
                         };
                     }
                     catch {
@@ -658,7 +733,7 @@ export class MCPToolWrapper {
                     try {
                         return {
                             ...memory,
-                            value: JSON.parse(memory.value)
+                            value: JSON.parse(memory.value),
                         };
                     }
                     catch {
@@ -709,11 +784,11 @@ export class MCPToolWrapper {
                 const stmt = this.memoryDb.prepare(query);
                 results = stmt.all(...params);
                 // Parse JSON values where possible
-                results = results.map(row => {
+                results = results.map((row) => {
                     try {
                         return {
                             ...row,
-                            value: JSON.parse(row.value)
+                            value: JSON.parse(row.value),
                         };
                     }
                     catch {
@@ -732,7 +807,7 @@ export class MCPToolWrapper {
                             try {
                                 results.push({
                                     ...memory,
-                                    value: JSON.parse(memory.value)
+                                    value: JSON.parse(memory.value),
                                 });
                             }
                             catch {
@@ -750,7 +825,7 @@ export class MCPToolWrapper {
                 namespace: swarmId,
                 pattern: pattern || '',
                 total: results.length,
-                results: results
+                results: results,
             };
         }
         catch (error) {
@@ -768,26 +843,36 @@ export class MCPToolWrapper {
         const monitoringInterval = {
             low: 10000,
             medium: 5000,
-            high: 2000
+            high: 2000,
         }[complexity] || 5000;
         const batch = [
-            { tool: 'task_orchestrate', params: {
+            {
+                tool: 'task_orchestrate',
+                params: {
                     task,
                     strategy,
                     taskId,
                     priority: metadata.priority || 5,
-                    estimatedDuration: metadata.estimatedDuration || 30000
-                } },
-            { tool: 'swarm_monitor', params: {
+                    estimatedDuration: metadata.estimatedDuration || 30000,
+                },
+            },
+            {
+                tool: 'swarm_monitor',
+                params: {
                     interval: monitoringInterval,
                     taskId,
-                    metrics: ['performance', 'progress', 'bottlenecks']
-                } },
+                    metrics: ['performance', 'progress', 'bottlenecks'],
+                },
+            },
             // Add performance tracking for high-priority tasks
-            ...(metadata.priority > 7 ? [{
-                    tool: 'performance_report',
-                    params: { format: 'detailed', taskId }
-                }] : [])
+            ...(metadata.priority > 7
+                ? [
+                    {
+                        tool: 'performance_report',
+                        params: { format: 'detailed', taskId },
+                    },
+                ]
+                : []),
         ];
         return await this.executeParallel(batch);
     }
@@ -798,7 +883,7 @@ export class MCPToolWrapper {
         const batch = [
             { tool: 'bottleneck_analyze', params: { component: swarmId } },
             { tool: 'performance_report', params: { format: 'detailed' } },
-            { tool: 'token_usage', params: { operation: swarmId } }
+            { tool: 'token_usage', params: { operation: swarmId } },
         ];
         return await this.executeParallel(batch);
     }
@@ -810,7 +895,7 @@ export class MCPToolWrapper {
             analyze: 'github_repo_analyze',
             pr: 'github_pr_manage',
             issue: 'github_issue_track',
-            review: 'github_code_review'
+            review: 'github_code_review',
         };
         const tool = githubTools[operation];
         if (!tool) {
@@ -826,7 +911,7 @@ export class MCPToolWrapper {
             train: 'neural_train',
             predict: 'neural_predict',
             analyze: 'neural_patterns',
-            optimize: 'wasm_optimize'
+            optimize: 'wasm_optimize',
         };
         const tool = neuralTools[operation];
         if (!tool) {
@@ -840,17 +925,229 @@ export class MCPToolWrapper {
     async destroySwarm(swarmId) {
         const batch = [
             { tool: 'swarm_destroy', params: { swarmId } },
-            { tool: 'memory_namespace', params: {
+            {
+                tool: 'memory_namespace',
+                params: {
                     action: 'delete',
-                    namespace: swarmId
-                } },
-            { tool: 'cache_manage', params: {
+                    namespace: swarmId,
+                },
+            },
+            {
+                tool: 'cache_manage',
+                params: {
                     action: 'clear',
-                    key: `swarm-${swarmId}`
-                } }
+                    key: `swarm-${swarmId}`,
+                },
+            },
         ];
         return await this.executeParallel(batch);
     }
+    /**
+     * Get real swarm status from memory storage
+     */
+    async getSwarmStatus(params = {}) {
+        try {
+            if (!this.memoryDb) {
+                await this.initializeMemoryStorage();
+            }
+            const swarms = [];
+            let activeAgents = 0;
+            let totalTasks = 0;
+            let completedTasks = 0;
+            if (this.memoryDb) {
+                // Get all unique swarm namespaces
+                const namespacesQuery = this.memoryDb.prepare(`
+          SELECT DISTINCT namespace FROM memories 
+          WHERE namespace LIKE 'swarm-%' OR namespace LIKE 'hive-%'
+          ORDER BY timestamp DESC
+        `);
+                const namespaces = namespacesQuery.all();
+                // For each swarm, gather its information
+                for (const { namespace } of namespaces) {
+                    const swarmId = namespace;
+                    // Get swarm metadata
+                    const metadataQuery = this.memoryDb.prepare(`
+            SELECT key, value, type, timestamp FROM memories 
+            WHERE namespace = ? AND (
+              key IN ('init_performance', 'config', 'status', 'agents', 'tasks', 'topology')
+              OR key LIKE 'agent-%'
+              OR key LIKE 'task-%'
+            )
+          `);
+                    const swarmData = metadataQuery.all(swarmId);
+                    // Parse swarm information
+                    let swarmInfo = {
+                        id: swarmId,
+                        name: swarmId,
+                        status: 'unknown',
+                        agents: 0,
+                        tasks: { total: 0, completed: 0, pending: 0, failed: 0 },
+                        topology: 'hierarchical',
+                        createdAt: null,
+                        lastActivity: null,
+                        memoryUsage: swarmData.length
+                    };
+                    // Process swarm data
+                    for (const record of swarmData) {
+                        try {
+                            const value = typeof record.value === 'string' ? JSON.parse(record.value) : record.value;
+                            switch (record.key) {
+                                case 'init_performance':
+                                    swarmInfo.createdAt = value.timestamp;
+                                    swarmInfo.topology = value.topology || 'hierarchical';
+                                    break;
+                                case 'status':
+                                    swarmInfo.status = value;
+                                    break;
+                                case 'config':
+                                    swarmInfo.topology = value.topology || swarmInfo.topology;
+                                    break;
+                            }
+                            // Count agents
+                            if (record.key.startsWith('agent-')) {
+                                swarmInfo.agents++;
+                                activeAgents++;
+                            }
+                            // Count tasks
+                            if (record.key.startsWith('task-')) {
+                                swarmInfo.tasks.total++;
+                                totalTasks++;
+                                if (value.status === 'completed') {
+                                    swarmInfo.tasks.completed++;
+                                    completedTasks++;
+                                }
+                                else if (value.status === 'failed') {
+                                    swarmInfo.tasks.failed++;
+                                }
+                                else if (value.status === 'pending' || value.status === 'in_progress') {
+                                    swarmInfo.tasks.pending++;
+                                }
+                            }
+                            // Track last activity
+                            if (record.timestamp > (swarmInfo.lastActivity || 0)) {
+                                swarmInfo.lastActivity = record.timestamp;
+                            }
+                        }
+                        catch (e) {
+                            // Skip invalid JSON values
+                        }
+                    }
+                    // Determine swarm status based on activity
+                    if (swarmInfo.status === 'unknown') {
+                        const now = Date.now();
+                        const lastActivityAge = now - (swarmInfo.lastActivity || 0);
+                        if (lastActivityAge < 60000) { // Active within last minute
+                            swarmInfo.status = 'active';
+                        }
+                        else if (lastActivityAge < 300000) { // Active within last 5 minutes
+                            swarmInfo.status = 'idle';
+                        }
+                        else {
+                            swarmInfo.status = 'inactive';
+                        }
+                    }
+                    swarms.push(swarmInfo);
+                }
+                // Get recent activity logs
+                const activityQuery = this.memoryDb.prepare(`
+          SELECT namespace, key, type, timestamp FROM memories 
+          WHERE (namespace LIKE 'swarm-%' OR namespace LIKE 'hive-%')
+          AND timestamp > ?
+          ORDER BY timestamp DESC
+          LIMIT 10
+        `);
+                const recentActivity = activityQuery.all(Date.now() - 300000); // Last 5 minutes
+                return {
+                    swarms,
+                    activeAgents,
+                    totalTasks,
+                    completedTasks,
+                    pendingTasks: totalTasks - completedTasks,
+                    recentActivity: recentActivity.map(r => ({
+                        swarmId: r.namespace,
+                        action: r.key,
+                        type: r.type,
+                        timestamp: r.timestamp
+                    })),
+                    summary: {
+                        totalSwarms: swarms.length,
+                        activeSwarms: swarms.filter(s => s.status === 'active').length,
+                        idleSwarms: swarms.filter(s => s.status === 'idle').length,
+                        inactiveSwarms: swarms.filter(s => s.status === 'inactive').length
+                    }
+                };
+            }
+            else {
+                // Fallback to in-memory storage
+                const swarmMap = new Map();
+                for (const [key, memory] of this.memoryStore) {
+                    const namespace = memory.namespace;
+                    if (namespace && (namespace.startsWith('swarm-') || namespace.startsWith('hive-'))) {
+                        if (!swarmMap.has(namespace)) {
+                            swarmMap.set(namespace, {
+                                id: namespace,
+                                name: namespace,
+                                status: 'active',
+                                agents: 0,
+                                tasks: { total: 0, completed: 0, pending: 0, failed: 0 },
+                                memoryUsage: 0
+                            });
+                        }
+                        const swarm = swarmMap.get(namespace);
+                        swarm.memoryUsage++;
+                        if (memory.key.startsWith('agent-')) {
+                            swarm.agents++;
+                            activeAgents++;
+                        }
+                        if (memory.key.startsWith('task-')) {
+                            swarm.tasks.total++;
+                            totalTasks++;
+                            try {
+                                const taskData = JSON.parse(memory.value);
+                                if (taskData.status === 'completed') {
+                                    swarm.tasks.completed++;
+                                    completedTasks++;
+                                }
+                            }
+                            catch (e) {
+                                // Skip invalid JSON
+                            }
+                        }
+                    }
+                }
+                return {
+                    swarms: Array.from(swarmMap.values()),
+                    activeAgents,
+                    totalTasks,
+                    completedTasks,
+                    pendingTasks: totalTasks - completedTasks,
+                    summary: {
+                        totalSwarms: swarmMap.size,
+                        activeSwarms: swarmMap.size
+                    }
+                };
+            }
+        }
+        catch (error) {
+            console.error('Error getting swarm status:', error);
+            // Return empty status on error
+            return {
+                swarms: [],
+                activeAgents: 0,
+                totalTasks: 0,
+                completedTasks: 0,
+                pendingTasks: 0,
+                recentActivity: [],
+                summary: {
+                    totalSwarms: 0,
+                    activeSwarms: 0,
+                    idleSwarms: 0,
+                    inactiveSwarms: 0
+                },
+                error: error.message
+            };
+        }
+    }
 }
 // Export tool categories for reference
 export { MCP_TOOLS };