@calmo/task-runner 3.7.0 → 3.8.1

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) {
@@ -113,7 +104,7 @@ export class TaskRunner<TContext> {
    * @returns The sanitized string.
    */
   private static sanitizeMermaidId(id: string): string {
-    return id.replaceAll(/ /g, "_").replaceAll(/:/g, "_").replaceAll(/"/g, "_");
+    return id.replaceAll(/[^a-zA-Z0-9_-]/g, "_");
   }
 
   /**
@@ -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/TaskStep.ts

@@ -18,6 +18,13 @@ export interface TaskStep<TContext> {
    */
   condition?: (context: TContext) => boolean | Promise<boolean>;
 
+  /**
+   * Optional priority.
+   * Higher values are picked first. Default is 0.
+   * Only affects ordering when multiple tasks are ready and concurrency slots are limited.
+   */
+  priority?: number;
+
   /**
    * The core logic of the task.
    * @param context The shared context object, allowing for state to be passed between tasks.

package/src/WorkflowExecutor.ts

@@ -114,6 +114,9 @@ export class WorkflowExecutor<TContext> {
       this.readyQueue.push(task);
     }
 
+    // Sort by priority (descending) once after adding new tasks
+    this.readyQueue.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+
     // Execute ready tasks while respecting concurrency limit
     while (this.readyQueue.length > 0) {
       if (

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. */