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

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

@@ -1,105 +0,0 @@
-/**
- * Swarm MCP Tools for CLI
- *
- * Tool definitions for swarm coordination.
- */
-
-import type { MCPTool } from './types.js';
-
-export const swarmTools: MCPTool[] = [
-  {
-    name: 'swarm/init',
-    description: 'Initialize a swarm',
-    category: 'swarm',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        topology: { type: 'string', description: 'Swarm topology type' },
-        maxAgents: { type: 'number', description: 'Maximum number of agents' },
-        config: { type: 'object', description: 'Swarm configuration' },
-      },
-    },
-    handler: async (input) => {
-      const topology = input.topology || 'hierarchical-mesh';
-      const maxAgents = input.maxAgents || 15;
-      const config = (input.config || {}) as Record<string, unknown>;
-
-      return {
-        success: true,
-        swarmId: `swarm-${Date.now()}`,
-        topology,
-        initializedAt: new Date().toISOString(),
-        config: {
-          topology,
-          maxAgents,
-          currentAgents: 0,
-          communicationProtocol: (config.communicationProtocol as string) || 'message-bus',
-          autoScaling: (config.autoScaling as boolean) ?? true,
-          consensusMechanism: (config.consensusMechanism as string) || 'majority',
-        },
-      };
-    },
-  },
-  {
-    name: 'swarm/status',
-    description: 'Get swarm status',
-    category: 'swarm',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        swarmId: { type: 'string', description: 'Swarm ID' },
-      },
-    },
-    handler: async (input) => {
-      return {
-        swarmId: input.swarmId,
-        status: 'running',
-        agentCount: 0,
-        taskCount: 0,
-      };
-    },
-  },
-  {
-    name: 'swarm/shutdown',
-    description: 'Shutdown a swarm',
-    category: 'swarm',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        swarmId: { type: 'string', description: 'Swarm ID' },
-        graceful: { type: 'boolean', description: 'Graceful shutdown' },
-      },
-    },
-    handler: async (input) => {
-      return {
-        success: true,
-        swarmId: input.swarmId,
-        terminated: true,
-      };
-    },
-  },
-  {
-    name: 'swarm/health',
-    description: 'Check swarm health status',
-    category: 'swarm',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        swarmId: { type: 'string', description: 'Swarm ID to check' },
-      },
-    },
-    handler: async (input) => {
-      return {
-        status: 'healthy' as const,
-        swarmId: input.swarmId || 'default',
-        checks: [
-          { name: 'coordinator', status: 'ok', message: 'Coordinator responding' },
-          { name: 'agents', status: 'ok', message: 'Agent pool healthy' },
-          { name: 'memory', status: 'ok', message: 'Memory backend connected' },
-          { name: 'messaging', status: 'ok', message: 'Message bus active' },
-        ],
-        checkedAt: new Date().toISOString(),
-      };
-    },
-  },
-];

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

