dartmind 17.0.0

package/dist/orchestrator/TaskQueue.d.ts

@@ -0,0 +1,142 @@
+/**
+ * DartMind V17 - Task Queue (I1)
+ * Days 20-21: Task Scheduling and Queue Management
+ *
+ * Provides the TaskQueue class for managing task scheduling,
+ * priority ordering, and concurrent execution.
+ *
+ * @module orchestrator/TaskQueue
+ * @version 17.0.0
+ */
+import { EventEmitter } from 'events';
+import { Task, TaskQueueConfig, QueueStats, TaskExecutor, OrchestratorEventHandler } from './OrchestratorTypes.js';
+/**
+ * Task queue for managing task scheduling and execution
+ */
+export declare class TaskQueue extends EventEmitter {
+    private readonly config;
+    private readonly queue;
+    private readonly running;
+    private readonly completed;
+    private readonly executors;
+    private readonly taskHashes;
+    private processing;
+    private totalProcessed;
+    private totalWaitTimeMs;
+    private totalExecutionTimeMs;
+    constructor(config?: Partial<TaskQueueConfig>);
+    /**
+     * Add event listener
+     */
+    onEvent(handler: OrchestratorEventHandler): void;
+    /**
+     * Emit typed event
+     */
+    private emitEvent;
+    /**
+     * Register a task executor
+     */
+    registerExecutor(taskType: string, executor: TaskExecutor): void;
+    /**
+     * Unregister a task executor
+     */
+    unregisterExecutor(taskType: string): boolean;
+    /**
+     * Get executor for task type
+     */
+    getExecutor(taskType: string): TaskExecutor | undefined;
+    /**
+     * Add task to queue
+     */
+    enqueue(task: Task): boolean;
+    /**
+     * Hash task for deduplication
+     */
+    private hashTask;
+    /**
+     * Get next task from queue
+     */
+    dequeue(): Task | undefined;
+    /**
+     * Cancel a task
+     */
+    cancel(taskId: string): boolean;
+    /**
+     * Get task by ID
+     */
+    getTask(taskId: string): Task | undefined;
+    /**
+     * Get all queued tasks
+     */
+    getQueuedTasks(): Task[];
+    /**
+     * Get all running tasks
+     */
+    getRunningTasks(): Task[];
+    /**
+     * Get completed tasks
+     */
+    getCompletedTasks(limit?: number): Task[];
+    /**
+     * Start processing queue
+     */
+    start(): void;
+    /**
+     * Stop processing queue
+     */
+    stop(): void;
+    /**
+     * Check if processing
+     */
+    isProcessing(): boolean;
+    /**
+     * Process queue
+     */
+    private processQueue;
+    /**
+     * Check if task dependencies are met
+     */
+    private areDependenciesMet;
+    /**
+     * Execute a task
+     */
+    private executeTask;
+    /**
+     * Complete a task
+     */
+    private completeTask;
+    /**
+     * Retry a task
+     */
+    private retryTask;
+    /**
+     * Get queue statistics
+     */
+    getStats(): QueueStats;
+    /**
+     * Reset statistics
+     */
+    resetStats(): void;
+    /**
+     * Clear completed tasks
+     */
+    clearCompleted(): void;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}
+/**
+ * Create a task queue instance
+ */
+export declare function createTaskQueue(config?: Partial<TaskQueueConfig>): TaskQueue;
+/**
+ * Create a high-concurrency task queue
+ */
+export declare function createHighConcurrencyQueue(): TaskQueue;
+/**
+ * Create a single-threaded task queue
+ */
+export declare function createSingleThreadedQueue(): TaskQueue;
+export default TaskQueue;
+//# sourceMappingURL=TaskQueue.d.ts.map

