@cloudpftc/opencode-orchestrator 3.5.15

package/v3/@claude-flow/shared/dist/core/orchestrator/task-manager.js

@@ -0,0 +1,253 @@
+/**
+ * V3 Task Manager
+ * Decomposed from orchestrator.ts - Task lifecycle management
+ * ~200 lines (target achieved)
+ */
+import { SystemEventTypes } from '../interfaces/event.interface.js';
+import { randomBytes } from 'crypto';
+// Secure task ID generation
+function generateSecureTaskId() {
+    const timestamp = Date.now().toString(36);
+    const random = randomBytes(12).toString('hex');
+    return `task_${timestamp}_${random}`;
+}
+/**
+ * Priority queue implementation for tasks
+ */
+export class TaskQueue {
+    tasks = [];
+    async enqueue(task) {
+        this.tasks.push(task);
+        this.tasks.sort((a, b) => b.priority - a.priority);
+    }
+    async dequeue() {
+        return this.tasks.shift();
+    }
+    async peek() {
+        return this.tasks[0];
+    }
+    size() {
+        return this.tasks.length;
+    }
+    isEmpty() {
+        return this.tasks.length === 0;
+    }
+    async clear() {
+        this.tasks = [];
+    }
+    async getAll() {
+        return [...this.tasks];
+    }
+    async remove(taskId) {
+        const index = this.tasks.findIndex(t => t.id === taskId);
+        if (index !== -1) {
+            this.tasks.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    async updatePriority(taskId, priority) {
+        const task = this.tasks.find(t => t.id === taskId);
+        if (task) {
+            task.priority = priority;
+            this.tasks.sort((a, b) => b.priority - a.priority);
+            return true;
+        }
+        return false;
+    }
+}
+/**
+ * Task manager implementation
+ */
+export class TaskManager {
+    eventBus;
+    tasks = new Map();
+    queue;
+    metrics = {
+        totalTasks: 0,
+        completedTasks: 0,
+        failedTasks: 0,
+        cancelledTasks: 0,
+        totalDuration: 0,
+        totalWaitTime: 0,
+    };
+    constructor(eventBus, queue) {
+        this.eventBus = eventBus;
+        this.queue = queue ?? new TaskQueue();
+    }
+    async createTask(params) {
+        const task = {
+            id: generateSecureTaskId(),
+            type: params.type,
+            description: params.description,
+            priority: params.priority ?? 50,
+            createdAt: new Date(),
+            status: 'pending',
+            timeout: params.timeout,
+            assignedAgent: params.assignedAgent,
+            input: params.input,
+            metadata: params.metadata,
+        };
+        this.tasks.set(task.id, task);
+        this.metrics.totalTasks++;
+        this.eventBus.emit(SystemEventTypes.TASK_CREATED, { task });
+        return task;
+    }
+    getTask(taskId) {
+        return this.tasks.get(taskId);
+    }
+    getTasks(filter) {
+        let tasks = Array.from(this.tasks.values());
+        if (filter) {
+            if (filter.status) {
+                tasks = tasks.filter(t => t.status === filter.status);
+            }
+            if (filter.type) {
+                tasks = tasks.filter(t => t.type === filter.type);
+            }
+            if (filter.assignedAgent) {
+                tasks = tasks.filter(t => t.assignedAgent === filter.assignedAgent);
+            }
+        }
+        return tasks;
+    }
+    async assignTask(taskId, agentId) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        task.assignedAgent = agentId;
+        task.status = 'assigned';
+        this.eventBus.emit(SystemEventTypes.TASK_ASSIGNED, {
+            taskId,
+            agentId,
+        });
+    }
+    async startTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        task.status = 'running';
+        task.startedAt = new Date();
+        // Calculate wait time
+        const waitTime = task.startedAt.getTime() - task.createdAt.getTime();
+        this.metrics.totalWaitTime += waitTime;
+        this.eventBus.emit(SystemEventTypes.TASK_STARTED, {
+            taskId,
+            agentId: task.assignedAgent,
+            startTime: task.startedAt,
+        });
+    }
+    async completeTask(taskId, result) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        task.status = 'completed';
+        task.completedAt = new Date();
+        task.output = result.output;
+        this.metrics.completedTasks++;
+        this.metrics.totalDuration += result.duration;
+        this.eventBus.emit(SystemEventTypes.TASK_COMPLETED, {
+            taskId,
+            result,
+        });
+    }
+    async failTask(taskId, error) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        task.status = 'failed';
+        task.completedAt = new Date();
+        task.error = error;
+        this.metrics.failedTasks++;
+        this.eventBus.emit(SystemEventTypes.TASK_FAILED, {
+            taskId,
+            error,
+            retryable: this.isRetryable(task),
+        });
+    }
+    async cancelTask(taskId, reason) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        task.status = 'cancelled';
+        task.completedAt = new Date();
+        this.metrics.cancelledTasks++;
+        this.eventBus.emit(SystemEventTypes.TASK_CANCELLED, {
+            taskId,
+            reason: reason ?? 'User requested',
+        });
+    }
+    async retryTask(taskId) {
+        const task = this.tasks.get(taskId);
+        if (!task) {
+            throw new Error(`Task not found: ${taskId}`);
+        }
+        const retryCount = task.metadata?.retryCount ?? 0;
+        const maxRetries = task.metadata?.maxRetries ?? 3;
+        if (retryCount >= maxRetries) {
+            throw new Error(`Task ${taskId} has exceeded max retries`);
+        }
+        task.status = 'pending';
+        task.assignedAgent = undefined;
+        task.startedAt = undefined;
+        task.completedAt = undefined;
+        task.error = undefined;
+        task.metadata = {
+            ...task.metadata,
+            retryCount: retryCount + 1,
+        };
+        await this.queue.enqueue(task);
+        this.eventBus.emit(SystemEventTypes.TASK_RETRY, {
+            taskId,
+            attempt: retryCount + 1,
+            maxAttempts: maxRetries,
+            error: task.error,
+        });
+    }
+    getMetrics() {
+        const pendingTasks = this.getTasks({ status: 'pending' }).length;
+        const runningTasks = this.getTasks({ status: 'running' }).length;
+        return {
+            totalTasks: this.metrics.totalTasks,
+            pendingTasks,
+            runningTasks,
+            completedTasks: this.metrics.completedTasks,
+            failedTasks: this.metrics.failedTasks,
+            cancelledTasks: this.metrics.cancelledTasks,
+            avgDuration: this.metrics.completedTasks > 0
+                ? this.metrics.totalDuration / this.metrics.completedTasks
+                : 0,
+            avgWaitTime: this.metrics.completedTasks > 0
+                ? this.metrics.totalWaitTime / this.metrics.completedTasks
+                : 0,
+        };
+    }
+    async cleanup(olderThan) {
+        let cleaned = 0;
+        const cutoffTime = olderThan.getTime();
+        for (const [taskId, task] of this.tasks.entries()) {
+            if (task.completedAt && task.completedAt.getTime() < cutoffTime) {
+                this.tasks.delete(taskId);
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
+    isRetryable(task) {
+        const retryCount = task.metadata?.retryCount ?? 0;
+        const maxRetries = task.metadata?.maxRetries ?? 3;
+        return retryCount < maxRetries;
+    }
+    /**
+     * Get the task queue
+     */
+    getQueue() {
+        return this.queue;
+    }
+}
+//# sourceMappingURL=task-manager.js.map

package/v3/@claude-flow/shared/dist/events/domain-events.d.ts

@@ -0,0 +1,282 @@
+/**
+ * Domain Events for Event Sourcing (ADR-007)
+ *
+ * Defines all domain events for the V3 system:
+ * - Agent lifecycle events (spawned, started, stopped, failed)
+ * - Task execution events (created, started, completed, failed)
+ * - Memory operations events (stored, retrieved, deleted)
+ * - Swarm coordination events (initialized, scaled, terminated)
+ *
+ * @module v3/shared/events/domain-events
+ */
+import { AgentId, TaskId } from '../types.js';
+export interface DomainEvent {
+    /** Unique event identifier */
+    id: string;
+    /** Event type discriminator */
+    type: string;
+    /** Aggregate ID (entity the event belongs to) */
+    aggregateId: string;
+    /** Aggregate type (agent, task, memory, swarm) */
+    aggregateType: 'agent' | 'task' | 'memory' | 'swarm';
+    /** Event version for ordering */
+    version: number;
+    /** Timestamp when event occurred */
+    timestamp: number;
+    /** Event source (agent or swarm system) */
+    source: AgentId | 'swarm';
+    /** Event payload data */
+    payload: Record<string, unknown>;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+    /** Optional causation ID (event that caused this event) */
+    causationId?: string;
+    /** Optional correlation ID (groups related events) */
+    correlationId?: string;
+}
+export interface AgentSpawnedEvent extends DomainEvent {
+    type: 'agent:spawned';
+    aggregateType: 'agent';
+    payload: {
+        agentId: AgentId;
+        role: string;
+        domain: string;
+        capabilities: string[];
+    };
+}
+export interface AgentStartedEvent extends DomainEvent {
+    type: 'agent:started';
+    aggregateType: 'agent';
+    payload: {
+        agentId: AgentId;
+        startedAt: number;
+    };
+}
+export interface AgentStoppedEvent extends DomainEvent {
+    type: 'agent:stopped';
+    aggregateType: 'agent';
+    payload: {
+        agentId: AgentId;
+        reason: string;
+        stoppedAt: number;
+    };
+}
+export interface AgentFailedEvent extends DomainEvent {
+    type: 'agent:failed';
+    aggregateType: 'agent';
+    payload: {
+        agentId: AgentId;
+        error: string;
+        stack?: string;
+        failedAt: number;
+    };
+}
+export interface AgentStatusChangedEvent extends DomainEvent {
+    type: 'agent:status-changed';
+    aggregateType: 'agent';
+    payload: {
+        agentId: AgentId;
+        previousStatus: string;
+        newStatus: string;
+    };
+}
+export interface AgentTaskAssignedEvent extends DomainEvent {
+    type: 'agent:task-assigned';
+    aggregateType: 'agent';
+    payload: {
+        agentId: AgentId;
+        taskId: TaskId;
+        assignedAt: number;
+    };
+}
+export interface AgentTaskCompletedEvent extends DomainEvent {
+    type: 'agent:task-completed';
+    aggregateType: 'agent';
+    payload: {
+        agentId: AgentId;
+        taskId: TaskId;
+        result: unknown;
+        completedAt: number;
+        duration: number;
+    };
+}
+export interface TaskCreatedEvent extends DomainEvent {
+    type: 'task:created';
+    aggregateType: 'task';
+    payload: {
+        taskId: TaskId;
+        taskType: string;
+        title: string;
+        description: string;
+        priority: string;
+        dependencies: TaskId[];
+        createdAt: number;
+    };
+}
+export interface TaskStartedEvent extends DomainEvent {
+    type: 'task:started';
+    aggregateType: 'task';
+    payload: {
+        taskId: TaskId;
+        agentId: AgentId;
+        startedAt: number;
+    };
+}
+export interface TaskCompletedEvent extends DomainEvent {
+    type: 'task:completed';
+    aggregateType: 'task';
+    payload: {
+        taskId: TaskId;
+        result: unknown;
+        completedAt: number;
+        duration: number;
+    };
+}
+export interface TaskFailedEvent extends DomainEvent {
+    type: 'task:failed';
+    aggregateType: 'task';
+    payload: {
+        taskId: TaskId;
+        error: string;
+        stack?: string;
+        failedAt: number;
+        retryCount: number;
+    };
+}
+export interface TaskBlockedEvent extends DomainEvent {
+    type: 'task:blocked';
+    aggregateType: 'task';
+    payload: {
+        taskId: TaskId;
+        blockedBy: TaskId[];
+        blockedAt: number;
+    };
+}
+export interface TaskQueuedEvent extends DomainEvent {
+    type: 'task:queued';
+    aggregateType: 'task';
+    payload: {
+        taskId: TaskId;
+        priority: string;
+        queuedAt: number;
+    };
+}
+export interface MemoryStoredEvent extends DomainEvent {
+    type: 'memory:stored';
+    aggregateType: 'memory';
+    payload: {
+        memoryId: string;
+        namespace: string;
+        key: string;
+        memoryType: string;
+        size: number;
+        storedAt: number;
+    };
+}
+export interface MemoryRetrievedEvent extends DomainEvent {
+    type: 'memory:retrieved';
+    aggregateType: 'memory';
+    payload: {
+        memoryId: string;
+        namespace: string;
+        key: string;
+        retrievedAt: number;
+        accessCount: number;
+    };
+}
+export interface MemoryDeletedEvent extends DomainEvent {
+    type: 'memory:deleted';
+    aggregateType: 'memory';
+    payload: {
+        memoryId: string;
+        namespace: string;
+        key: string;
+        deletedAt: number;
+    };
+}
+export interface MemoryExpiredEvent extends DomainEvent {
+    type: 'memory:expired';
+    aggregateType: 'memory';
+    payload: {
+        memoryId: string;
+        namespace: string;
+        key: string;
+        expiredAt: number;
+        expiresAt: number;
+    };
+}
+export interface SwarmInitializedEvent extends DomainEvent {
+    type: 'swarm:initialized';
+    aggregateType: 'swarm';
+    payload: {
+        topology: string;
+        maxAgents: number;
+        config: Record<string, unknown>;
+        initializedAt: number;
+    };
+}
+export interface SwarmScaledEvent extends DomainEvent {
+    type: 'swarm:scaled';
+    aggregateType: 'swarm';
+    payload: {
+        previousAgentCount: number;
+        newAgentCount: number;
+        scaledAt: number;
+        reason: string;
+    };
+}
+export interface SwarmTerminatedEvent extends DomainEvent {
+    type: 'swarm:terminated';
+    aggregateType: 'swarm';
+    payload: {
+        reason: string;
+        terminatedAt: number;
+        metrics: Record<string, unknown>;
+    };
+}
+export interface SwarmPhaseChangedEvent extends DomainEvent {
+    type: 'swarm:phase-changed';
+    aggregateType: 'swarm';
+    payload: {
+        previousPhase: string;
+        newPhase: string;
+        changedAt: number;
+    };
+}
+export interface SwarmMilestoneReachedEvent extends DomainEvent {
+    type: 'swarm:milestone-reached';
+    aggregateType: 'swarm';
+    payload: {
+        milestoneId: string;
+        name: string;
+        reachedAt: number;
+    };
+}
+export interface SwarmErrorEvent extends DomainEvent {
+    type: 'swarm:error';
+    aggregateType: 'swarm';
+    payload: {
+        error: string;
+        stack?: string;
+        context: Record<string, unknown>;
+        errorAt: number;
+    };
+}
+export type AllDomainEvents = AgentSpawnedEvent | AgentStartedEvent | AgentStoppedEvent | AgentFailedEvent | AgentStatusChangedEvent | AgentTaskAssignedEvent | AgentTaskCompletedEvent | TaskCreatedEvent | TaskStartedEvent | TaskCompletedEvent | TaskFailedEvent | TaskBlockedEvent | TaskQueuedEvent | MemoryStoredEvent | MemoryRetrievedEvent | MemoryDeletedEvent | MemoryExpiredEvent | SwarmInitializedEvent | SwarmScaledEvent | SwarmTerminatedEvent | SwarmPhaseChangedEvent | SwarmMilestoneReachedEvent | SwarmErrorEvent;
+export declare function createAgentSpawnedEvent(agentId: AgentId, role: string, domain: string, capabilities: string[]): AgentSpawnedEvent;
+export declare function createAgentStartedEvent(agentId: AgentId): AgentStartedEvent;
+export declare function createAgentStoppedEvent(agentId: AgentId, reason: string): AgentStoppedEvent;
+export declare function createAgentFailedEvent(agentId: AgentId, error: Error): AgentFailedEvent;
+export declare function createAgentTaskAssignedEvent(agentId: AgentId, taskId: TaskId, assignedAt?: number): AgentTaskAssignedEvent;
+export declare function createAgentTaskCompletedEvent(agentId: AgentId, taskId: TaskId, result: unknown, completedAt: number, duration: number): AgentTaskCompletedEvent;
+export declare function createTaskCreatedEvent(taskId: TaskId, taskType: string, title: string, description: string, priority: string, dependencies: TaskId[]): TaskCreatedEvent;
+export declare function createTaskStartedEvent(taskId: TaskId, agentId: AgentId): TaskStartedEvent;
+export declare function createTaskCompletedEvent(taskId: TaskId, result: unknown, duration: number): TaskCompletedEvent;
+export declare function createTaskFailedEvent(taskId: TaskId, error: Error, retryCount: number): TaskFailedEvent;
+export declare function createMemoryStoredEvent(memoryId: string, namespace: string, key: string, memoryType: string, size: number): MemoryStoredEvent;
+export declare function createMemoryRetrievedEvent(memoryId: string, namespace: string, key: string, accessCount: number): MemoryRetrievedEvent;
+export declare function createMemoryDeletedEvent(memoryId: string, namespace: string, key: string): MemoryDeletedEvent;
+export declare function createSwarmInitializedEvent(topology: string, maxAgents: number, config: Record<string, unknown>): SwarmInitializedEvent;
+export declare function createSwarmScaledEvent(previousAgentCount: number, newAgentCount: number, reason: string): SwarmScaledEvent;
+export declare function createSwarmTerminatedEvent(reason: string, metrics: Record<string, unknown>): SwarmTerminatedEvent;
+//# sourceMappingURL=domain-events.d.ts.map

package/v3/@claude-flow/shared/dist/events/domain-events.js

@@ -0,0 +1,165 @@
+/**
+ * Domain Events for Event Sourcing (ADR-007)
+ *
+ * Defines all domain events for the V3 system:
+ * - Agent lifecycle events (spawned, started, stopped, failed)
+ * - Task execution events (created, started, completed, failed)
+ * - Memory operations events (stored, retrieved, deleted)
+ * - Swarm coordination events (initialized, scaled, terminated)
+ *
+ * @module v3/shared/events/domain-events
+ */
+// =============================================================================
+// Event Factory Functions
+// =============================================================================
+let eventCounter = 0;
+function createDomainEvent(type, aggregateId, aggregateType, payload, metadata, causationId, correlationId) {
+    return {
+        id: `evt-${Date.now()}-${++eventCounter}`,
+        type,
+        aggregateId,
+        aggregateType,
+        version: 1, // Version will be set by event store
+        timestamp: Date.now(),
+        source: 'swarm', // Default to swarm, can be overridden
+        payload,
+        metadata,
+        causationId,
+        correlationId,
+    };
+}
+// Agent Event Factories
+export function createAgentSpawnedEvent(agentId, role, domain, capabilities) {
+    return createDomainEvent('agent:spawned', agentId, 'agent', {
+        agentId,
+        role,
+        domain,
+        capabilities,
+    });
+}
+export function createAgentStartedEvent(agentId) {
+    return createDomainEvent('agent:started', agentId, 'agent', {
+        agentId,
+        startedAt: Date.now(),
+    });
+}
+export function createAgentStoppedEvent(agentId, reason) {
+    return createDomainEvent('agent:stopped', agentId, 'agent', {
+        agentId,
+        reason,
+        stoppedAt: Date.now(),
+    });
+}
+export function createAgentFailedEvent(agentId, error) {
+    return createDomainEvent('agent:failed', agentId, 'agent', {
+        agentId,
+        error: error.message,
+        stack: error.stack,
+        failedAt: Date.now(),
+    });
+}
+export function createAgentTaskAssignedEvent(agentId, taskId, assignedAt) {
+    return createDomainEvent('agent:task-assigned', agentId, 'agent', {
+        agentId,
+        taskId,
+        assignedAt: assignedAt ?? Date.now(),
+    });
+}
+export function createAgentTaskCompletedEvent(agentId, taskId, result, completedAt, duration) {
+    return createDomainEvent('agent:task-completed', agentId, 'agent', {
+        agentId,
+        taskId,
+        result,
+        completedAt,
+        duration,
+    });
+}
+// Task Event Factories
+export function createTaskCreatedEvent(taskId, taskType, title, description, priority, dependencies) {
+    return createDomainEvent('task:created', taskId, 'task', {
+        taskId,
+        taskType,
+        title,
+        description,
+        priority,
+        dependencies,
+        createdAt: Date.now(),
+    });
+}
+export function createTaskStartedEvent(taskId, agentId) {
+    return createDomainEvent('task:started', taskId, 'task', {
+        taskId,
+        agentId,
+        startedAt: Date.now(),
+    });
+}
+export function createTaskCompletedEvent(taskId, result, duration) {
+    return createDomainEvent('task:completed', taskId, 'task', {
+        taskId,
+        result,
+        completedAt: Date.now(),
+        duration,
+    });
+}
+export function createTaskFailedEvent(taskId, error, retryCount) {
+    return createDomainEvent('task:failed', taskId, 'task', {
+        taskId,
+        error: error.message,
+        stack: error.stack,
+        failedAt: Date.now(),
+        retryCount,
+    });
+}
+// Memory Event Factories
+export function createMemoryStoredEvent(memoryId, namespace, key, memoryType, size) {
+    return createDomainEvent('memory:stored', memoryId, 'memory', {
+        memoryId,
+        namespace,
+        key,
+        memoryType,
+        size,
+        storedAt: Date.now(),
+    });
+}
+export function createMemoryRetrievedEvent(memoryId, namespace, key, accessCount) {
+    return createDomainEvent('memory:retrieved', memoryId, 'memory', {
+        memoryId,
+        namespace,
+        key,
+        retrievedAt: Date.now(),
+        accessCount,
+    });
+}
+export function createMemoryDeletedEvent(memoryId, namespace, key) {
+    return createDomainEvent('memory:deleted', memoryId, 'memory', {
+        memoryId,
+        namespace,
+        key,
+        deletedAt: Date.now(),
+    });
+}
+// Swarm Event Factories
+export function createSwarmInitializedEvent(topology, maxAgents, config) {
+    return createDomainEvent('swarm:initialized', 'swarm', 'swarm', {
+        topology,
+        maxAgents,
+        config,
+        initializedAt: Date.now(),
+    });
+}
+export function createSwarmScaledEvent(previousAgentCount, newAgentCount, reason) {
+    return createDomainEvent('swarm:scaled', 'swarm', 'swarm', {
+        previousAgentCount,
+        newAgentCount,
+        scaledAt: Date.now(),
+        reason,
+    });
+}
+export function createSwarmTerminatedEvent(reason, metrics) {
+    return createDomainEvent('swarm:terminated', 'swarm', 'swarm', {
+        reason,
+        terminatedAt: Date.now(),
+        metrics,
+    });
+}
+//# sourceMappingURL=domain-events.js.map