@auto-engineer/component-implementor-react 1.107.0 → 1.109.0

package/src/pipeline/steps/storybook-test.ts

@@ -1,27 +0,0 @@
-import { runStorybookTest } from '../../tools/storybook-runner';
-import { runTypeCheck } from '../../tools/type-checker';
-import type { PipelineContext, StepResult } from '../run-pipeline';
-
-export async function storybookTestStep(ctx: PipelineContext, enableStorybookCli: boolean): Promise<StepResult> {
-  const typeResult = runTypeCheck(ctx.targetDir, [ctx.storyPath]);
-
-  if (!typeResult.passed) {
-    return {
-      success: false,
-      error: `Story type errors: ${typeResult.errors.join('; ')}`,
-    };
-  }
-
-  if (enableStorybookCli) {
-    const testResult = runStorybookTest(ctx.storyPath, ctx.targetDir);
-
-    if (!testResult.passed) {
-      return {
-        success: false,
-        error: `Storybook test failures: ${testResult.errors.join('; ')}`,
-      };
-    }
-  }
-
-  return { success: true };
-}

package/src/pipeline/steps/test-fix-loop.test.ts

@@ -1,205 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-vi.mock('ai', () => ({
-  generateText: vi.fn(),
-}));
-
-vi.mock('node:fs/promises', () => ({
-  readFile: vi.fn(),
-  writeFile: vi.fn(),
-}));
-
-vi.mock('../../tools/test-runner', () => ({
-  runTests: vi.fn(),
-}));
-
-import { readFile, writeFile } from 'node:fs/promises';
-import { generateText } from 'ai';
-import { runTests } from '../../tools/test-runner';
-import type { PipelineContext } from '../run-pipeline';
-import { testFixLoop } from './test-fix-loop';
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-function makeCtx(overrides: Partial<PipelineContext> = {}): PipelineContext {
-  return {
-    componentName: 'MyButton',
-    componentPath: '/project/src/MyButton.tsx',
-    testPath: '/project/src/MyButton.test.tsx',
-    storyPath: '/project/src/MyButton.stories.tsx',
-    componentImportPath: '@/components/ui/MyButton',
-    targetDir: '/project',
-    specDeltas: { structure: [], rendering: [], interaction: [], styling: [] },
-    projectSection: '',
-    composes: [],
-    isModify: false,
-    llmCalls: 0,
-    fixIterations: 0,
-    typeFixIterations: 0,
-    testFixIterations: 0,
-    lintFixIterations: 0,
-    storyFixIterations: 0,
-    componentCode: 'original component',
-    testCode: 'original test',
-    ...overrides,
-  };
-}
-
-describe('testFixLoop', () => {
-  it('returns success immediately when all tests pass', async () => {
-    vi.mocked(runTests).mockReturnValue({
-      passed: true,
-      numPassed: 3,
-      numFailed: 0,
-      failures: [],
-      output: '',
-    });
-
-    const result = await testFixLoop('mock-model' as never, makeCtx(), 3);
-
-    expect(result).toEqual({ success: true });
-    expect(generateText).not.toHaveBeenCalled();
-  });
-
-  it('calls LLM to fix failures and writes fixed files', async () => {
-    vi.mocked(runTests)
-      .mockReturnValueOnce({
-        passed: false,
-        numPassed: 1,
-        numFailed: 1,
-        failures: ['renders button: element not found'],
-        output: 'FAIL',
-      })
-      .mockReturnValueOnce({
-        passed: true,
-        numPassed: 2,
-        numFailed: 0,
-        failures: [],
-        output: 'PASS',
-      });
-
-    vi.mocked(generateText).mockResolvedValue({
-      text: '```tsx\nfixed component\n```\n```tsx\nfixed test\n```',
-    } as Awaited<ReturnType<typeof generateText>>);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const result = await testFixLoop('mock-model' as never, makeCtx(), 3);
-
-    expect(result).toEqual({ success: true });
-    expect(generateText).toHaveBeenCalledTimes(1);
-    expect(writeFile).toHaveBeenCalledWith('/project/src/MyButton.tsx', 'fixed component', 'utf-8');
-    expect(writeFile).toHaveBeenCalledWith('/project/src/MyButton.test.tsx', 'fixed test', 'utf-8');
-  });
-
-  it('returns failure after exhausting max iterations', async () => {
-    vi.mocked(runTests).mockReturnValue({
-      passed: false,
-      numPassed: 0,
-      numFailed: 1,
-      failures: ['persistent failure'],
-      output: 'FAIL',
-    });
-
-    vi.mocked(generateText).mockResolvedValue({
-      text: '```tsx\nstill broken\n```\n```tsx\nstill broken test\n```',
-    } as Awaited<ReturnType<typeof generateText>>);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-    vi.mocked(readFile).mockResolvedValue('still broken' as never);
-
-    const result = await testFixLoop('mock-model' as never, makeCtx(), 1);
-
-    expect(result).toEqual({
-      success: false,
-      error: expect.stringContaining('Test failures remain after 1 iterations'),
-    });
-  });
-
-  it('handles single code block response by updating only component', async () => {
-    vi.mocked(runTests)
-      .mockReturnValueOnce({
-        passed: false,
-        numPassed: 0,
-        numFailed: 1,
-        failures: ['failure'],
-        output: 'FAIL',
-      })
-      .mockReturnValueOnce({
-        passed: true,
-        numPassed: 1,
-        numFailed: 0,
-        failures: [],
-        output: 'PASS',
-      });
-
-    vi.mocked(generateText).mockResolvedValue({
-      text: '```tsx\nfixed component only\n```',
-    } as Awaited<ReturnType<typeof generateText>>);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const result = await testFixLoop('mock-model' as never, makeCtx(), 3);
-
-    expect(result).toEqual({ success: true });
-    expect(writeFile).toHaveBeenCalledWith('/project/src/MyButton.tsx', 'fixed component only', 'utf-8');
-    expect(writeFile).toHaveBeenCalledTimes(1);
-  });
-
-  it('returns success when final check passes after last iteration fix', async () => {
-    vi.mocked(runTests)
-      .mockReturnValueOnce({
-        passed: false,
-        numPassed: 0,
-        numFailed: 1,
-        failures: ['failure'],
-        output: 'FAIL',
-      })
-      .mockReturnValueOnce({
-        passed: true,
-        numPassed: 1,
-        numFailed: 0,
-        failures: [],
-        output: 'PASS',
-      });
-
-    vi.mocked(generateText).mockResolvedValue({
-      text: '```tsx\nfixed\n```\n```tsx\nfixed test\n```',
-    } as Awaited<ReturnType<typeof generateText>>);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const result = await testFixLoop('mock-model' as never, makeCtx(), 1);
-
-    expect(result).toEqual({ success: true });
-  });
-
-  it('uses empty string fallback when componentCode and testCode are undefined', async () => {
-    vi.mocked(runTests)
-      .mockReturnValueOnce({
-        passed: false,
-        numPassed: 0,
-        numFailed: 1,
-        failures: ['failure'],
-        output: 'FAIL',
-      })
-      .mockReturnValueOnce({
-        passed: true,
-        numPassed: 1,
-        numFailed: 0,
-        failures: [],
-        output: 'PASS',
-      });
-
-    vi.mocked(generateText).mockResolvedValue({
-      text: '```tsx\nfixed\n```\n```tsx\nfixed test\n```',
-    } as Awaited<ReturnType<typeof generateText>>);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const result = await testFixLoop(
-      'mock-model' as never,
-      makeCtx({ componentCode: undefined, testCode: undefined }),
-      1,
-    );
-
-    expect(result).toEqual({ success: true });
-  });
-});

