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

package/src/application/index.ts

@@ -1,30 +0,0 @@
-/**
- * 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

@@ -1,200 +0,0 @@
-/**
- * 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();
-  }
-}