dartmind 17.0.0

package/dist/__tests__/pipeline.test.js

@@ -0,0 +1,729 @@
+/**
+ * DartMind V17 - Pipeline Tests
+ * Days 22-24: Pipeline (I2)
+ *
+ * Tests for end-to-end pipeline execution and stage management.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { 
+// Factory functions
+createPipeline, createDevelopmentPipeline, createAnalysisPipeline, createReviewPipeline, 
+// Stage functions
+createStage, createStageFromHandler, registerStageHandler, getStageHandler, listStageHandlers, 
+// Built-in handlers
+inputValidationHandler, planningHandler, generationHandler, validationHandler, reviewHandler, approvalHandler, executionHandler, cleanupHandler, 
+// Utility functions
+generatePipelineId, generateRunId, generateStageId, generateRequestId, isTerminalPipelineStatus, isTerminalStageStatus, createStageMetadata, createEmptyMetrics, createStageSuccess, createStageFailure, createPipelineRequest, formatPipelineStatus, formatStageStatus, hashData, mergeStageOptions, 
+// Constants
+DEFAULT_PIPELINE_CONFIG, DEFAULT_STAGE_OPTIONS, } from '../pipeline/index.js';
+// ============================================================================
+// Utility Function Tests
+// ============================================================================
+describe('Pipeline Utility Functions', () => {
+    describe('ID Generation', () => {
+        it('should generate unique pipeline IDs', () => {
+            const id1 = generatePipelineId();
+            const id2 = generatePipelineId();
+            expect(id1).toMatch(/^pipe_[a-z0-9]+_[a-z0-9]+$/);
+            expect(id2).toMatch(/^pipe_[a-z0-9]+_[a-z0-9]+$/);
+            expect(id1).not.toBe(id2);
+        });
+        it('should generate unique run IDs', () => {
+            const id1 = generateRunId();
+            const id2 = generateRunId();
+            expect(id1).toMatch(/^run_[a-z0-9]+_[a-z0-9]+$/);
+            expect(id1).not.toBe(id2);
+        });
+        it('should generate unique stage IDs', () => {
+            const id1 = generateStageId('analysis');
+            const id2 = generateStageId('generation');
+            expect(id1).toMatch(/^analysis_[a-z0-9]+_[a-z0-9]+$/);
+            expect(id2).toMatch(/^generation_[a-z0-9]+_[a-z0-9]+$/);
+        });
+        it('should generate unique request IDs', () => {
+            const id = generateRequestId();
+            expect(id).toMatch(/^req_[a-z0-9]+_[a-z0-9]+$/);
+        });
+    });
+    describe('Status Checks', () => {
+        it('should identify terminal pipeline statuses', () => {
+            expect(isTerminalPipelineStatus('completed')).toBe(true);
+            expect(isTerminalPipelineStatus('failed')).toBe(true);
+            expect(isTerminalPipelineStatus('cancelled')).toBe(true);
+        });
+        it('should identify non-terminal pipeline statuses', () => {
+            expect(isTerminalPipelineStatus('idle')).toBe(false);
+            expect(isTerminalPipelineStatus('running')).toBe(false);
+            expect(isTerminalPipelineStatus('paused')).toBe(false);
+        });
+        it('should identify terminal stage statuses', () => {
+            expect(isTerminalStageStatus('completed')).toBe(true);
+            expect(isTerminalStageStatus('failed')).toBe(true);
+            expect(isTerminalStageStatus('skipped')).toBe(true);
+            expect(isTerminalStageStatus('cancelled')).toBe(true);
+        });
+        it('should identify non-terminal stage statuses', () => {
+            expect(isTerminalStageStatus('pending')).toBe(false);
+            expect(isTerminalStageStatus('running')).toBe(false);
+        });
+    });
+    describe('Stage Result Creation', () => {
+        it('should create success result', () => {
+            const result = createStageSuccess({ output: 'test' });
+            expect(result.success).toBe(true);
+            expect(result.data).toEqual({ output: 'test' });
+        });
+        it('should create success result with options', () => {
+            const result = createStageSuccess({ output: 'test' }, { warnings: ['warning1'], cost: 0.5 });
+            expect(result.success).toBe(true);
+            expect(result.warnings).toEqual(['warning1']);
+            expect(result.cost).toBe(0.5);
+        });
+        it('should create failure result', () => {
+            const result = createStageFailure('Something failed');
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Something failed');
+        });
+    });
+    describe('Request Creation', () => {
+        it('should create pipeline request', () => {
+            const request = createPipelineRequest('generate', 'Create a widget');
+            expect(request.id).toMatch(/^req_/);
+            expect(request.type).toBe('generate');
+            expect(request.prompt).toBe('Create a widget');
+        });
+        it('should create request with options', () => {
+            const request = createPipelineRequest('modify', 'Update widget', {
+                targets: ['lib/widget.dart'],
+                options: { dryRun: true },
+            });
+            expect(request.targets).toEqual(['lib/widget.dart']);
+            expect(request.options?.dryRun).toBe(true);
+        });
+    });
+    describe('Formatting', () => {
+        it('should format pipeline status with colors', () => {
+            const formatted = formatPipelineStatus('completed');
+            expect(formatted).toContain('COMPLETED');
+            expect(formatted).toContain('\x1b[32m'); // Green
+        });
+        it('should format stage status with colors', () => {
+            const formatted = formatStageStatus('running');
+            expect(formatted).toContain('RUNNING');
+            expect(formatted).toContain('\x1b[33m'); // Yellow
+        });
+    });
+    describe('Hash Function', () => {
+        it('should generate consistent hashes', () => {
+            const data = { key: 'value', num: 123 };
+            const hash1 = hashData(data);
+            const hash2 = hashData(data);
+            expect(hash1).toBe(hash2);
+        });
+        it('should generate different hashes for different data', () => {
+            const hash1 = hashData({ a: 1 });
+            const hash2 = hashData({ a: 2 });
+            expect(hash1).not.toBe(hash2);
+        });
+    });
+    describe('Stage Options', () => {
+        it('should merge with defaults', () => {
+            const options = mergeStageOptions({ timeoutMs: 60000 });
+            expect(options.timeoutMs).toBe(60000);
+            expect(options.required).toBe(true);
+            expect(options.retryable).toBe(true);
+            expect(options.maxRetries).toBe(2);
+        });
+    });
+    describe('Metadata Creation', () => {
+        it('should create empty stage metadata', () => {
+            const metadata = createStageMetadata();
+            expect(metadata.retryCount).toBe(0);
+            expect(metadata.startedAt).toBeUndefined();
+        });
+        it('should create empty metrics', () => {
+            const metrics = createEmptyMetrics();
+            expect(metrics.totalDurationMs).toBe(0);
+            expect(metrics.totalCost).toBe(0);
+            expect(metrics.stagesCompleted).toBe(0);
+        });
+    });
+});
+// ============================================================================
+// Stage Handler Tests
+// ============================================================================
+describe('Stage Handlers', () => {
+    describe('Handler Registry', () => {
+        it('should list built-in handlers', () => {
+            const handlers = listStageHandlers();
+            expect(handlers).toContain('input-validation');
+            expect(handlers).toContain('context-analysis');
+            expect(handlers).toContain('planning');
+            expect(handlers).toContain('generation');
+            expect(handlers).toContain('validation');
+            expect(handlers).toContain('review');
+            expect(handlers).toContain('approval');
+            expect(handlers).toContain('execution');
+            expect(handlers).toContain('verification');
+            expect(handlers).toContain('cleanup');
+        });
+        it('should get handler by name', () => {
+            const handler = getStageHandler('input-validation');
+            expect(handler).toBe(inputValidationHandler);
+        });
+        it('should return undefined for unknown handler', () => {
+            const handler = getStageHandler('unknown-handler');
+            expect(handler).toBeUndefined();
+        });
+        it('should register custom handler', () => {
+            const customHandler = async () => createStageSuccess({ custom: true });
+            registerStageHandler('custom-test', customHandler);
+            expect(getStageHandler('custom-test')).toBe(customHandler);
+        });
+    });
+    describe('Stage Creation', () => {
+        it('should create stage with handler', () => {
+            const handler = async () => createStageSuccess();
+            const stage = createStage('test-stage', 'analysis', handler);
+            expect(stage.name).toBe('test-stage');
+            expect(stage.type).toBe('analysis');
+            expect(stage.handler).toBe(handler);
+            expect(stage.status).toBe('pending');
+        });
+        it('should create stage from handler name', () => {
+            const stage = createStageFromHandler('input', 'input', 'input-validation');
+            expect(stage.name).toBe('input');
+            expect(stage.type).toBe('input');
+            expect(stage.handler).toBe(inputValidationHandler);
+        });
+        it('should throw for unknown handler name', () => {
+            expect(() => {
+                createStageFromHandler('test', 'analysis', 'unknown-handler');
+            }).toThrow('Unknown stage handler');
+        });
+    });
+    describe('Input Validation Handler', () => {
+        it('should validate valid request', async () => {
+            const context = createMockContext({ prompt: 'Create a widget' });
+            const stage = createStage('input', 'input', inputValidationHandler);
+            const result = await inputValidationHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.validated).toBe(true);
+        });
+        it('should fail on empty prompt', async () => {
+            const context = createMockContext({ prompt: '' });
+            const stage = createStage('input', 'input', inputValidationHandler);
+            const result = await inputValidationHandler(context, stage);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('empty');
+        });
+        it('should fail on overly long prompt', async () => {
+            const context = createMockContext({ prompt: 'a'.repeat(60000) });
+            const stage = createStage('input', 'input', inputValidationHandler);
+            const result = await inputValidationHandler(context, stage);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('maximum length');
+        });
+    });
+    describe('Planning Handler', () => {
+        it('should create plan for generate request', async () => {
+            const context = createMockContext({ type: 'generate', prompt: 'Create widget' });
+            const stage = createStage('plan', 'planning', planningHandler);
+            const result = await planningHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.plan).toBeDefined();
+            expect((result.data?.plan).steps.length).toBeGreaterThan(0);
+        });
+        it('should create plan for analyze request', async () => {
+            const context = createMockContext({ type: 'analyze', prompt: 'Analyze code' });
+            const stage = createStage('plan', 'planning', planningHandler);
+            const result = await planningHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect((result.data?.plan).requestType).toBe('analyze');
+        });
+    });
+    describe('Generation Handler', () => {
+        it('should generate content', async () => {
+            const context = createMockContext({ type: 'generate', prompt: 'Create widget' });
+            const stage = createStage('generate', 'generation', generationHandler);
+            const result = await generationHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.generated).toBeDefined();
+            expect(result.artifacts).toBeDefined();
+            expect(result.artifacts.length).toBeGreaterThan(0);
+        });
+    });
+    describe('Validation Handler', () => {
+        it('should validate generated content', async () => {
+            const context = createMockContext({ prompt: 'test' });
+            context.data.generated = {
+                content: [{ path: 'test.dart', action: 'create', content: 'void main() {}' }],
+            };
+            const stage = createStage('validate', 'validation', validationHandler);
+            const result = await validationHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.validated).toBe(true);
+        });
+        it('should skip when requested', async () => {
+            const context = createMockContext({
+                prompt: 'test',
+                options: { skipValidation: true },
+            });
+            const stage = createStage('validate', 'validation', validationHandler);
+            const result = await validationHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.skipped).toBe(true);
+        });
+    });
+    describe('Review Handler', () => {
+        it('should review content', async () => {
+            const context = createMockContext({ prompt: 'test' });
+            context.data.generated = {
+                content: [{ path: 'test.dart', action: 'create', content: 'void main() {}' }],
+            };
+            const stage = createStage('review', 'review', reviewHandler);
+            const result = await reviewHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.reviewed).toBe(true);
+            expect(result.data?.reviewResult).toBeDefined();
+        });
+        it('should skip when requested', async () => {
+            const context = createMockContext({
+                prompt: 'test',
+                options: { skipReview: true },
+            });
+            const stage = createStage('review', 'review', reviewHandler);
+            const result = await reviewHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.skipped).toBe(true);
+        });
+    });
+    describe('Approval Handler', () => {
+        it('should auto-approve when requested', async () => {
+            const context = createMockContext({
+                prompt: 'test',
+                options: { autoApprove: true },
+            });
+            const stage = createStage('approve', 'approval', approvalHandler);
+            const result = await approvalHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.approved).toBe(true);
+            expect(result.data?.autoApproved).toBe(true);
+        });
+        it('should approve based on review score', async () => {
+            const context = createMockContext({ prompt: 'test' });
+            context.data.reviewResult = { score: 80, approved: true, feedback: [], suggestions: [] };
+            const stage = createStage('approve', 'approval', approvalHandler);
+            const result = await approvalHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.approved).toBe(true);
+        });
+    });
+    describe('Execution Handler', () => {
+        it('should execute changes', async () => {
+            const context = createMockContext({ prompt: 'test' });
+            context.data.approved = true;
+            context.data.generated = {
+                content: [{ path: 'test.dart', action: 'create', content: 'void main() {}' }],
+            };
+            const stage = createStage('execute', 'execution', executionHandler);
+            const result = await executionHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.executed).toBe(true);
+            expect(result.data?.appliedChanges).toBeDefined();
+        });
+        it('should respect dry run option', async () => {
+            const context = createMockContext({
+                prompt: 'test',
+                options: { dryRun: true },
+            });
+            context.data.approved = true;
+            const stage = createStage('execute', 'execution', executionHandler);
+            const result = await executionHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.dryRun).toBe(true);
+            expect(result.data?.executed).toBe(false);
+        });
+        it('should fail without approval', async () => {
+            const context = createMockContext({ prompt: 'test' });
+            const stage = createStage('execute', 'execution', executionHandler);
+            const result = await executionHandler(context, stage);
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('not approved');
+        });
+    });
+    describe('Cleanup Handler', () => {
+        it('should generate summary', async () => {
+            const context = createMockContext({ prompt: 'test' });
+            const stage = createStage('cleanup', 'cleanup', cleanupHandler);
+            const result = await cleanupHandler(context, stage);
+            expect(result.success).toBe(true);
+            expect(result.data?.summary).toBeDefined();
+            expect(result.data?.cleanedUp).toBe(true);
+        });
+    });
+});
+// ============================================================================
+// Pipeline Tests
+// ============================================================================
+describe('Pipeline', () => {
+    let pipeline;
+    beforeEach(() => {
+        pipeline = createPipeline({ name: 'test-pipeline', stages: [] });
+    });
+    afterEach(() => {
+        pipeline.dispose();
+    });
+    describe('Constructor', () => {
+        it('should create pipeline with name', () => {
+            expect(pipeline.name).toBe('test-pipeline');
+            expect(pipeline.id).toMatch(/^pipe_/);
+        });
+        it('should create with custom config', () => {
+            const custom = createPipeline({
+                name: 'custom',
+                maxTotalCost: 20.0,
+                enableRollback: false,
+            });
+            expect(custom.config.maxTotalCost).toBe(20.0);
+            expect(custom.config.enableRollback).toBe(false);
+            custom.dispose();
+        });
+    });
+    describe('Factory Functions', () => {
+        it('should create development pipeline', () => {
+            const dev = createDevelopmentPipeline();
+            expect(dev.name).toBe('development-pipeline');
+            expect(dev.listStages().length).toBe(10);
+            dev.dispose();
+        });
+        it('should create analysis pipeline', () => {
+            const analysis = createAnalysisPipeline();
+            expect(analysis.name).toBe('analysis-pipeline');
+            expect(analysis.listStages().length).toBe(4);
+            analysis.dispose();
+        });
+        it('should create review pipeline', () => {
+            const review = createReviewPipeline();
+            expect(review.name).toBe('review-pipeline');
+            expect(review.listStages().length).toBe(4);
+            review.dispose();
+        });
+    });
+    describe('Stage Management', () => {
+        it('should add stage', () => {
+            const stage = createStage('test', 'analysis', async () => createStageSuccess());
+            pipeline.addStage(stage);
+            expect(pipeline.listStages()).toHaveLength(1);
+            expect(pipeline.getStage(stage.id)).toBe(stage);
+        });
+        it('should add stage at position', () => {
+            const stage1 = createStage('first', 'input', async () => createStageSuccess());
+            const stage2 = createStage('second', 'analysis', async () => createStageSuccess());
+            const stage3 = createStage('middle', 'planning', async () => createStageSuccess());
+            pipeline.addStage(stage1);
+            pipeline.addStage(stage2);
+            pipeline.addStage(stage3, 1);
+            const stages = pipeline.listStages();
+            expect(stages[0].name).toBe('first');
+            expect(stages[1].name).toBe('middle');
+            expect(stages[2].name).toBe('second');
+        });
+        it('should remove stage', () => {
+            const stage = createStage('test', 'analysis', async () => createStageSuccess());
+            pipeline.addStage(stage);
+            const removed = pipeline.removeStage(stage.id);
+            expect(removed).toBe(true);
+            expect(pipeline.listStages()).toHaveLength(0);
+        });
+        it('should reorder stages', () => {
+            const stage1 = createStage('first', 'input', async () => createStageSuccess());
+            const stage2 = createStage('second', 'analysis', async () => createStageSuccess());
+            pipeline.addStage(stage1);
+            pipeline.addStage(stage2);
+            pipeline.reorderStages([stage2.id, stage1.id]);
+            const stages = pipeline.listStages();
+            expect(stages[0].name).toBe('second');
+            expect(stages[1].name).toBe('first');
+        });
+    });
+    describe('Service Registration', () => {
+        it('should register service', () => {
+            const mockService = { name: 'mock' };
+            pipeline.registerService('mock', mockService);
+            expect(pipeline.getService('mock')).toBe(mockService);
+        });
+        it('should register multiple services', () => {
+            pipeline.registerServices({
+                service1: { id: 1 },
+                service2: { id: 2 },
+            });
+            expect(pipeline.getService('service1')).toEqual({ id: 1 });
+            expect(pipeline.getService('service2')).toEqual({ id: 2 });
+        });
+    });
+    describe('Pipeline Execution', () => {
+        it('should run empty pipeline', async () => {
+            const request = createPipelineRequest('analyze', 'Test prompt');
+            const run = await pipeline.run(request);
+            expect(run.status).toBe('completed');
+            expect(run.id).toMatch(/^run_/);
+        });
+        it('should run pipeline with stages', async () => {
+            pipeline.addStage(createStage('input', 'input', async () => {
+                return createStageSuccess({ step1: true });
+            }));
+            pipeline.addStage(createStage('process', 'analysis', async (ctx) => {
+                return createStageSuccess({ step2: true, fromStep1: ctx.data.step1 });
+            }));
+            const request = createPipelineRequest('analyze', 'Test');
+            const run = await pipeline.run(request);
+            expect(run.status).toBe('completed');
+            expect(run.results.size).toBe(2);
+            expect(run.metrics.stagesCompleted).toBe(2);
+        });
+        it('should fail on required stage failure', async () => {
+            pipeline.addStage(createStage('failing', 'analysis', async () => {
+                return createStageFailure('Stage failed');
+            }, { required: true }));
+            const request = createPipelineRequest('analyze', 'Test');
+            const run = await pipeline.run(request);
+            expect(run.status).toBe('failed');
+            expect(run.error).toContain('Required stage failed');
+        });
+        it('should run all stages in sequence', async () => {
+            // Just verify that all stages run in order
+            const execOrder = [];
+            pipeline.addStage(createStage('stage1', 'analysis', async () => {
+                execOrder.push('stage1');
+                return createStageSuccess({ s1: true });
+            }));
+            pipeline.addStage(createStage('stage2', 'generation', async () => {
+                execOrder.push('stage2');
+                return createStageSuccess({ s2: true });
+            }));
+            const request = createPipelineRequest('analyze', 'Test');
+            const run = await pipeline.run(request);
+            expect(run.status).toBe('completed');
+            expect(execOrder).toEqual(['stage1', 'stage2']);
+        });
+        it('should pass data between stages', async () => {
+            pipeline.addStage(createStage('producer', 'analysis', async () => {
+                return createStageSuccess({ value: 42 });
+            }));
+            pipeline.addStage(createStage('consumer', 'generation', async (ctx) => {
+                const value = ctx.data.value;
+                return createStageSuccess({ doubled: value * 2 });
+            }));
+            const request = createPipelineRequest('analyze', 'Test');
+            const run = await pipeline.run(request);
+            expect(run.status).toBe('completed');
+            const consumerResult = run.results.get(pipeline.listStages()[1].id);
+            expect(consumerResult?.data?.doubled).toBe(84);
+        });
+        it('should collect artifacts', async () => {
+            pipeline.addStage(createStage('producer', 'generation', async () => {
+                return createStageSuccess({}, {
+                    artifacts: [
+                        { name: 'output.dart', type: 'code', content: 'void main() {}', size: 14 },
+                    ],
+                });
+            }));
+            const request = createPipelineRequest('generate', 'Test');
+            const run = await pipeline.run(request);
+            expect(run.output?.artifacts).toHaveLength(1);
+            expect(run.output?.artifacts[0].name).toBe('output.dart');
+        });
+        it('should track metrics', async () => {
+            pipeline.addStage(createStage('stage1', 'analysis', async () => {
+                return createStageSuccess({}, { tokenUsage: { input: 100, output: 50, total: 150 }, cost: 0.01 });
+            }));
+            pipeline.addStage(createStage('stage2', 'generation', async () => {
+                return createStageSuccess({}, { tokenUsage: { input: 200, output: 100, total: 300 }, cost: 0.02 });
+            }));
+            const request = createPipelineRequest('analyze', 'Test');
+            const run = await pipeline.run(request);
+            expect(run.metrics.totalTokens.total).toBe(450);
+            expect(run.metrics.totalCost).toBe(0.03);
+        });
+        it('should emit events', async () => {
+            const events = [];
+            pipeline.onEvent((event) => { events.push(event); });
+            // Add a simple stage that succeeds
+            pipeline.addStage(createStage('test', 'analysis', async () => {
+                return createStageSuccess({ done: true });
+            }));
+            const request = createPipelineRequest('analyze', 'Test');
+            const run = await pipeline.run(request);
+            // Verify run completed
+            expect(run.status).toBe('completed');
+            const types = events.map((e) => e.type);
+            expect(types).toContain('pipeline:started');
+            expect(types).toContain('stage:started');
+            // Stage should complete successfully
+            expect(types.some((t) => t === 'stage:completed' || t === 'stage:failed')).toBe(true);
+            expect(types).toContain('pipeline:completed');
+        });
+        it('should prevent concurrent runs', async () => {
+            pipeline.addStage(createStage('slow', 'analysis', async () => {
+                await new Promise((r) => setTimeout(r, 100));
+                return createStageSuccess();
+            }));
+            const request = createPipelineRequest('analyze', 'Test');
+            const run1Promise = pipeline.run(request);
+            await expect(pipeline.run(request)).rejects.toThrow('already running');
+            await run1Promise;
+        });
+    });
+    describe('Stage Dependencies', () => {
+        it('should handle stages with dependencies when dependency succeeds', async () => {
+            // Create first stage that succeeds
+            const stage1 = createStage('dep', 'analysis', async () => {
+                return createStageSuccess({ value: 10 });
+            });
+            // Create second stage with dependency on first
+            const stage2 = createStage('dependent', 'generation', async (ctx) => {
+                const value = ctx.data.value;
+                return createStageSuccess({ doubled: value * 2 });
+            });
+            stage2.dependencies = [stage1.id];
+            pipeline.addStage(stage1);
+            pipeline.addStage(stage2);
+            const request = createPipelineRequest('analyze', 'Test');
+            const run = await pipeline.run(request);
+            // Pipeline should complete
+            expect(run.status).toBe('completed');
+            // Both stages should complete
+            expect(run.stages.get(stage1.id)).toBe('completed');
+            expect(run.stages.get(stage2.id)).toBe('completed');
+            // Verify data was passed between stages
+            const stage2Result = run.results.get(stage2.id);
+            expect(stage2Result?.data?.doubled).toBe(20);
+        });
+    });
+    describe('Retry Logic', () => {
+        it('should retry failed stage', async () => {
+            let attempts = 0;
+            pipeline.addStage(createStage('retrying', 'analysis', async () => {
+                attempts++;
+                if (attempts < 2) {
+                    throw new Error('Temporary failure');
+                }
+                return createStageSuccess({ attempts });
+            }, { retryable: true, maxRetries: 2 }));
+            const request = createPipelineRequest('analyze', 'Test');
+            const run = await pipeline.run(request);
+            expect(run.status).toBe('completed');
+            expect(attempts).toBe(2);
+            expect(run.metrics.totalRetries).toBe(1);
+        });
+        it('should not retry non-retryable stage', async () => {
+            let attempts = 0;
+            pipeline.addStage(createStage('noretry', 'analysis', async () => {
+                attempts++;
+                return createStageFailure('Permanent failure');
+            }, { retryable: false, required: false }));
+            const request = createPipelineRequest('analyze', 'Test');
+            const run = await pipeline.run(request);
+            expect(attempts).toBe(1);
+        });
+    });
+    describe('Control Methods', () => {
+        it('should cancel running pipeline', async () => {
+            // Create pipeline without rollback for cleaner cancel test
+            const cancelPipeline = createPipeline({
+                name: 'cancel-test',
+                stages: [],
+                enableRollback: false,
+            });
+            cancelPipeline.addStage(createStage('slow', 'analysis', async () => {
+                await new Promise((r) => setTimeout(r, 1000));
+                return createStageSuccess();
+            }));
+            const request = createPipelineRequest('analyze', 'Test');
+            const runPromise = cancelPipeline.run(request);
+            // Wait for pipeline to start
+            await new Promise((r) => setTimeout(r, 50));
+            const cancelled = cancelPipeline.cancel();
+            expect(cancelled).toBe(true);
+            const run = await runPromise;
+            expect(run.status).toBe('cancelled');
+            cancelPipeline.dispose();
+        });
+        it('should report status', () => {
+            expect(pipeline.getStatus()).toBe('idle');
+            expect(pipeline.isRunning()).toBe(false);
+        });
+    });
+    describe('Run Management', () => {
+        it('should store completed runs', async () => {
+            pipeline.addStage(createStage('test', 'analysis', async () => createStageSuccess()));
+            const request = createPipelineRequest('analyze', 'Test');
+            const run = await pipeline.run(request);
+            expect(pipeline.getRun(run.id)).toBe(run);
+            expect(pipeline.listRuns()).toHaveLength(1);
+        });
+        it('should get active run', async () => {
+            pipeline.addStage(createStage('slow', 'analysis', async () => {
+                await new Promise((r) => setTimeout(r, 100));
+                return createStageSuccess();
+            }));
+            const request = createPipelineRequest('analyze', 'Test');
+            const runPromise = pipeline.run(request);
+            await new Promise((r) => setTimeout(r, 20));
+            expect(pipeline.getActiveRun()).not.toBeNull();
+            await runPromise;
+            expect(pipeline.getActiveRun()).toBeNull();
+        });
+    });
+});
+// ============================================================================
+// Default Configuration Tests
+// ============================================================================
+describe('Default Configurations', () => {
+    describe('DEFAULT_PIPELINE_CONFIG', () => {
+        it('should have expected values', () => {
+            expect(DEFAULT_PIPELINE_CONFIG.timeoutMs).toBe(600000);
+            expect(DEFAULT_PIPELINE_CONFIG.maxRetriesPerStage).toBe(2);
+            expect(DEFAULT_PIPELINE_CONFIG.maxTotalCost).toBe(10.0);
+            expect(DEFAULT_PIPELINE_CONFIG.enableRollback).toBe(true);
+            expect(DEFAULT_PIPELINE_CONFIG.enableCheckpoints).toBe(true);
+        });
+    });
+    describe('DEFAULT_STAGE_OPTIONS', () => {
+        it('should have expected values', () => {
+            expect(DEFAULT_STAGE_OPTIONS.required).toBe(true);
+            expect(DEFAULT_STAGE_OPTIONS.retryable).toBe(true);
+            expect(DEFAULT_STAGE_OPTIONS.maxRetries).toBe(2);
+            expect(DEFAULT_STAGE_OPTIONS.timeoutMs).toBe(120000);
+        });
+    });
+});
+// ============================================================================
+// Helper Functions
+// ============================================================================
+function createMockContext(requestOverrides = {}) {
+    const request = {
+        id: generateRequestId(),
+        type: 'generate',
+        prompt: 'Test prompt',
+        ...requestOverrides,
+    };
+    return {
+        pipelineId: 'test-pipeline',
+        runId: 'test-run',
+        request,
+        data: {},
+        artifacts: [],
+        variables: {},
+        stageResults: new Map(),
+        services: {},
+        logger: {
+            debug: () => { },
+            info: () => { },
+            warn: () => { },
+            error: () => { },
+        },
+    };
+}
+//# sourceMappingURL=pipeline.test.js.map