package/src/pipeline/steps/test-fix-loop.ts

@@ -1,57 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises';
-import type { LanguageModel } from 'ai';
-import { generateText } from 'ai';
-import { extractCodeBlocks } from '../../extract-code-block';
-import { buildTestFixPrompt } from '../../prompt';
-import { runTests } from '../../tools/test-runner';
-import type { PipelineContext, StepResult } from '../run-pipeline';
-
-export async function testFixLoop(
-  model: LanguageModel,
-  ctx: PipelineContext,
-  maxIterations: number,
-): Promise<StepResult> {
-  for (let i = 0; i < maxIterations; i++) {
-    const result = runTests(ctx.testPath, ctx.targetDir);
-
-    if (result.passed) {
-      return { success: true };
-    }
-
-    const { system, prompt } = buildTestFixPrompt({
-      componentCode: ctx.componentCode ?? '',
-      testCode: ctx.testCode ?? '',
-      failures: result.failures,
-      testOutput: result.output,
-    });
-
-    const { text } = await generateText({ model, system, prompt });
-    ctx.llmCalls++;
-    ctx.fixIterations++;
-    ctx.testFixIterations++;
-
-    const blocks = extractCodeBlocks(text);
-    if (blocks.length >= 2) {
-      ctx.componentCode = blocks[0];
-      ctx.testCode = blocks[1];
-      await writeFile(ctx.componentPath, blocks[0], 'utf-8');
-      await writeFile(ctx.testPath, blocks[1], 'utf-8');
-    } else if (blocks.length === 1) {
-      ctx.componentCode = blocks[0];
-      await writeFile(ctx.componentPath, blocks[0], 'utf-8');
-    }
-  }
-
-  const finalResult = runTests(ctx.testPath, ctx.targetDir);
-  if (finalResult.passed) {
-    return { success: true };
-  }
-
-  ctx.componentCode = await readFile(ctx.componentPath, 'utf-8');
-  ctx.testCode = await readFile(ctx.testPath, 'utf-8');
-
-  return {
-    success: false,
-    error: `Test failures remain after ${maxIterations} iterations: ${finalResult.failures.join('; ')}`,
-  };
-}