package/dist/orchestrator/TaskQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskQueue.d.ts","sourceRoot":"","sources":["../../src/orchestrator/TaskQueue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EACL,IAAI,EAGJ,eAAe,EACf,UAAU,EACV,YAAY,EAEZ,wBAAwB,EAOzB,MAAM,wBAAwB,CAAC;AA0FhC;;GAEG;AACH,qBAAa,SAAU,SAAQ,YAAY;IACzC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkB;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAsB;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgC;IACxD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;IAC1D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwC;IAClE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0B;IAErD,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,oBAAoB,CAAa;gBAE7B,MAAM,GAAE,OAAO,CAAC,eAAe,CAAM;IAMjD;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI;IAIhD;;OAEG;IACH,OAAO,CAAC,SAAS;IAQjB;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,GAAG,IAAI;IAIhE;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAI7C;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAQvD;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IA0C5B;;OAEG;IACH,OAAO,CAAC,QAAQ;IAYhB;;OAEG;IACH,OAAO,IAAI,IAAI,GAAG,SAAS;IAI3B;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IA4B/B;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAazC;;OAEG;IACH,cAAc,IAAI,IAAI,EAAE;IAIxB;;OAEG;IACH,eAAe,IAAI,IAAI,EAAE;IAIzB;;OAEG;IACH,iBAAiB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE;IASzC;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,IAAI,IAAI,IAAI;IAIZ;;OAEG;IACH,YAAY,IAAI,OAAO;IAIvB;;OAEG;YACW,YAAY;IA0B1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;OAEG;YACW,WAAW;IAkGzB;;OAEG;IACH,OAAO,CAAC,YAAY;IAyCpB;;OAEG;IACH,OAAO,CAAC,SAAS;IAmCjB;;OAEG;IACH,QAAQ,IAAI,UAAU;IAqBtB;;OAEG;IACH,UAAU,IAAI,IAAI;IAMlB;;OAEG;IACH,cAAc,IAAI,IAAI;IAItB;;OAEG;IACH,OAAO,IAAI,IAAI;CAQhB;AAMD;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,SAAS,CAE5E;AAED;;GAEG;AACH,wBAAgB,0BAA0B,IAAI,SAAS,CAKtD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,SAAS,CAKrD;AAED,eAAe,SAAS,CAAC"}

package/dist/orchestrator/TaskQueue.js

