confused-ai-core 0.1.0

package/src/execution/engine.ts

@@ -0,0 +1,522 @@
+/**
+ * Execution engine implementation
+ */
+
+import {
+    ExecutionEngine,
+    ExecutionEngineConfig,
+    ExecutionOptions,
+    ExecutionStatus,
+    ExecutionState,
+    ExecutionProgress,
+    ExecutionEvent,
+    ExecutionEventType,
+    ExecutionEventHandler,
+    ExecutionGraph,
+    ExecutionNode,
+    ExecutionNodeStatus,
+    TaskExecutor,
+    ExecutionContext,
+    BackoffStrategy,
+} from './types.js';
+import {
+    Plan,
+    Task,
+    TaskResult,
+    TaskStatus,
+    PlanExecutionResult,
+    PlanExecutionStatus,
+} from '../planner/types.js';
+import type { EntityId } from '../core/types.js';
+import { EventEmitter } from 'events';
+
+/**
+ * Default execution configuration
+ */
+const DEFAULT_CONFIG: Required<ExecutionEngineConfig> = {
+    maxConcurrency: 4,
+    defaultTimeoutMs: 30000,
+    enableParallelExecution: true,
+    workerPoolSize: 4,
+    retryPolicy: {
+        maxRetries: 3,
+        backoffStrategy: BackoffStrategy.EXPONENTIAL,
+        initialDelayMs: 1000,
+        maxDelayMs: 30000,
+    },
+};
+
+/**
+ * Execution engine implementation
+ */
+export class ExecutionEngineImpl extends EventEmitter implements ExecutionEngine {
+    private config: Required<ExecutionEngineConfig>;
+    private executors: Map<string, TaskExecutor> = new Map();
+    private executions: Map<EntityId, ExecutionStatus> = new Map();
+    private runningExecutions: Map<EntityId, AbortController> = new Map();
+
+    constructor(config: Partial<ExecutionEngineConfig> = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+
+    async execute(plan: Plan, options: ExecutionOptions = {}): Promise<PlanExecutionResult> {
+        const executionId = options.executionId ?? this.generateId();
+        // timeoutMs is used for potential future timeout implementation
+        void (options.timeoutMs ?? this.config.defaultTimeoutMs);
+
+        // Create execution graph
+        const graph = this.buildExecutionGraph(plan);
+
+        // Initialize execution status
+        const status: ExecutionStatus = {
+            executionId,
+            planId: plan.id,
+            state: ExecutionState.PENDING,
+            progress: this.calculateProgress(graph),
+            currentTasks: [],
+            startedAt: new Date(),
+        };
+
+        this.executions.set(executionId, status);
+
+        // Create abort controller for cancellation
+        const abortController = new AbortController();
+        this.runningExecutions.set(executionId, abortController);
+
+        try {
+            // Update state to running
+            this.updateExecutionState(executionId, ExecutionState.RUNNING);
+            this.emitEvent('execution:start', executionId, { planId: plan.id });
+
+            // Execute the plan
+            const results = await this.executeGraph(
+                graph,
+                executionId,
+                abortController.signal,
+                options
+            );
+
+            // Determine final status
+            const failedTasks = Array.from(results.values()).filter(
+                r => r.status === TaskStatus.FAILED
+            );
+            const cancelledTasks = Array.from(results.values()).filter(
+                r => r.status === TaskStatus.CANCELLED
+            );
+
+            let finalStatus: PlanExecutionStatus;
+            if (cancelledTasks.length > 0) {
+                finalStatus = PlanExecutionStatus.CANCELLED;
+            } else if (failedTasks.length === 0) {
+                finalStatus = PlanExecutionStatus.COMPLETED;
+            } else if (failedTasks.length < results.size) {
+                finalStatus = PlanExecutionStatus.PARTIAL;
+            } else {
+                finalStatus = PlanExecutionStatus.FAILED;
+            }
+
+            const endTime = new Date();
+            const result: PlanExecutionResult = {
+                planId: plan.id,
+                status: finalStatus,
+                taskResults: results,
+                startedAt: status.startedAt,
+                completedAt: endTime,
+                totalExecutionTimeMs: endTime.getTime() - status.startedAt.getTime(),
+            };
+
+            // Update execution status
+            this.updateExecutionState(
+                executionId,
+                finalStatus === PlanExecutionStatus.COMPLETED
+                    ? ExecutionState.COMPLETED
+                    : ExecutionState.FAILED
+            );
+
+            this.emitEvent('execution:complete', executionId, { result });
+
+            return result;
+        } catch (error) {
+            this.updateExecutionState(executionId, ExecutionState.FAILED);
+            this.emitEvent('execution:fail', executionId, { error });
+
+            throw error;
+        } finally {
+            this.runningExecutions.delete(executionId);
+        }
+    }
+
+    async cancel(executionId: EntityId): Promise<boolean> {
+        const controller = this.runningExecutions.get(executionId);
+        if (!controller) {
+            return false;
+        }
+
+        controller.abort();
+        this.updateExecutionState(executionId, ExecutionState.CANCELLED);
+        this.emitEvent('execution:cancel', executionId, {});
+
+        return true;
+    }
+
+    getStatus(executionId: EntityId): ExecutionStatus | undefined {
+        return this.executions.get(executionId);
+    }
+
+    registerExecutor(executor: TaskExecutor): void {
+        const type = executor.constructor.name;
+        this.executors.set(type, executor);
+    }
+
+    on(event: ExecutionEventType, handler: ExecutionEventHandler): this {
+        super.on(event, handler);
+        return this;
+    }
+
+    off(event: ExecutionEventType, handler: ExecutionEventHandler): this {
+        super.off(event, handler);
+        return this;
+    }
+
+    /**
+     * Build execution graph from plan
+     */
+    private buildExecutionGraph(plan: Plan): ExecutionGraph {
+        const nodes = new Map<EntityId, ExecutionNode>();
+        const readyQueue: EntityId[] = [];
+
+        // Create nodes for all tasks
+        for (const task of plan.tasks) {
+            const node: ExecutionNode = {
+                task,
+                status: ExecutionNodeStatus.PENDING,
+                dependencies: new Set(task.dependencies),
+                dependents: new Set(),
+            };
+            nodes.set(task.id, node);
+
+            // Add to ready queue if no dependencies
+            if (task.dependencies.length === 0) {
+                readyQueue.push(task.id);
+            }
+        }
+
+        // Build reverse dependency map (dependents)
+        for (const [id, node] of nodes) {
+            for (const depId of node.dependencies) {
+                const depNode = nodes.get(depId);
+                if (depNode) {
+                    depNode.dependents.add(id);
+                }
+            }
+        }
+
+        return {
+            planId: plan.id,
+            nodes,
+            readyQueue,
+            completedCount: 0,
+            failedCount: 0,
+            totalCount: plan.tasks.length,
+        };
+    }
+
+    /**
+     * Execute the execution graph
+     */
+    private async executeGraph(
+        graph: ExecutionGraph,
+        executionId: EntityId,
+        abortSignal: AbortSignal,
+        options: ExecutionOptions
+    ): Promise<Map<EntityId, TaskResult>> {
+        const results = new Map<EntityId, TaskResult>();
+        const executing = new Set<Promise<void>>();
+
+        const processNode = async (nodeId: EntityId): Promise<void> => {
+            const node = graph.nodes.get(nodeId);
+            if (!node || abortSignal.aborted) {
+                return;
+            }
+
+            // Check if all dependencies are satisfied
+            for (const depId of node.dependencies) {
+                const depResult = results.get(depId);
+                if (!depResult || depResult.status === TaskStatus.FAILED) {
+                    // Skip this task if dependency failed
+                    const skipResult: TaskResult = {
+                        taskId: nodeId,
+                        status: TaskStatus.SKIPPED,
+                        executionTimeMs: 0,
+                        startedAt: new Date(),
+                    };
+                    results.set(nodeId, skipResult);
+                    this.updateNodeStatus(graph, nodeId, ExecutionNodeStatus.CANCELLED);
+                    return;
+                }
+            }
+
+            // Update status
+            this.updateNodeStatus(graph, nodeId, ExecutionNodeStatus.RUNNING);
+            this.emitEvent('task:start', executionId, { taskId: nodeId });
+
+            if (options.onTaskStart) {
+                options.onTaskStart(nodeId);
+            }
+
+            const startTime = new Date();
+
+            try {
+                // Find appropriate executor
+                const executor = this.findExecutor(node.task);
+                if (!executor) {
+                    throw new Error(`No executor found for task: ${node.task.name}`);
+                }
+
+                // Create execution context
+                const context: ExecutionContext = {
+                    executionId,
+                    taskId: nodeId,
+                    planId: graph.planId,
+                    inputs: this.collectInputs(node.task, results),
+                    sharedState: new Map(),
+                    metadata: {
+                        startedAt: startTime,
+                        attemptNumber: 1,
+                    },
+                };
+
+                // Execute task
+                const result = await executor.execute(node.task, context);
+
+                results.set(nodeId, result);
+
+                // Update status based on result
+                if (result.status === TaskStatus.COMPLETED) {
+                    this.updateNodeStatus(graph, nodeId, ExecutionNodeStatus.COMPLETED);
+                    this.emitEvent('task:complete', executionId, { taskId: nodeId, result });
+
+                    if (options.onTaskComplete) {
+                        options.onTaskComplete(nodeId, result);
+                    }
+                } else {
+                    this.updateNodeStatus(graph, nodeId, ExecutionNodeStatus.FAILED);
+                    this.emitEvent('task:fail', executionId, { taskId: nodeId, result });
+
+                    if (options.onTaskError) {
+                        options.onTaskError(nodeId, new Error(result.error?.message ?? 'Task failed'));
+                    }
+                }
+            } catch (error) {
+                const failedResult: TaskResult = {
+                    taskId: nodeId,
+                    status: TaskStatus.FAILED,
+                    error: {
+                        code: 'EXECUTION_ERROR',
+                        message: error instanceof Error ? error.message : String(error),
+                        retryable: true,
+                    },
+                    executionTimeMs: Date.now() - startTime.getTime(),
+                    startedAt: startTime,
+                    completedAt: new Date(),
+                };
+
+                results.set(nodeId, failedResult);
+                this.updateNodeStatus(graph, nodeId, ExecutionNodeStatus.FAILED);
+                this.emitEvent('task:fail', executionId, { taskId: nodeId, error });
+
+                if (options.onTaskError) {
+                    options.onTaskError(nodeId, error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+        };
+
+        // Process ready queue
+        while (graph.readyQueue.length > 0 || executing.size > 0) {
+            if (abortSignal.aborted) {
+                break;
+            }
+
+            // Start new tasks up to concurrency limit
+            while (
+                graph.readyQueue.length > 0 &&
+                executing.size < this.config.maxConcurrency
+            ) {
+                const nodeId = graph.readyQueue.shift()!;
+                const promise = processNode(nodeId).then(() => {
+                    executing.delete(promise);
+
+                    // Add dependents to ready queue
+                    const node = graph.nodes.get(nodeId);
+                    if (node) {
+                        for (const dependentId of node.dependents) {
+                            const dependent = graph.nodes.get(dependentId);
+                            if (dependent && dependent.status === ExecutionNodeStatus.PENDING) {
+                                // Check if all dependencies are completed
+                                const allDepsCompleted = Array.from(dependent.dependencies).every(
+                                    depId => {
+                                        const depNode = graph.nodes.get(depId);
+                                        return depNode?.status === ExecutionNodeStatus.COMPLETED;
+                                    }
+                                );
+
+                                if (allDepsCompleted) {
+                                    graph.readyQueue.push(dependentId);
+                                }
+                            }
+                        }
+                    }
+                });
+
+                executing.add(promise);
+            }
+
+            // Wait for at least one task to complete
+            if (executing.size > 0) {
+                await Promise.race(executing);
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Find an executor for a task
+     */
+    private findExecutor(task: Task): TaskExecutor | undefined {
+        for (const executor of this.executors.values()) {
+            if (executor.canExecute(task)) {
+                return executor;
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * Collect inputs from completed dependencies
+     */
+    private collectInputs(
+        task: Task,
+        results: Map<EntityId, TaskResult>
+    ): Map<EntityId, unknown> {
+        const inputs = new Map<EntityId, unknown>();
+
+        for (const depId of task.dependencies) {
+            const result = results.get(depId);
+            if (result?.output !== undefined) {
+                inputs.set(depId, result.output);
+            }
+        }
+
+        return inputs;
+    }
+
+    /**
+     * Update node status and execution progress
+     */
+    private updateNodeStatus(
+        graph: ExecutionGraph,
+        nodeId: EntityId,
+        status: ExecutionNodeStatus
+    ): void {
+        const node = graph.nodes.get(nodeId) as MutableExecutionNode | undefined;
+        if (!node) {
+            return;
+        }
+
+        node.status = status;
+
+        if (status === ExecutionNodeStatus.COMPLETED) {
+            (graph as MutableExecutionGraph).completedCount++;
+        } else if (status === ExecutionNodeStatus.FAILED) {
+            (graph as MutableExecutionGraph).failedCount++;
+        }
+
+        // Update execution status
+        for (const execStatus of this.executions.values()) {
+            if (execStatus.planId === graph.planId) {
+                (execStatus as MutableExecutionStatus).progress = this.calculateProgress(graph);
+            }
+        }
+    }
+
+    /**
+     * Calculate execution progress
+     */
+    private calculateProgress(graph: ExecutionGraph): ExecutionProgress {
+        const total = graph.totalCount;
+        const completed = graph.completedCount;
+        const failed = graph.failedCount;
+        const running = Array.from(graph.nodes.values()).filter(
+            n => n.status === ExecutionNodeStatus.RUNNING
+        ).length;
+        const pending = total - completed - failed - running;
+
+        return {
+            total,
+            completed,
+            failed,
+            pending,
+            running,
+            percentage: total > 0 ? Math.round(((completed + failed) / total) * 100) : 0,
+        };
+    }
+
+    /**
+     * Update execution state
+     */
+    private updateExecutionState(executionId: EntityId, state: ExecutionState): void {
+        const status = this.executions.get(executionId);
+        if (status) {
+            this.executions.set(executionId, { ...status, state });
+        }
+    }
+
+    /**
+     * Emit execution event
+     */
+    private emitEvent(
+        type: ExecutionEventType,
+        executionId: EntityId,
+        data: unknown
+    ): void {
+        const event: ExecutionEvent = {
+            type,
+            executionId,
+            timestamp: new Date(),
+            data,
+        };
+
+        this.emit(type, event);
+    }
+
+    /**
+     * Generate a unique ID
+     */
+    private generateId(): EntityId {
+        return `exec-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+    }
+}
+
+/**
+ * Mutable execution node for internal use
+ */
+interface MutableExecutionNode extends ExecutionNode {
+    status: ExecutionNodeStatus;
+}
+
+/**
+ * Mutable execution graph for internal use
+ */
+interface MutableExecutionGraph extends ExecutionGraph {
+    completedCount: number;
+    failedCount: number;
+}
+
+/**
+ * Mutable execution status for internal use
+ */
+interface MutableExecutionStatus extends ExecutionStatus {
+    progress: ExecutionProgress;
+}