@auto-engineer/pipeline 0.0.1

package/src/testing/fixtures/kanban.pipeline.ts

@@ -0,0 +1,124 @@
+import type { Event } from '@auto-engineer/message-bus';
+import { define } from '../../builder/define';
+
+interface Component {
+  id: string;
+  type: 'molecule' | 'organism' | 'page';
+  filePath: string;
+}
+
+interface SchemaExportedData {
+  outputPath: string;
+}
+
+interface SliceGeneratedData {
+  slicePath: string;
+}
+
+interface SliceImplementedData {
+  slicePath: string;
+}
+
+interface ClientGeneratedData {
+  components: Component[];
+}
+
+interface CheckEventData {
+  target: string;
+}
+
+const MAX_RETRIES = 3;
+const retryState = new Map<string, number>();
+
+function hasAnyFailures(events: Event[]): boolean {
+  return events.some((e) => e.type.includes('Failed'));
+}
+
+function collectErrors(events: Event[]): string[] {
+  return events.filter((e) => e.type.includes('Failed')).map((e) => JSON.stringify(e.data));
+}
+
+function extractSlicePath(events: Record<string, Event[]>): string {
+  const firstEvent = events.CheckTests?.[0] ?? events.CheckTypes?.[0] ?? events.CheckLint?.[0];
+  const data = firstEvent?.data as CheckEventData | undefined;
+  return data?.target ?? 'unknown';
+}
+
+function gatherAllCheckEvents(events: Record<string, Event[]>): Event[] {
+  return [...(events.CheckTests ?? []), ...(events.CheckTypes ?? []), ...(events.CheckLint ?? [])];
+}
+
+function shouldRetry(slicePath: string): boolean {
+  const attempts = retryState.get(slicePath) ?? 0;
+  return attempts < MAX_RETRIES;
+}
+
+function incrementRetryCount(slicePath: string): number {
+  const attempts = retryState.get(slicePath) ?? 0;
+  retryState.set(slicePath, attempts + 1);
+  return attempts + 1;
+}
+
+export function createKanbanPipeline() {
+  return define('kanban')
+    .on('SchemaExported')
+    .emit('GenerateServer', (e: { data: SchemaExportedData }) => ({ modelPath: e.data.outputPath }))
+
+    .on('SliceGenerated')
+    .emit('ImplementSlice', (e: { data: SliceGeneratedData }) => ({ slicePath: e.data.slicePath }))
+
+    .on('SliceImplemented')
+    .emit('CheckTests', (e: { data: SliceImplementedData }) => ({ target: e.data.slicePath }))
+    .emit('CheckTypes', (e: { data: SliceImplementedData }) => ({ target: e.data.slicePath }))
+    .emit('CheckLint', (e: { data: SliceImplementedData }) => ({ target: e.data.slicePath }))
+
+    .settled(['CheckTests', 'CheckTypes', 'CheckLint'])
+    .dispatch({ dispatches: ['ImplementSlice'] }, (events, send) => {
+      const allEvents = gatherAllCheckEvents(events);
+
+      if (!hasAnyFailures(allEvents)) {
+        return;
+      }
+
+      const slicePath = extractSlicePath(events);
+
+      if (!shouldRetry(slicePath)) {
+        return;
+      }
+
+      const retryAttempt = incrementRetryCount(slicePath);
+      send('ImplementSlice', { slicePath, context: { errors: collectErrors(allEvents), retryAttempt } });
+      return { persist: true };
+    })
+
+    .on('ServerGenerated')
+    .emit('GenerateIA', (e: { data: { modelPath: string } }) => ({ modelPath: e.data.modelPath }))
+    .emit('StartServer', {})
+
+    .on('IAGenerated')
+    .emit('GenerateClient', {})
+
+    .on('ClientGenerated')
+    .forEach((e: { data: ClientGeneratedData }) => e.data.components)
+    .groupInto(['molecule', 'organism', 'page'], (c) => c.type)
+    .process('ImplementComponent', (c) => ({ filePath: c.filePath }))
+    .onComplete({
+      success: 'AllComponentsImplemented',
+      failure: 'ComponentsFailed',
+      itemKey: (e) => (e.data as { filePath?: string }).filePath ?? '',
+    })
+
+    .build();
+}
+
+export function resetRetryState(): void {
+  retryState.clear();
+}
+
+export function setRetryCount(slicePath: string, count: number): void {
+  retryState.set(slicePath, count);
+}
+
+export function testShouldRetry(slicePath: string): boolean {
+  return shouldRetry(slicePath);
+}

package/src/testing/kanban-todo.e2e.specs.ts