@@ -0,0 +1,548 @@
+/**
+ * DartMind V17 - Task Queue (I1)
+ * Days 20-21: Task Scheduling and Queue Management
+ *
+ * Provides the TaskQueue class for managing task scheduling,
+ * priority ordering, and concurrent execution.
+ *
+ * @module orchestrator/TaskQueue
+ * @version 17.0.0
+ */
+import { EventEmitter } from 'events';
+import { DEFAULT_TASK_QUEUE_CONFIG, getPriorityLevel, canRetry, calculateRetryDelay, createFailureResult, } from './OrchestratorTypes.js';
+// ============================================================================
+// Priority Queue
+// ============================================================================
+/**
+ * Simple priority queue using a sorted array
+ */
+class PriorityQueue {
+    items = [];
+    /**
+     * Add item with priority
+     */
+    enqueue(item, priority) {
+        const entry = { item, priority };
+        // Find insertion point (higher priority first)
+        let insertIndex = this.items.length;
+        for (let i = 0; i < this.items.length; i++) {
+            if (priority > this.items[i].priority) {
+                insertIndex = i;
+                break;
+            }
+        }
+        this.items.splice(insertIndex, 0, entry);
+    }
+    /**
+     * Remove and return highest priority item
+     */
+    dequeue() {
+        const entry = this.items.shift();
+        return entry?.item;
+    }
+    /**
+     * Peek at highest priority item
+     */
+    peek() {
+        return this.items[0]?.item;
+    }
+    /**
+     * Remove specific item
+     */
+    remove(predicate) {
+        const index = this.items.findIndex((entry) => predicate(entry.item));
+        if (index === -1) {
+            return undefined;
+        }
+        const [removed] = this.items.splice(index, 1);
+        return removed.item;
+    }
+    /**
+     * Get queue size
+     */
+    size() {
+        return this.items.length;
+    }
+    /**
+     * Check if empty
+     */
+    isEmpty() {
+        return this.items.length === 0;
+    }
+    /**
+     * Get all items
+     */
+    getAll() {
+        return this.items.map((entry) => entry.item);
+    }
+    /**
+     * Clear queue
+     */
+    clear() {
+        this.items = [];
+    }
+}
+// ============================================================================
+// Task Queue
+// ============================================================================
+/**
+ * Task queue for managing task scheduling and execution
+ */
+export class TaskQueue extends EventEmitter {
+    config;
+    queue;
+    running = new Map();
+    completed = new Map();
+    executors = new Map();
+    taskHashes = new Set(); // For deduplication
+    processing = false;
+    totalProcessed = 0;
+    totalWaitTimeMs = 0;
+    totalExecutionTimeMs = 0;
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_TASK_QUEUE_CONFIG, ...config };
+        this.queue = new PriorityQueue();
+    }
+    /**
+     * Add event listener
+     */
+    onEvent(handler) {
+        this.on('event', handler);
+    }
+    /**
+     * Emit typed event
+     */
+    emitEvent(event) {
+        this.emit('event', event);
+    }
+    // ============================================================================
+    // Executor Management
+    // ============================================================================
+    /**
+     * Register a task executor
+     */
+    registerExecutor(taskType, executor) {
+        this.executors.set(taskType, executor);
+    }
+    /**
+     * Unregister a task executor
+     */
+    unregisterExecutor(taskType) {
+        return this.executors.delete(taskType);
+    }
+    /**
+     * Get executor for task type
+     */
+    getExecutor(taskType) {
+        return this.executors.get(taskType);
+    }
+    // ============================================================================
+    // Queue Operations
+    // ============================================================================
+    /**
+     * Add task to queue
+     */
+    enqueue(task) {
+        // Check queue size
+        if (this.queue.size() >= this.config.maxQueueSize) {
+            this.emitEvent({
+                type: 'queue:full',
+                queueSize: this.queue.size(),
+                timestamp: Date.now(),
+            });
+            return false;
+        }
+        // Check for duplicates
+        if (this.config.enableDeduplication) {
+            const hash = this.hashTask(task);
+            if (this.taskHashes.has(hash)) {
+                return false; // Duplicate task
+            }
+            this.taskHashes.add(hash);
+        }
+        // Update task status
+        task.status = 'queued';
+        task.metadata.queuedAt = Date.now();
+        // Add to queue with priority
+        const priority = this.config.enablePriority
+            ? getPriorityLevel(task.priority)
+            : 0;
+        this.queue.enqueue(task, priority);
+        this.emitEvent({
+            type: 'task:queued',
+            task,
+            timestamp: Date.now(),
+        });
+        // Try to process queue
+        this.processQueue();
+        return true;
+    }
+    /**
+     * Hash task for deduplication
+     */
+    hashTask(task) {
+        const key = `${task.type}:${task.name}:${JSON.stringify(task.payload)}`;
+        // Simple hash
+        let hash = 0;
+        for (let i = 0; i < key.length; i++) {
+            const char = key.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return hash.toString(36);
+    }
+    /**
+     * Get next task from queue
+     */
+    dequeue() {
+        return this.queue.dequeue();
+    }
+    /**
+     * Cancel a task
+     */
+    cancel(taskId) {
+        // Try to remove from queue
+        const queuedTask = this.queue.remove((t) => t.id === taskId);
+        if (queuedTask) {
+            queuedTask.status = 'cancelled';
+            queuedTask.metadata.completedAt = Date.now();
+            this.completed.set(taskId, queuedTask);
+            this.emitEvent({
+                type: 'task:cancelled',
+                task: queuedTask,
+                timestamp: Date.now(),
+            });
+            return true;
+        }
+        // Check if running (can't cancel running tasks directly)
+        const runningTask = this.running.get(taskId);
+        if (runningTask) {
+            // Mark for cancellation - executor should check this
+            runningTask.status = 'cancelled';
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get task by ID
+     */
+    getTask(taskId) {
+        // Check running
+        const running = this.running.get(taskId);
+        if (running)
+            return running;
+        // Check completed
+        const completed = this.completed.get(taskId);
+        if (completed)
+            return completed;
+        // Check queue
+        return this.queue.getAll().find((t) => t.id === taskId);
+    }
+    /**
+     * Get all queued tasks
+     */
+    getQueuedTasks() {
+        return this.queue.getAll();
+    }
+    /**
+     * Get all running tasks
+     */
+    getRunningTasks() {
+        return Array.from(this.running.values());
+    }
+    /**
+     * Get completed tasks
+     */
+    getCompletedTasks(limit) {
+        const tasks = Array.from(this.completed.values());
+        return limit ? tasks.slice(-limit) : tasks;
+    }
+    // ============================================================================
+    // Processing
+    // ============================================================================
+    /**
+     * Start processing queue
+     */
+    start() {
+        this.processing = true;
+        this.processQueue();
+    }
+    /**
+     * Stop processing queue
+     */
+    stop() {
+        this.processing = false;
+    }
+    /**
+     * Check if processing
+     */
+    isProcessing() {
+        return this.processing;
+    }
+    /**
+     * Process queue
+     */
+    async processQueue() {
+        if (!this.processing) {
+            return;
+        }
+        // Check if we can run more tasks
+        while (this.processing &&
+            this.running.size < this.config.maxConcurrency &&
+            !this.queue.isEmpty()) {
+            const task = this.dequeue();
+            if (!task)
+                break;
+            // Check dependencies
+            if (!this.areDependenciesMet(task)) {
+                // Re-queue with lower priority
+                this.queue.enqueue(task, getPriorityLevel(task.priority) - 0.5);
+                continue;
+            }
+            // Execute task
+            this.executeTask(task);
+        }
+    }
+    /**
+     * Check if task dependencies are met
+     */
+    areDependenciesMet(task) {
+        for (const depId of task.dependencies) {
+            const dep = this.completed.get(depId);
+            if (!dep || dep.status !== 'completed' || !dep.result?.success) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Execute a task
+     */
+    async executeTask(task) {
+        const executor = this.executors.get(task.type);
+        if (!executor) {
+            // No executor registered
+            task.status = 'failed';
+            task.result = createFailureResult(`No executor registered for task type: ${task.type}`);
+            task.metadata.completedAt = Date.now();
+            this.completed.set(task.id, task);
+            this.emitEvent({
+                type: 'task:failed',
+                task,
+                error: task.result.error,
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        // Mark as running
+        task.status = 'running';
+        task.metadata.startedAt = Date.now();
+        this.running.set(task.id, task);
+        // Calculate wait time
+        if (task.metadata.queuedAt) {
+            this.totalWaitTimeMs += task.metadata.startedAt - task.metadata.queuedAt;
+        }
+        this.emitEvent({
+            type: 'task:started',
+            task,
+            timestamp: Date.now(),
+        });
+        // Create timeout promise
+        const timeoutMs = task.metadata.timeoutMs || this.config.defaultTimeoutMs;
+        let timeoutHandle = null;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                reject(new Error('Task timeout'));
+            }, timeoutMs);
+        });
+        try {
+            // Execute with timeout
+            const result = await Promise.race([
+                executor(task),
+                timeoutPromise,
+            ]);
+            // Clear timeout
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            // Check if cancelled during execution (status may be changed externally)
+            if (task.status === 'cancelled') {
+                this.completeTask(task, createFailureResult('Task was cancelled'));
+                return;
+            }
+            // Complete task
+            this.completeTask(task, result);
+        }
+        catch (error) {
+            // Clear timeout
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+            const errorMessage = error.message;
+            const isTimeout = errorMessage === 'Task timeout';
+            if (isTimeout) {
+                task.status = 'timeout';
+                this.emitEvent({
+                    type: 'task:timeout',
+                    task,
+                    timestamp: Date.now(),
+                });
+            }
+            else {
+                // Mark as failed so canRetry can check properly
+                task.status = 'failed';
+            }
+            // Check if can retry
+            if (!isTimeout && canRetry(task)) {
+                this.retryTask(task, errorMessage);
+            }
+            else {
+                this.completeTask(task, createFailureResult(errorMessage, error.stack));
+            }
+        }
+    }
+    /**
+     * Complete a task
+     */
+    completeTask(task, result) {
+        task.result = result;
+        task.status = result.success ? 'completed' : 'failed';
+        task.metadata.completedAt = Date.now();
+        if (task.metadata.startedAt) {
+            task.metadata.actualDurationMs = task.metadata.completedAt - task.metadata.startedAt;
+            this.totalExecutionTimeMs += task.metadata.actualDurationMs;
+        }
+        // Move from running to completed
+        this.running.delete(task.id);
+        this.completed.set(task.id, task);
+        this.totalProcessed++;
+        // Clear deduplication hash
+        if (this.config.enableDeduplication) {
+            const hash = this.hashTask(task);
+            this.taskHashes.delete(hash);
+        }
+        if (result.success) {
+            this.emitEvent({
+                type: 'task:completed',
+                task,
+                result,
+                timestamp: Date.now(),
+            });
+        }
+        else {
+            this.emitEvent({
+                type: 'task:failed',
+                task,
+                error: result.error || 'Unknown error',
+                timestamp: Date.now(),
+            });
+        }
+        // Continue processing
+        this.processQueue();
+    }
+    /**
+     * Retry a task
+     */
+    retryTask(task, error) {
+        task.metadata.retryCount++;
+        this.emitEvent({
+            type: 'task:retrying',
+            task,
+            attempt: task.metadata.retryCount,
+            timestamp: Date.now(),
+        });
+        // Remove from running
+        this.running.delete(task.id);
+        // Calculate retry delay
+        const delay = calculateRetryDelay(task.metadata.retryCount, this.config.retryDelayMs, this.config.retryBackoffMultiplier);
+        // Re-queue after delay
+        setTimeout(() => {
+            task.status = 'queued';
+            const priority = this.config.enablePriority
+                ? getPriorityLevel(task.priority)
+                : 0;
+            this.queue.enqueue(task, priority);
+            this.processQueue();
+        }, delay);
+    }
+    // ============================================================================
+    // Statistics
+    // ============================================================================
+    /**
+     * Get queue statistics
+     */
+    getStats() {
+        const pending = this.queue.size();
+        const running = this.running.size;
+        const completedTasks = Array.from(this.completed.values());
+        const completed = completedTasks.filter((t) => t.status === 'completed').length;
+        const failed = completedTasks.filter((t) => t.status === 'failed').length;
+        const cancelled = completedTasks.filter((t) => t.status === 'cancelled').length;
+        return {
+            pending,
+            running,
+            completed,
+            failed,
+            cancelled,
+            avgWaitTimeMs: this.totalProcessed > 0 ? this.totalWaitTimeMs / this.totalProcessed : 0,
+            avgExecutionTimeMs: this.totalProcessed > 0 ? this.totalExecutionTimeMs / this.totalProcessed : 0,
+            totalProcessed: this.totalProcessed,
+            utilization: running / this.config.maxConcurrency,
+        };
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.totalProcessed = 0;
+        this.totalWaitTimeMs = 0;
+        this.totalExecutionTimeMs = 0;
+    }
+    /**
+     * Clear completed tasks
+     */
+    clearCompleted() {
+        this.completed.clear();
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        this.stop();
+        this.queue.clear();
+        this.running.clear();
+        this.completed.clear();
+        this.executors.clear();
+        this.taskHashes.clear();
+    }
+}
+// ============================================================================
+// Factory Functions
+// ============================================================================
+/**
+ * Create a task queue instance
+ */
+export function createTaskQueue(config) {
+    return new TaskQueue(config);
+}
+/**
+ * Create a high-concurrency task queue
+ */
+export function createHighConcurrencyQueue() {
+    return new TaskQueue({
+        maxConcurrency: 10,
+        maxQueueSize: 500,
+    });
+}
+/**
+ * Create a single-threaded task queue
+ */
+export function createSingleThreadedQueue() {
+    return new TaskQueue({
+        maxConcurrency: 1,
+        enablePriority: false,
+    });
+}
+export default TaskQueue;
+//# sourceMappingURL=TaskQueue.js.map