package/src/pipeline/steps/type-fix-loop.test.ts

@@ -1,149 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-vi.mock('ai', () => ({
-  generateText: vi.fn(),
-}));
-
-vi.mock('node:fs/promises', () => ({
-  readFile: vi.fn(),
-  writeFile: vi.fn(),
-}));
-
-vi.mock('../../tools/type-checker', () => ({
-  runTypeCheck: vi.fn(),
-}));
-
-import { readFile, writeFile } from 'node:fs/promises';
-import { generateText } from 'ai';
-import { runTypeCheck } from '../../tools/type-checker';
-import type { PipelineContext } from '../run-pipeline';
-import { typeFixLoop } from './type-fix-loop';
-
-afterEach(() => {
-  vi.clearAllMocks();
-});
-
-function makeCtx(overrides: Partial<PipelineContext> = {}): PipelineContext {
-  return {
-    componentName: 'MyButton',
-    componentPath: '/project/src/MyButton.tsx',
-    testPath: '/project/src/MyButton.test.tsx',
-    storyPath: '/project/src/MyButton.stories.tsx',
-    componentImportPath: '@/components/ui/MyButton',
-    targetDir: '/project',
-    specDeltas: { structure: [], rendering: [], interaction: [], styling: [] },
-    projectSection: '',
-    composes: [],
-    isModify: false,
-    llmCalls: 0,
-    fixIterations: 0,
-    typeFixIterations: 0,
-    testFixIterations: 0,
-    lintFixIterations: 0,
-    storyFixIterations: 0,
-    componentCode: 'original component',
-    testCode: 'original test',
-    ...overrides,
-  };
-}
-
-describe('typeFixLoop', () => {
-  it('returns success immediately when type check passes', async () => {
-    vi.mocked(runTypeCheck).mockReturnValue({ passed: true, errors: [] });
-
-    const result = await typeFixLoop('mock-model' as never, makeCtx(), 3);
-
-    expect(result).toEqual({ success: true });
-    expect(generateText).not.toHaveBeenCalled();
-  });
-
-  it('calls LLM to fix type errors and writes fixed files', async () => {
-    vi.mocked(runTypeCheck)
-      .mockReturnValueOnce({ passed: false, errors: ['error TS2307: Module not found'] })
-      .mockReturnValueOnce({ passed: true, errors: [] });
-
-    vi.mocked(generateText).mockResolvedValue({
-      text: '```tsx\nfixed component\n```\n```tsx\nfixed test\n```',
-    } as Awaited<ReturnType<typeof generateText>>);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const result = await typeFixLoop('mock-model' as never, makeCtx(), 3);
-
-    expect(result).toEqual({ success: true });
-    expect(generateText).toHaveBeenCalledTimes(1);
-    expect(writeFile).toHaveBeenCalledWith('/project/src/MyButton.tsx', 'fixed component', 'utf-8');
-    expect(writeFile).toHaveBeenCalledWith('/project/src/MyButton.test.tsx', 'fixed test', 'utf-8');
-  });
-
-  it('returns failure after exhausting max iterations', async () => {
-    vi.mocked(runTypeCheck).mockReturnValue({
-      passed: false,
-      errors: ['persistent error'],
-    });
-
-    vi.mocked(generateText).mockResolvedValue({
-      text: '```tsx\nstill broken\n```\n```tsx\nstill broken test\n```',
-    } as Awaited<ReturnType<typeof generateText>>);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-    vi.mocked(readFile).mockResolvedValue('still broken' as never);
-
-    const result = await typeFixLoop('mock-model' as never, makeCtx(), 2);
-
-    expect(result).toEqual({
-      success: false,
-      error: expect.stringContaining('Type errors remain after 2 iterations'),
-    });
-    expect(generateText).toHaveBeenCalledTimes(2);
-  });
-
-  it('handles single code block response by updating only component', async () => {
-    vi.mocked(runTypeCheck)
-      .mockReturnValueOnce({ passed: false, errors: ['error in component'] })
-      .mockReturnValueOnce({ passed: true, errors: [] });
-
-    vi.mocked(generateText).mockResolvedValue({
-      text: '```tsx\nfixed component only\n```',
-    } as Awaited<ReturnType<typeof generateText>>);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const result = await typeFixLoop('mock-model' as never, makeCtx(), 3);
-
-    expect(result).toEqual({ success: true });
-    expect(writeFile).toHaveBeenCalledWith('/project/src/MyButton.tsx', 'fixed component only', 'utf-8');
-    expect(writeFile).toHaveBeenCalledTimes(1);
-  });
-
-  it('returns success when final check passes after last iteration fix', async () => {
-    vi.mocked(runTypeCheck)
-      .mockReturnValueOnce({ passed: false, errors: ['error'] })
-      .mockReturnValueOnce({ passed: true, errors: [] });
-
-    vi.mocked(generateText).mockResolvedValue({
-      text: '```tsx\nfixed\n```\n```tsx\nfixed test\n```',
-    } as Awaited<ReturnType<typeof generateText>>);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const result = await typeFixLoop('mock-model' as never, makeCtx(), 1);
-
-    expect(result).toEqual({ success: true });
-  });
-
-  it('uses empty string fallback when componentCode and testCode are undefined', async () => {
-    vi.mocked(runTypeCheck)
-      .mockReturnValueOnce({ passed: false, errors: ['error'] })
-      .mockReturnValueOnce({ passed: true, errors: [] });
-
-    vi.mocked(generateText).mockResolvedValue({
-      text: '```tsx\nfixed\n```\n```tsx\nfixed test\n```',
-    } as Awaited<ReturnType<typeof generateText>>);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const result = await typeFixLoop(
-      'mock-model' as never,
-      makeCtx({ componentCode: undefined, testCode: undefined }),
-      1,
-    );
-
-    expect(result).toEqual({ success: true });
-  });
-});

