claude-flow 3.0.0-alpha.1 → 3.0.0-alpha.10

package/src/mcp-tools/agent-tools.ts

@@ -0,0 +1,466 @@
+/**
+ * Agent MCP Tools for CLI
+ *
+ * Tool definitions for agent lifecycle management with file persistence.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import type { MCPTool } from './types.js';
+
+// Storage paths
+const STORAGE_DIR = '.claude-flow';
+const AGENT_DIR = 'agents';
+const AGENT_FILE = 'store.json';
+
+interface AgentRecord {
+  agentId: string;
+  agentType: string;
+  status: 'idle' | 'busy' | 'terminated';
+  health: number;
+  taskCount: number;
+  config: Record<string, unknown>;
+  createdAt: string;
+  domain?: string;
+}
+
+interface AgentStore {
+  agents: Record<string, AgentRecord>;
+  version: string;
+}
+
+function getAgentDir(): string {
+  return join(process.cwd(), STORAGE_DIR, AGENT_DIR);
+}
+
+function getAgentPath(): string {
+  return join(getAgentDir(), AGENT_FILE);
+}
+
+function ensureAgentDir(): void {
+  const dir = getAgentDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function loadAgentStore(): AgentStore {
+  try {
+    const path = getAgentPath();
+    if (existsSync(path)) {
+      const data = readFileSync(path, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch {
+    // Return empty store on error
+  }
+  return { agents: {}, version: '3.0.0' };
+}
+
+function saveAgentStore(store: AgentStore): void {
+  ensureAgentDir();
+  writeFileSync(getAgentPath(), JSON.stringify(store, null, 2), 'utf-8');
+}
+
+export const agentTools: MCPTool[] = [
+  {
+    name: 'agent/spawn',
+    description: 'Spawn a new agent',
+    category: 'agent',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agentType: { type: 'string', description: 'Type of agent to spawn' },
+        agentId: { type: 'string', description: 'Optional custom agent ID' },
+        config: { type: 'object', description: 'Agent configuration' },
+        domain: { type: 'string', description: 'Agent domain' },
+      },
+      required: ['agentType'],
+    },
+    handler: async (input) => {
+      const store = loadAgentStore();
+      const agentId = (input.agentId as string) || `agent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+      const agent: AgentRecord = {
+        agentId,
+        agentType: input.agentType as string,
+        status: 'idle',
+        health: 1.0,
+        taskCount: 0,
+        config: (input.config as Record<string, unknown>) || {},
+        createdAt: new Date().toISOString(),
+        domain: input.domain as string,
+      };
+
+      store.agents[agentId] = agent;
+      saveAgentStore(store);
+
+      return {
+        success: true,
+        agentId,
+        agentType: agent.agentType,
+        status: 'spawned',
+        createdAt: agent.createdAt,
+      };
+    },
+  },
+  {
+    name: 'agent/terminate',
+    description: 'Terminate an agent',
+    category: 'agent',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agentId: { type: 'string', description: 'ID of agent to terminate' },
+        force: { type: 'boolean', description: 'Force immediate termination' },
+      },
+      required: ['agentId'],
+    },
+    handler: async (input) => {
+      const store = loadAgentStore();
+      const agentId = input.agentId as string;
+
+      if (store.agents[agentId]) {
+        store.agents[agentId].status = 'terminated';
+        saveAgentStore(store);
+        return {
+          success: true,
+          agentId,
+          terminated: true,
+          terminatedAt: new Date().toISOString(),
+        };
+      }
+
+      return {
+        success: false,
+        agentId,
+        error: 'Agent not found',
+      };
+    },
+  },
+  {
+    name: 'agent/status',
+    description: 'Get agent status',
+    category: 'agent',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agentId: { type: 'string', description: 'ID of agent' },
+      },
+      required: ['agentId'],
+    },
+    handler: async (input) => {
+      const store = loadAgentStore();
+      const agentId = input.agentId as string;
+      const agent = store.agents[agentId];
+
+      if (agent) {
+        return {
+          agentId: agent.agentId,
+          agentType: agent.agentType,
+          status: agent.status,
+          health: agent.health,
+          taskCount: agent.taskCount,
+          createdAt: agent.createdAt,
+          domain: agent.domain,
+        };
+      }
+
+      return {
+        agentId,
+        status: 'not_found',
+        error: 'Agent not found',
+      };
+    },
+  },
+  {
+    name: 'agent/list',
+    description: 'List all agents',
+    category: 'agent',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', description: 'Filter by status' },
+        domain: { type: 'string', description: 'Filter by domain' },
+        includeTerminated: { type: 'boolean', description: 'Include terminated agents' },
+      },
+    },
+    handler: async (input) => {
+      const store = loadAgentStore();
+      let agents = Object.values(store.agents);
+
+      // Filter by status
+      if (input.status) {
+        agents = agents.filter(a => a.status === input.status);
+      } else if (!input.includeTerminated) {
+        agents = agents.filter(a => a.status !== 'terminated');
+      }
+
+      // Filter by domain
+      if (input.domain) {
+        agents = agents.filter(a => a.domain === input.domain);
+      }
+
+      return {
+        agents: agents.map(a => ({
+          agentId: a.agentId,
+          agentType: a.agentType,
+          status: a.status,
+          health: a.health,
+          taskCount: a.taskCount,
+          createdAt: a.createdAt,
+          domain: a.domain,
+        })),
+        total: agents.length,
+        filters: {
+          status: input.status,
+          domain: input.domain,
+          includeTerminated: input.includeTerminated,
+        },
+      };
+    },
+  },
+  {
+    name: 'agent/pool',
+    description: 'Manage agent pool',
+    category: 'agent',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        action: { type: 'string', enum: ['status', 'scale', 'drain', 'fill'], description: 'Pool action' },
+        targetSize: { type: 'number', description: 'Target pool size (for scale action)' },
+        agentType: { type: 'string', description: 'Agent type filter' },
+      },
+      required: ['action'],
+    },
+    handler: async (input) => {
+      const store = loadAgentStore();
+      const agents = Object.values(store.agents).filter(a => a.status !== 'terminated');
+      const action = (input.action as string) || 'status';  // Default to status
+
+      if (action === 'status') {
+        const byType: Record<string, number> = {};
+        const byStatus: Record<string, number> = {};
+        for (const agent of agents) {
+          byType[agent.agentType] = (byType[agent.agentType] || 0) + 1;
+          byStatus[agent.status] = (byStatus[agent.status] || 0) + 1;
+        }
+        const idleAgents = agents.filter(a => a.status === 'idle').length;
+        const busyAgents = agents.filter(a => a.status === 'busy').length;
+        const utilization = agents.length > 0 ? busyAgents / agents.length : 0;
+        return {
+          action,
+          // CLI expected fields
+          poolId: 'agent-pool-default',
+          currentSize: agents.length,
+          minSize: (input.min as number) || 0,
+          maxSize: (input.max as number) || 100,
+          autoScale: (input.autoScale as boolean) ?? false,
+          utilization,
+          agents: agents.map(a => ({
+            id: a.agentId,
+            type: a.agentType,
+            status: a.status,
+          })),
+          // Additional fields
+          id: 'agent-pool-default',
+          size: agents.length,
+          totalAgents: agents.length,
+          byType,
+          byStatus,
+          avgHealth: agents.length > 0 ? agents.reduce((sum, a) => sum + a.health, 0) / agents.length : 0,
+        };
+      }
+
+      if (action === 'scale') {
+        const targetSize = (input.targetSize as number) || 5;
+        const agentType = (input.agentType as string) || 'worker';
+        const currentSize = agents.filter(a => a.agentType === agentType).length;
+        const delta = targetSize - currentSize;
+        const added: string[] = [];
+        const removed: string[] = [];
+
+        if (delta > 0) {
+          for (let i = 0; i < delta; i++) {
+            const agentId = `agent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            store.agents[agentId] = {
+              agentId,
+              agentType,
+              status: 'idle',
+              health: 1.0,
+              taskCount: 0,
+              config: {},
+              createdAt: new Date().toISOString(),
+            };
+            added.push(agentId);
+          }
+        } else if (delta < 0) {
+          const toRemove = agents.filter(a => a.agentType === agentType && a.status === 'idle').slice(0, -delta);
+          for (const agent of toRemove) {
+            store.agents[agent.agentId].status = 'terminated';
+            removed.push(agent.agentId);
+          }
+        }
+
+        saveAgentStore(store);
+        return {
+          action,
+          agentType,
+          previousSize: currentSize,
+          targetSize,
+          newSize: currentSize + delta,
+          added,
+          removed,
+        };
+      }
+
+      if (action === 'drain') {
+        const agentType = input.agentType as string;
+        let drained = 0;
+        for (const agent of agents) {
+          if (!agentType || agent.agentType === agentType) {
+            if (agent.status === 'idle') {
+              store.agents[agent.agentId].status = 'terminated';
+              drained++;
+            }
+          }
+        }
+        saveAgentStore(store);
+        return {
+          action,
+          agentType: agentType || 'all',
+          drained,
+          remaining: agents.length - drained,
+        };
+      }
+
+      return { action, error: 'Unknown action' };
+    },
+  },
+  {
+    name: 'agent/health',
+    description: 'Check agent health',
+    category: 'agent',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agentId: { type: 'string', description: 'Specific agent ID (optional)' },
+        threshold: { type: 'number', description: 'Health threshold (0-1)' },
+      },
+    },
+    handler: async (input) => {
+      const store = loadAgentStore();
+      const agents = Object.values(store.agents).filter(a => a.status !== 'terminated');
+      const threshold = (input.threshold as number) || 0.5;
+
+      if (input.agentId) {
+        const agent = store.agents[input.agentId as string];
+        if (agent) {
+          return {
+            agentId: agent.agentId,
+            health: agent.health,
+            status: agent.status,
+            healthy: agent.health >= threshold,
+            taskCount: agent.taskCount,
+            uptime: Date.now() - new Date(agent.createdAt).getTime(),
+          };
+        }
+        return { agentId: input.agentId, error: 'Agent not found' };
+      }
+
+      const healthyAgents = agents.filter(a => a.health >= threshold);
+      const degradedAgents = agents.filter(a => a.health >= 0.3 && a.health < threshold);
+      const unhealthyAgents = agents.filter(a => a.health < 0.3);
+      const avgHealth = agents.length > 0 ? agents.reduce((sum, a) => sum + a.health, 0) / agents.length : 1;
+      const avgCpu = agents.length > 0 ? 35 + Math.random() * 30 : 0; // Simulated CPU
+      const avgMemory = avgHealth * 0.6; // Correlated with health
+
+      return {
+        // CLI expected fields
+        agents: agents.map(a => {
+          const uptime = Date.now() - new Date(a.createdAt).getTime();
+          return {
+            id: a.agentId,
+            type: a.agentType,
+            health: a.health >= threshold ? 'healthy' : (a.health >= 0.3 ? 'degraded' : 'unhealthy'),
+            uptime,
+            memory: { used: Math.floor(256 * (1 - a.health * 0.3)), limit: 512 },
+            cpu: 20 + Math.floor(a.health * 40),
+            tasks: { active: a.taskCount > 0 ? 1 : 0, queued: 0, completed: a.taskCount, failed: 0 },
+            latency: { avg: 50 + Math.floor((1 - a.health) * 100), p99: 150 + Math.floor((1 - a.health) * 200) },
+            errors: { count: a.health < threshold ? 1 : 0 },
+          };
+        }),
+        overall: {
+          healthy: healthyAgents.length,
+          degraded: degradedAgents.length,
+          unhealthy: unhealthyAgents.length,
+          avgCpu,
+          avgMemory,
+          score: Math.round(avgHealth * 100),
+          issues: unhealthyAgents.length,
+        },
+        // Additional fields
+        total: agents.length,
+        healthyCount: healthyAgents.length,
+        unhealthyCount: unhealthyAgents.length,
+        threshold,
+        avgHealth,
+        unhealthyAgents: unhealthyAgents.map(a => ({
+          agentId: a.agentId,
+          health: a.health,
+          status: a.status,
+        })),
+      };
+    },
+  },
+  {
+    name: 'agent/update',
+    description: 'Update agent status or config',
+    category: 'agent',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agentId: { type: 'string', description: 'ID of agent' },
+        status: { type: 'string', description: 'New status' },
+        health: { type: 'number', description: 'Health value (0-1)' },
+        taskCount: { type: 'number', description: 'Task count' },
+        config: { type: 'object', description: 'Config updates' },
+      },
+      required: ['agentId'],
+    },
+    handler: async (input) => {
+      const store = loadAgentStore();
+      const agentId = input.agentId as string;
+      const agent = store.agents[agentId];
+
+      if (agent) {
+        if (input.status) agent.status = input.status as AgentRecord['status'];
+        if (typeof input.health === 'number') agent.health = input.health as number;
+        if (typeof input.taskCount === 'number') agent.taskCount = input.taskCount as number;
+        if (input.config) {
+          agent.config = { ...agent.config, ...(input.config as Record<string, unknown>) };
+        }
+        saveAgentStore(store);
+
+        return {
+          success: true,
+          agentId,
+          updated: true,
+          agent: {
+            agentId: agent.agentId,
+            status: agent.status,
+            health: agent.health,
+            taskCount: agent.taskCount,
+          },
+        };
+      }
+
+      return {
+        success: false,
+        agentId,
+        error: 'Agent not found',
+      };
+    },
+  },
+];