claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/mcp/fixes/mcp-error-fixes.js

@@ -1,133 +1,152 @@
 /**
  * MCP Error Fixes
  * Fixes for agent_metrics, swarm_monitor, and neural_train errors
- */ // Fix 1: agent_metrics - Ensure neuralNetworks is always an array
+ */
+
+// Fix 1: agent_metrics - Ensure neuralNetworks is always an array
 export function fixAgentMetrics(data) {
-    if (!data) {
-        return {
-            success: true,
-            agentId: null,
-            metrics: {
-                tasksCompleted: 0,
-                successRate: 0,
-                avgExecutionTime: 0,
-                neuralNetworks: [],
-                memoryUsage: 0,
-                cpuUsage: 0
-            },
-            timestamp: new Date().toISOString()
-        };
-    }
-    // Ensure neuralNetworks is an array
-    if (data.metrics && !Array.isArray(data.metrics.neuralNetworks)) {
-        data.metrics.neuralNetworks = [];
-    }
-    // If neuralNetworks exists but isn't an array, convert it
-    if (data.neuralNetworks && !Array.isArray(data.neuralNetworks)) {
-        data.neuralNetworks = [];
-    }
-    return data;
+  if (!data) {
+    return {
+      success: true,
+      agentId: null,
+      metrics: {
+        tasksCompleted: 0,
+        successRate: 0,
+        avgExecutionTime: 0,
+        neuralNetworks: [], // Ensure it's an array
+        memoryUsage: 0,
+        cpuUsage: 0,
+      },
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  // Ensure neuralNetworks is an array
+  if (data.metrics && !Array.isArray(data.metrics.neuralNetworks)) {
+    data.metrics.neuralNetworks = [];
+  }
+
+  // If neuralNetworks exists but isn't an array, convert it
+  if (data.neuralNetworks && !Array.isArray(data.neuralNetworks)) {
+    data.neuralNetworks = [];
+  }
+
+  return data;
 }
+
 // Fix 2: swarm_monitor - Ensure recentEvents is always an array
 export function fixSwarmMonitor(data) {
-    if (!data) {
-        return {
-            success: true,
-            monitoring: {
-                swarmId: null,
-                status: 'active',
-                recentEvents: [],
-                agentActivity: [],
-                taskProgress: [],
-                resourceUsage: {
-                    cpu: 0,
-                    memory: 0,
-                    network: 0
-                }
-            },
-            timestamp: new Date().toISOString()
-        };
-    }
-    // Ensure recentEvents is an array
-    if (data.monitoring && !Array.isArray(data.monitoring.recentEvents)) {
-        data.monitoring.recentEvents = [];
-    }
-    // If recentEvents exists at top level but isn't an array, convert it
-    if (data.recentEvents && !Array.isArray(data.recentEvents)) {
-        data.recentEvents = [];
-    }
-    return data;
+  if (!data) {
+    return {
+      success: true,
+      monitoring: {
+        swarmId: null,
+        status: 'active',
+        recentEvents: [], // Ensure it's an array
+        agentActivity: [],
+        taskProgress: [],
+        resourceUsage: {
+          cpu: 0,
+          memory: 0,
+          network: 0,
+        },
+      },
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  // Ensure recentEvents is an array
+  if (data.monitoring && !Array.isArray(data.monitoring.recentEvents)) {
+    data.monitoring.recentEvents = [];
+  }
+
+  // If recentEvents exists at top level but isn't an array, convert it
+  if (data.recentEvents && !Array.isArray(data.recentEvents)) {
+    data.recentEvents = [];
+  }
+
+  return data;
 }
+
 // Fix 3: neural_train - Add proper parameter validation
 export function fixNeuralTrain(args) {
-    // Ensure agentId is provided as a string
-    if (!args.agentId && !args.agent_id) {
-        // Generate a default agent ID if not provided
-        args.agentId = `agent_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
-    }
-    // Normalize parameter names
-    if (args.agent_id && !args.agentId) {
-        args.agentId = args.agent_id;
-    }
-    // Ensure agentId is a string
-    if (typeof args.agentId !== 'string') {
-        args.agentId = String(args.agentId || '');
-    }
-    // Set default iterations if not provided
-    if (!args.iterations && !args.epochs) {
-        args.iterations = 10;
-    }
-    // Normalize epochs to iterations
-    if (args.epochs && !args.iterations) {
-        args.iterations = args.epochs;
-    }
-    return args;
+  // Ensure agentId is provided as a string
+  if (!args.agentId && !args.agent_id) {
+    // Generate a default agent ID if not provided
+    args.agentId = `agent_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
+  }
+
+  // Normalize parameter names
+  if (args.agent_id && !args.agentId) {
+    args.agentId = args.agent_id;
+  }
+
+  // Ensure agentId is a string
+  if (typeof args.agentId !== 'string') {
+    args.agentId = String(args.agentId || '');
+  }
+
+  // Set default iterations if not provided
+  if (!args.iterations && !args.epochs) {
+    args.iterations = 10;
+  }
+
+  // Normalize epochs to iterations
+  if (args.epochs && !args.iterations) {
+    args.iterations = args.epochs;
+  }
+
+  return args;
 }
+
 // Wrapper function to handle ruv-swarm MCP responses
 export function wrapRuvSwarmResponse(toolName, response) {
-    try {
-        // Parse response if it's a string
-        let data = response;
-        if (typeof response === 'string') {
-            try {
-                data = JSON.parse(response);
-            } catch  {
-                // If can't parse, wrap in object
-                data = {
-                    output: response
-                };
-            }
-        }
-        // Apply specific fixes based on tool name
-        switch(toolName){
-            case 'agent_metrics':
-            case 'mcp__ruv-swarm__agent_metrics':
-                return fixAgentMetrics(data);
-            case 'swarm_monitor':
-            case 'mcp__ruv-swarm__swarm_monitor':
-                return fixSwarmMonitor(data);
-            case 'neural_train':
-            case 'mcp__ruv-swarm__neural_train':
-                // For neural_train, we fix the args before calling
-                return data;
-            default:
-                return data;
-        }
-    } catch (error) {
-        console.error(`Error wrapping response for ${toolName}:`, error);
-        return {
-            success: false,
-            error: error.message,
-            timestamp: new Date().toISOString()
-        };
+  try {
+    // Parse response if it's a string
+    let data = response;
+    if (typeof response === 'string') {
+      try {
+        data = JSON.parse(response);
+      } catch {
+        // If can't parse, wrap in object
+        data = { output: response };
+      }
+    }
+
+    // Apply specific fixes based on tool name
+    switch (toolName) {
+      case 'agent_metrics':
+      case 'mcp__ruv-swarm__agent_metrics':
+        return fixAgentMetrics(data);
+
+      case 'swarm_monitor':
+      case 'mcp__ruv-swarm__swarm_monitor':
+        return fixSwarmMonitor(data);
+
+      case 'neural_train':
+      case 'mcp__ruv-swarm__neural_train':
+        // For neural_train, we fix the args before calling
+        return data;
+
+      default:
+        return data;
     }
+  } catch (error) {
+    console.error(`Error wrapping response for ${toolName}:`, error);
+    return {
+      success: false,
+      error: error.message,
+      timestamp: new Date().toISOString(),
+    };
+  }
 }
+
 // Export for use in MCP server
 if (typeof module !== 'undefined' && module.exports) {
-    module.exports = {
-        fixAgentMetrics,
-        fixSwarmMonitor,
-        fixNeuralTrain,
-        wrapRuvSwarmResponse
-    };
+  module.exports = {
+    fixAgentMetrics,
+    fixSwarmMonitor,
+    fixNeuralTrain,
+    wrapRuvSwarmResponse,
+  };
 }

package/dist/src/mcp/implementations/agent-tracker.js

@@ -1,133 +1,147 @@
 /**
  * Agent Tracker Module
  * Tracks spawned agents in memory for real-time status
- */ let AgentTracker = class AgentTracker {
-    // Track agent spawn
-    trackAgent(agentId, agentData) {
-        this.agents.set(agentId, {
-            ...agentData,
-            createdAt: new Date().toISOString(),
-            lastActive: new Date().toISOString()
-        });
-        // Update swarm agent count
-        if (agentData.swarmId && this.swarms.has(agentData.swarmId)) {
-            const swarm = this.swarms.get(agentData.swarmId);
-            swarm.agentCount = (swarm.agentCount || 0) + 1;
-            swarm.activeAgents = (swarm.activeAgents || 0) + 1;
-        }
-    }
-    // Track swarm creation
-    trackSwarm(swarmId, swarmData) {
-        this.swarms.set(swarmId, {
-            ...swarmData,
-            agentCount: 0,
-            activeAgents: 0,
-            taskCount: 0,
-            pendingTasks: 0,
-            completedTasks: 0,
-            createdAt: new Date().toISOString()
-        });
+ */
+
+class AgentTracker {
+  constructor() {
+    this.agents = new Map();
+    this.swarms = new Map();
+    this.tasks = new Map();
+  }
+
+  // Track agent spawn
+  trackAgent(agentId, agentData) {
+    this.agents.set(agentId, {
+      ...agentData,
+      createdAt: new Date().toISOString(),
+      lastActive: new Date().toISOString(),
+    });
+
+    // Update swarm agent count
+    if (agentData.swarmId && this.swarms.has(agentData.swarmId)) {
+      const swarm = this.swarms.get(agentData.swarmId);
+      swarm.agentCount = (swarm.agentCount || 0) + 1;
+      swarm.activeAgents = (swarm.activeAgents || 0) + 1;
     }
-    // Track task creation
-    trackTask(taskId, taskData) {
-        this.tasks.set(taskId, {
-            ...taskData,
-            createdAt: new Date().toISOString(),
-            status: taskData.status || 'pending'
-        });
-        // Update swarm task counts
-        if (taskData.swarmId && this.swarms.has(taskData.swarmId)) {
-            const swarm = this.swarms.get(taskData.swarmId);
-            swarm.taskCount = (swarm.taskCount || 0) + 1;
-            if (taskData.status === 'pending') {
-                swarm.pendingTasks = (swarm.pendingTasks || 0) + 1;
-            }
-        }
+  }
+
+  // Track swarm creation
+  trackSwarm(swarmId, swarmData) {
+    this.swarms.set(swarmId, {
+      ...swarmData,
+      agentCount: 0,
+      activeAgents: 0,
+      taskCount: 0,
+      pendingTasks: 0,
+      completedTasks: 0,
+      createdAt: new Date().toISOString(),
+    });
+  }
+
+  // Track task creation
+  trackTask(taskId, taskData) {
+    this.tasks.set(taskId, {
+      ...taskData,
+      createdAt: new Date().toISOString(),
+      status: taskData.status || 'pending',
+    });
+
+    // Update swarm task counts
+    if (taskData.swarmId && this.swarms.has(taskData.swarmId)) {
+      const swarm = this.swarms.get(taskData.swarmId);
+      swarm.taskCount = (swarm.taskCount || 0) + 1;
+      if (taskData.status === 'pending') {
+        swarm.pendingTasks = (swarm.pendingTasks || 0) + 1;
+      }
     }
-    // Get agents for a swarm
-    getAgents(swarmId) {
-        const agents = [];
-        for (const [id, agent] of this.agents){
-            if (!swarmId || agent.swarmId === swarmId) {
-                agents.push({
-                    id,
-                    ...agent
-                });
-            }
-        }
-        return agents;
+  }
+
+  // Get agents for a swarm
+  getAgents(swarmId) {
+    const agents = [];
+    for (const [id, agent] of this.agents) {
+      if (!swarmId || agent.swarmId === swarmId) {
+        agents.push({ id, ...agent });
+      }
     }
-    // Store task results
-    storeTaskResult(taskId, result) {
-        if (this.tasks.has(taskId)) {
-            const task = this.tasks.get(taskId);
-            task.result = result;
-            task.completedAt = new Date().toISOString();
-            this.updateTaskStatus(taskId, 'completed');
-            return true;
-        }
-        // Store even if task wasn't tracked
-        this.tasks.set(taskId, {
-            id: taskId,
-            result: result,
-            status: 'completed',
-            completedAt: new Date().toISOString()
-        });
-        return true;
+    return agents;
+  }
+
+  // Store task results
+  storeTaskResult(taskId, result) {
+    if (this.tasks.has(taskId)) {
+      const task = this.tasks.get(taskId);
+      task.result = result;
+      task.completedAt = new Date().toISOString();
+      this.updateTaskStatus(taskId, 'completed');
+      return true;
     }
-    // Get task results
-    getTaskResult(taskId) {
-        const task = this.tasks.get(taskId);
-        return task ? task.result : null;
+    // Store even if task wasn't tracked
+    this.tasks.set(taskId, {
+      id: taskId,
+      result: result,
+      status: 'completed',
+      completedAt: new Date().toISOString(),
+    });
+    return true;
+  }
+
+  // Get task results
+  getTaskResult(taskId) {
+    const task = this.tasks.get(taskId);
+    return task ? task.result : null;
+  }
+
+  // Get swarm status
+  getSwarmStatus(swarmId) {
+    if (!this.swarms.has(swarmId)) {
+      // If not tracked, return with real agent counts
+      const agents = this.getAgents(swarmId);
+      return {
+        swarmId,
+        agentCount: agents.length,
+        activeAgents: agents.filter((a) => a.status === 'active').length,
+        taskCount: 0,
+        pendingTasks: 0,
+        completedTasks: 0,
+      };
     }
-    // Get swarm status
-    getSwarmStatus(swarmId) {
-        if (!this.swarms.has(swarmId)) {
-            // If not tracked, return with real agent counts
-            const agents = this.getAgents(swarmId);
-            return {
-                swarmId,
-                agentCount: agents.length,
-                activeAgents: agents.filter((a)=>a.status === 'active').length,
-                taskCount: 0,
-                pendingTasks: 0,
-                completedTasks: 0
-            };
+    return this.swarms.get(swarmId);
+  }
+
+  // Update task status
+  updateTaskStatus(taskId, status) {
+    if (this.tasks.has(taskId)) {
+      const task = this.tasks.get(taskId);
+      const oldStatus = task.status;
+      task.status = status;
+      task.lastUpdated = new Date().toISOString();
+
+      // Update swarm counts
+      if (task.swarmId && this.swarms.has(task.swarmId)) {
+        const swarm = this.swarms.get(task.swarmId);
+
+        if (oldStatus === 'pending' && status !== 'pending') {
+          swarm.pendingTasks = Math.max(0, (swarm.pendingTasks || 0) - 1);
         }
-        return this.swarms.get(swarmId);
-    }
-    // Update task status
-    updateTaskStatus(taskId, status) {
-        if (this.tasks.has(taskId)) {
-            const task = this.tasks.get(taskId);
-            const oldStatus = task.status;
-            task.status = status;
-            task.lastUpdated = new Date().toISOString();
-            // Update swarm counts
-            if (task.swarmId && this.swarms.has(task.swarmId)) {
-                const swarm = this.swarms.get(task.swarmId);
-                if (oldStatus === 'pending' && status !== 'pending') {
-                    swarm.pendingTasks = Math.max(0, (swarm.pendingTasks || 0) - 1);
-                }
-                if (status === 'completed' && oldStatus !== 'completed') {
-                    swarm.completedTasks = (swarm.completedTasks || 0) + 1;
-                }
-            }
+        if (status === 'completed' && oldStatus !== 'completed') {
+          swarm.completedTasks = (swarm.completedTasks || 0) + 1;
         }
+      }
     }
-    constructor(){
-        this.agents = new Map();
-        this.swarms = new Map();
-        this.tasks = new Map();
-    }
-};
+  }
+}
+
 // Singleton instance
 const tracker = new AgentTracker();
+
 // Export for use in MCP tools
 if (typeof module !== 'undefined' && module.exports) {
-    module.exports = tracker;
+  module.exports = tracker;
 }
+
 // Also make available globally for the MCP server
 if (typeof global !== 'undefined') {
-    global.agentTracker = tracker;
+  global.agentTracker = tracker;
 }