package/src/pipeline/steps/type-fix-loop.ts

@@ -1,56 +0,0 @@
-import { readFile, writeFile } from 'node:fs/promises';
-import type { LanguageModel } from 'ai';
-import { generateText } from 'ai';
-import { extractCodeBlocks } from '../../extract-code-block';
-import { buildTypeFixPrompt } from '../../prompt';
-import { runTypeCheck } from '../../tools/type-checker';
-import type { PipelineContext, StepResult } from '../run-pipeline';
-
-export async function typeFixLoop(
-  model: LanguageModel,
-  ctx: PipelineContext,
-  maxIterations: number,
-): Promise<StepResult> {
-  for (let i = 0; i < maxIterations; i++) {
-    const result = runTypeCheck(ctx.targetDir, [ctx.componentPath, ctx.testPath]);
-
-    if (result.passed) {
-      return { success: true };
-    }
-
-    const { system, prompt } = buildTypeFixPrompt({
-      componentCode: ctx.componentCode ?? '',
-      testCode: ctx.testCode ?? '',
-      errors: result.errors,
-    });
-
-    const { text } = await generateText({ model, system, prompt });
-    ctx.llmCalls++;
-    ctx.fixIterations++;
-    ctx.typeFixIterations++;
-
-    const blocks = extractCodeBlocks(text);
-    if (blocks.length >= 2) {
-      ctx.componentCode = blocks[0];
-      ctx.testCode = blocks[1];
-      await writeFile(ctx.componentPath, blocks[0], 'utf-8');
-      await writeFile(ctx.testPath, blocks[1], 'utf-8');
-    } else if (blocks.length === 1) {
-      ctx.componentCode = blocks[0];
-      await writeFile(ctx.componentPath, blocks[0], 'utf-8');
-    }
-  }
-
-  const finalResult = runTypeCheck(ctx.targetDir, [ctx.componentPath, ctx.testPath]);
-  if (finalResult.passed) {
-    return { success: true };
-  }
-
-  ctx.componentCode = await readFile(ctx.componentPath, 'utf-8');
-  ctx.testCode = await readFile(ctx.testPath, 'utf-8');
-
-  return {
-    success: false,
-    error: `Type errors remain after ${maxIterations} iterations: ${finalResult.errors.join('; ')}`,
-  };
-}

package/src/pipeline/steps/visual-test.test.ts

@@ -1,10 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { visualTestStep } from './visual-test';
-
-describe('visualTestStep', () => {
-  it('returns success (placeholder)', async () => {
-    const result = await visualTestStep();
-
-    expect(result).toEqual({ success: true });
-  });
-});

package/src/pipeline/steps/visual-test.ts

@@ -1,5 +0,0 @@
-import type { StepResult } from '../run-pipeline';
-
-export async function visualTestStep(): Promise<StepResult> {
-  return { success: true };
-}