@@ -1,347 +0,0 @@
-/**
- * Task MCP Tools for CLI
- *
- * Tool definitions for task 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 TASK_DIR = 'tasks';
-const TASK_FILE = 'store.json';
-
-interface TaskRecord {
-  taskId: string;
-  type: string;
-  description: string;
-  priority: 'low' | 'normal' | 'high' | 'critical';
-  status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
-  progress: number;
-  assignedTo: string[];
-  tags: string[];
-  createdAt: string;
-  startedAt: string | null;
-  completedAt: string | null;
-  result?: Record<string, unknown>;
-}
-
-interface TaskStore {
-  tasks: Record<string, TaskRecord>;
-  version: string;
-}
-
-function getTaskDir(): string {
-  return join(process.cwd(), STORAGE_DIR, TASK_DIR);
-}
-
-function getTaskPath(): string {
-  return join(getTaskDir(), TASK_FILE);
-}
-
-function ensureTaskDir(): void {
-  const dir = getTaskDir();
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-
-function loadTaskStore(): TaskStore {
-  try {
-    const path = getTaskPath();
-    if (existsSync(path)) {
-      const data = readFileSync(path, 'utf-8');
-      return JSON.parse(data);
-    }
-  } catch {
-    // Return empty store on error
-  }
-  return { tasks: {}, version: '3.0.0' };
-}
-
-function saveTaskStore(store: TaskStore): void {
-  ensureTaskDir();
-  writeFileSync(getTaskPath(), JSON.stringify(store, null, 2), 'utf-8');
-}
-
-export const taskTools: MCPTool[] = [
-  {
-    name: 'task/create',
-    description: 'Create a new task',
-    category: 'task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        type: { type: 'string', description: 'Task type (feature, bugfix, research, refactor)' },
-        description: { type: 'string', description: 'Task description' },
-        priority: { type: 'string', description: 'Task priority (low, normal, high, critical)' },
-        assignTo: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
-        tags: { type: 'array', items: { type: 'string' }, description: 'Task tags' },
-      },
-      required: ['type', 'description'],
-    },
-    handler: async (input) => {
-      const store = loadTaskStore();
-      const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-
-      const task: TaskRecord = {
-        taskId,
-        type: input.type as string,
-        description: input.description as string,
-        priority: (input.priority as TaskRecord['priority']) || 'normal',
-        status: 'pending',
-        progress: 0,
-        assignedTo: (input.assignTo as string[]) || [],
-        tags: (input.tags as string[]) || [],
-        createdAt: new Date().toISOString(),
-        startedAt: null,
-        completedAt: null,
-      };
-
-      store.tasks[taskId] = task;
-      saveTaskStore(store);
-
-      return {
-        taskId,
-        type: task.type,
-        description: task.description,
-        priority: task.priority,
-        status: task.status,
-        createdAt: task.createdAt,
-        assignedTo: task.assignedTo,
-        tags: task.tags,
-      };
-    },
-  },
-  {
-    name: 'task/status',
-    description: 'Get task status',
-    category: 'task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        taskId: { type: 'string', description: 'Task ID' },
-      },
-      required: ['taskId'],
-    },
-    handler: async (input) => {
-      const store = loadTaskStore();
-      const taskId = input.taskId as string;
-      const task = store.tasks[taskId];
-
-      if (task) {
-        return {
-          taskId: task.taskId,
-          type: task.type,
-          description: task.description,
-          status: task.status,
-          progress: task.progress,
-          priority: task.priority,
-          assignedTo: task.assignedTo,
-          tags: task.tags,
-          createdAt: task.createdAt,
-          startedAt: task.startedAt,
-          completedAt: task.completedAt,
-        };
-      }
-
-      return {
-        taskId,
-        status: 'not_found',
-        error: 'Task not found',
-      };
-    },
-  },
-  {
-    name: 'task/list',
-    description: 'List all tasks',
-    category: 'task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        status: { type: 'string', description: 'Filter by status' },
-        type: { type: 'string', description: 'Filter by type' },
-        assignedTo: { type: 'string', description: 'Filter by assigned agent' },
-        priority: { type: 'string', description: 'Filter by priority' },
-        limit: { type: 'number', description: 'Max tasks to return' },
-      },
-    },
-    handler: async (input) => {
-      const store = loadTaskStore();
-      let tasks = Object.values(store.tasks);
-
-      // Apply filters
-      if (input.status) {
-        // Support comma-separated status values
-        const statuses = (input.status as string).split(',').map(s => s.trim());
-        tasks = tasks.filter(t => statuses.includes(t.status));
-      }
-      if (input.type) {
-        tasks = tasks.filter(t => t.type === input.type);
-      }
-      if (input.assignedTo) {
-        tasks = tasks.filter(t => t.assignedTo.includes(input.assignedTo as string));
-      }
-      if (input.priority) {
-        tasks = tasks.filter(t => t.priority === input.priority);
-      }
-
-      // Sort by creation date (newest first)
-      tasks.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-
-      // Apply limit
-      const limit = (input.limit as number) || 50;
-      tasks = tasks.slice(0, limit);
-
-      return {
-        tasks: tasks.map(t => ({
-          taskId: t.taskId,
-          type: t.type,
-          description: t.description,
-          status: t.status,
-          progress: t.progress,
-          priority: t.priority,
-          assignedTo: t.assignedTo,
-          createdAt: t.createdAt,
-        })),
-        total: tasks.length,
-        filters: {
-          status: input.status,
-          type: input.type,
-          assignedTo: input.assignedTo,
-          priority: input.priority,
-        },
-      };
-    },
-  },
-  {
-    name: 'task/complete',
-    description: 'Mark task as complete',
-    category: 'task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        taskId: { type: 'string', description: 'Task ID' },
-        result: { type: 'object', description: 'Task result data' },
-      },
-      required: ['taskId'],
-    },
-    handler: async (input) => {
-      const store = loadTaskStore();
-      const taskId = input.taskId as string;
-      const task = store.tasks[taskId];
-
-      if (task) {
-        task.status = 'completed';
-        task.progress = 100;
-        task.completedAt = new Date().toISOString();
-        task.result = (input.result as Record<string, unknown>) || {};
-        saveTaskStore(store);
-
-        return {
-          taskId: task.taskId,
-          status: task.status,
-          completedAt: task.completedAt,
-          result: task.result,
-        };
-      }
-
-      return {
-        taskId,
-        status: 'not_found',
-        error: 'Task not found',
-      };
-    },
-  },
-  {
-    name: 'task/update',
-    description: 'Update task status or progress',
-    category: 'task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        taskId: { type: 'string', description: 'Task ID' },
-        status: { type: 'string', description: 'New status' },
-        progress: { type: 'number', description: 'Progress percentage (0-100)' },
-        assignTo: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to assign' },
-      },
-      required: ['taskId'],
-    },
-    handler: async (input) => {
-      const store = loadTaskStore();
-      const taskId = input.taskId as string;
-      const task = store.tasks[taskId];
-
-      if (task) {
-        if (input.status) {
-          const newStatus = input.status as TaskRecord['status'];
-          task.status = newStatus;
-          if (newStatus === 'in_progress' && !task.startedAt) {
-            task.startedAt = new Date().toISOString();
-          }
-        }
-        if (typeof input.progress === 'number') {
-          task.progress = Math.min(100, Math.max(0, input.progress as number));
-        }
-        if (input.assignTo) {
-          task.assignedTo = input.assignTo as string[];
-        }
-        saveTaskStore(store);
-
-        return {
-          success: true,
-          taskId: task.taskId,
-          status: task.status,
-          progress: task.progress,
-          assignedTo: task.assignedTo,
-        };
-      }
-
-      return {
-        success: false,
-        taskId,
-        error: 'Task not found',
-      };
-    },
-  },
-  {
-    name: 'task/cancel',
-    description: 'Cancel a task',
-    category: 'task',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        taskId: { type: 'string', description: 'Task ID' },
-        reason: { type: 'string', description: 'Cancellation reason' },
-      },
-      required: ['taskId'],
-    },
-    handler: async (input) => {
-      const store = loadTaskStore();
-      const taskId = input.taskId as string;
-      const task = store.tasks[taskId];
-
-      if (task) {
-        task.status = 'cancelled';
-        task.completedAt = new Date().toISOString();
-        task.result = { cancelReason: input.reason || 'Cancelled by user' };
-        saveTaskStore(store);
-
-        return {
-          success: true,
-          taskId: task.taskId,
-          status: task.status,
-          cancelledAt: task.completedAt,
-        };
-      }
-
-      return {
-        success: false,
-        taskId,
-        error: 'Task not found',
-      };
-    },
-  },
-];

package/src/mcp-tools/types.ts

@@ -1,33 +0,0 @@
-/**
- * MCP Tool Types for CLI
- *
- * Local type definitions to avoid external imports outside package boundary.
- */
-
-export interface MCPToolInputSchema {
-  type: 'object';
-  properties: Record<string, unknown>;
-  required?: string[];
-}
-
-export interface MCPToolResult {
-  content: Array<{
-    type: 'text' | 'image' | 'resource';
-    text?: string;
-    data?: string;
-    mimeType?: string;
-  }>;
-  isError?: boolean;
-}
-
-export interface MCPTool {
-  name: string;
-  description: string;
-  inputSchema: MCPToolInputSchema;
-  category?: string;
-  tags?: string[];
-  version?: string;
-  cacheable?: boolean;
-  cacheTTL?: number;
-  handler: (input: Record<string, unknown>, context?: Record<string, unknown>) => Promise<MCPToolResult | unknown>;
-}