@calmo/task-runner 3.4.0 → 3.4.1

package/src/TaskRunner.ts

@@ -2,7 +2,10 @@ import { TaskStep } from "./TaskStep.js";
 import { TaskResult } from "./TaskResult.js";
 import { TaskGraphValidator } from "./TaskGraphValidator.js";
 import { TaskGraph } from "./TaskGraph.js";
-import { RunnerEventPayloads, RunnerEventListener } from "./contracts/RunnerEvents.js";
+import {
+  RunnerEventPayloads,
+  RunnerEventListener,
+} from "./contracts/RunnerEvents.js";
 import { EventBus } from "./EventBus.js";
 import { WorkflowExecutor } from "./WorkflowExecutor.js";
 import { TaskRunnerExecutionConfig } from "./TaskRunnerExecutionConfig.js";
@@ -24,9 +27,8 @@ export { RunnerEventPayloads, RunnerEventListener, TaskRunnerExecutionConfig };
 export class TaskRunner<TContext> {
   private eventBus = new EventBus<TContext>();
   private validator = new TaskGraphValidator();
-  private executionStrategy: IExecutionStrategy<TContext> = new RetryingExecutionStrategy(
-    new StandardExecutionStrategy()
-  );
+  private executionStrategy: IExecutionStrategy<TContext> =
+    new RetryingExecutionStrategy(new StandardExecutionStrategy());
 
   /**
    * @param context The shared context object to be passed to each task.
@@ -85,7 +87,6 @@ export class TaskRunner<TContext> {
     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
@@ -98,9 +99,7 @@ export class TaskRunner<TContext> {
     for (const step of steps) {
       if (step.dependencies) {
         for (const dep of step.dependencies) {
-          graphLines.push(
-            `  ${sanitize(dep)} --> ${sanitize(step.name)}`
-          );
+          graphLines.push(`  ${sanitize(dep)} --> ${sanitize(step.name)}`);
         }
       }
     }
@@ -162,40 +161,42 @@ export class TaskRunner<TContext> {
 
     // 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);
-          }
-       }
-
-       try {
-         return await executor.execute(steps, effectiveSignal);
-       } finally {
-         clearTimeout(timeoutId);
-         if (config.signal && onAbort) {
-            config.signal.removeEventListener("abort", onAbort);
-         }
-       }
+      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);
+        }
+      }
+
+      try {
+        return await executor.execute(steps, effectiveSignal);
+      } finally {
+        clearTimeout(timeoutId);
+        if (config.signal && onAbort) {
+          config.signal.removeEventListener("abort", onAbort);
+        }
+      }
     } else {
-       return executor.execute(steps, config?.signal);
+      return executor.execute(steps, config?.signal);
     }
   }
 }

package/src/TaskRunnerBuilder.ts

@@ -1,5 +1,8 @@
 import { TaskRunner } from "./TaskRunner.js";
-import { RunnerEventPayloads, RunnerEventListener } from "./contracts/RunnerEvents.js";
+import {
+  RunnerEventPayloads,
+  RunnerEventListener,
+} from "./contracts/RunnerEvents.js";
 import { IExecutionStrategy } from "./strategies/IExecutionStrategy.js";
 
 /**
@@ -9,7 +12,10 @@ export class TaskRunnerBuilder<TContext> {
   private context: TContext;
   private strategy?: IExecutionStrategy<TContext>;
   private listeners: {
-    [K in keyof RunnerEventPayloads<TContext>]?: RunnerEventListener<TContext, K>[];
+    [K in keyof RunnerEventPayloads<TContext>]?: RunnerEventListener<
+      TContext,
+      K
+    >[];
   } = {};
 
   /**
@@ -57,7 +63,9 @@ export class TaskRunnerBuilder<TContext> {
       runner.setExecutionStrategy(this.strategy);
     }
 
-    (Object.keys(this.listeners) as Array<keyof RunnerEventPayloads<TContext>>).forEach((event) => {
+    (
+      Object.keys(this.listeners) as Array<keyof RunnerEventPayloads<TContext>>
+    ).forEach((event) => {
       const callbacks = this.listeners[event];
       // callbacks is always defined because we are iterating keys of the object
       callbacks!.forEach((callback) =>

package/src/WorkflowExecutor.ts

@@ -41,7 +41,9 @@ export class WorkflowExecutor<TContext> {
 
     // Check if already aborted
     if (signal?.aborted) {
-      this.stateManager.cancelAllPending("Workflow cancelled before execution started.");
+      this.stateManager.cancelAllPending(
+        "Workflow cancelled before execution started."
+      );
       const results = this.stateManager.getResults();
       this.eventBus.emit("workflowEnd", { context: this.context, results });
       return results;
@@ -55,7 +57,7 @@ export class WorkflowExecutor<TContext> {
     };
 
     if (signal) {
-       signal.addEventListener("abort", onAbort);
+      signal.addEventListener("abort", onAbort);
     }
 
     try {
@@ -77,10 +79,10 @@ export class WorkflowExecutor<TContext> {
         }
 
         if (signal?.aborted) {
-           this.stateManager.cancelAllPending("Workflow cancelled.");
+          this.stateManager.cancelAllPending("Workflow cancelled.");
         } else {
-           // After a task finishes, check for new work
-           this.processLoop(executingPromises, signal);
+          // After a task finishes, check for new work
+          this.processLoop(executingPromises, signal);
         }
       }
 
@@ -124,14 +126,15 @@ export class WorkflowExecutor<TContext> {
 
       this.stateManager.markRunning(step);
 
-      const taskPromise = this.strategy.execute(step, this.context, signal)
+      const taskPromise = this.strategy
+        .execute(step, this.context, signal)
         .then((result) => {
-            this.stateManager.markCompleted(step, result);
+          this.stateManager.markCompleted(step, result);
         })
         .finally(() => {
-             executingPromises.delete(taskPromise);
-             // When a task finishes, we try to run more
-             this.processLoop(executingPromises, signal);
+          executingPromises.delete(taskPromise);
+          // When a task finishes, we try to run more
+          this.processLoop(executingPromises, signal);
         });
 
       executingPromises.add(taskPromise);

package/src/contracts/ITaskGraphValidator.ts

@@ -5,17 +5,17 @@ import { ValidationResult } from "./ValidationResult.js";
  * Defines the interface for a task graph validator.
  */
 export interface ITaskGraphValidator {
-    /**
-     * Validates a given task graph for structural integrity.
-     * @param taskGraph The task graph to validate.
-     * @returns A ValidationResult object indicating the outcome of the validation.
-     */
-    validate(taskGraph: TaskGraph): ValidationResult;
+  /**
+   * Validates a given task graph for structural integrity.
+   * @param taskGraph The task graph to validate.
+   * @returns A ValidationResult object indicating the outcome of the validation.
+   */
+  validate(taskGraph: TaskGraph): ValidationResult;
 
-    /**
-     * 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;
+  /**
+   * 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;
 }

package/src/contracts/ValidationError.ts

@@ -2,10 +2,10 @@
  * Describes a specific validation error found in the task graph.
  */
 export interface ValidationError {
-    /** The type of validation error. */
-    type: "cycle" | "missing_dependency" | "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. */
-    details?: unknown;
+  /** The type of validation error. */
+  type: "cycle" | "missing_dependency" | "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. */
+  details?: unknown;
 }

package/src/contracts/ValidationResult.ts

@@ -4,8 +4,8 @@ import { ValidationError } from "./ValidationError.js";
  * The result of a task graph validation operation.
  */
 export interface ValidationResult {
-    /** True if the graph is valid, false otherwise. */
-    isValid: boolean;
-    /** An array of ValidationError objects if the graph is not valid. Empty if isValid is true. */
-    errors: ValidationError[];
+  /** True if the graph is valid, false otherwise. */
+  isValid: boolean;
+  /** An array of ValidationError objects if the graph is not valid. Empty if isValid is true. */
+  errors: ValidationError[];
 }

package/src/strategies/DryRunExecutionStrategy.ts

@@ -5,9 +5,9 @@ import { TaskResult } from "../TaskResult.js";
 /**
  * Execution strategy that simulates task execution without running the actual logic.
  */
-export class DryRunExecutionStrategy<TContext>
-  implements IExecutionStrategy<TContext>
-{
+export class DryRunExecutionStrategy<
+  TContext,
+> implements IExecutionStrategy<TContext> {
   /**
    * Simulates execution by returning a success result immediately.
    * @param step The task step (ignored).

package/src/strategies/RetryingExecutionStrategy.ts

@@ -5,7 +5,9 @@ import { TaskResult } from "../TaskResult.js";
 /**
  * Execution strategy that retries tasks upon failure based on their retry configuration.
  */
-export class RetryingExecutionStrategy<TContext> implements IExecutionStrategy<TContext> {
+export class RetryingExecutionStrategy<
+  TContext,
+> implements IExecutionStrategy<TContext> {
   constructor(private innerStrategy: IExecutionStrategy<TContext>) {}
 
   async execute(
@@ -30,7 +32,11 @@ export class RetryingExecutionStrategy<TContext> implements IExecutionStrategy<T
 
       const result = await this.innerStrategy.execute(step, context, signal);
 
-      if (result.status === "success" || result.status === "cancelled" || result.status === "skipped") {
+      if (
+        result.status === "success" ||
+        result.status === "cancelled" ||
+        result.status === "skipped"
+      ) {
         return result;
       }
 
@@ -51,13 +57,13 @@ export class RetryingExecutionStrategy<TContext> implements IExecutionStrategy<T
       try {
         await this.sleep(delay, signal);
       } catch (e) {
-      if (signal?.aborted) {
-        return {
-          status: "cancelled",
-          message: "Task cancelled during retry delay",
-        };
-      }
-      throw e;
+        if (signal?.aborted) {
+          return {
+            status: "cancelled",
+            message: "Task cancelled during retry delay",
+          };
+        }
+        throw e;
       }
     }
   }

package/src/strategies/StandardExecutionStrategy.ts

@@ -5,9 +5,9 @@ import { TaskResult } from "../TaskResult.js";
 /**
  * Standard execution strategy that runs the task's run method.
  */
-export class StandardExecutionStrategy<TContext>
-  implements IExecutionStrategy<TContext>
-{
+export class StandardExecutionStrategy<
+  TContext,
+> implements IExecutionStrategy<TContext> {
   async execute(
     step: TaskStep<TContext>,
     context: TContext,
@@ -19,7 +19,7 @@ export class StandardExecutionStrategy<TContext>
       // Check if error is due to abort
       if (
         signal?.aborted &&
-        (e instanceof Error && e.name === "AbortError" || signal.reason === e)
+        ((e instanceof Error && e.name === "AbortError") || signal.reason === e)
       ) {
         return {
           status: "cancelled",