@@ -0,0 +1,209 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { loadPipelineConfig } from '../config/pipeline-config';
+import { PipelineServer } from '../server/pipeline-server';
+import { EventCapture } from './event-capture';
+import { resetKanbanState } from './fixtures/kanban-full.pipeline';
+import kanbanTodoConfig from './fixtures/kanban-todo.config';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGES_DIR = path.resolve(__dirname, '../../..');
+const CLI_SNAPSHOTS_DIR = path.join(PACKAGES_DIR, 'cli/src/__tests__/e2e/__snapshots__/kanban-todo');
+
+interface PipelineGraph {
+  nodes: Array<{ id: string; name: string; title?: string; alias?: string; status: string }>;
+  edges: Array<{ from: string; to: string }>;
+  commandToEvents: Record<string, string[]>;
+  eventToCommand: Record<string, string>;
+}
+
+interface Registry {
+  eventHandlers: string[];
+  commandHandlers: string[];
+  commandsWithMetadata: Array<{ name: string; alias?: string; description?: string }>;
+  folds: string[];
+}
+
+function loadCliSnapshot<T>(filename: string): T | null {
+  const snapshotPath = path.join(CLI_SNAPSHOTS_DIR, filename);
+  if (!existsSync(snapshotPath)) {
+    console.log(`Snapshot not found: ${snapshotPath}`);
+    return null;
+  }
+  const content = readFileSync(snapshotPath, 'utf-8');
+  return JSON.parse(content) as T;
+}
+
+describe('Kanban-Todo Pipeline E2E Comparison', () => {
+  let server: PipelineServer;
+  let eventCapture: EventCapture;
+
+  beforeAll(async () => {
+    const loaded = await loadPipelineConfig(kanbanTodoConfig);
+
+    server = new PipelineServer({ port: 0 });
+    server.registerCommandHandlers(loaded.handlers);
+    server.registerPipeline(loaded.pipeline);
+    await server.start();
+
+    eventCapture = new EventCapture();
+  }, 30000);
+
+  afterAll(async () => {
+    await server.stop();
+  });
+
+  beforeEach(() => {
+    resetKanbanState();
+    eventCapture.clear();
+  });
+
+  describe('Registry Comparison', () => {
+    it('should have matching command handlers', async () => {
+      const response = await fetch(`http://localhost:${server.port}/registry`);
+      const registry = (await response.json()) as Registry;
+      const cliRegistry = loadCliSnapshot<Registry>('registry.snapshot.json');
+
+      console.log('=== Pipeline Registry ===');
+      console.log('Command handlers:', registry.commandHandlers.sort().join(', '));
+
+      if (cliRegistry !== null) {
+        console.log('\n=== CLI Registry ===');
+        console.log('Command handlers:', cliRegistry.commandHandlers.sort().join(', '));
+
+        const pipelineCommands = new Set(registry.commandHandlers);
+        const cliCommands = new Set(cliRegistry.commandHandlers);
+
+        const missingInPipeline = cliRegistry.commandHandlers.filter((c) => !pipelineCommands.has(c));
+        const extraInPipeline = registry.commandHandlers.filter((c) => !cliCommands.has(c));
+
+        console.log('\n=== Differences ===');
+        console.log('Missing in pipeline:', missingInPipeline.join(', ') || 'none');
+        console.log('Extra in pipeline:', extraInPipeline.join(', ') || 'none');
+
+        expect(missingInPipeline.length).toBeLessThanOrEqual(3);
+      } else {
+        expect(registry.commandHandlers.length).toBeGreaterThan(10);
+      }
+    });
+
+    it('should have matching event handlers', async () => {
+      const response = await fetch(`http://localhost:${server.port}/registry`);
+      const registry = (await response.json()) as Registry;
+      const cliRegistry = loadCliSnapshot<Registry>('registry.snapshot.json');
+
+      console.log('=== Pipeline Event Handlers ===');
+      console.log(registry.eventHandlers.sort().join(', '));
+
+      if (cliRegistry !== null) {
+        console.log('\n=== CLI Event Handlers ===');
+        console.log(cliRegistry.eventHandlers.sort().join(', '));
+
+        const pipelineEvents = new Set(registry.eventHandlers);
+        const cliEvents = new Set(cliRegistry.eventHandlers);
+
+        const missingInPipeline = cliRegistry.eventHandlers.filter((e) => !pipelineEvents.has(e));
+        const extraInPipeline = registry.eventHandlers.filter((e) => !cliEvents.has(e));
+
+        console.log('\n=== Differences ===');
+        console.log('Missing in pipeline:', missingInPipeline.join(', ') || 'none');
+        console.log('Extra in pipeline:', extraInPipeline.join(', ') || 'none');
+      }
+
+      expect(registry.eventHandlers.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Pipeline Graph Comparison', () => {
+    it('should have similar edge structure to CLI', async () => {
+      const response = await fetch(`http://localhost:${server.port}/pipeline`);
+      const graph = (await response.json()) as PipelineGraph;
+      const cliGraph = loadCliSnapshot<PipelineGraph>('pipeline-graph.snapshot.json');
+
+      console.log('=== Pipeline Graph ===');
+      console.log(`Nodes: ${graph.nodes.length}`);
+      console.log(`Edges: ${graph.edges.length}`);
+
+      if (cliGraph !== null) {
+        console.log('\n=== CLI Graph ===');
+        console.log(`Nodes: ${cliGraph.nodes.length}`);
+        console.log(`Edges: ${cliGraph.edges.length}`);
+
+        console.log('\n=== CLI Edges (by command name) ===');
+        cliGraph.edges.forEach((e) => {
+          const fromNode = cliGraph.nodes.find((n) => n.id === e.from);
+          const toNode = cliGraph.nodes.find((n) => n.id === e.to);
+          console.log(`  ${fromNode?.name ?? e.from} → ${toNode?.name ?? e.to}`);
+        });
+      }
+
+      console.log('\n=== Pipeline Edges ===');
+      graph.edges.forEach((e) => console.log(`  ${e.from} → ${e.to}`));
+
+      expect(graph.edges.length).toBeGreaterThan(5);
+    });
+
+    it('should have commandToEvents mapping', async () => {
+      const response = await fetch(`http://localhost:${server.port}/pipeline`);
+      const graph = (await response.json()) as PipelineGraph;
+      const cliGraph = loadCliSnapshot<PipelineGraph>('pipeline-graph.snapshot.json');
+
+      console.log('=== Pipeline commandToEvents ===');
+      Object.entries(graph.commandToEvents).forEach(([cmd, events]) => {
+        console.log(`  ${cmd}: [${events.join(', ')}]`);
+      });
+
+      if (cliGraph !== null) {
+        console.log('\n=== CLI commandToEvents ===');
+        Object.entries(cliGraph.commandToEvents).forEach(([cmd, events]) => {
+          console.log(`  ${cmd}: [${events.join(', ')}]`);
+        });
+      }
+
+      expect(Object.keys(graph.commandToEvents).length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Workflow Sequence Validation', () => {
+    it('should have correct causal dependencies in pipeline definition', () => {
+      const expectedDependencies: [string, string][] = [
+        ['SchemaExported', 'GenerateServer'],
+        ['SliceGenerated', 'ImplementSlice'],
+        ['SliceImplemented', 'CheckTests'],
+        ['SliceImplemented', 'CheckTypes'],
+        ['SliceImplemented', 'CheckLint'],
+        ['ServerGenerated', 'GenerateIA'],
+        ['ServerGenerated', 'StartServer'],
+        ['IAGenerated', 'GenerateClient'],
+        ['ClientGenerated', 'ImplementComponent'],
+        ['ClientGenerated', 'StartClient'],
+      ];
+
+      const pipelineHandlers = kanbanTodoConfig.pipeline.descriptor.handlers;
+
+      console.log('=== Pipeline Handler Event Types ===');
+      pipelineHandlers.forEach((h) => {
+        if (h.type === 'emit') {
+          const commands = h.commands.map((c) => c.commandType).join(', ');
+          console.log(`  ${h.eventType} → [${commands}]`);
+        } else if (h.type === 'settled') {
+          console.log(`  settled(${h.commandTypes.join(', ')}) → dispatch handler`);
+        } else if (h.type === 'foreach-phased') {
+          console.log(
+            `  ${h.eventType} → forEach/phased → ${h.emitFactory({}, '', { type: '', data: {} }).commandType}`,
+          );
+        }
+      });
+
+      console.log('\n=== Expected Dependencies ===');
+      expectedDependencies.forEach(([from, to]) => {
+        console.log(`  ${from} → ${to}`);
+      });
+
+      const emitHandlers = pipelineHandlers.filter((h) => h.type === 'emit');
+      expect(emitHandlers.length).toBeGreaterThan(5);
+    });
+  });
+});

package/src/testing/mock-handlers.specs.ts

@@ -0,0 +1,229 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { createMockHandlers, createStatefulHandler, getHandlerCallCount, resetCallCounts } from './mock-handlers';
+
+describe('mock-handlers', () => {
+  beforeEach(() => {
+    resetCallCounts();
+  });
+
+  describe('createMockHandlers', () => {
+    it('should create handlers with correct names', () => {
+      const handlers = createMockHandlers([
+        {
+          name: 'CheckTests',
+          events: ['TestsCheckPassed'],
+          fn: () => ({ type: 'TestsCheckPassed', data: {} }),
+        },
+        {
+          name: 'CheckTypes',
+          events: ['TypeCheckPassed'],
+          fn: () => ({ type: 'TypeCheckPassed', data: {} }),
+        },
+      ]);
+
+      expect(handlers).toHaveLength(2);
+      expect(handlers[0].name).toBe('CheckTests');
+      expect(handlers[1].name).toBe('CheckTypes');
+    });
+
+    it('should create handlers with correct events', () => {
+      const handlers = createMockHandlers([
+        {
+          name: 'CheckTests',
+          events: ['TestsCheckPassed', 'TestsCheckFailed'],
+          fn: () => ({ type: 'TestsCheckPassed', data: {} }),
+        },
+      ]);
+
+      expect(handlers[0].events).toEqual(['TestsCheckPassed', 'TestsCheckFailed']);
+    });
+
+    it('should call handler function with command', async () => {
+      let receivedCommand: unknown = null;
+      const handlers = createMockHandlers([
+        {
+          name: 'TestHandler',
+          events: ['Done'],
+          fn: (cmd) => {
+            receivedCommand = cmd;
+            return { type: 'Done', data: {} };
+          },
+        },
+      ]);
+
+      const command = { type: 'TestHandler', data: { foo: 'bar' } };
+      await handlers[0].handle(command);
+
+      expect(receivedCommand).toEqual(command);
+    });
+
+    it('should return event from handler function', async () => {
+      const handlers = createMockHandlers([
+        {
+          name: 'TestHandler',
+          events: ['Result'],
+          fn: () => ({ type: 'Result', data: { value: 42 } }),
+        },
+      ]);
+
+      const result = await handlers[0].handle({ type: 'TestHandler', data: {} });
+
+      expect(result).toEqual({ type: 'Result', data: { value: 42 } });
+    });
+
+    it('should return array of events from handler function', async () => {
+      const handlers = createMockHandlers([
+        {
+          name: 'MultiEventHandler',
+          events: ['First', 'Second'],
+          fn: () => [
+            { type: 'First', data: {} },
+            { type: 'Second', data: {} },
+          ],
+        },
+      ]);
+
+      const result = await handlers[0].handle({ type: 'MultiEventHandler', data: {} });
+
+      expect(result).toEqual([
+        { type: 'First', data: {} },
+        { type: 'Second', data: {} },
+      ]);
+    });
+
+    it('should pass attempt number to handler function', async () => {
+      const receivedAttempts: number[] = [];
+      const handlers = createMockHandlers([
+        {
+          name: 'TrackingHandler',
+          events: ['Done'],
+          fn: (_, attempt) => {
+            receivedAttempts.push(attempt);
+            return { type: 'Done', data: {} };
+          },
+        },
+      ]);
+
+      await handlers[0].handle({ type: 'TrackingHandler', data: {} });
+      await handlers[0].handle({ type: 'TrackingHandler', data: {} });
+      await handlers[0].handle({ type: 'TrackingHandler', data: {} });
+
+      expect(receivedAttempts).toEqual([1, 2, 3]);
+    });
+
+    it('should reset call counts when creating new handlers', () => {
+      createMockHandlers([
+        {
+          name: 'First',
+          events: ['Done'],
+          fn: () => ({ type: 'Done', data: {} }),
+        },
+      ]);
+
+      expect(getHandlerCallCount('First')).toBe(0);
+    });
+  });
+
+  describe('getHandlerCallCount', () => {
+    it('should return 0 for uncalled handler', () => {
+      createMockHandlers([
+        {
+          name: 'Uncalled',
+          events: ['Done'],
+          fn: () => ({ type: 'Done', data: {} }),
+        },
+      ]);
+
+      expect(getHandlerCallCount('Uncalled')).toBe(0);
+    });
+
+    it('should track call count for handler', async () => {
+      const handlers = createMockHandlers([
+        {
+          name: 'Called',
+          events: ['Done'],
+          fn: () => ({ type: 'Done', data: {} }),
+        },
+      ]);
+
+      await handlers[0].handle({ type: 'Called', data: {} });
+      await handlers[0].handle({ type: 'Called', data: {} });
+
+      expect(getHandlerCallCount('Called')).toBe(2);
+    });
+  });
+
+  describe('resetCallCounts', () => {
+    it('should clear all call counts', async () => {
+      const handlers = createMockHandlers([
+        {
+          name: 'Handler1',
+          events: ['Done'],
+          fn: () => ({ type: 'Done', data: {} }),
+        },
+        {
+          name: 'Handler2',
+          events: ['Done'],
+          fn: () => ({ type: 'Done', data: {} }),
+        },
+      ]);
+
+      await handlers[0].handle({ type: 'Handler1', data: {} });
+      await handlers[1].handle({ type: 'Handler2', data: {} });
+
+      resetCallCounts();
+
+      expect(getHandlerCallCount('Handler1')).toBe(0);
+      expect(getHandlerCallCount('Handler2')).toBe(0);
+    });
+  });
+
+  describe('createStatefulHandler', () => {
+    it('should fail for initial attempts', async () => {
+      const handler = createStatefulHandler({
+        name: 'CheckTests',
+        events: ['TestsCheckPassed', 'TestsCheckFailed'],
+        initialFails: 2,
+        failEvent: (cmd) => ({ type: 'TestsCheckFailed', data: { target: cmd.data } }),
+        successEvent: (cmd) => ({ type: 'TestsCheckPassed', data: { target: cmd.data } }),
+      });
+
+      const command = { type: 'CheckTests', data: { dir: './src' } };
+
+      const result1 = await handler.handle(command);
+      expect(Array.isArray(result1) ? result1[0].type : result1.type).toBe('TestsCheckFailed');
+
+      const result2 = await handler.handle(command);
+      expect(Array.isArray(result2) ? result2[0].type : result2.type).toBe('TestsCheckFailed');
+
+      const result3 = await handler.handle(command);
+      expect(Array.isArray(result3) ? result3[0].type : result3.type).toBe('TestsCheckPassed');
+    });
+
+    it('should preserve handler metadata', () => {
+      const handler = createStatefulHandler({
+        name: 'CheckTypes',
+        events: ['TypeCheckPassed', 'TypeCheckFailed'],
+        initialFails: 1,
+        failEvent: () => ({ type: 'TypeCheckFailed', data: {} }),
+        successEvent: () => ({ type: 'TypeCheckPassed', data: {} }),
+      });
+
+      expect(handler.name).toBe('CheckTypes');
+      expect(handler.events).toEqual(['TypeCheckPassed', 'TypeCheckFailed']);
+    });
+
+    it('should succeed immediately when initialFails is 0', async () => {
+      const handler = createStatefulHandler({
+        name: 'AlwaysPass',
+        events: ['Passed'],
+        initialFails: 0,
+        failEvent: () => ({ type: 'Failed', data: {} }),
+        successEvent: () => ({ type: 'Passed', data: {} }),
+      });
+
+      const result = await handler.handle({ type: 'AlwaysPass', data: {} });
+      expect(Array.isArray(result) ? result[0].type : result.type).toBe('Passed');
+    });
+  });
+});

package/src/testing/mock-handlers.ts

@@ -0,0 +1,58 @@
+import type { Command, Event } from '@auto-engineer/message-bus';
+import type { CommandHandlerWithMetadata } from '../server/pipeline-server';
+
+type MockHandlerFn = (cmd: Command, attempt: number) => Event | Event[];
+
+interface MockHandlerConfig {
+  name: string;
+  events: string[];
+  fn: MockHandlerFn;
+}
+
+const callCounts = new Map<string, number>();
+
+export function createMockHandlers(configs: MockHandlerConfig[]): CommandHandlerWithMetadata[] {
+  callCounts.clear();
+
+  return configs.map((config) => ({
+    name: config.name,
+    events: config.events,
+    handle: async (cmd: Command): Promise<Event | Event[]> => {
+      const currentCount = (callCounts.get(config.name) ?? 0) + 1;
+      callCounts.set(config.name, currentCount);
+      return config.fn(cmd, currentCount);
+    },
+  }));
+}
+
+export function getHandlerCallCount(handlerName: string): number {
+  return callCounts.get(handlerName) ?? 0;
+}
+
+export function resetCallCounts(): void {
+  callCounts.clear();
+}
+
+interface StatefulHandlerConfig {
+  name: string;
+  events: string[];
+  initialFails: number;
+  failEvent: (cmd: Command) => Event;
+  successEvent: (cmd: Command) => Event;
+}
+
+export function createStatefulHandler(config: StatefulHandlerConfig): CommandHandlerWithMetadata {
+  let callCount = 0;
+
+  return {
+    name: config.name,
+    events: config.events,
+    handle: async (cmd: Command): Promise<Event> => {
+      callCount++;
+      if (callCount <= config.initialFails) {
+        return config.failEvent(cmd);
+      }
+      return config.successEvent(cmd);
+    },
+  };
+}