@claude-flow/swarm 3.0.0-alpha.1

package/src/application/commands/spawn-agent.command.ts

@@ -0,0 +1,122 @@
+/**
+ * Spawn Agent Command - Application Layer (CQRS)
+ *
+ * Command for spawning a new agent in the swarm.
+ *
+ * @module v3/swarm/application/commands
+ */
+
+import { Agent, AgentRole, AgentProps } from '../../domain/entities/agent.js';
+import { IAgentRepository } from '../../domain/repositories/agent-repository.interface.js';
+
+/**
+ * Spawn Agent Command Input
+ */
+export interface SpawnAgentInput {
+  name: string;
+  role: AgentRole;
+  domain: string;
+  capabilities: string[];
+  parentId?: string;
+  metadata?: Record<string, unknown>;
+  maxConcurrentTasks?: number;
+  autoStart?: boolean;
+}
+
+/**
+ * Spawn Agent Command Result
+ */
+export interface SpawnAgentResult {
+  success: boolean;
+  agentId: string;
+  agent: Agent;
+  startedAutomatically: boolean;
+}
+
+/**
+ * Spawn Agent Command Handler
+ */
+export class SpawnAgentCommandHandler {
+  constructor(private readonly repository: IAgentRepository) {}
+
+  async execute(input: SpawnAgentInput): Promise<SpawnAgentResult> {
+    // Check if agent with same name exists
+    const existing = await this.repository.findByName(input.name);
+    if (existing) {
+      throw new Error(`Agent with name '${input.name}' already exists`);
+    }
+
+    // Create agent
+    const agent = Agent.create({
+      name: input.name,
+      role: input.role,
+      domain: input.domain,
+      capabilities: input.capabilities,
+      parentId: input.parentId,
+      metadata: input.metadata,
+      maxConcurrentTasks: input.maxConcurrentTasks,
+    });
+
+    // Auto-start if requested
+    let startedAutomatically = false;
+    if (input.autoStart) {
+      agent.start();
+      startedAutomatically = true;
+    }
+
+    await this.repository.save(agent);
+
+    return {
+      success: true,
+      agentId: agent.id,
+      agent,
+      startedAutomatically,
+    };
+  }
+}
+
+/**
+ * Terminate Agent Command Input
+ */
+export interface TerminateAgentInput {
+  agentId: string;
+  force?: boolean;
+}
+
+/**
+ * Terminate Agent Command Result
+ */
+export interface TerminateAgentResult {
+  success: boolean;
+  agentId: string;
+  tasksReassigned: number;
+}
+
+/**
+ * Terminate Agent Command Handler
+ */
+export class TerminateAgentCommandHandler {
+  constructor(private readonly repository: IAgentRepository) {}
+
+  async execute(input: TerminateAgentInput): Promise<TerminateAgentResult> {
+    const agent = await this.repository.findById(input.agentId);
+    if (!agent) {
+      throw new Error(`Agent '${input.agentId}' not found`);
+    }
+
+    const currentTasks = agent.currentTaskCount;
+
+    if (currentTasks > 0 && !input.force) {
+      throw new Error(`Agent has ${currentTasks} active tasks. Use force=true to terminate anyway.`);
+    }
+
+    agent.terminate();
+    await this.repository.save(agent);
+
+    return {
+      success: true,
+      agentId: input.agentId,
+      tasksReassigned: currentTasks,
+    };
+  }
+}

package/src/application/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Swarm Application Layer - Public Exports
+ *
+ * @module v3/swarm/application
+ */
+
+// Commands
+export {
+  SpawnAgentCommandHandler,
+  TerminateAgentCommandHandler,
+  type SpawnAgentInput,
+  type SpawnAgentResult,
+  type TerminateAgentInput,
+  type TerminateAgentResult,
+} from './commands/spawn-agent.command.js';
+
+export {
+  CreateTaskCommandHandler,
+  CancelTaskCommandHandler,
+  type CreateTaskInput,
+  type CreateTaskResult,
+  type CancelTaskInput,
+  type CancelTaskResult,
+} from './commands/create-task.command.js';
+
+// Application Service
+export {
+  SwarmApplicationService,
+  type SwarmConfig,
+} from './services/swarm-application-service.js';

package/src/application/services/swarm-application-service.ts

