@auto-engineer/pipeline 0.0.1

package/src/testing/fixtures/kanban-full.pipeline.specs.ts

@@ -0,0 +1,337 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import type { EmitHandlerDescriptor, ForEachPhasedDescriptor } from '../../core/descriptors';
+import {
+  createKanbanFullPipeline,
+  resetKanbanState,
+  setProjectRoot,
+  setSliceRetryCount,
+  testResolvePath,
+  testShouldRetry,
+} from './kanban-full.pipeline';
+
+describe('kanban-full.pipeline', () => {
+  beforeEach(() => {
+    resetKanbanState();
+  });
+
+  describe('resolvePath', () => {
+    it('should return relativePath when projectRoot is empty', () => {
+      expect(testResolvePath('./foo/bar')).toBe('./foo/bar');
+    });
+
+    it('should return absolute path unchanged', () => {
+      setProjectRoot('/my/project');
+      expect(testResolvePath('/absolute/path')).toBe('/absolute/path');
+    });
+
+    it('should resolve ./ relative paths', () => {
+      setProjectRoot('/my/project');
+      expect(testResolvePath('./foo/bar')).toBe('/my/project/foo/bar');
+    });
+
+    it('should resolve bare relative paths', () => {
+      setProjectRoot('/my/project');
+      expect(testResolvePath('foo/bar')).toBe('/my/project/foo/bar');
+    });
+  });
+
+  describe('shouldRetry', () => {
+    it('should return true when retry count is below max', () => {
+      expect(testShouldRetry('./slice-path')).toBe(true);
+    });
+
+    it('should return false when retry count reaches max', () => {
+      setSliceRetryCount('./slice-path', 4);
+      expect(testShouldRetry('./slice-path')).toBe(false);
+    });
+  });
+
+  describe('pipeline structure', () => {
+    it('should have name kanban-full', () => {
+      const pipeline = createKanbanFullPipeline();
+      expect(pipeline.descriptor.name).toBe('kanban-full');
+    });
+
+    it('should have emit handlers for schema export', () => {
+      const pipeline = createKanbanFullPipeline();
+      const emitHandlers = pipeline.descriptor.handlers.filter((h): h is EmitHandlerDescriptor => h.type === 'emit');
+      const eventTypes = emitHandlers.map((h) => h.eventType);
+      expect(eventTypes).toContain('SchemaExported');
+    });
+
+    it('should have settled handler for slice checks', () => {
+      const pipeline = createKanbanFullPipeline();
+      const settledHandlers = pipeline.descriptor.handlers.filter((h) => h.type === 'settled');
+      expect(settledHandlers.length).toBeGreaterThan(0);
+      const commandTypes = settledHandlers[0].commandTypes;
+      expect(commandTypes).toContain('CheckTests');
+      expect(commandTypes).toContain('CheckTypes');
+      expect(commandTypes).toContain('CheckLint');
+    });
+
+    it('should have foreach-phased handler for client components', () => {
+      const pipeline = createKanbanFullPipeline();
+      const foreachHandlers = pipeline.descriptor.handlers.filter((h) => h.type === 'foreach-phased');
+      expect(foreachHandlers.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('command data shapes', () => {
+    function findEmitCommand(
+      pipeline: ReturnType<typeof createKanbanFullPipeline>,
+      eventType: string,
+      commandType: string,
+    ) {
+      const emitHandlers = pipeline.descriptor.handlers.filter(
+        (h): h is EmitHandlerDescriptor => h.type === 'emit' && h.eventType === eventType,
+      );
+      for (const handler of emitHandlers) {
+        const cmd = handler.commands.find((c) => c.commandType === commandType);
+        if (cmd) return cmd;
+      }
+      return undefined;
+    }
+
+    it('should emit GenerateServer with modelPath and destination', () => {
+      const pipeline = createKanbanFullPipeline();
+      const cmd = findEmitCommand(pipeline, 'SchemaExported', 'GenerateServer');
+      expect(cmd).toBeDefined();
+      const data =
+        typeof cmd?.data === 'function'
+          ? cmd.data({
+              type: 'SchemaExported',
+              data: { outputPath: './.context/schema.json', directory: '.' },
+            })
+          : cmd?.data;
+      expect(data).toEqual({
+        modelPath: './.context/schema.json',
+        destination: '.',
+      });
+    });
+
+    it('should emit ImplementSlice with slicePath, context, and aiOptions', () => {
+      const pipeline = createKanbanFullPipeline();
+      const cmd = findEmitCommand(pipeline, 'SliceGenerated', 'ImplementSlice');
+      expect(cmd).toBeDefined();
+      const data =
+        typeof cmd?.data === 'function'
+          ? cmd.data({ type: 'SliceGenerated', data: { slicePath: './adds-todo' } })
+          : cmd?.data;
+      expect(data).toEqual({
+        slicePath: './adds-todo',
+        context: { previousOutputs: 'errors', attemptNumber: 0 },
+        aiOptions: { maxTokens: 2000 },
+      });
+    });
+
+    it('should emit CheckTests with targetDirectory and scope', () => {
+      const pipeline = createKanbanFullPipeline();
+      const cmd = findEmitCommand(pipeline, 'SliceImplemented', 'CheckTests');
+      expect(cmd).toBeDefined();
+      const data =
+        typeof cmd?.data === 'function'
+          ? cmd.data({ type: 'SliceImplemented', data: { slicePath: './adds-todo' } })
+          : cmd?.data;
+      expect(data).toEqual({
+        targetDirectory: './adds-todo',
+        scope: 'slice',
+      });
+    });
+
+    it('should emit CheckTypes with targetDirectory and scope', () => {
+      const pipeline = createKanbanFullPipeline();
+      const cmd = findEmitCommand(pipeline, 'SliceImplemented', 'CheckTypes');
+      expect(cmd).toBeDefined();
+      const data =
+        typeof cmd?.data === 'function'
+          ? cmd.data({ type: 'SliceImplemented', data: { slicePath: './adds-todo' } })
+          : cmd?.data;
+      expect(data).toEqual({
+        targetDirectory: './adds-todo',
+        scope: 'slice',
+      });
+    });
+
+    it('should emit CheckLint with targetDirectory, scope, and fix', () => {
+      const pipeline = createKanbanFullPipeline();
+      const cmd = findEmitCommand(pipeline, 'SliceImplemented', 'CheckLint');
+      expect(cmd).toBeDefined();
+      const data =
+        typeof cmd?.data === 'function'
+          ? cmd.data({ type: 'SliceImplemented', data: { slicePath: './adds-todo' } })
+          : cmd?.data;
+      expect(data).toEqual({
+        targetDirectory: './adds-todo',
+        scope: 'slice',
+        fix: true,
+      });
+    });
+
+    it('should emit GenerateIA with modelPath and outputDir', () => {
+      const pipeline = createKanbanFullPipeline();
+      const cmd = findEmitCommand(pipeline, 'ServerGenerated', 'GenerateIA');
+      expect(cmd).toBeDefined();
+      const data = typeof cmd?.data === 'function' ? cmd.data({ type: 'ServerGenerated', data: {} }) : cmd?.data;
+      expect(data).toEqual({
+        modelPath: './.context/schema.json',
+        outputDir: './.context',
+      });
+    });
+
+    it('should emit StartServer with serverDirectory', () => {
+      const pipeline = createKanbanFullPipeline();
+      const cmd = findEmitCommand(pipeline, 'ServerGenerated', 'StartServer');
+      expect(cmd).toBeDefined();
+      const data = typeof cmd?.data === 'function' ? cmd.data({ type: 'ServerGenerated', data: {} }) : cmd?.data;
+      expect(data).toEqual({
+        serverDirectory: './server',
+      });
+    });
+
+    it('should emit GenerateClient with all paths', () => {
+      const pipeline = createKanbanFullPipeline();
+      const cmd = findEmitCommand(pipeline, 'IAGenerated', 'GenerateClient');
+      expect(cmd).toBeDefined();
+      const data = typeof cmd?.data === 'function' ? cmd.data({ type: 'IAGenerated', data: {} }) : cmd?.data;
+      expect(data).toEqual({
+        targetDir: './client',
+        iaSchemaPath: './.context/auto-ia-scheme.json',
+        gqlSchemaPath: './.context/schema.graphql',
+        figmaVariablesPath: './.context/figma-file.json',
+      });
+    });
+  });
+
+  describe('ClientGenerated with StartClient', () => {
+    it('should emit StartClient when ClientGenerated has valid components', () => {
+      const pipeline = createKanbanFullPipeline();
+      const emitHandlers = pipeline.descriptor.handlers.filter(
+        (h): h is EmitHandlerDescriptor =>
+          h.type === 'emit' && h.eventType === 'ClientGenerated' && h.predicate !== undefined,
+      );
+      const startClientHandler = emitHandlers.find((h) => h.commands.some((c) => c.commandType === 'StartClient'));
+      expect(startClientHandler).toBeDefined();
+      const startClientCmd = startClientHandler?.commands.find((c) => c.commandType === 'StartClient');
+      expect(startClientCmd).toBeDefined();
+      const data =
+        typeof startClientCmd?.data === 'function'
+          ? startClientCmd.data({ type: 'ClientGenerated', data: { components: [], targetDir: './client' } })
+          : startClientCmd?.data;
+      expect(data).toEqual({ clientDirectory: './client' });
+    });
+
+    it('should have predicate for StartClient that checks valid components', () => {
+      const pipeline = createKanbanFullPipeline();
+      const emitHandlers = pipeline.descriptor.handlers.filter(
+        (h): h is EmitHandlerDescriptor =>
+          h.type === 'emit' && h.eventType === 'ClientGenerated' && h.predicate !== undefined,
+      );
+      const startClientHandler = emitHandlers.find((h) => h.commands.some((c) => c.commandType === 'StartClient'));
+      const predicate = startClientHandler?.predicate;
+      expect(
+        predicate?.({ type: 'ClientGenerated', data: { components: [{ type: 'molecule', filePath: 'x' }] } }),
+      ).toBe(true);
+      expect(predicate?.({ type: 'ClientGenerated', data: { components: [] } })).toBe(false);
+    });
+  });
+
+  describe('ClientGenerated edge cases', () => {
+    it('should have predicate on foreach-phased handler to check for valid components', () => {
+      const pipeline = createKanbanFullPipeline();
+      const foreachHandler = pipeline.descriptor.handlers.find(
+        (h): h is ForEachPhasedDescriptor => h.type === 'foreach-phased' && h.eventType === 'ClientGenerated',
+      );
+      expect(foreachHandler).toBeDefined();
+      expect(foreachHandler?.predicate).toBeDefined();
+    });
+
+    it('should predicate return true when components array has items', () => {
+      const pipeline = createKanbanFullPipeline();
+      const foreachHandler = pipeline.descriptor.handlers.find(
+        (h): h is ForEachPhasedDescriptor => h.type === 'foreach-phased' && h.eventType === 'ClientGenerated',
+      );
+      const predicate = foreachHandler?.predicate;
+      const eventWithComponents = {
+        type: 'ClientGenerated',
+        data: {
+          components: [{ type: 'molecule', filePath: 'src/Foo.tsx' }],
+          targetDir: './client',
+        },
+      };
+      expect(predicate?.(eventWithComponents)).toBe(true);
+    });
+
+    it('should predicate return false when data is null', () => {
+      const pipeline = createKanbanFullPipeline();
+      const foreachHandler = pipeline.descriptor.handlers.find(
+        (h): h is ForEachPhasedDescriptor => h.type === 'foreach-phased' && h.eventType === 'ClientGenerated',
+      );
+      const predicate = foreachHandler?.predicate;
+      const eventWithNullData = { type: 'ClientGenerated', data: null as unknown as Record<string, unknown> };
+      expect(predicate?.(eventWithNullData)).toBe(false);
+    });
+
+    it('should predicate return false when components is not an array', () => {
+      const pipeline = createKanbanFullPipeline();
+      const foreachHandler = pipeline.descriptor.handlers.find(
+        (h): h is ForEachPhasedDescriptor => h.type === 'foreach-phased' && h.eventType === 'ClientGenerated',
+      );
+      const predicate = foreachHandler?.predicate;
+      const eventWithInvalidComponents = { type: 'ClientGenerated', data: { components: 'not-array' } };
+      expect(predicate?.(eventWithInvalidComponents)).toBe(false);
+    });
+
+    it('should predicate return false when components array is empty', () => {
+      const pipeline = createKanbanFullPipeline();
+      const foreachHandler = pipeline.descriptor.handlers.find(
+        (h): h is ForEachPhasedDescriptor => h.type === 'foreach-phased' && h.eventType === 'ClientGenerated',
+      );
+      const predicate = foreachHandler?.predicate;
+      const eventWithEmptyComponents = { type: 'ClientGenerated', data: { components: [] } };
+      expect(predicate?.(eventWithEmptyComponents)).toBe(false);
+    });
+
+    it('should have fallback emit handler for invalid ClientGenerated data', () => {
+      const pipeline = createKanbanFullPipeline();
+      const fallbackHandler = pipeline.descriptor.handlers.find(
+        (h): h is EmitHandlerDescriptor =>
+          h.type === 'emit' &&
+          h.eventType === 'ClientGenerated' &&
+          h.predicate !== undefined &&
+          h.commands.some((c) => c.commandType === 'ImplementComponent'),
+      );
+      expect(fallbackHandler).toBeDefined();
+      const fallbackPredicate = fallbackHandler?.predicate;
+      expect(fallbackPredicate?.({ type: 'ClientGenerated', data: null as unknown as Record<string, unknown> })).toBe(
+        true,
+      );
+      expect(fallbackPredicate?.({ type: 'ClientGenerated', data: { components: [] } })).toBe(true);
+    });
+
+    it('should fallback handler emit ImplementComponent with example data', () => {
+      const pipeline = createKanbanFullPipeline();
+      const fallbackHandler = pipeline.descriptor.handlers.find(
+        (h): h is EmitHandlerDescriptor =>
+          h.type === 'emit' &&
+          h.eventType === 'ClientGenerated' &&
+          h.predicate !== undefined &&
+          h.commands.some((c) => c.commandType === 'ImplementComponent'),
+      );
+      const implementCmd = fallbackHandler?.commands.find((c) => c.commandType === 'ImplementComponent');
+      expect(implementCmd).toBeDefined();
+      const data =
+        typeof implementCmd?.data === 'function'
+          ? implementCmd.data({ type: 'ClientGenerated', data: null as unknown as Record<string, unknown> })
+          : implementCmd?.data;
+      expect(data).toEqual({
+        projectDir: './client',
+        iaSchemeDir: './.context',
+        designSystemPath: './.context/design-system.md',
+        componentType: 'molecule',
+        filePath: 'client/src/components/molecules/Example.tsx',
+        componentName: 'Example.tsx',
+        aiOptions: { maxTokens: 3000 },
+      });
+    });
+  });
+});

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

@@ -0,0 +1,225 @@
+import type { Event } from '@auto-engineer/message-bus';
+import { define } from '../../builder/define';
+
+interface Component {
+  type: 'molecule' | 'organism' | 'page';
+  filePath: string;
+}
+
+interface SchemaExportedData {
+  directory: string;
+  outputPath: string;
+}
+
+interface SliceGeneratedData {
+  slicePath: string;
+}
+
+interface SliceImplementedData {
+  slicePath: string;
+}
+
+interface ClientGeneratedData {
+  components: Component[];
+  targetDir: string;
+}
+
+interface CheckEventData {
+  targetDirectory?: string;
+  errors?: string;
+}
+
+const MAX_RETRIES = 4;
+const sliceRetryState = new Map<string, number>();
+let projectRoot = '';
+
+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) => (e.data as CheckEventData).errors ?? '')
+    .filter((s) => s.length > 0)
+    .join('\n');
+}
+
+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?.targetDirectory ?? '';
+}
+
+function gatherAllCheckEvents(events: Record<string, Event[]>): Event[] {
+  return [...(events.CheckTests ?? []), ...(events.CheckTypes ?? []), ...(events.CheckLint ?? [])];
+}
+
+function shouldRetry(slicePath: string): boolean {
+  const attempts = sliceRetryState.get(slicePath) ?? 0;
+  return attempts < MAX_RETRIES;
+}
+
+function incrementRetryCount(slicePath: string): number {
+  const attempts = sliceRetryState.get(slicePath) ?? 0;
+  sliceRetryState.set(slicePath, attempts + 1);
+  return attempts + 1;
+}
+
+function hasValidComponents(e: { data: ClientGeneratedData | null }): boolean {
+  return e.data !== null && Array.isArray(e.data.components) && e.data.components.length > 0;
+}
+
+function hasInvalidComponents(e: { data: ClientGeneratedData | null }): boolean {
+  return !hasValidComponents(e);
+}
+
+function resolvePath(relativePath: string): string {
+  if (projectRoot === '') {
+    return relativePath;
+  }
+  if (relativePath.startsWith('/')) {
+    return relativePath;
+  }
+  if (relativePath.startsWith('./')) {
+    return `${projectRoot}/${relativePath.slice(2)}`;
+  }
+  return `${projectRoot}/${relativePath}`;
+}
+
+export function createKanbanFullPipeline() {
+  return define('kanban-full')
+    .on('SchemaExported')
+    .emit('GenerateServer', (e: { data: SchemaExportedData }) => {
+      projectRoot = e.data.directory;
+      return {
+        modelPath: e.data.outputPath,
+        destination: e.data.directory,
+      };
+    })
+
+    .on('SliceGenerated')
+    .emit('ImplementSlice', (e: { data: SliceGeneratedData }) => ({
+      slicePath: resolvePath(e.data.slicePath),
+      context: { previousOutputs: 'errors', attemptNumber: 0 },
+      aiOptions: { maxTokens: 2000 },
+    }))
+
+    .on('SliceImplemented')
+    .emit('CheckTests', (e: { data: SliceImplementedData }) => ({
+      targetDirectory: e.data.slicePath,
+      scope: 'slice',
+    }))
+    .emit('CheckTypes', (e: { data: SliceImplementedData }) => ({
+      targetDirectory: e.data.slicePath,
+      scope: 'slice',
+    }))
+    .emit('CheckLint', (e: { data: SliceImplementedData }) => ({
+      targetDirectory: e.data.slicePath,
+      scope: 'slice',
+      fix: true,
+    }))
+
+    .settled(['CheckTests', 'CheckTypes', 'CheckLint'])
+    .dispatch({ dispatches: ['ImplementSlice'] }, (events, send) => {
+      const allEvents = gatherAllCheckEvents(events);
+
+      if (!hasAnyFailures(allEvents)) {
+        const slicePath = extractSlicePath(events);
+        sliceRetryState.delete(slicePath);
+        return;
+      }
+
+      const slicePath = extractSlicePath(events);
+
+      if (!shouldRetry(slicePath)) {
+        sliceRetryState.delete(slicePath);
+        return;
+      }
+
+      const retryAttempt = incrementRetryCount(slicePath);
+      send('ImplementSlice', {
+        slicePath,
+        context: { previousOutputs: collectErrors(allEvents), attemptNumber: retryAttempt },
+        aiOptions: { maxTokens: 2000 },
+      });
+      return { persist: true };
+    })
+
+    .on('ServerGenerated')
+    .emit('GenerateIA', () => ({
+      modelPath: resolvePath('./.context/schema.json'),
+      outputDir: resolvePath('./.context'),
+    }))
+    .emit('StartServer', () => ({
+      serverDirectory: resolvePath('./server'),
+    }))
+
+    .on('IAGenerated')
+    .emit('GenerateClient', () => ({
+      targetDir: resolvePath('./client'),
+      iaSchemaPath: resolvePath('./.context/auto-ia-scheme.json'),
+      gqlSchemaPath: resolvePath('./.context/schema.graphql'),
+      figmaVariablesPath: resolvePath('./.context/figma-file.json'),
+    }))
+
+    .on('ClientGenerated')
+    .when(hasValidComponents)
+    .emit('StartClient', () => ({
+      clientDirectory: resolvePath('./client'),
+    }))
+
+    .on('ClientGenerated')
+    .when(hasInvalidComponents)
+    .emit('ImplementComponent', () => ({
+      projectDir: resolvePath('./client'),
+      iaSchemeDir: resolvePath('./.context'),
+      designSystemPath: resolvePath('./.context/design-system.md'),
+      componentType: 'molecule',
+      filePath: resolvePath('client/src/components/molecules/Example.tsx'),
+      componentName: 'Example.tsx',
+      aiOptions: { maxTokens: 3000 },
+    }))
+
+    .on('ClientGenerated')
+    .when(hasValidComponents)
+    .forEach((e: { data: ClientGeneratedData }) => e.data.components)
+    .groupInto(['molecule', 'organism', 'page'], (c) => c.type)
+    .process('ImplementComponent', (c: Component) => ({
+      projectDir: resolvePath('./client'),
+      iaSchemeDir: resolvePath('./.context'),
+      designSystemPath: resolvePath('./.context/design-system.md'),
+      componentType: c.type ?? 'molecule',
+      filePath: resolvePath(c.filePath ?? ''),
+      componentName: (c.filePath ?? '').split('/').pop()?.replace('.tsx', '') ?? '',
+      aiOptions: { maxTokens: 3000 },
+    }))
+    .onComplete({
+      success: 'AllComponentsImplemented',
+      failure: 'ComponentsFailed',
+      itemKey: (e) => (e.data as { filePath?: string }).filePath ?? '',
+    })
+
+    .build();
+}
+
+export function resetKanbanState(): void {
+  sliceRetryState.clear();
+  projectRoot = '';
+}
+
+export function setProjectRoot(root: string): void {
+  projectRoot = root;
+}
+
+export function testResolvePath(relativePath: string): string {
+  return resolvePath(relativePath);
+}
+
+export function setSliceRetryCount(slicePath: string, count: number): void {
+  sliceRetryState.set(slicePath, count);
+}
+
+export function testShouldRetry(slicePath: string): boolean {
+  return shouldRetry(slicePath);
+}

package/src/testing/fixtures/kanban-todo.config.ts

@@ -0,0 +1,19 @@
+import { pipelineConfig } from '../../config/pipeline-config';
+import { createKanbanFullPipeline } from './kanban-full.pipeline';
+
+export default pipelineConfig({
+  plugins: [
+    '@auto-engineer/server-checks',
+    '@auto-engineer/design-system-importer',
+    '@auto-engineer/server-generator-apollo-emmett',
+    '@auto-engineer/narrative',
+    '@auto-engineer/frontend-checks',
+    '@auto-engineer/frontend-implementer',
+    '@auto-engineer/component-implementer',
+    '@auto-engineer/information-architect',
+    '@auto-engineer/frontend-generator-react-graphql',
+    '@auto-engineer/server-implementer',
+    '@auto-engineer/dev-server',
+  ],
+  pipeline: createKanbanFullPipeline(),
+});

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

@@ -0,0 +1,33 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { createKanbanPipeline, resetRetryState, setRetryCount, testShouldRetry } from './kanban.pipeline';
+
+describe('kanban.pipeline', () => {
+  beforeEach(() => {
+    resetRetryState();
+  });
+
+  describe('shouldRetry', () => {
+    it('should return true when retry count is below max', () => {
+      expect(testShouldRetry('./slice-path')).toBe(true);
+    });
+
+    it('should return false when retry count reaches max', () => {
+      setRetryCount('./slice-path', 3);
+      expect(testShouldRetry('./slice-path')).toBe(false);
+    });
+  });
+
+  describe('pipeline structure', () => {
+    it('should have name kanban', () => {
+      const pipeline = createKanbanPipeline();
+      expect(pipeline.descriptor.name).toBe('kanban');
+    });
+
+    it('should have handlers for slice workflow', () => {
+      const pipeline = createKanbanPipeline();
+      const eventTypes = pipeline.descriptor.handlers.filter((h) => h.type === 'emit').map((h) => h.eventType);
+      expect(eventTypes).toContain('SchemaExported');
+      expect(eventTypes).toContain('SliceGenerated');
+    });
+  });
+});