agent-pipeline 0.1.0 → 0.1.1

package/dist/core/pipeline-runner.js

@@ -7,10 +7,10 @@ import { PipelineInitializer } from './pipeline-initializer.js';
 import { GroupExecutionOrchestrator } from './group-execution-orchestrator.js';
 import { PipelineFinalizer } from './pipeline-finalizer.js';
 import { NotificationManager } from '../notifications/notification-manager.js';
-import { ProjectConfigLoader } from '../config/project-config-loader.js';
 import { PipelineLoader } from '../config/pipeline-loader.js';
 import { LoopStateManager } from './loop-state-manager.js';
 import { AgentRuntimeRegistry } from './agent-runtime-registry.js';
+import { PipelineAbortError } from './abort-controller.js';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 export class PipelineRunner {
@@ -27,8 +27,9 @@ export class PipelineRunner {
     repoPath;
     runtime;
     stateUpdateCallbacks = [];
-    projectConfigLoader;
     loopStateManager;
+    loopExecutionDirs;
+    loopMainDirs;
     constructor(repoPath, dryRun = false) {
         this.repoPath = repoPath;
         this.dryRun = dryRun;
@@ -37,55 +38,71 @@ export class PipelineRunner {
         this.prCreator = new PRCreator();
         this.stateManager = new StateManager(repoPath);
         this.dagPlanner = new DAGPlanner();
-        this.projectConfigLoader = new ProjectConfigLoader(repoPath);
         this.loopStateManager = new LoopStateManager(repoPath);
-        this.runtime = AgentRuntimeRegistry.getRuntime('claude-sdk');
-        this.initializer = new PipelineInitializer(this.gitManager, this.branchManager, this.repoPath, this.dryRun, this.runtime);
-        this.groupOrchestrator = new GroupExecutionOrchestrator(this.gitManager, this.stateManager, this.repoPath, this.dryRun, this.runtime, this.shouldLog.bind(this), this.notifyStateChange.bind(this), this.notifyStageResults.bind(this));
+        this.runtime = AgentRuntimeRegistry.getRuntime('claude-code-headless');
+        this.initializer = new PipelineInitializer(this.gitManager, this.repoPath, this.dryRun, this.runtime);
+        this.groupOrchestrator = new GroupExecutionOrchestrator(this.stateManager, this.shouldLog.bind(this), this.notifyStateChange.bind(this), this.notifyStageResults.bind(this));
         this.finalizer = new PipelineFinalizer(this.gitManager, this.branchManager, this.prCreator, this.stateManager, this.repoPath, this.dryRun, this.shouldLog.bind(this));
     }
     shouldLog(interactive) {
         return !interactive;
     }
     async notifyStageResults(executions, state) {
+        const notificationContexts = [];
         for (const execution of executions) {
             if (execution.status === 'success') {
-                await this.notify({
+                notificationContexts.push({
                     event: 'stage.completed',
                     pipelineState: state,
                     stage: execution
                 });
             }
             else if (execution.status === 'failed') {
-                await this.notify({
+                notificationContexts.push({
                     event: 'stage.failed',
                     pipelineState: state,
                     stage: execution
                 });
             }
         }
+        if (notificationContexts.length > 0) {
+            await Promise.all(notificationContexts.map(context => this.notify(context)));
+        }
     }
     async runPipeline(config, options = {}) {
         const interactive = options.interactive || false;
+        const verbose = options.verbose || false;
         const notificationManager = config.notifications
             ? new NotificationManager(config.notifications)
             : undefined;
-        const loopingConfig = await this.projectConfigLoader.loadLoopingConfig();
-        let loopEnabled = options.loop || false;
-        if (loopEnabled && !loopingConfig.enabled) {
-            console.warn('⚠️  Loop mode requested but looping is disabled in config');
+        this.loopExecutionDirs = undefined;
+        this.loopMainDirs = undefined;
+        let loopSession;
+        let loopEnabled;
+        let loopingConfig;
+        if (options.loop === false) {
             loopEnabled = false;
+            loopingConfig = this.getDefaultLoopingConfig();
+        }
+        else {
+            loopEnabled = config.looping?.enabled ?? false;
+            if (loopEnabled) {
+                loopSession = await this.loopStateManager.startSession(options.maxLoopIterations ?? config.looping?.maxIterations ?? 100);
+                loopingConfig = config.looping;
+            }
+            else {
+                loopingConfig = this.getDefaultLoopingConfig();
+            }
         }
-        const maxIterations = options.maxLoopIterations ?? loopingConfig.maxIterations ?? 100;
+        const maxIterations = options.maxLoopIterations ?? loopingConfig.maxIterations;
         let iterationCount = 0;
         let lastState;
         let currentConfig = config;
         let currentMetadata = options.loopMetadata;
         let loopTerminationReason = 'natural';
-        let loopSession;
-        if (loopEnabled) {
-            loopSession = this.loopStateManager.startSession(maxIterations);
-        }
+        let loopDirCreated = false;
+        let loopDirs = loopingConfig.directories;
+        const loopIterationHistory = [];
         while (true) {
             iterationCount++;
             if (iterationCount > maxIterations) {
@@ -99,20 +116,65 @@ export class PipelineRunner {
                     : currentConfig.name;
                 console.log(`🔁 Loop iteration ${iterationCount}: Running pipeline '${pipelineName}'...`);
             }
+            if (loopEnabled && loopSession) {
+                const pipelineName = this.getPipelineName(currentConfig, currentMetadata);
+                await this.loopStateManager.appendIteration(loopSession.sessionId, {
+                    iterationNumber: iterationCount,
+                    pipelineName,
+                    status: 'in-progress'
+                });
+            }
             const loopContext = loopEnabled && loopingConfig.enabled
                 ? {
                     enabled: true,
-                    directories: loopingConfig.directories,
+                    directories: loopDirs,
                     currentIteration: iterationCount,
-                    maxIterations
+                    maxIterations,
+                    sessionId: loopSession?.sessionId
                 }
                 : undefined;
             lastState = await this._executeSinglePipeline(currentConfig, currentMetadata, {
                 interactive,
+                verbose,
                 notificationManager,
                 loopContext,
-                loopSessionId: loopSession?.sessionId
+                loopSessionId: loopSession?.sessionId,
+                abortController: options.abortController,
+                isFirstLoopIteration: loopEnabled && !loopDirCreated,
+                suppressCompletionNotification: loopEnabled
             });
+            if (loopEnabled && !loopDirCreated && loopContext) {
+                loopDirCreated = true;
+                loopDirs = loopContext.directories;
+            }
+            if (loopEnabled && lastState) {
+                let totalInput = 0;
+                let totalOutput = 0;
+                let totalCacheRead = 0;
+                for (const stage of lastState.stages) {
+                    if (stage.tokenUsage) {
+                        totalInput += stage.tokenUsage.actual_input || 0;
+                        totalOutput += stage.tokenUsage.output || 0;
+                        totalCacheRead += stage.tokenUsage.cache_read || 0;
+                    }
+                }
+                const historyEntry = {
+                    iterationNumber: iterationCount,
+                    pipelineName: currentMetadata?.sourcePath
+                        ? path.basename(currentMetadata.sourcePath, '.yml')
+                        : currentConfig.name,
+                    status: lastState.status === 'completed' ? 'completed'
+                        : lastState.status === 'aborted' ? 'aborted' : 'failed',
+                    duration: lastState.artifacts.totalDuration,
+                    commitCount: lastState.stages.filter(s => s.commitSha).length,
+                    stageCount: lastState.stages.length,
+                    successfulStages: lastState.stages.filter(s => s.status === 'success').length,
+                    failedStages: lastState.stages.filter(s => s.status === 'failed').length,
+                    tokenUsage: totalInput > 0 ? { totalInput, totalOutput, totalCacheRead } : undefined
+                };
+                loopIterationHistory.push(historyEntry);
+                lastState.loopIterationHistory = [...loopIterationHistory];
+            }
             this.notifyStateChange(lastState);
             if (this.shouldLog(interactive) && loopEnabled && lastState.status === 'completed') {
                 console.log(`✅ Completed iteration ${iterationCount}`);
@@ -120,8 +182,8 @@ export class PipelineRunner {
             if (currentMetadata?.sourceType === 'loop-pending') {
                 try {
                     const destDir = lastState.status === 'completed'
-                        ? loopingConfig.directories.finished
-                        : loopingConfig.directories.failed;
+                        ? loopDirs.finished
+                        : loopDirs.failed;
                     const fileName = path.basename(currentMetadata.sourcePath);
                     await this._moveFile(currentMetadata.sourcePath, destDir, fileName);
                     if (this.shouldLog(interactive)) {
@@ -133,26 +195,38 @@ export class PipelineRunner {
                     console.error(`⚠️  Failed to move pipeline file: ${error}`);
                 }
             }
-            if (lastState.status === 'failed') {
+            if (lastState.status === 'aborted') {
                 if (loopEnabled && loopSession) {
                     await this.recordIteration(loopSession.sessionId, lastState, currentMetadata, false);
                 }
-                loopTerminationReason = 'failure';
-                const pipelineName = currentMetadata?.sourcePath
-                    ? path.basename(currentMetadata.sourcePath, '.yml')
-                    : currentConfig.name;
                 if (this.shouldLog(interactive)) {
-                    console.log(`Loop: terminating after failure of ${pipelineName}`);
+                    console.log('Loop: terminating due to abort');
                 }
                 break;
             }
+            if (lastState.status === 'failed') {
+                if (loopEnabled && loopSession) {
+                    await this.recordIteration(loopSession.sessionId, lastState, currentMetadata, false);
+                }
+                const failureStrategy = currentConfig.execution?.failureStrategy ?? 'stop';
+                if (failureStrategy === 'stop') {
+                    loopTerminationReason = 'failure';
+                    const pipelineName = currentMetadata?.sourcePath
+                        ? path.basename(currentMetadata.sourcePath, '.yml')
+                        : currentConfig.name;
+                    if (this.shouldLog(interactive)) {
+                        console.log(`Loop: terminating after failure of ${pipelineName}`);
+                    }
+                    break;
+                }
+            }
             if (!loopEnabled) {
                 if (loopSession) {
                     await this.recordIteration(loopSession.sessionId, lastState, currentMetadata, false);
                 }
                 break;
             }
-            const nextFile = await this._findNextPipelineFile(loopingConfig);
+            const nextFile = await this._findNextPipelineFile(loopDirs);
             const triggeredNext = nextFile !== undefined;
             if (loopSession) {
                 await this.recordIteration(loopSession.sessionId, lastState, currentMetadata, triggeredNext);
@@ -166,7 +240,7 @@ export class PipelineRunner {
             const fileName = path.basename(nextFile);
             let runningPath;
             try {
-                runningPath = await this._moveFile(nextFile, loopingConfig.directories.running, fileName);
+                runningPath = await this._moveFile(nextFile, loopDirs.running, fileName);
             }
             catch (error) {
                 console.error(`❌ Failed to move ${fileName} to running directory: ${error}`);
@@ -181,7 +255,7 @@ export class PipelineRunner {
             catch (error) {
                 console.error(`❌ Failed to load pipeline ${fileName}: ${error}`);
                 try {
-                    await this._moveFile(runningPath, loopingConfig.directories.failed, fileName);
+                    await this._moveFile(runningPath, loopDirs.failed, fileName);
                 }
                 catch (moveError) {
                     console.error(`⚠️  Failed to move ${fileName} to failed directory: ${moveError}`);
@@ -194,18 +268,55 @@ export class PipelineRunner {
         }
         if (lastState.loopContext) {
             lastState.loopContext.terminationReason = loopTerminationReason;
+            this.notifyStateChange(lastState);
+        }
+        if (loopEnabled &&
+            lastState.artifacts.worktreePath &&
+            this.loopExecutionDirs &&
+            this.loopMainDirs) {
+            try {
+                await this.copyLoopDirectories(this.loopExecutionDirs, this.loopMainDirs);
+                if (this.shouldLog(interactive)) {
+                    console.log('📋 Copied loop directories to main repo');
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️  Could not copy loop directories: ${error instanceof Error ? error.message : String(error)}`);
+            }
         }
         if (loopEnabled && loopSession) {
-            const sessionStatus = loopTerminationReason === 'natural' ? 'completed' :
-                loopTerminationReason === 'limit-reached' ? 'limit-reached' :
-                    'failed';
+            const sessionStatus = lastState.status === 'aborted' ? 'aborted' :
+                loopTerminationReason === 'natural' ? 'completed' :
+                    loopTerminationReason === 'limit-reached' ? 'limit-reached' :
+                        'failed';
             await this.loopStateManager.completeSession(loopSession.sessionId, sessionStatus);
         }
+        if (loopEnabled) {
+            const event = lastState.status === 'aborted'
+                ? 'pipeline.aborted'
+                : loopTerminationReason === 'natural'
+                    ? 'pipeline.completed'
+                    : 'pipeline.failed';
+            await this.notify({
+                event,
+                pipelineState: lastState,
+                metadata: {
+                    loopCompleted: loopTerminationReason === 'natural',
+                    terminationReason: loopTerminationReason,
+                    totalIterations: iterationCount
+                }
+            });
+        }
         return lastState;
     }
     notifyStateChange(state) {
+        const clonedState = {
+            ...state,
+            stages: [...state.stages],
+            artifacts: { ...state.artifacts }
+        };
         for (const callback of this.stateUpdateCallbacks) {
-            callback(state);
+            callback(clonedState);
         }
     }
     async notify(context) {
@@ -227,9 +338,85 @@ export class PipelineRunner {
     onStateChange(callback) {
         this.stateUpdateCallbacks.push(callback);
     }
-    async _findNextPipelineFile(loopingConfig) {
+    getDefaultLoopingConfig(sessionId) {
+        const baseDir = sessionId
+            ? `.agent-pipeline/loops/${sessionId}`
+            : '.agent-pipeline/loops/default';
+        return {
+            enabled: true,
+            maxIterations: 100,
+            directories: this.getSessionLoopDirs(this.repoPath, baseDir),
+        };
+    }
+    getSessionLoopDirs(basePath, sessionBaseDir) {
+        return {
+            pending: path.resolve(basePath, `${sessionBaseDir}/pending`),
+            running: path.resolve(basePath, `${sessionBaseDir}/running`),
+            finished: path.resolve(basePath, `${sessionBaseDir}/finished`),
+            failed: path.resolve(basePath, `${sessionBaseDir}/failed`),
+        };
+    }
+    resolveLoopDirectories(loopContext, executionRepoPath, worktreePath) {
+        const sessionId = loopContext.sessionId ?? 'default';
+        const sessionBaseDir = `.agent-pipeline/loops/${sessionId}`;
+        const sessionMainDirs = this.getSessionLoopDirs(this.repoPath, sessionBaseDir);
+        const sessionExecutionDirs = this.getSessionLoopDirs(executionRepoPath, sessionBaseDir);
+        const providedDirs = loopContext.directories;
+        const mainDirs = {
+            pending: providedDirs.pending || sessionMainDirs.pending,
+            running: providedDirs.running || sessionMainDirs.running,
+            finished: providedDirs.finished || sessionMainDirs.finished,
+            failed: providedDirs.failed || sessionMainDirs.failed,
+        };
+        if (!worktreePath) {
+            return { executionDirs: mainDirs, mainDirs, sessionExecutionDirs };
+        }
+        const executionDirs = {
+            pending: this.mapToExecutionDir(mainDirs.pending, executionRepoPath, sessionExecutionDirs.pending),
+            running: this.mapToExecutionDir(mainDirs.running, executionRepoPath, sessionExecutionDirs.running),
+            finished: this.mapToExecutionDir(mainDirs.finished, executionRepoPath, sessionExecutionDirs.finished),
+            failed: this.mapToExecutionDir(mainDirs.failed, executionRepoPath, sessionExecutionDirs.failed),
+        };
+        return { executionDirs, mainDirs, sessionExecutionDirs };
+    }
+    mapToExecutionDir(mainDir, executionRepoPath, fallbackDir) {
+        const relativePath = path.relative(this.repoPath, mainDir);
+        const isInsideRepo = relativePath && !relativePath.startsWith('..') && !path.isAbsolute(relativePath);
+        if (!isInsideRepo) {
+            return fallbackDir;
+        }
+        return path.resolve(executionRepoPath, relativePath);
+    }
+    areSameLoopDirs(left, right) {
+        return left.pending === right.pending &&
+            left.running === right.running &&
+            left.finished === right.finished &&
+            left.failed === right.failed;
+    }
+    async ensureLoopDirectoriesExist(directories) {
+        const dirs = [
+            directories.pending,
+            directories.running,
+            directories.finished,
+            directories.failed,
+        ];
+        await Promise.all(dirs.map(dir => fs.mkdir(dir, { recursive: true })));
+    }
+    async copyLoopDirectories(executionDirs, mainDirs) {
+        const dirPairs = [
+            { source: executionDirs.pending, dest: mainDirs.pending },
+            { source: executionDirs.running, dest: mainDirs.running },
+            { source: executionDirs.finished, dest: mainDirs.finished },
+            { source: executionDirs.failed, dest: mainDirs.failed },
+        ];
+        for (const { source, dest } of dirPairs) {
+            await fs.mkdir(path.dirname(dest), { recursive: true });
+            await fs.cp(source, dest, { recursive: true, force: true });
+        }
+    }
+    async _findNextPipelineFile(loopDirs) {
         try {
-            const pendingDir = loopingConfig.directories.pending;
+            const pendingDir = loopDirs.pending;
             const files = await fs.readdir(pendingDir);
             const yamlFiles = files.filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
             if (yamlFiles.length === 0) {
@@ -267,17 +454,84 @@ export class PipelineRunner {
         return destPath;
     }
     async _executeSinglePipeline(config, metadata, options) {
-        const { interactive, loopContext, loopSessionId } = options;
-        this.notificationManager = options.notificationManager;
-        const initResult = await this.initializer.initialize(config, {
-            interactive,
-            notificationManager: this.notificationManager,
-            loopContext,
-            loopSessionId,
-            metadata
-        }, this.notify.bind(this), this.notifyStateChange.bind(this));
-        let { state, parallelExecutor, pipelineBranch, originalBranch, startTime } = initResult;
+        const { interactive, verbose, loopContext, loopSessionId, abortController, isFirstLoopIteration, suppressCompletionNotification } = options;
+        this.notificationManager = options.notificationManager ||
+            (config.notifications ? new NotificationManager(config.notifications) : undefined);
+        let initResult;
+        try {
+            initResult = await this.initializer.initialize(config, {
+                interactive,
+                verbose,
+                notificationManager: this.notificationManager,
+                loopContext,
+                loopSessionId,
+                metadata,
+                abortController
+            }, this.notify.bind(this), this.notifyStateChange.bind(this));
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const now = new Date().toISOString();
+            if (this.shouldLog(interactive)) {
+                console.error(`\n❌ Pipeline initialization failed: ${errorMessage}\n`);
+            }
+            const failedState = {
+                runId: 'init-failed',
+                pipelineConfig: config,
+                trigger: {
+                    type: config.trigger,
+                    commitSha: '',
+                    timestamp: now
+                },
+                stages: [
+                    {
+                        stageName: 'pipeline-initialization',
+                        status: 'failed',
+                        startTime: now,
+                        endTime: now,
+                        duration: 0,
+                        error: {
+                            message: errorMessage,
+                            timestamp: now
+                        }
+                    }
+                ],
+                status: 'failed',
+                artifacts: {
+                    initialCommit: '',
+                    changedFiles: [],
+                    totalDuration: 0,
+                    handoverDir: ''
+                }
+            };
+            await this.notify({
+                event: 'pipeline.failed',
+                pipelineState: failedState,
+                metadata: { error: errorMessage }
+            });
+            return failedState;
+        }
+        let { state, parallelExecutor, pipelineBranch, worktreePath, executionRepoPath, startTime, pipelineLogger } = initResult;
         this.notificationManager = initResult.notificationManager;
+        if (isFirstLoopIteration && loopContext?.sessionId) {
+            const { executionDirs, mainDirs, sessionExecutionDirs } = this.resolveLoopDirectories(loopContext, executionRepoPath, worktreePath);
+            const usesSessionDirs = this.areSameLoopDirs(executionDirs, sessionExecutionDirs);
+            if (usesSessionDirs) {
+                await this.loopStateManager.createSessionDirectories(loopContext.sessionId, executionRepoPath);
+            }
+            else {
+                await this.ensureLoopDirectoriesExist(executionDirs);
+            }
+            loopContext.directories = executionDirs;
+            this.loopExecutionDirs = executionDirs;
+            this.loopMainDirs = mainDirs;
+            if (this.shouldLog(interactive)) {
+                const baseDir = usesSessionDirs
+                    ? this.loopStateManager.getSessionQueueDir(loopContext.sessionId, executionRepoPath)
+                    : executionRepoPath;
+                console.log(`📁 Created loop directories under: ${baseDir}`);
+            }
+        }
         try {
             const executionGraph = this.dagPlanner.buildExecutionPlan(config);
             if (this.shouldLog(interactive) && executionGraph.plan.groups.length > 0) {
@@ -288,39 +542,77 @@ export class PipelineRunner {
                 }
                 console.log('');
             }
-            for (const group of executionGraph.plan.groups) {
-                const result = await this.groupOrchestrator.processGroup(group, state, config, executionGraph, parallelExecutor, interactive);
+            const totalGroups = executionGraph.plan.groups.length;
+            let abortedAtGroup;
+            for (let groupIndex = 0; groupIndex < totalGroups; groupIndex++) {
+                if (abortController?.aborted) {
+                    state.status = 'aborted';
+                    abortedAtGroup = groupIndex + 1;
+                    break;
+                }
+                const group = executionGraph.plan.groups[groupIndex];
+                const isFinalGroup = groupIndex === totalGroups - 1;
+                const result = await this.groupOrchestrator.processGroup(group, state, config, parallelExecutor, interactive, initResult.handoverManager, { isFinalGroup }, verbose);
                 state = result.state;
+                if (abortController?.aborted) {
+                    state.status = 'aborted';
+                    abortedAtGroup = groupIndex + 1;
+                    break;
+                }
                 if (result.shouldStopPipeline) {
                     state.status = 'failed';
                     break;
                 }
             }
-            if (state.status === 'running') {
+            if (abortedAtGroup !== undefined && this.shouldLog(interactive)) {
+                console.log(`\n⚠️  Pipeline aborted at group ${abortedAtGroup}/${totalGroups}\n`);
+            }
+            if (state.status === 'running' && !abortController?.aborted) {
                 state.status = 'completed';
             }
         }
         catch (error) {
-            state.status = 'failed';
-            if (this.shouldLog(interactive)) {
-                console.error(`\n❌ Pipeline failed: ${error}\n`);
+            if (error instanceof PipelineAbortError || abortController?.aborted) {
+                state.status = 'aborted';
+                if (this.shouldLog(interactive)) {
+                    console.log(`\n⚠️  Pipeline aborted\n`);
+                }
+            }
+            else {
+                state.status = 'failed';
+                if (this.shouldLog(interactive)) {
+                    console.error(`\n❌ Pipeline failed: ${error}\n`);
+                }
             }
         }
-        state = await this.finalizer.finalize(state, config, pipelineBranch, originalBranch, startTime, interactive, this.notify.bind(this), this.notifyStateChange.bind(this));
+        state = await this.finalizer.finalize(state, config, pipelineBranch, worktreePath, executionRepoPath, startTime, interactive, verbose, this.notify.bind(this), this.notifyStateChange.bind(this), { suppressCompletionNotification, pipelineLogger });
         return state;
     }
     async recordIteration(sessionId, state, metadata, triggeredNext) {
-        const pipelineName = metadata?.sourcePath
-            ? path.basename(metadata.sourcePath, '.yml')
-            : state.pipelineConfig.name;
-        await this.loopStateManager.appendIteration(sessionId, {
-            iterationNumber: state.loopContext?.currentIteration ?? 1,
+        const pipelineName = this.getPipelineName(state.pipelineConfig, metadata);
+        const iterationNumber = state.loopContext?.currentIteration ?? 1;
+        const updated = await this.loopStateManager.updateIteration(sessionId, iterationNumber, {
             pipelineName,
             runId: state.runId,
-            status: state.status === 'completed' ? 'completed' : 'failed',
+            status: state.status === 'completed' ? 'completed' : state.status === 'aborted' ? 'aborted' : 'failed',
             duration: state.artifacts.totalDuration,
             triggeredNext
         });
+        if (!updated) {
+            await this.loopStateManager.appendIteration(sessionId, {
+                iterationNumber,
+                pipelineName,
+                runId: state.runId,
+                status: state.status === 'completed' ? 'completed' : state.status === 'aborted' ? 'aborted' : 'failed',
+                duration: state.artifacts.totalDuration,
+                triggeredNext
+            });
+        }
+    }
+    getPipelineName(config, metadata) {
+        return metadata?.sourcePath
+            ? path.basename(metadata.sourcePath, '.yml')
+            : config.name;
     }
 }
 //# sourceMappingURL=pipeline-runner.js.map