@@ -0,0 +1,200 @@
+/**
+ * Swarm Application Service - Application Layer
+ *
+ * Orchestrates swarm operations and provides simplified interface.
+ *
+ * @module v3/swarm/application/services
+ */
+
+import { Agent, AgentRole, AgentStatus } from '../../domain/entities/agent.js';
+import { Task, TaskStatus, TaskPriority } from '../../domain/entities/task.js';
+import { IAgentRepository, AgentStatistics } from '../../domain/repositories/agent-repository.interface.js';
+import { ITaskRepository, TaskStatistics } from '../../domain/repositories/task-repository.interface.js';
+import { CoordinationService, LoadBalancingStrategy, SwarmHealth } from '../../domain/services/coordination-service.js';
+import { SpawnAgentCommandHandler, SpawnAgentInput, TerminateAgentCommandHandler } from '../commands/spawn-agent.command.js';
+import { CreateTaskCommandHandler, CreateTaskInput, CancelTaskCommandHandler } from '../commands/create-task.command.js';
+
+/**
+ * Swarm configuration
+ */
+export interface SwarmConfig {
+  loadBalancingStrategy?: LoadBalancingStrategy;
+  autoScaling?: boolean;
+  minAgents?: number;
+  maxAgents?: number;
+}
+
+/**
+ * Swarm Application Service
+ */
+export class SwarmApplicationService {
+  private readonly coordinationService: CoordinationService;
+  private readonly spawnHandler: SpawnAgentCommandHandler;
+  private readonly terminateHandler: TerminateAgentCommandHandler;
+  private readonly createTaskHandler: CreateTaskCommandHandler;
+  private readonly cancelTaskHandler: CancelTaskCommandHandler;
+
+  constructor(
+    private readonly agentRepository: IAgentRepository,
+    private readonly taskRepository: ITaskRepository,
+    private readonly config: SwarmConfig = {}
+  ) {
+    this.coordinationService = new CoordinationService(agentRepository, taskRepository);
+    this.spawnHandler = new SpawnAgentCommandHandler(agentRepository);
+    this.terminateHandler = new TerminateAgentCommandHandler(agentRepository);
+    this.createTaskHandler = new CreateTaskCommandHandler(taskRepository);
+    this.cancelTaskHandler = new CancelTaskCommandHandler(taskRepository);
+  }
+
+  // ============================================================================
+  // Agent Operations
+  // ============================================================================
+
+  /**
+   * Spawn a new agent
+   */
+  async spawnAgent(input: SpawnAgentInput): Promise<Agent> {
+    const result = await this.spawnHandler.execute(input);
+    return result.agent;
+  }
+
+  /**
+   * Terminate an agent
+   */
+  async terminateAgent(agentId: string, force = false): Promise<void> {
+    await this.terminateHandler.execute({ agentId, force });
+  }
+
+  /**
+   * Get agent by ID
+   */
+  async getAgent(agentId: string): Promise<Agent | null> {
+    return this.agentRepository.findById(agentId);
+  }
+
+  /**
+   * List all agents
+   */
+  async listAgents(options?: {
+    status?: AgentStatus;
+    role?: AgentRole;
+    domain?: string;
+  }): Promise<Agent[]> {
+    return this.agentRepository.findAll(options);
+  }
+
+  /**
+   * Get agent statistics
+   */
+  async getAgentStatistics(): Promise<AgentStatistics> {
+    return this.agentRepository.getStatistics();
+  }
+
+  // ============================================================================
+  // Task Operations
+  // ============================================================================
+
+  /**
+   * Create a new task
+   */
+  async createTask(input: CreateTaskInput): Promise<Task> {
+    const result = await this.createTaskHandler.execute(input);
+    return result.task;
+  }
+
+  /**
+   * Cancel a task
+   */
+  async cancelTask(taskId: string): Promise<void> {
+    await this.cancelTaskHandler.execute({ taskId });
+  }
+
+  /**
+   * Get task by ID
+   */
+  async getTask(taskId: string): Promise<Task | null> {
+    return this.taskRepository.findById(taskId);
+  }
+
+  /**
+   * List tasks
+   */
+  async listTasks(options?: {
+    status?: TaskStatus;
+    priority?: TaskPriority;
+    assignedAgentId?: string;
+  }): Promise<Task[]> {
+    return this.taskRepository.findAll(options);
+  }
+
+  /**
+   * Get task statistics
+   */
+  async getTaskStatistics(): Promise<TaskStatistics> {
+    return this.taskRepository.getStatistics();
+  }
+
+  // ============================================================================
+  // Orchestration
+  // ============================================================================
+
+  /**
+   * Assign pending tasks to available agents
+   */
+  async processPendingTasks(): Promise<number> {
+    const queuedTasks = await this.taskRepository.findQueued();
+    let assigned = 0;
+
+    for (const task of queuedTasks) {
+      const result = await this.coordinationService.assignTask(
+        task.id,
+        this.config.loadBalancingStrategy ?? 'capability-match'
+      );
+      if (result.success) assigned++;
+    }
+
+    return assigned;
+  }
+
+  /**
+   * Complete a task
+   */
+  async completeTask(taskId: string, output?: unknown): Promise<void> {
+    await this.coordinationService.processTaskCompletion(taskId, output);
+  }
+
+  /**
+   * Fail a task
+   */
+  async failTask(taskId: string, error: string): Promise<boolean> {
+    return this.coordinationService.processTaskFailure(taskId, error);
+  }
+
+  /**
+   * Get swarm health
+   */
+  async getHealth(): Promise<SwarmHealth> {
+    return this.coordinationService.getSwarmHealth();
+  }
+
+  /**
+   * Get scaling recommendation
+   */
+  async getScalingRecommendation() {
+    return this.coordinationService.calculateScalingRecommendation();
+  }
+
+  // ============================================================================
+  // Lifecycle
+  // ============================================================================
+
+  async initialize(): Promise<void> {
+    await this.agentRepository.initialize();
+    await this.taskRepository.initialize();
+  }
+
+  async shutdown(): Promise<void> {
+    await this.agentRepository.shutdown();
+    await this.taskRepository.shutdown();
+  }
+}