@calmo/task-runner 3.8.0 → 3.8.2

package/src/TaskGraphValidator.ts

@@ -2,6 +2,11 @@ import { ITaskGraphValidator } from "./contracts/ITaskGraphValidator.js";
 import { ValidationResult } from "./contracts/ValidationResult.js";
 import { ValidationError } from "./contracts/ValidationError.js";
 import { TaskGraph } from "./TaskGraph.js";
+import {
+  ERROR_CYCLE,
+  ERROR_DUPLICATE_TASK,
+  ERROR_MISSING_DEPENDENCY,
+} from "./contracts/ErrorTypes.js";
 
 export class TaskGraphValidator implements ITaskGraphValidator {
   /**
@@ -18,11 +23,46 @@ export class TaskGraphValidator implements ITaskGraphValidator {
     const errors: ValidationError[] = [];
 
     // 1. Check for duplicate tasks
+    const taskIds = this.checkDuplicateTasks(taskGraph, errors);
+
+    // 2. Check for missing dependencies
+    this.checkMissingDependencies(taskGraph, taskIds, errors);
+
+    // 3. Check for cycles
+    // Only run cycle detection if there are no missing dependencies, otherwise we might chase non-existent nodes.
+    const hasMissingDependencies = errors.some(
+      (e) => e.type === ERROR_MISSING_DEPENDENCY
+    );
+
+    if (!hasMissingDependencies) {
+      this.checkCycles(taskGraph, errors);
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors,
+    };
+  }
+
+  /**
+   * Creates a human-readable error message from a validation result.
+   * @param result The validation result containing errors.
+   * @returns A formatted error string.
+   */
+  createErrorMessage(result: ValidationResult): string {
+    const errorDetails = result.errors.map((e) => e.message);
+    return `Task graph validation failed: ${errorDetails.join("; ")}`;
+  }
+
+  private checkDuplicateTasks(
+    taskGraph: TaskGraph,
+    errors: ValidationError[]
+  ): Set<string> {
     const taskIds = new Set<string>();
     for (const task of taskGraph.tasks) {
       if (taskIds.has(task.id)) {
         errors.push({
-          type: "duplicate_task",
+          type: ERROR_DUPLICATE_TASK,
           message: `Duplicate task detected with ID: ${task.id}`,
           details: { taskId: task.id },
         });
@@ -30,33 +70,28 @@ export class TaskGraphValidator implements ITaskGraphValidator {
         taskIds.add(task.id);
       }
     }
+    return taskIds;
+  }
 
-    // 2. Check for missing dependencies
+  private checkMissingDependencies(
+    taskGraph: TaskGraph,
+    taskIds: Set<string>,
+    errors: ValidationError[]
+  ): void {
     for (const task of taskGraph.tasks) {
       for (const dependenceId of task.dependencies) {
         if (!taskIds.has(dependenceId)) {
           errors.push({
-            type: "missing_dependency",
+            type: ERROR_MISSING_DEPENDENCY,
             message: `Task '${task.id}' depends on missing task '${dependenceId}'`,
             details: { taskId: task.id, missingDependencyId: dependenceId },
           });
         }
       }
     }
+  }
 
-    // 3. Check for cycles
-    // Only run cycle detection if there are no missing dependencies, otherwise we might chase non-existent nodes.
-    const hasMissingDependencies = errors.some(
-      (e) => e.type === "missing_dependency"
-    );
-
-    if (hasMissingDependencies) {
-      return {
-        isValid: errors.length === 0,
-        errors,
-      };
-    }
-
+  private checkCycles(taskGraph: TaskGraph, errors: ValidationError[]): void {
     // Build adjacency list
     const adjacencyList = new Map<string, string[]>();
     for (const task of taskGraph.tasks) {
@@ -82,7 +117,7 @@ export class TaskGraphValidator implements ITaskGraphValidator {
         const cyclePath = path.slice(cycleStartIndex);
 
         errors.push({
-          type: "cycle",
+          type: ERROR_CYCLE,
           message: `Cycle detected: ${cyclePath.join(" -> ")}`,
           details: { cyclePath },
         });
@@ -90,21 +125,6 @@ export class TaskGraphValidator implements ITaskGraphValidator {
         break;
       }
     }
-
-    return {
-      isValid: errors.length === 0,
-      errors,
-    };
-  }
-
-  /**
-   * Creates a human-readable error message from a validation result.
-   * @param result The validation result containing errors.
-   * @returns A formatted error string.
-   */
-  createErrorMessage(result: ValidationResult): string {
-    const errorDetails = result.errors.map((e) => e.message);
-    return `Task graph validation failed: ${errorDetails.join("; ")}`;
   }
 
   private detectCycle(

package/src/TaskRunner.ts

@@ -79,23 +79,14 @@ export class TaskRunner<TContext> {
   public static getMermaidGraph<T>(steps: TaskStep<T>[]): string {
     const graphLines = ["graph TD"];
 
-    // Helper to sanitize node names or wrap them if needed
-    // For simplicity, we just wrap in quotes and use the name as ID if it's simple
-    // or generate an ID if strictly needed. Here we assume names are unique IDs.
-    // We will wrap names in quotes for the label, but use the name as the ID.
-    // Actually, Mermaid ID cannot have spaces without quotes.
-    const safeId = (name: string) => JSON.stringify(name);
     const sanitize = (name: string) => this.sanitizeMermaidId(name);
 
-    // Add all nodes first to ensure they exist
     for (const step of steps) {
-      // Using the name as both ID and Label for simplicity
-      // Format: ID["Label"]
-      // safeId returns a quoted string (e.g. "Task Name"), so we use it directly as the label
-      graphLines.push(`  ${sanitize(step.name)}[${safeId(step.name)}]`);
+      graphLines.push(
+        `  ${sanitize(step.name)}[${JSON.stringify(step.name)}]`
+      );
     }
 
-    // Add edges
     for (const step of steps) {
       if (step.dependencies) {
         for (const dep of step.dependencies) {
@@ -159,44 +150,58 @@ export class TaskRunner<TContext> {
       config?.concurrency
     );
 
-    // We need to handle the timeout cleanup properly.
     if (config?.timeout !== undefined) {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => {
-        controller.abort(
-          new Error(`Workflow timed out after ${config.timeout}ms`)
-        );
-      }, config.timeout);
-
-      let effectiveSignal = controller.signal;
-      let onAbort: (() => void) | undefined;
-
-      // Handle combination of signals if user provided one
-      if (config.signal) {
-        if (config.signal.aborted) {
-          // If already aborted, use it directly (WorkflowExecutor handles early abort)
-          // We can cancel timeout immediately
-          clearTimeout(timeoutId);
-          effectiveSignal = config.signal;
-        } else {
-          // Listen to user signal to abort our controller
-          onAbort = () => {
-            controller.abort(config.signal?.reason);
-          };
-          config.signal.addEventListener("abort", onAbort);
-        }
-      }
+      return this.executeWithTimeout(
+        executor,
+        steps,
+        config.timeout,
+        config.signal
+      );
+    } else {
+      return executor.execute(steps, config?.signal);
+    }
+  }
 
-      try {
-        return await executor.execute(steps, effectiveSignal);
-      } finally {
+  /**
+   * Executes tasks with a timeout, ensuring resources are cleaned up.
+   */
+  private async executeWithTimeout(
+    executor: WorkflowExecutor<TContext>,
+    steps: TaskStep<TContext>[],
+    timeout: number,
+    signal?: AbortSignal
+  ): Promise<Map<string, TaskResult>> {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort(new Error(`Workflow timed out after ${timeout}ms`));
+    }, timeout);
+
+    let effectiveSignal = controller.signal;
+    let onAbort: (() => void) | undefined;
+
+    // Handle combination of signals if user provided one
+    if (signal) {
+      if (signal.aborted) {
+        // If already aborted, use it directly (WorkflowExecutor handles early abort)
+        // We can cancel timeout immediately
         clearTimeout(timeoutId);
-        if (config.signal && onAbort) {
-          config.signal.removeEventListener("abort", onAbort);
-        }
+        effectiveSignal = signal;
+      } else {
+        // Listen to user signal to abort our controller
+        onAbort = () => {
+          controller.abort(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort);
+      }
+    }
+
+    try {
+      return await executor.execute(steps, effectiveSignal);
+    } finally {
+      clearTimeout(timeoutId);
+      if (signal && onAbort) {
+        signal.removeEventListener("abort", onAbort);
       }
-    } else {
-      return executor.execute(steps, config?.signal);
     }
   }
 }

package/src/TaskStateManager.ts

@@ -101,20 +101,16 @@ export class TaskStateManager<TContext> {
     for (const step of this.pendingSteps) {
       // Also check running? No, running tasks are handled by AbortSignal in Executor.
       // We only cancel what is pending and hasn't started.
-      /* v8 ignore next 1 */
       if (!this.results.has(step.name) && !this.running.has(step.name)) {
         const result: TaskResult = {
           status: "cancelled",
           message,
         };
         this.results.set(step.name, result);
+        this.eventBus.emit("taskEnd", { step, result });
       }
     }
     // Clear pending set as they are now "done" (cancelled)
-    // Wait, if we clear pending steps, processDependencies won't pick them up.
-    // The loop in Executor relies on results.size or pendingSteps.
-    // The previous implementation iterated `steps` (all steps) to cancel.
-    // Here we iterate `pendingSteps`.
     this.pendingSteps.clear();
   }
 

package/src/contracts/ErrorTypes.ts

@@ -0,0 +1,6 @@
+/**
+ * Error type constants for task graph validation.
+ */
+export const ERROR_DUPLICATE_TASK = "duplicate_task" as const;
+export const ERROR_MISSING_DEPENDENCY = "missing_dependency" as const;
+export const ERROR_CYCLE = "cycle" as const;

package/src/contracts/ValidationError.ts

@@ -1,9 +1,18 @@
+import {
+  ERROR_CYCLE,
+  ERROR_DUPLICATE_TASK,
+  ERROR_MISSING_DEPENDENCY,
+} from "./ErrorTypes.js";
+
 /**
  * Describes a specific validation error found in the task graph.
  */
 export interface ValidationError {
   /** The type of validation error. */
-  type: "cycle" | "missing_dependency" | "duplicate_task";
+  type:
+    | typeof ERROR_CYCLE
+    | typeof ERROR_MISSING_DEPENDENCY
+    | typeof ERROR_DUPLICATE_TASK;
   /** A human-readable message describing the error. */
   message: string;
   /** Optional detailed information about the error, e.g., the cycle path, or the task with a missing dependency. */