@claude-flow/cli 3.0.0-alpha.13 → 3.0.0-alpha.14

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

@@ -1,466 +0,0 @@
-/**
- * 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',
-      };
-    },
-  },
-];