@claude-flow/cli 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/infrastructure/in-memory-repositories.ts

@@ -1,310 +0,0 @@
-/**
- * In-Memory Repositories - CLI Infrastructure
- *
- * Lightweight in-memory implementations for CLI use.
- *
- * @module v3/cli/infrastructure
- */
-
-import { Agent, AgentStatus, AgentRole } from '../../../swarm/src/domain/entities/agent.js';
-import { Task, TaskStatus, TaskPriority } from '../../../swarm/src/domain/entities/task.js';
-import {
-  IAgentRepository,
-  AgentQueryOptions,
-  AgentStatistics,
-} from '../../../swarm/src/domain/repositories/agent-repository.interface.js';
-import {
-  ITaskRepository,
-  TaskQueryOptions,
-  TaskStatistics,
-} from '../../../swarm/src/domain/repositories/task-repository.interface.js';
-
-/**
- * In-Memory Agent Repository
- */
-export class InMemoryAgentRepository implements IAgentRepository {
-  private agents: Map<string, Agent> = new Map();
-  private initialized = false;
-
-  async initialize(): Promise<void> {
-    this.initialized = true;
-  }
-
-  async shutdown(): Promise<void> {
-    this.agents.clear();
-    this.initialized = false;
-  }
-
-  async clear(): Promise<void> {
-    this.agents.clear();
-  }
-
-  async save(agent: Agent): Promise<void> {
-    this.agents.set(agent.id, agent);
-  }
-
-  async findById(id: string): Promise<Agent | null> {
-    return this.agents.get(id) ?? null;
-  }
-
-  async findByName(name: string): Promise<Agent | null> {
-    for (const agent of this.agents.values()) {
-      if (agent.name === name) return agent;
-    }
-    return null;
-  }
-
-  async delete(id: string): Promise<boolean> {
-    return this.agents.delete(id);
-  }
-
-  async exists(id: string): Promise<boolean> {
-    return this.agents.has(id);
-  }
-
-  async saveMany(agents: Agent[]): Promise<void> {
-    for (const agent of agents) {
-      this.agents.set(agent.id, agent);
-    }
-  }
-
-  async findByIds(ids: string[]): Promise<Agent[]> {
-    return ids.map((id) => this.agents.get(id)).filter((a): a is Agent => a !== undefined);
-  }
-
-  async deleteMany(ids: string[]): Promise<number> {
-    let deleted = 0;
-    for (const id of ids) {
-      if (this.agents.delete(id)) deleted++;
-    }
-    return deleted;
-  }
-
-  async findAll(options?: AgentQueryOptions): Promise<Agent[]> {
-    let result = Array.from(this.agents.values());
-    if (options?.status) result = result.filter((a) => a.status === options.status);
-    if (options?.role) result = result.filter((a) => a.role === options.role);
-    if (options?.domain) result = result.filter((a) => a.domain === options.domain);
-    if (options?.limit) result = result.slice(0, options.limit);
-    return result;
-  }
-
-  async findByStatus(status: AgentStatus): Promise<Agent[]> {
-    return this.findAll({ status });
-  }
-
-  async findByRole(role: AgentRole): Promise<Agent[]> {
-    return this.findAll({ role });
-  }
-
-  async findByDomain(domain: string): Promise<Agent[]> {
-    return this.findAll({ domain });
-  }
-
-  async findByParent(parentId: string): Promise<Agent[]> {
-    return Array.from(this.agents.values()).filter((a) => a.parentId === parentId);
-  }
-
-  async findByCapability(capability: string): Promise<Agent[]> {
-    return Array.from(this.agents.values()).filter((a) => a.hasCapability(capability));
-  }
-
-  async findAvailable(): Promise<Agent[]> {
-    return Array.from(this.agents.values()).filter((a) => a.isAvailable());
-  }
-
-  async getStatistics(): Promise<AgentStatistics> {
-    const agents = Array.from(this.agents.values());
-    const byStatus: Record<AgentStatus, number> = {
-      idle: 0,
-      active: 0,
-      busy: 0,
-      paused: 0,
-      terminated: 0,
-      error: 0,
-    };
-    const byRole: Record<string, number> = {};
-    const byDomain: Record<string, number> = {};
-    let totalCompleted = 0;
-    let totalUtilization = 0;
-
-    for (const agent of agents) {
-      byStatus[agent.status]++;
-      byRole[agent.role] = (byRole[agent.role] ?? 0) + 1;
-      byDomain[agent.domain] = (byDomain[agent.domain] ?? 0) + 1;
-      totalCompleted += agent.completedTaskCount;
-      totalUtilization += agent.getUtilization();
-    }
-
-    return {
-      total: agents.length,
-      byStatus,
-      byRole,
-      byDomain,
-      totalTasksCompleted: totalCompleted,
-      averageUtilization: agents.length > 0 ? totalUtilization / agents.length : 0,
-    };
-  }
-
-  async count(options?: AgentQueryOptions): Promise<number> {
-    return (await this.findAll(options)).length;
-  }
-}
-
-/**
- * In-Memory Task Repository
- */
-export class InMemoryTaskRepository implements ITaskRepository {
-  private tasks: Map<string, Task> = new Map();
-  private initialized = false;
-
-  async initialize(): Promise<void> {
-    this.initialized = true;
-  }
-
-  async shutdown(): Promise<void> {
-    this.tasks.clear();
-    this.initialized = false;
-  }
-
-  async clear(): Promise<void> {
-    this.tasks.clear();
-  }
-
-  async save(task: Task): Promise<void> {
-    this.tasks.set(task.id, task);
-  }
-
-  async findById(id: string): Promise<Task | null> {
-    return this.tasks.get(id) ?? null;
-  }
-
-  async delete(id: string): Promise<boolean> {
-    return this.tasks.delete(id);
-  }
-
-  async exists(id: string): Promise<boolean> {
-    return this.tasks.has(id);
-  }
-
-  async saveMany(tasks: Task[]): Promise<void> {
-    for (const task of tasks) {
-      this.tasks.set(task.id, task);
-    }
-  }
-
-  async findByIds(ids: string[]): Promise<Task[]> {
-    return ids.map((id) => this.tasks.get(id)).filter((t): t is Task => t !== undefined);
-  }
-
-  async deleteMany(ids: string[]): Promise<number> {
-    let deleted = 0;
-    for (const id of ids) {
-      if (this.tasks.delete(id)) deleted++;
-    }
-    return deleted;
-  }
-
-  async findAll(options?: TaskQueryOptions): Promise<Task[]> {
-    let result = Array.from(this.tasks.values());
-    if (options?.status) result = result.filter((t) => t.status === options.status);
-    if (options?.priority) result = result.filter((t) => t.priority === options.priority);
-    if (options?.type) result = result.filter((t) => t.type === options.type);
-    if (options?.assignedAgentId) result = result.filter((t) => t.assignedAgentId === options.assignedAgentId);
-    if (options?.limit) result = result.slice(0, options.limit);
-    return result;
-  }
-
-  async findByStatus(status: TaskStatus): Promise<Task[]> {
-    return this.findAll({ status });
-  }
-
-  async findByPriority(priority: TaskPriority): Promise<Task[]> {
-    return this.findAll({ priority });
-  }
-
-  async findByAgent(agentId: string): Promise<Task[]> {
-    return this.findAll({ assignedAgentId: agentId });
-  }
-
-  async findPending(): Promise<Task[]> {
-    return this.findByStatus('pending');
-  }
-
-  async findQueued(): Promise<Task[]> {
-    return this.findByStatus('queued');
-  }
-
-  async findRunning(): Promise<Task[]> {
-    return this.findByStatus('running');
-  }
-
-  async findTimedOut(): Promise<Task[]> {
-    return Array.from(this.tasks.values()).filter((t) => t.isTimedOut());
-  }
-
-  async getNextTask(agentCapabilities?: string[]): Promise<Task | null> {
-    const queued = await this.findQueued();
-    if (queued.length === 0) return null;
-    queued.sort((a, b) => a.comparePriority(b));
-    return queued[0];
-  }
-
-  async getTaskQueue(limit = 10): Promise<Task[]> {
-    const queued = await this.findQueued();
-    queued.sort((a, b) => a.comparePriority(b));
-    return queued.slice(0, limit);
-  }
-
-  async getStatistics(): Promise<TaskStatistics> {
-    const tasks = Array.from(this.tasks.values());
-    const byStatus: Record<TaskStatus, number> = {
-      pending: 0,
-      queued: 0,
-      assigned: 0,
-      running: 0,
-      completed: 0,
-      failed: 0,
-      cancelled: 0,
-    };
-    const byPriority: Record<TaskPriority, number> = {
-      critical: 0,
-      high: 0,
-      normal: 0,
-      low: 0,
-    };
-    const byType: Record<string, number> = {};
-    let totalDuration = 0;
-    let completedCount = 0;
-    let failedCount = 0;
-    let retryTotal = 0;
-
-    for (const task of tasks) {
-      byStatus[task.status]++;
-      byPriority[task.priority]++;
-      byType[task.type] = (byType[task.type] ?? 0) + 1;
-
-      if (task.status === 'completed') {
-        completedCount++;
-        const duration = task.getExecutionDuration();
-        if (duration) totalDuration += duration;
-      }
-      if (task.status === 'failed') failedCount++;
-      retryTotal += task.retryCount;
-    }
-
-    return {
-      total: tasks.length,
-      byStatus,
-      byPriority,
-      byType,
-      averageExecutionTime: completedCount > 0 ? totalDuration / completedCount : 0,
-      successRate: tasks.length > 0 ? completedCount / tasks.length : 0,
-      retryRate: tasks.length > 0 ? retryTotal / tasks.length : 0,
-    };
-  }
-
-  async count(options?: TaskQueryOptions): Promise<number> {
-    return (await this.findAll(options)).length;
-  }
-}