claude-flow 3.25.6 → 3.26.1

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

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

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

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