builderman 1.2.0 → 1.3.0

package/dist/pipeline.js

@@ -1,14 +1,13 @@
 import { spawn } from "node:child_process";
-import * as path from "node:path";
-import * as fs from "node:fs";
 import { $TASK_INTERNAL } from "./constants.js";
 import { createTaskGraph } from "./graph.js";
+import { PipelineError } from "./pipeline-error.js";
 import { createScheduler } from "./scheduler.js";
 import { task } from "./task.js";
 import { validateTasks } from "./util.js";
-// Module-level cache for pipeline-to-task conversions
-// Key: Pipeline, Value: Map of name -> Task
-const pipelineTaskCache = new WeakMap();
+import { createTeardownManager } from "./modules/teardown-manager.js";
+import { createSignalHandler } from "./modules/signal-handler.js";
+import { executeTask } from "./modules/task-executor.js";
 // Store tasks for each pipeline (for nested pipeline skip tracking)
 const pipelineTasksCache = new WeakMap();
 /**
@@ -21,27 +20,21 @@ const pipelineTasksCache = new WeakMap();
  * await pipeline([task1, task2]).run()
  */
 export function pipeline(tasks) {
-    const graph = createTaskGraph(tasks);
+    const tasksClone = [...tasks];
+    validateTasks(tasksClone);
+    const graph = createTaskGraph(tasksClone);
     graph.validate();
     graph.simplify();
     const pipelineImpl = {
-        toTask(config) {
-            validateTasks(config.dependencies);
+        toTask({ name, dependencies }) {
             const syntheticTask = task({
-                name: config.name,
+                name,
                 commands: {},
-                cwd: ".", // Dummy cwd
-                dependencies: [...(config.dependencies || [])],
+                cwd: ".",
+                dependencies,
             });
-            // Mark this task as a pipeline task
+            // Mark this task as a pipeline task so it can be detected by the executor
             syntheticTask[$TASK_INTERNAL].pipeline = pipelineImpl;
-            // Cache this conversion
-            let cache = pipelineTaskCache.get(pipelineImpl);
-            if (!cache) {
-                cache = new Map();
-                pipelineTaskCache.set(pipelineImpl, cache);
-            }
-            cache.set(config.name, syntheticTask);
             return syntheticTask;
         },
         async run(config) {
@@ -49,144 +42,100 @@ export function pipeline(tasks) {
             const signal = config?.signal;
             const runningTasks = new Map();
             const runningPipelines = new Map();
-            const teardownCommands = new Map();
             let failed = false;
+            const command = config?.command ??
+                (process.env.NODE_ENV === "production" ? "build" : "dev");
+            const startedAt = Date.now();
+            // Initialize task stats tracking
+            const taskStats = new Map();
+            for (const [taskId, node] of graph.nodes) {
+                const task = node.task;
+                taskStats.set(taskId, {
+                    id: taskId,
+                    name: task.name,
+                    status: "pending",
+                    dependencies: Array.from(node.dependencies),
+                    dependents: Array.from(node.dependents),
+                });
+            }
+            // Helper to update task status
+            const updateTaskStatus = (taskId, updates) => {
+                const stats = taskStats.get(taskId);
+                if (stats) {
+                    Object.assign(stats, updates);
+                }
+            };
             // Check if signal is already aborted
             if (signal?.aborted) {
-                throw new PipelineError("Aborted", PipelineError.Aborted);
+                const error = new PipelineError("Aborted", PipelineError.Aborted);
+                return buildResult(error, startedAt, command, taskStats, "aborted");
             }
             const scheduler = createScheduler(graph);
             let completionResolver = null;
-            let completionRejector = null;
-            const completionPromise = new Promise((resolve, reject) => {
+            const completionPromise = new Promise((resolve) => {
                 completionResolver = resolve;
-                completionRejector = reject;
             });
-            const executeTeardown = (taskId) => {
-                const teardown = teardownCommands.get(taskId);
-                if (!teardown)
-                    return Promise.resolve();
-                // Remove from map so it doesn't run again
-                teardownCommands.delete(taskId);
-                config?.onTaskTeardown?.(teardown.taskName);
-                return new Promise((resolve) => {
-                    try {
-                        const teardownProcess = spawnFn(teardown.command, {
-                            cwd: teardown.cwd,
-                            stdio: "inherit",
-                            shell: true,
-                        });
-                        let resolved = false;
-                        const resolveOnce = () => {
-                            if (!resolved) {
-                                resolved = true;
-                                resolve();
-                            }
-                        };
-                        teardownProcess.on("error", (error) => {
-                            const teardownError = new Error(`[${teardown.taskName}] Teardown failed: ${error.message}`);
-                            config?.onTaskTeardownError?.(teardown.taskName, teardownError);
-                            resolveOnce();
-                        });
-                        teardownProcess.on("exit", (code) => {
-                            if (code !== 0) {
-                                const teardownError = new Error(`[${teardown.taskName}] Teardown failed with exit code ${code ?? 1}`);
-                                config?.onTaskTeardownError?.(teardown.taskName, teardownError);
-                            }
-                            resolveOnce();
-                        });
+            // Initialize teardown manager with stats tracking
+            const teardownManager = createTeardownManager({
+                ...config,
+                spawn: spawnFn,
+                updateTaskTeardownStatus: (taskId, status, error) => {
+                    const stats = taskStats.get(taskId);
+                    if (stats) {
+                        stats.teardown = { status, error };
                     }
-                    catch (error) {
-                        const teardownError = new Error(`[${teardown.taskName}] Teardown failed to start: ${error.message}`);
-                        config?.onTaskTeardownError?.(teardown.taskName, teardownError);
-                        resolve();
-                    }
-                });
-            };
-            const executeAllTeardowns = async () => {
-                // Execute teardowns in reverse dependency order
-                // Tasks with dependents should be torn down before their dependencies
-                const taskIdsWithTeardown = Array.from(teardownCommands.keys());
-                if (taskIdsWithTeardown.length === 0) {
+                },
+            });
+            const advanceScheduler = (input) => {
+                // Check if signal is aborted before advancing scheduler
+                if (signal?.aborted) {
+                    failPipeline(new PipelineError("Aborted", PipelineError.Aborted));
                     return;
                 }
-                // Calculate reverse topological order
-                // Tasks that have dependents should be torn down first
-                const teardownOrder = getReverseDependencyOrder(taskIdsWithTeardown, graph);
-                // Execute teardowns sequentially in reverse dependency order
-                // This ensures dependents are torn down before their dependencies
-                for (const taskId of teardownOrder) {
-                    await executeTeardown(taskId);
+                let result = input ? scheduler.next(input) : scheduler.next();
+                // If we passed skip/complete input and got "idle", the generator processed it
+                // but returned the old yield. Call next() again to get the result after processing.
+                if (input &&
+                    (input.type === "skip" || input.type === "complete") &&
+                    result.value?.type === "idle") {
+                    result = scheduler.next();
                 }
-            };
-            const getReverseDependencyOrder = (taskIds, graph) => {
-                // Create a set for quick lookup
-                const taskIdSet = new Set(taskIds);
-                // For reverse dependency order, we want to tear down dependents before dependencies
-                // If api depends on db, we want: api first, then db
-                // This is the reverse of normal execution order
-                // Count how many dependencies each task has (within the teardown set)
-                const dependencyCount = new Map();
-                for (const taskId of taskIds) {
-                    const node = graph.nodes.get(taskId);
-                    if (node) {
-                        let count = 0;
-                        for (const depId of node.dependencies) {
-                            if (taskIdSet.has(depId)) {
-                                count++;
-                            }
-                        }
-                        dependencyCount.set(taskId, count);
+                while (true) {
+                    // Check signal again in the loop
+                    if (signal?.aborted) {
+                        failPipeline(new PipelineError("Aborted", PipelineError.Aborted));
+                        return;
                     }
-                }
-                // Build result in reverse order
-                // Start with tasks that have no dependencies (leaf nodes) - these go LAST
-                const result = [];
-                const visited = new Set();
-                const queue = [];
-                // Find leaf nodes (tasks with no dependencies in teardown set)
-                for (const taskId of taskIds) {
-                    if (dependencyCount.get(taskId) === 0) {
-                        queue.push(taskId);
+                    const event = result.value;
+                    const isFinished = result.done && result.value.type === "done";
+                    if (isFinished) {
+                        completionResolver?.(null);
+                        return;
                     }
-                }
-                // Process in reverse topological order
-                while (queue.length > 0) {
-                    const taskId = queue.shift();
-                    if (visited.has(taskId))
+                    if (event.type === "run") {
+                        startTask(graph.nodes.get(event.taskId).task);
+                        result = scheduler.next();
                         continue;
-                    visited.add(taskId);
-                    // Add to front (so we get reverse order: dependents before dependencies)
-                    result.unshift(taskId);
-                    // Find tasks that depend on this one (dependents)
-                    const node = graph.nodes.get(taskId);
-                    if (node) {
-                        for (const dependentId of node.dependents) {
-                            if (taskIdSet.has(dependentId) && !visited.has(dependentId)) {
-                                const currentCount = dependencyCount.get(dependentId) ?? 0;
-                                const newCount = currentCount - 1;
-                                dependencyCount.set(dependentId, newCount);
-                                // When a dependent has no more dependencies to wait for, add it to queue
-                                if (newCount === 0) {
-                                    queue.push(dependentId);
-                                }
-                            }
-                        }
                     }
-                }
-                // Add any remaining tasks (shouldn't happen in a valid graph, but handle it)
-                for (const taskId of taskIds) {
-                    if (!visited.has(taskId)) {
-                        result.unshift(taskId);
+                    if (event.type === "idle") {
+                        return;
                     }
                 }
-                return result;
             };
             const failPipeline = async (error) => {
                 if (failed)
                     return;
                 failed = true;
-                for (const child of runningTasks.values()) {
+                // Mark running tasks as aborted
+                for (const [taskId, child] of runningTasks.entries()) {
+                    updateTaskStatus(taskId, {
+                        status: "aborted",
+                        finishedAt: Date.now(),
+                    });
+                    const stats = taskStats.get(taskId);
+                    if (stats && stats.startedAt) {
+                        stats.durationMs = stats.finishedAt - stats.startedAt;
+                    }
                     try {
                         child.kill("SIGTERM");
                     }
@@ -202,379 +151,113 @@ export function pipeline(tasks) {
                 // Execute all teardown commands and wait for them to complete
                 // Even if teardowns fail, we still want to reject the pipeline
                 try {
-                    await executeAllTeardowns();
+                    await teardownManager.executeAll(graph);
                 }
                 catch (teardownError) {
                     // Teardown errors are already reported via onTaskTeardownError
                     // We continue to reject the pipeline with the original error
                 }
-                config?.onPipelineError?.(error);
-                completionRejector?.(error);
+                completionResolver?.(error);
             };
             const startTask = (task) => {
-                // Check if signal is aborted before starting new tasks
-                if (signal?.aborted) {
-                    failPipeline(new PipelineError("Aborted", PipelineError.InvalidSignal));
-                    return;
-                }
-                const { name: taskName, [$TASK_INTERNAL]: { id: taskId, pipeline: nestedPipeline }, } = task;
-                if (runningTasks.has(taskId))
-                    return;
-                // Handle pipeline tasks
-                if (nestedPipeline) {
-                    // Track nested pipeline state for skip behavior
-                    let nestedSkippedCount = 0;
-                    let nestedCompletedCount = 0;
-                    // Get total tasks from nested pipeline
-                    const nestedTasks = pipelineTasksCache.get(nestedPipeline);
-                    const nestedTotalTasks = nestedTasks
-                        ? createTaskGraph(nestedTasks).nodes.size
-                        : 0;
-                    // Mark as ready immediately (pipeline entry nodes will handle their own ready state)
-                    advanceScheduler({ type: "ready", taskId });
-                    config?.onTaskBegin?.(taskName);
-                    // Create an abort controller to stop the nested pipeline if needed
-                    let pipelineStopped = false;
-                    const stopPipeline = () => {
-                        pipelineStopped = true;
-                        // The nested pipeline will continue running, but we've marked it as stopped
-                        // In a more sophisticated implementation, we could propagate stop signals
-                    };
-                    runningPipelines.set(taskId, { stop: stopPipeline });
-                    // Run the nested pipeline with signal propagation
-                    nestedPipeline
-                        .run({
-                        spawn: spawnFn,
-                        command: config?.command,
-                        strict: config?.strict,
-                        signal, // Pass signal to nested pipeline
-                        onTaskBegin: (nestedTaskName) => {
-                            if (pipelineStopped)
-                                return;
-                            config?.onTaskBegin?.(`${taskName}:${nestedTaskName}`);
-                        },
-                        onTaskComplete: (nestedTaskName) => {
-                            if (pipelineStopped)
-                                return;
-                            nestedCompletedCount++;
-                            config?.onTaskComplete?.(`${taskName}:${nestedTaskName}`);
-                        },
-                        onTaskSkipped: (nestedTaskName, mode) => {
-                            if (pipelineStopped)
-                                return;
-                            nestedSkippedCount++;
-                            config?.onTaskSkipped?.(`${taskName}:${nestedTaskName}`, mode);
-                        },
-                        onPipelineError: (error) => {
-                            if (pipelineStopped)
-                                return;
-                            runningPipelines.delete(taskId);
-                            // error is already a PipelineError
-                            failPipeline(error);
-                        },
-                        onPipelineComplete: () => {
-                            if (pipelineStopped)
-                                return;
-                            runningPipelines.delete(taskId);
-                            // Determine nested pipeline result based on skip behavior:
-                            // - If all inner tasks are skipped → outer task is skipped
-                            // - If some run, some skip → outer task is completed
-                            // - If any fail → outer task fails (handled in onPipelineError)
-                            const commandName = config?.command ?? process.env.NODE_ENV === "production"
-                                ? "build"
-                                : "dev";
-                            if (nestedSkippedCount === nestedTotalTasks &&
-                                nestedTotalTasks > 0) {
-                                // All tasks were skipped
-                                console.log(`[${taskName}] skipped (all nested tasks skipped)`);
-                                config?.onTaskSkipped?.(taskName, commandName);
-                                setImmediate(() => {
-                                    advanceScheduler({ type: "skip", taskId });
-                                });
-                            }
-                            else {
-                                // Some tasks ran (and completed successfully)
-                                config?.onTaskComplete?.(taskName);
-                                advanceScheduler({ type: "complete", taskId });
-                            }
-                        },
-                    })
-                        .catch((error) => {
-                        if (pipelineStopped)
-                            return;
-                        runningPipelines.delete(taskId);
-                        failPipeline(error);
-                    });
-                    return;
-                }
-                // Regular task execution
-                const commandName = config?.command ?? process.env.NODE_ENV === "production"
-                    ? "build"
-                    : "dev";
-                const commandConfig = task[$TASK_INTERNAL].commands[commandName];
-                // Check if command exists
-                if (commandConfig === undefined) {
-                    const allowSkip = task[$TASK_INTERNAL].allowSkip ?? false;
-                    const strict = config?.strict ?? false;
-                    // If strict mode and not explicitly allowed to skip, fail
-                    if (strict && !allowSkip) {
-                        failPipeline(new PipelineError(`[${taskName}] No command for "${commandName}" and strict mode is enabled`, PipelineError.TaskFailed));
-                        return;
-                    }
-                    // Skip the task
-                    console.log(`[${taskName}] skipped "${commandName}"`);
-                    config?.onTaskSkipped?.(taskName, commandName);
-                    // Mark as skipped - this satisfies dependencies and unblocks dependents
-                    // Use setImmediate to ensure scheduler is at idle yield before receiving skip
-                    setImmediate(() => {
-                        advanceScheduler({ type: "skip", taskId });
-                    });
-                    return;
-                }
-                const command = typeof commandConfig === "string" ? commandConfig : commandConfig.run;
-                const readyWhen = typeof commandConfig === "string"
-                    ? undefined
-                    : commandConfig.readyWhen;
-                const readyTimeout = typeof commandConfig === "string"
-                    ? Infinity
-                    : commandConfig.readyTimeout ?? Infinity;
-                const teardown = typeof commandConfig === "string" ? undefined : commandConfig.teardown;
-                const { cwd } = task[$TASK_INTERNAL];
-                const taskCwd = path.isAbsolute(cwd)
-                    ? cwd
-                    : path.resolve(process.cwd(), cwd);
-                if (!fs.existsSync(taskCwd)) {
-                    failPipeline(new PipelineError(`[${taskName}] Working directory does not exist: ${taskCwd}`, PipelineError.InvalidTask));
-                    return;
-                }
-                const accumulatedPath = [
-                    path.join(taskCwd, "node_modules", ".bin"),
-                    path.join(process.cwd(), "node_modules", ".bin"),
-                    process.env.PATH,
-                ]
-                    .filter(Boolean)
-                    .join(process.platform === "win32" ? ";" : ":");
-                const env = {
-                    ...process.env,
-                    PATH: accumulatedPath,
-                    Path: accumulatedPath,
-                };
-                const child = spawnFn(command, {
-                    cwd: taskCwd,
-                    stdio: ["inherit", "pipe", "pipe"],
-                    shell: true,
-                    env,
+                executeTask(task, {
+                    spawn: spawnFn,
+                    signal,
+                    config,
+                    graph,
+                    runningTasks,
+                    runningPipelines,
+                    teardownManager,
+                    pipelineTasksCache,
+                    failPipeline,
+                    advanceScheduler,
+                    updateTaskStatus,
+                    taskStats,
                 });
-                runningTasks.set(taskId, child);
-                // Store teardown command if provided
-                if (teardown) {
-                    teardownCommands.set(taskId, {
-                        command: teardown,
-                        cwd: taskCwd,
-                        taskName,
-                    });
-                }
-                config?.onTaskBegin?.(taskName);
-                let didMarkReady = false;
-                let readyTimeoutId = null;
-                if (!readyWhen) {
-                    advanceScheduler({ type: "ready", taskId });
-                    didMarkReady = true;
-                }
-                else if (readyTimeout !== Infinity) {
-                    // Set up timeout for readyWhen condition
-                    readyTimeoutId = setTimeout(() => {
-                        if (!didMarkReady) {
-                            failPipeline(new PipelineError(`[${taskName}] Task did not become ready within ${readyTimeout}ms`, PipelineError.TaskFailed));
-                        }
-                    }, readyTimeout);
-                }
-                let output = "";
-                child.stdout?.on("data", (buf) => {
-                    // Check if signal is aborted before processing stdout
-                    if (signal?.aborted) {
-                        return;
-                    }
-                    const chunk = buf.toString();
-                    output += chunk;
-                    process.stdout.write(chunk);
-                    if (!didMarkReady && readyWhen && readyWhen(output)) {
-                        if (readyTimeoutId) {
-                            clearTimeout(readyTimeoutId);
-                            readyTimeoutId = null;
-                        }
-                        advanceScheduler({ type: "ready", taskId });
-                        didMarkReady = true;
-                    }
-                });
-                child.stderr?.on("data", (buf) => {
-                    process.stderr.write(buf);
-                });
-                child.on("error", (error) => {
-                    // Task failed before entering running state, so don't execute teardown
-                    // Remove teardown from map since it was never actually running
-                    teardownCommands.delete(taskId);
-                    // Clear ready timeout if it exists
-                    if (readyTimeoutId) {
-                        clearTimeout(readyTimeoutId);
-                        readyTimeoutId = null;
-                    }
-                    failPipeline(new PipelineError(`[${taskName}] Failed to start: ${error.message}`, PipelineError.TaskFailed));
-                });
-                child.on("exit", (code) => {
-                    runningTasks.delete(taskId);
-                    // Clear ready timeout if it exists
-                    if (readyTimeoutId) {
-                        clearTimeout(readyTimeoutId);
-                        readyTimeoutId = null;
-                    }
-                    // Don't execute teardown immediately - it will be executed in reverse dependency order
-                    // when the pipeline completes or fails
-                    if (code !== 0) {
-                        failPipeline(new PipelineError(`[${taskName}] Task failed with exit code ${code ?? 1}`, PipelineError.TaskFailed));
-                        return;
-                    }
-                    config?.onTaskComplete?.(taskName);
-                    // 🔑 Notify scheduler and drain newly runnable tasks
-                    advanceScheduler({ type: "complete", taskId });
-                });
-            };
-            const advanceScheduler = (input) => {
-                // Check if signal is aborted before advancing scheduler
-                if (signal?.aborted) {
-                    failPipeline(new PipelineError("Aborted", PipelineError.Aborted));
-                    return;
-                }
-                let result = input ? scheduler.next(input) : scheduler.next();
-                // If we passed skip/complete input and got "idle", the generator processed it
-                // but returned the old yield. Call next() again to get the result after processing.
-                if (input &&
-                    (input.type === "skip" || input.type === "complete") &&
-                    result.value?.type === "idle") {
-                    result = scheduler.next();
-                }
-                while (true) {
-                    // Check signal again in the loop
-                    if (signal?.aborted) {
-                        failPipeline(new PipelineError("Aborted", PipelineError.Aborted));
-                        return;
-                    }
-                    const event = result.value;
-                    const isFinished = result.done && result.value.type === "done";
-                    if (isFinished) {
-                        config?.onPipelineComplete?.();
-                        completionResolver?.();
-                        return;
-                    }
-                    if (event.type === "run") {
-                        startTask(graph.nodes.get(event.taskId).task);
-                        result = scheduler.next();
-                        continue;
-                    }
-                    if (event.type === "idle") {
-                        return;
-                    }
-                }
             };
-            // Handle termination signals
-            const processTerminationListenerCleanups = [
-                "SIGINT",
-                "SIGTERM",
-                "SIGQUIT",
-                "SIGBREAK",
-            ].map((sig) => {
-                const handleSignal = () => {
-                    failPipeline(new PipelineError(`Received ${sig}`, PipelineError.ProcessTerminated));
-                };
-                process.once(sig, handleSignal);
-                return () => {
-                    process.removeListener(sig, handleSignal);
-                };
+            // Initialize signal handler
+            const signalHandler = createSignalHandler({
+                abortSignal: signal,
+                onAborted: () => failPipeline(new PipelineError("Aborted", PipelineError.Aborted)),
+                onProcessTerminated: (message) => new PipelineError(message, PipelineError.ProcessTerminated),
             });
-            // Handle abort signal if provided
-            let signalCleanup = null;
-            if (signal) {
-                const handleAbort = () => {
-                    failPipeline(new PipelineError("Aborted", PipelineError.Aborted));
-                };
-                signal.addEventListener("abort", handleAbort);
-                signalCleanup = () => {
-                    signal.removeEventListener("abort", handleAbort);
-                };
-            }
             // 🚀 Kick off initial runnable tasks
             advanceScheduler();
-            await completionPromise
-                .then(async () => {
-                // Pipeline completed successfully - execute any remaining teardowns
+            const error = await completionPromise.then(async (err) => {
+                // Pipeline completed - execute any remaining teardowns
                 // (for tasks that completed successfully) and wait for them to complete
                 // Even if teardowns fail, the pipeline still resolves successfully
                 // (teardown errors are reported via onTaskTeardownError)
                 try {
-                    await executeAllTeardowns();
+                    await teardownManager.executeAll(graph);
                 }
                 catch (teardownError) {
                     // Teardown errors are already reported via onTaskTeardownError
                     // The pipeline still resolves successfully
                 }
-            })
-                .finally(() => {
-                processTerminationListenerCleanups.forEach((cleanup) => cleanup());
-                signalCleanup?.();
+                return err;
             });
+            signalHandler.cleanup();
+            const status = error
+                ? error.code === PipelineError.Aborted
+                    ? "aborted"
+                    : "failed"
+                : "success";
+            return buildResult(error, startedAt, command, taskStats, status);
         },
     };
     // Store tasks for nested pipeline skip tracking
-    pipelineTasksCache.set(pipelineImpl, tasks);
+    pipelineTasksCache.set(pipelineImpl, tasksClone);
     return pipelineImpl;
 }
-export class PipelineError extends Error {
-    constructor(message, code, taskName) {
-        super(message);
-        Object.defineProperty(this, "code", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "taskName", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "PipelineError";
-        this.code = code;
-        this.taskName = taskName;
+function buildResult(error, startedAt, command, taskStats, status) {
+    const finishedAt = Date.now();
+    const durationMs = finishedAt - startedAt;
+    // Convert task stats map to record
+    const tasks = {};
+    for (const [taskId, stats] of taskStats) {
+        tasks[taskId] = stats;
+    }
+    // Calculate summary
+    let completed = 0;
+    let failed = 0;
+    let skipped = 0;
+    let running = 0;
+    for (const stats of taskStats.values()) {
+        switch (stats.status) {
+            case "completed":
+                completed++;
+                break;
+            case "failed":
+                failed++;
+                break;
+            case "skipped":
+                skipped++;
+                break;
+            case "running":
+                running++;
+                break;
+        }
+    }
+    const pipelineStats = {
+        command,
+        startedAt,
+        finishedAt,
+        durationMs,
+        status,
+        tasks,
+        summary: {
+            total: taskStats.size,
+            completed,
+            failed,
+            skipped,
+            running,
+        },
+    };
+    if (error) {
+        return { ok: false, error, stats: pipelineStats };
+    }
+    else {
+        return { ok: true, error: null, stats: pipelineStats };
     }
 }
-Object.defineProperty(PipelineError, "Aborted", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: 0
-});
-Object.defineProperty(PipelineError, "ProcessTerminated", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: 1
-});
-Object.defineProperty(PipelineError, "TaskFailed", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: 2
-});
-Object.defineProperty(PipelineError, "InvalidSignal", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: 3
-});
-Object.defineProperty(PipelineError, "InvalidTask", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: 4
-});