@claude-flow/swarm 3.0.0-alpha.7 → 3.0.0-alpha.9

package/src/coordination/agent-registry.ts

@@ -1,544 +0,0 @@
-/**
- * V3 Agent Registry
- * Manages registration, lifecycle, and capabilities of all 15 agents
- *
- * Based on ADR-002 (DDD) and 15-Agent Swarm Architecture
- */
-
-import {
-  AgentId,
-  AgentRole,
-  AgentDomain,
-  AgentStatus,
-  AgentDefinition,
-  AgentState,
-  AgentCapability,
-  AgentMetrics,
-  TaskType,
-  TaskId,
-  SwarmEvent,
-  EventHandler
-} from '../shared/types';
-import {
-  IEventBus,
-  agentSpawnedEvent,
-  agentStatusChangedEvent,
-  agentErrorEvent
-} from '../shared/events';
-
-// =============================================================================
-// Agent Registry Interface
-// =============================================================================
-
-export interface IAgentRegistry {
-  // Registration
-  register(definition: AgentDefinition): void;
-  unregister(agentId: AgentId): boolean;
-  isRegistered(agentId: AgentId): boolean;
-
-  // Lifecycle
-  spawn(agentId: AgentId): Promise<AgentState>;
-  terminate(agentId: AgentId): Promise<boolean>;
-
-  // State Management
-  getState(agentId: AgentId): AgentState | undefined;
-  updateStatus(agentId: AgentId, status: AgentStatus): void;
-  assignTask(agentId: AgentId, taskId: TaskId): void;
-  completeTask(agentId: AgentId, taskId: TaskId): void;
-
-  // Queries
-  getDefinition(agentId: AgentId): AgentDefinition | undefined;
-  getAllAgents(): AgentDefinition[];
-  getActiveAgents(): AgentState[];
-  getAgentsByDomain(domain: AgentDomain): AgentDefinition[];
-  getAgentsByCapability(taskType: TaskType): AgentDefinition[];
-
-  // Health
-  heartbeat(agentId: AgentId): void;
-  getHealthStatus(): Map<AgentId, HealthStatus>;
-
-  // Events
-  onAgentEvent(handler: EventHandler): () => void;
-}
-
-export interface HealthStatus {
-  agentId: AgentId;
-  healthy: boolean;
-  lastHeartbeat: number;
-  consecutiveMisses: number;
-  status: AgentStatus;
-}
-
-// =============================================================================
-// Agent Registry Implementation
-// =============================================================================
-
-export class AgentRegistry implements IAgentRegistry {
-  private definitions: Map<AgentId, AgentDefinition> = new Map();
-  private states: Map<AgentId, AgentState> = new Map();
-  private healthChecks: Map<AgentId, HealthStatus> = new Map();
-  private eventBus: IEventBus;
-  private healthCheckInterval: number = 5000;
-  private healthCheckTimer: ReturnType<typeof setInterval> | null = null;
-  private maxMissedHeartbeats: number = 3;
-
-  constructor(eventBus: IEventBus) {
-    this.eventBus = eventBus;
-    this.registerDefaultAgents();
-  }
-
-  // ==========================================================================
-  // Registration
-  // ==========================================================================
-
-  register(definition: AgentDefinition): void {
-    if (this.definitions.has(definition.id)) {
-      throw new Error(`Agent ${definition.id} is already registered`);
-    }
-
-    this.definitions.set(definition.id, definition);
-
-    this.healthChecks.set(definition.id, {
-      agentId: definition.id,
-      healthy: false,
-      lastHeartbeat: 0,
-      consecutiveMisses: 0,
-      status: 'idle'
-    });
-  }
-
-  unregister(agentId: AgentId): boolean {
-    if (this.states.has(agentId)) {
-      throw new Error(`Cannot unregister active agent ${agentId}`);
-    }
-
-    this.healthChecks.delete(agentId);
-    return this.definitions.delete(agentId);
-  }
-
-  isRegistered(agentId: AgentId): boolean {
-    return this.definitions.has(agentId);
-  }
-
-  // ==========================================================================
-  // Lifecycle
-  // ==========================================================================
-
-  async spawn(agentId: AgentId): Promise<AgentState> {
-    const definition = this.definitions.get(agentId);
-    if (!definition) {
-      throw new Error(`Agent ${agentId} is not registered`);
-    }
-
-    if (this.states.has(agentId)) {
-      throw new Error(`Agent ${agentId} is already spawned`);
-    }
-
-    const state: AgentState = {
-      id: agentId,
-      role: definition.role,
-      status: 'idle',
-      currentTask: null,
-      completedTasks: [],
-      metrics: this.createInitialMetrics(),
-      lastHeartbeat: Date.now()
-    };
-
-    this.states.set(agentId, state);
-
-    const healthStatus = this.healthChecks.get(agentId)!;
-    healthStatus.healthy = true;
-    healthStatus.lastHeartbeat = Date.now();
-    healthStatus.status = 'idle';
-
-    await this.eventBus.emit(agentSpawnedEvent(agentId, definition.role));
-
-    return state;
-  }
-
-  async terminate(agentId: AgentId): Promise<boolean> {
-    const state = this.states.get(agentId);
-    if (!state) {
-      return false;
-    }
-
-    if (state.currentTask) {
-      throw new Error(`Cannot terminate agent ${agentId} with active task ${state.currentTask}`);
-    }
-
-    this.states.delete(agentId);
-
-    const healthStatus = this.healthChecks.get(agentId);
-    if (healthStatus) {
-      healthStatus.healthy = false;
-      healthStatus.status = 'idle';
-    }
-
-    await this.eventBus.emit(agentStatusChangedEvent(agentId, state.status, 'terminated'));
-
-    return true;
-  }
-
-  // ==========================================================================
-  // State Management
-  // ==========================================================================
-
-  getState(agentId: AgentId): AgentState | undefined {
-    return this.states.get(agentId);
-  }
-
-  updateStatus(agentId: AgentId, status: AgentStatus): void {
-    const state = this.states.get(agentId);
-    if (!state) {
-      throw new Error(`Agent ${agentId} is not spawned`);
-    }
-
-    const previousStatus = state.status;
-    state.status = status;
-
-    const healthStatus = this.healthChecks.get(agentId);
-    if (healthStatus) {
-      healthStatus.status = status;
-    }
-
-    this.eventBus.emitSync(agentStatusChangedEvent(agentId, previousStatus, status));
-  }
-
-  assignTask(agentId: AgentId, taskId: TaskId): void {
-    const state = this.states.get(agentId);
-    if (!state) {
-      throw new Error(`Agent ${agentId} is not spawned`);
-    }
-
-    if (state.currentTask) {
-      throw new Error(`Agent ${agentId} already has task ${state.currentTask}`);
-    }
-
-    state.currentTask = taskId;
-    this.updateStatus(agentId, 'active');
-  }
-
-  completeTask(agentId: AgentId, taskId: TaskId): void {
-    const state = this.states.get(agentId);
-    if (!state) {
-      throw new Error(`Agent ${agentId} is not spawned`);
-    }
-
-    if (state.currentTask !== taskId) {
-      throw new Error(`Agent ${agentId} current task is ${state.currentTask}, not ${taskId}`);
-    }
-
-    state.completedTasks.push(taskId);
-    state.currentTask = null;
-    state.metrics.tasksCompleted++;
-
-    this.updateStatus(agentId, 'idle');
-  }
-
-  // ==========================================================================
-  // Queries
-  // ==========================================================================
-
-  getDefinition(agentId: AgentId): AgentDefinition | undefined {
-    return this.definitions.get(agentId);
-  }
-
-  getAllAgents(): AgentDefinition[] {
-    return Array.from(this.definitions.values());
-  }
-
-  getActiveAgents(): AgentState[] {
-    return Array.from(this.states.values()).filter(s => s.status === 'active');
-  }
-
-  getAgentsByDomain(domain: AgentDomain): AgentDefinition[] {
-    return Array.from(this.definitions.values()).filter(d => d.domain === domain);
-  }
-
-  getAgentsByCapability(taskType: TaskType): AgentDefinition[] {
-    return Array.from(this.definitions.values()).filter(d =>
-      d.capabilities.some(c => c.supportedTaskTypes.includes(taskType))
-    );
-  }
-
-  // ==========================================================================
-  // Health Management
-  // ==========================================================================
-
-  heartbeat(agentId: AgentId): void {
-    const state = this.states.get(agentId);
-    if (state) {
-      state.lastHeartbeat = Date.now();
-    }
-
-    const healthStatus = this.healthChecks.get(agentId);
-    if (healthStatus) {
-      healthStatus.lastHeartbeat = Date.now();
-      healthStatus.consecutiveMisses = 0;
-      healthStatus.healthy = true;
-    }
-  }
-
-  getHealthStatus(): Map<AgentId, HealthStatus> {
-    return new Map(this.healthChecks);
-  }
-
-  startHealthChecks(): void {
-    if (this.healthCheckTimer) {
-      return;
-    }
-
-    this.healthCheckTimer = setInterval(() => {
-      this.performHealthCheck();
-    }, this.healthCheckInterval);
-  }
-
-  stopHealthChecks(): void {
-    if (this.healthCheckTimer) {
-      clearInterval(this.healthCheckTimer);
-      this.healthCheckTimer = null;
-    }
-  }
-
-  private performHealthCheck(): void {
-    const now = Date.now();
-
-    for (const [agentId, healthStatus] of this.healthChecks) {
-      const state = this.states.get(agentId);
-      if (!state) {
-        continue;
-      }
-
-      const timeSinceHeartbeat = now - healthStatus.lastHeartbeat;
-
-      if (timeSinceHeartbeat > this.healthCheckInterval) {
-        healthStatus.consecutiveMisses++;
-
-        if (healthStatus.consecutiveMisses >= this.maxMissedHeartbeats) {
-          healthStatus.healthy = false;
-          this.updateStatus(agentId, 'error');
-
-          this.eventBus.emitSync(agentErrorEvent(
-            agentId,
-            new Error(`Agent ${agentId} missed ${healthStatus.consecutiveMisses} heartbeats`)
-          ));
-        }
-      }
-    }
-  }
-
-  // ==========================================================================
-  // Events
-  // ==========================================================================
-
-  onAgentEvent(handler: EventHandler): () => void {
-    const unsubscribers = [
-      this.eventBus.subscribe('agent:spawned', handler),
-      this.eventBus.subscribe('agent:status-changed', handler),
-      this.eventBus.subscribe('agent:task-assigned', handler),
-      this.eventBus.subscribe('agent:task-completed', handler),
-      this.eventBus.subscribe('agent:error', handler)
-    ];
-
-    return () => {
-      unsubscribers.forEach(unsub => unsub());
-    };
-  }
-
-  // ==========================================================================
-  // Default Agent Registration
-  // ==========================================================================
-
-  private registerDefaultAgents(): void {
-    const agentDefinitions: AgentDefinition[] = [
-      {
-        id: 'agent-1',
-        role: 'queen-coordinator',
-        domain: 'core',
-        description: 'Orchestration & GitHub Issue management for all 15 agents',
-        capabilities: [
-          { name: 'orchestration', description: 'Coordinate all agents', supportedTaskTypes: ['architecture-design'] },
-          { name: 'github-management', description: 'Manage GitHub issues and PRs', supportedTaskTypes: ['documentation'] }
-        ],
-        dependencies: [],
-        priority: 1
-      },
-      {
-        id: 'agent-2',
-        role: 'security-architect',
-        domain: 'security',
-        description: 'Security architecture review and design',
-        capabilities: [
-          { name: 'security-design', description: 'Design security architecture', supportedTaskTypes: ['security-audit', 'architecture-design'] }
-        ],
-        dependencies: [],
-        priority: 2
-      },
-      {
-        id: 'agent-3',
-        role: 'security-implementer',
-        domain: 'security',
-        description: 'CVE fixes and security code implementation',
-        capabilities: [
-          { name: 'security-implementation', description: 'Implement security fixes', supportedTaskTypes: ['security-fix', 'implementation'] }
-        ],
-        dependencies: ['agent-2'],
-        priority: 2
-      },
-      {
-        id: 'agent-4',
-        role: 'security-tester',
-        domain: 'security',
-        description: 'Security testing using TDD London School methodology',
-        capabilities: [
-          { name: 'security-testing', description: 'Write and run security tests', supportedTaskTypes: ['security-test', 'test-writing'] }
-        ],
-        dependencies: ['agent-2'],
-        priority: 2
-      },
-      {
-        id: 'agent-5',
-        role: 'core-architect',
-        domain: 'core',
-        description: 'Core module DDD architecture design',
-        capabilities: [
-          { name: 'architecture', description: 'Design core architecture', supportedTaskTypes: ['architecture-design'] }
-        ],
-        dependencies: ['agent-2'],
-        priority: 3
-      },
-      {
-        id: 'agent-6',
-        role: 'core-implementer',
-        domain: 'core',
-        description: 'Core module implementation and type system modernization',
-        capabilities: [
-          { name: 'core-implementation', description: 'Implement core modules', supportedTaskTypes: ['implementation'] }
-        ],
-        dependencies: ['agent-5'],
-        priority: 3
-      },
-      {
-        id: 'agent-7',
-        role: 'memory-specialist',
-        domain: 'core',
-        description: 'Memory system unification with AgentDB (150x-12500x improvement)',
-        capabilities: [
-          { name: 'memory-optimization', description: 'Optimize memory systems', supportedTaskTypes: ['memory-optimization', 'implementation'] }
-        ],
-        dependencies: ['agent-5'],
-        priority: 4
-      },
-      {
-        id: 'agent-8',
-        role: 'swarm-specialist',
-        domain: 'core',
-        description: 'Single SwarmCoordinator (merge 4 systems)',
-        capabilities: [
-          { name: 'swarm-coordination', description: 'Design swarm coordination', supportedTaskTypes: ['swarm-coordination', 'implementation'] }
-        ],
-        dependencies: ['agent-5'],
-        priority: 4
-      },
-      {
-        id: 'agent-9',
-        role: 'mcp-specialist',
-        domain: 'core',
-        description: 'MCP server optimization and enhancement',
-        capabilities: [
-          { name: 'mcp-optimization', description: 'Optimize MCP server', supportedTaskTypes: ['mcp-enhancement', 'implementation'] }
-        ],
-        dependencies: ['agent-5'],
-        priority: 4
-      },
-      {
-        id: 'agent-10',
-        role: 'integration-architect',
-        domain: 'integration',
-        description: 'agentic-flow@alpha deep integration',
-        capabilities: [
-          { name: 'integration', description: 'Integrate with agentic-flow', supportedTaskTypes: ['integration', 'architecture-design'] }
-        ],
-        dependencies: ['agent-5', 'agent-7', 'agent-8', 'agent-9'],
-        priority: 5
-      },
-      {
-        id: 'agent-11',
-        role: 'cli-hooks-developer',
-        domain: 'integration',
-        description: 'CLI modernization and hooks system development',
-        capabilities: [
-          { name: 'cli-development', description: 'Develop CLI and hooks', supportedTaskTypes: ['cli-development', 'implementation'] }
-        ],
-        dependencies: ['agent-9', 'agent-10'],
-        priority: 5
-      },
-      {
-        id: 'agent-12',
-        role: 'neural-learning-dev',
-        domain: 'integration',
-        description: 'Neural and SONA learning system integration',
-        capabilities: [
-          { name: 'neural-training', description: 'Implement neural features', supportedTaskTypes: ['neural-training', 'implementation'] }
-        ],
-        dependencies: ['agent-7', 'agent-10'],
-        priority: 5
-      },
-      {
-        id: 'agent-13',
-        role: 'tdd-test-engineer',
-        domain: 'quality',
-        description: 'TDD London School methodology implementation',
-        capabilities: [
-          { name: 'testing', description: 'Write comprehensive tests', supportedTaskTypes: ['test-writing'] }
-        ],
-        dependencies: [],
-        priority: 3
-      },
-      {
-        id: 'agent-14',
-        role: 'performance-engineer',
-        domain: 'performance',
-        description: 'Benchmarking and performance optimization (2.49x-7.47x target)',
-        capabilities: [
-          { name: 'benchmarking', description: 'Run performance benchmarks', supportedTaskTypes: ['benchmark'] }
-        ],
-        dependencies: ['agent-7', 'agent-8'],
-        priority: 6
-      },
-      {
-        id: 'agent-15',
-        role: 'release-engineer',
-        domain: 'deployment',
-        description: 'Deployment pipeline and release management',
-        capabilities: [
-          { name: 'deployment', description: 'Manage releases', supportedTaskTypes: ['deployment', 'documentation'] }
-        ],
-        dependencies: ['agent-10', 'agent-13', 'agent-14'],
-        priority: 7
-      }
-    ];
-
-    for (const definition of agentDefinitions) {
-      this.register(definition);
-    }
-  }
-
-  private createInitialMetrics(): AgentMetrics {
-    return {
-      tasksCompleted: 0,
-      tasksFailed: 0,
-      averageTaskDuration: 0,
-      utilization: 0,
-      startTime: Date.now()
-    };
-  }
-}
-
-// =============================================================================
-// Factory Function
-// =============================================================================
-
-export function createAgentRegistry(eventBus: IEventBus): IAgentRegistry {
-  return new AgentRegistry(eventBus);
-}

package/src/coordination/index.ts

@@ -1,23 +0,0 @@
-/**
- * Coordination Components
- * Agent registry, task orchestration, and swarm hub
- */
-
-export {
-  AgentRegistry,
-  createAgentRegistry,
-  type IAgentRegistry,
-} from './agent-registry.js';
-
-export {
-  TaskOrchestrator,
-  createTaskOrchestrator,
-  type ITaskOrchestrator,
-  type TaskSpec,
-} from './task-orchestrator.js';
-
-export {
-  SwarmHub,
-  createSwarmHub,
-  type ISwarmHub,
-} from './swarm-hub.js';