claudecode-omc 4.9.4 → 5.0.0

package/docs/plans/2026-03-06-llm-testing-system-phase3.md

@@ -1,1830 +0,0 @@
-# LLM Testing System - Phase 3 Implementation Plan
-
-> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
-
-**Goal:** Complete the testing ecosystem with Promptfoo integration, Giskard behavioral testing, Playwright E2E generation, CI/CD templates, Ralph mode testing loop, Autopilot testing phase, test quality scoring, and performance optimization.
-
-**Architecture:** Build on Phase 1 and Phase 2 foundation by adding Promptfoo config generator, Giskard behavioral test suite, Playwright E2E generator, GitHub Actions templates, Ralph/Autopilot integration hooks, test quality scorer, and performance optimization layer.
-
-**Tech Stack:** TypeScript, Node.js, Promptfoo, Giskard, Playwright, GitHub Actions
-
----
-
-## Task 1: Promptfoo Integration - Config Generator
-
-**Files:**
-- Create: `src/testing/integrations/promptfoo/config-generator.ts`
-- Create: `src/testing/integrations/promptfoo/types.ts`
-- Create: `tests/testing/integrations/promptfoo/config-generator.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/integrations/promptfoo/config-generator.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generatePromptfooConfig, generateTestCases } from '../../../../src/testing/integrations/promptfoo/config-generator';
-
-describe('Promptfoo Config Generator', () => {
-  it('should generate promptfoo config for LLM prompt testing', async () => {
-    const result = await generatePromptfooConfig({
-      promptFile: 'src/prompts/code-review.txt',
-      testCases: [
-        { input: 'function add(a, b) { return a + b; }', expected: 'contains:function,parameters' },
-        { input: 'const x = 1;', expected: 'contains:variable,declaration' },
-      ],
-      provider: 'anthropic:claude-3-5-sonnet-20241022',
-    });
-
-    expect(result.prompts).toHaveLength(1);
-    expect(result.prompts[0]).toBe('file://src/prompts/code-review.txt');
-    expect(result.providers).toContain('anthropic:claude-3-5-sonnet-20241022');
-    expect(result.tests).toHaveLength(2);
-  });
-
-  it('should generate test cases from code examples', async () => {
-    const result = await generateTestCases({
-      codeExamples: [
-        { code: 'function multiply(a, b) { return a * b; }', language: 'javascript' },
-        { code: 'def divide(a, b): return a / b', language: 'python' },
-      ],
-      assertionType: 'contains',
-    });
-
-    expect(result).toHaveLength(2);
-    expect(result[0]).toMatchObject({
-      vars: { code: expect.any(String), language: 'javascript' },
-      assert: expect.arrayContaining([{ type: 'contains', value: expect.any(String) }]),
-    });
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/integrations/promptfoo/config-generator.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement Promptfoo config generator**
-
-Create `src/testing/integrations/promptfoo/types.ts`:
-
-```typescript
-export interface PromptfooConfig {
-  prompts: string[];
-  providers: string[];
-  tests: PromptfooTestCase[];
-  defaultTest?: {
-    assert?: PromptfooAssertion[];
-  };
-  outputPath?: string;
-}
-
-export interface PromptfooTestCase {
-  vars?: Record<string, any>;
-  assert?: PromptfooAssertion[];
-  description?: string;
-}
-
-export interface PromptfooAssertion {
-  type: 'equals' | 'contains' | 'not-contains' | 'regex' | 'javascript' | 'llm-rubric';
-  value?: string;
-  threshold?: number;
-}
-
-export interface GenerateConfigOptions {
-  promptFile: string;
-  testCases: Array<{ input: string; expected: string }>;
-  provider: string;
-  outputPath?: string;
-}
-
-export interface GenerateTestCasesOptions {
-  codeExamples: Array<{ code: string; language: string }>;
-  assertionType: 'contains' | 'equals' | 'regex';
-}
-```
-
-Create `src/testing/integrations/promptfoo/config-generator.ts`:
-
-```typescript
-import fs from 'fs/promises';
-import path from 'path';
-import yaml from 'yaml';
-import type {
-  PromptfooConfig,
-  PromptfooTestCase,
-  GenerateConfigOptions,
-  GenerateTestCasesOptions,
-} from './types';
-
-export async function generatePromptfooConfig(options: GenerateConfigOptions): Promise<PromptfooConfig> {
-  const { promptFile, testCases, provider, outputPath } = options;
-
-  const tests: PromptfooTestCase[] = testCases.map((tc) => {
-    const [assertType, assertValue] = tc.expected.split(':');
-    return {
-      vars: { input: tc.input },
-      assert: [
-        {
-          type: assertType as any,
-          value: assertValue,
-        },
-      ],
-    };
-  });
-
-  const config: PromptfooConfig = {
-    prompts: [`file://${promptFile}`],
-    providers: [provider],
-    tests,
-    outputPath: outputPath || './promptfoo-results.json',
-  };
-
-  return config;
-}
-
-export async function generateTestCases(options: GenerateTestCasesOptions): Promise<PromptfooTestCase[]> {
-  const { codeExamples, assertionType } = options;
-
-  return codeExamples.map((example) => ({
-    vars: {
-      code: example.code,
-      language: example.language,
-    },
-    assert: [
-      {
-        type: assertionType,
-        value: example.language === 'javascript' ? 'function' : 'def',
-      },
-    ],
-  }));
-}
-
-export async function savePromptfooConfig(config: PromptfooConfig, outputPath: string): Promise<void> {
-  const yamlContent = yaml.stringify(config);
-  await fs.writeFile(outputPath, yamlContent, 'utf-8');
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/integrations/promptfoo/config-generator.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/integrations/promptfoo/ tests/testing/integrations/promptfoo/
-git commit -m "feat(testing): add Promptfoo config generator for LLM prompt testing"
-```
-
----
-
-## Task 2: Giskard Behavioral Testing Integration
-
-**Files:**
-- Create: `src/testing/integrations/giskard/behavioral-tests.ts`
-- Create: `src/testing/integrations/giskard/types.ts`
-- Create: `tests/testing/integrations/giskard/behavioral-tests.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/integrations/giskard/behavioral-tests.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generatePerturbationTests, generateRobustnessTests } from '../../../../src/testing/integrations/giskard/behavioral-tests';
-
-describe('Giskard Behavioral Tests', () => {
-  it('should generate perturbation tests for text inputs', async () => {
-    const result = await generatePerturbationTests({
-      testCases: [
-        { input: 'Hello world', expectedOutput: 'greeting' },
-        { input: 'Goodbye friend', expectedOutput: 'farewell' },
-      ],
-      perturbations: ['typo', 'negation', 'synonym'],
-    });
-
-    expect(result.tests).toHaveLength(6); // 2 inputs × 3 perturbations
-    expect(result.tests[0]).toMatchObject({
-      original: 'Hello world',
-      perturbed: expect.any(String),
-      perturbationType: 'typo',
-      expectedBehavior: 'should still classify as greeting',
-    });
-  });
-
-  it('should generate robustness tests', async () => {
-    const result = await generateRobustnessTests({
-      modelEndpoint: '/api/classify',
-      testInputs: ['Test input 1', 'Test input 2'],
-      robustnessChecks: ['case-sensitivity', 'whitespace', 'special-chars'],
-    });
-
-    expect(result.checks).toHaveLength(3);
-    expect(result.checks[0].type).toBe('case-sensitivity');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/integrations/giskard/behavioral-tests.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement Giskard behavioral testing**
-
-Create `src/testing/integrations/giskard/types.ts`:
-
-```typescript
-export interface PerturbationTest {
-  original: string;
-  perturbed: string;
-  perturbationType: 'typo' | 'negation' | 'synonym' | 'paraphrase';
-  expectedBehavior: string;
-  expectedOutput?: string;
-}
-
-export interface PerturbationTestSuite {
-  tests: PerturbationTest[];
-  totalTests: number;
-}
-
-export interface RobustnessCheck {
-  type: 'case-sensitivity' | 'whitespace' | 'special-chars' | 'unicode';
-  testCases: Array<{ input: string; expected: string }>;
-}
-
-export interface RobustnessTestSuite {
-  checks: RobustnessCheck[];
-  totalChecks: number;
-}
-
-export interface GeneratePerturbationOptions {
-  testCases: Array<{ input: string; expectedOutput: string }>;
-  perturbations: Array<'typo' | 'negation' | 'synonym' | 'paraphrase'>;
-}
-
-export interface GenerateRobustnessOptions {
-  modelEndpoint: string;
-  testInputs: string[];
-  robustnessChecks: Array<'case-sensitivity' | 'whitespace' | 'special-chars' | 'unicode'>;
-}
-```
-
-Create `src/testing/integrations/giskard/behavioral-tests.ts`:
-
-```typescript
-import type {
-  PerturbationTest,
-  PerturbationTestSuite,
-  RobustnessCheck,
-  RobustnessTestSuite,
-  GeneratePerturbationOptions,
-  GenerateRobustnessOptions,
-} from './types';
-
-export async function generatePerturbationTests(options: GeneratePerturbationOptions): Promise<PerturbationTestSuite> {
-  const { testCases, perturbations } = options;
-  const tests: PerturbationTest[] = [];
-
-  for (const testCase of testCases) {
-    for (const perturbationType of perturbations) {
-      const perturbed = applyPerturbation(testCase.input, perturbationType);
-      tests.push({
-        original: testCase.input,
-        perturbed,
-        perturbationType,
-        expectedBehavior: `should still classify as ${testCase.expectedOutput}`,
-        expectedOutput: testCase.expectedOutput,
-      });
-    }
-  }
-
-  return {
-    tests,
-    totalTests: tests.length,
-  };
-}
-
-function applyPerturbation(text: string, type: string): string {
-  switch (type) {
-    case 'typo':
-      // Simple typo: swap two adjacent characters
-      const pos = Math.floor(Math.random() * (text.length - 1));
-      return text.slice(0, pos) + text[pos + 1] + text[pos] + text.slice(pos + 2);
-    case 'negation':
-      return `not ${text}`;
-    case 'synonym':
-      // Simple synonym replacement (in real implementation, use NLP library)
-      return text.replace(/hello/gi, 'hi').replace(/goodbye/gi, 'bye');
-    default:
-      return text;
-  }
-}
-
-export async function generateRobustnessTests(options: GenerateRobustnessOptions): Promise<RobustnessTestSuite> {
-  const { modelEndpoint, testInputs, robustnessChecks } = options;
-  const checks: RobustnessCheck[] = [];
-
-  for (const checkType of robustnessChecks) {
-    const testCases = testInputs.map((input) => ({
-      input: applyRobustnessTransform(input, checkType),
-      expected: input, // Expected to behave same as original
-    }));
-
-    checks.push({
-      type: checkType as any,
-      testCases,
-    });
-  }
-
-  return {
-    checks,
-    totalChecks: checks.length,
-  };
-}
-
-function applyRobustnessTransform(text: string, type: string): string {
-  switch (type) {
-    case 'case-sensitivity':
-      return text.toUpperCase();
-    case 'whitespace':
-      return `  ${text}  `;
-    case 'special-chars':
-      return `${text}!!!`;
-    default:
-      return text;
-  }
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/integrations/giskard/behavioral-tests.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/integrations/giskard/ tests/testing/integrations/giskard/
-git commit -m "feat(testing): add Giskard behavioral testing with perturbation and robustness checks"
-```
-
----
-
-## Task 3: Playwright E2E Test Generator
-
-**Files:**
-- Create: `src/testing/generators/e2e-generator.ts`
-- Create: `src/testing/generators/playwright-templates.ts`
-- Create: `tests/testing/generators/e2e-generator.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/generators/e2e-generator.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generateE2ETest, generateFromUserFlow } from '../../../src/testing/generators/e2e-generator';
-
-describe('E2E Test Generator', () => {
-  it('should generate Playwright test from user flow description', async () => {
-    const result = await generateFromUserFlow({
-      flowDescription: 'User logs in, navigates to dashboard, clicks on settings',
-      baseUrl: 'http://localhost:3000',
-      testName: 'User Settings Flow',
-    });
-
-    expect(result.testCode).toContain("test('User Settings Flow'");
-    expect(result.testCode).toContain('await page.goto');
-    expect(result.testCode).toContain('await page.click');
-    expect(result.steps).toHaveLength(3);
-  });
-
-  it('should generate test with assertions', async () => {
-    const result = await generateE2ETest({
-      steps: [
-        { action: 'goto', target: '/login' },
-        { action: 'fill', target: '#username', value: 'testuser' },
-        { action: 'fill', target: '#password', value: 'password123' },
-        { action: 'click', target: 'button[type="submit"]' },
-        { action: 'expect', target: '.dashboard', assertion: 'toBeVisible' },
-      ],
-      testName: 'Login Flow',
-    });
-
-    expect(result).toContain("await page.fill('#username'");
-    expect(result).toContain("await expect(page.locator('.dashboard')).toBeVisible()");
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/generators/e2e-generator.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement E2E test generator**
-
-Create `src/testing/generators/playwright-templates.ts`:
-
-```typescript
-export const PLAYWRIGHT_TEST_TEMPLATE = `import { test, expect } from '@playwright/test';
-
-test.describe('{{testSuite}}', () => {
-  test('{{testName}}', async ({ page }) => {
-    {{testSteps}}
-  });
-});
-`;
-
-export const STEP_TEMPLATES = {
-  goto: "await page.goto('{{target}}');",
-  click: "await page.click('{{target}}');",
-  fill: "await page.fill('{{target}}', '{{value}}');",
-  expect: "await expect(page.locator('{{target}}')).{{assertion}}();",
-  waitFor: "await page.waitForSelector('{{target}}');",
-  screenshot: "await page.screenshot({ path: '{{target}}' });",
-};
-
-export function renderTemplate(template: string, vars: Record<string, string>): string {
-  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] || '');
-}
-```
-
-Create `src/testing/generators/e2e-generator.ts`:
-
-```typescript
-import { PLAYWRIGHT_TEST_TEMPLATE, STEP_TEMPLATES, renderTemplate } from './playwright-templates';
-
-interface E2EStep {
-  action: 'goto' | 'click' | 'fill' | 'expect' | 'waitFor' | 'screenshot';
-  target: string;
-  value?: string;
-  assertion?: string;
-}
-
-interface GenerateE2ETestOptions {
-  steps: E2EStep[];
-  testName: string;
-  testSuite?: string;
-}
-
-interface GenerateFromUserFlowOptions {
-  flowDescription: string;
-  baseUrl: string;
-  testName: string;
-}
-
-interface UserFlowResult {
-  testCode: string;
-  steps: E2EStep[];
-}
-
-export async function generateE2ETest(options: GenerateE2ETestOptions): Promise<string> {
-  const { steps, testName, testSuite = 'E2E Tests' } = options;
-
-  const testSteps = steps
-    .map((step) => {
-      const template = STEP_TEMPLATES[step.action];
-      return renderTemplate(template, {
-        target: step.target,
-        value: step.value || '',
-        assertion: step.assertion || '',
-      });
-    })
-    .join('\n    ');
-
-  return renderTemplate(PLAYWRIGHT_TEST_TEMPLATE, {
-    testSuite,
-    testName,
-    testSteps,
-  });
-}
-
-export async function generateFromUserFlow(options: GenerateFromUserFlowOptions): Promise<UserFlowResult> {
-  const { flowDescription, baseUrl, testName } = options;
-
-  // Parse flow description into steps (simplified - in real implementation, use LLM)
-  const steps: E2EStep[] = [];
-  const lowerFlow = flowDescription.toLowerCase();
-
-  if (lowerFlow.includes('logs in') || lowerFlow.includes('login')) {
-    steps.push({ action: 'goto', target: `${baseUrl}/login` });
-    steps.push({ action: 'fill', target: '#username', value: 'testuser' });
-    steps.push({ action: 'fill', target: '#password', value: 'password' });
-    steps.push({ action: 'click', target: 'button[type="submit"]' });
-  }
-
-  if (lowerFlow.includes('dashboard')) {
-    steps.push({ action: 'goto', target: `${baseUrl}/dashboard` });
-  }
-
-  if (lowerFlow.includes('settings')) {
-    steps.push({ action: 'click', target: 'a[href="/settings"]' });
-  }
-
-  const testCode = await generateE2ETest({ steps, testName });
-
-  return {
-    testCode,
-    steps,
-  };
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/generators/e2e-generator.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/generators/e2e-generator.ts src/testing/generators/playwright-templates.ts tests/testing/generators/e2e-generator.test.ts
-git commit -m "feat(testing): add Playwright E2E test generator from user flow descriptions"
-```
-
----
-
-## Task 4: GitHub Actions CI/CD Templates
-
-**Files:**
-- Create: `src/testing/ci/github-actions-generator.ts`
-- Create: `src/testing/ci/templates/test-workflow.yml`
-- Create: `tests/testing/ci/github-actions-generator.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/ci/github-actions-generator.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generateTestWorkflow, generateCoverageWorkflow } from '../../../src/testing/ci/github-actions-generator';
-
-describe('GitHub Actions Generator', () => {
-  it('should generate test workflow for Node.js project', async () => {
-    const result = await generateTestWorkflow({
-      projectType: 'nodejs',
-      testCommand: 'pnpm test',
-      nodeVersion: '20',
-    });
-
-    expect(result).toContain('name: Test');
-    expect(result).toContain('node-version: 20');
-    expect(result).toContain('run: pnpm test');
-  });
-
-  it('should generate coverage workflow with upload', async () => {
-    const result = await generateCoverageWorkflow({
-      projectType: 'nodejs',
-      coverageCommand: 'pnpm test --coverage',
-      uploadTo: 'codecov',
-    });
-
-    expect(result).toContain('name: Coverage');
-    expect(result).toContain('run: pnpm test --coverage');
-    expect(result).toContain('codecov/codecov-action');
-  });
-
-  it('should generate multi-language workflow', async () => {
-    const result = await generateTestWorkflow({
-      projectType: 'monorepo',
-      languages: ['nodejs', 'python', 'go'],
-      testCommands: {
-        nodejs: 'pnpm test',
-        python: 'pytest',
-        go: 'go test ./...',
-      },
-    });
-
-    expect(result).toContain('matrix:');
-    expect(result).toContain('language: [nodejs, python, go]');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/ci/github-actions-generator.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement GitHub Actions generator**
-
-Create `src/testing/ci/templates/test-workflow.yml`:
-
-```yaml
-name: {{workflowName}}
-
-on:
-  push:
-    branches: [{{branches}}]
-  pull_request:
-    branches: [{{branches}}]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    {{#if matrix}}
-    strategy:
-      matrix:
-        {{matrixConfig}}
-    {{/if}}
-    steps:
-      - uses: actions/checkout@v4
-
-      {{#if nodejs}}
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: {{nodeVersion}}
-          cache: 'pnpm'
-
-      - name: Install dependencies
-        run: pnpm install
-      {{/if}}
-
-      {{#if python}}
-      - name: Setup Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: {{pythonVersion}}
-
-      - name: Install dependencies
-        run: pip install -r requirements.txt
-      {{/if}}
-
-      {{#if go}}
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: {{goVersion}}
-      {{/if}}
-
-      - name: Run tests
-        run: {{testCommand}}
-
-      {{#if coverage}}
-      - name: Upload coverage
-        uses: {{coverageAction}}
-        with:
-          file: {{coverageFile}}
-      {{/if}}
-```
-
-Create `src/testing/ci/github-actions-generator.ts`:
-
-```typescript
-import fs from 'fs/promises';
-import path from 'path';
-import Handlebars from 'handlebars';
-
-interface GenerateTestWorkflowOptions {
-  projectType: 'nodejs' | 'python' | 'go' | 'rust' | 'monorepo';
-  testCommand?: string;
-  nodeVersion?: string;
-  pythonVersion?: string;
-  goVersion?: string;
-  languages?: string[];
-  testCommands?: Record<string, string>;
-}
-
-interface GenerateCoverageWorkflowOptions {
-  projectType: string;
-  coverageCommand: string;
-  uploadTo: 'codecov' | 'coveralls' | 'codeclimate';
-  coverageFile?: string;
-}
-
-export async function generateTestWorkflow(options: GenerateTestWorkflowOptions): Promise<string> {
-  const { projectType, testCommand, nodeVersion = '20', languages, testCommands } = options;
-
-  const templatePath = path.join(__dirname, 'templates', 'test-workflow.yml');
-  const templateContent = await fs.readFile(templatePath, 'utf-8');
-  const template = Handlebars.compile(templateContent);
-
-  const isMonorepo = projectType === 'monorepo' && languages && testCommands;
-
-  const data = {
-    workflowName: 'Test',
-    branches: 'main, dev',
-    matrix: isMonorepo,
-    matrixConfig: isMonorepo
-      ? `language: [${languages.join(', ')}]`
-      : undefined,
-    nodejs: projectType === 'nodejs' || languages?.includes('nodejs'),
-    python: projectType === 'python' || languages?.includes('python'),
-    go: projectType === 'go' || languages?.includes('go'),
-    nodeVersion,
-    testCommand: testCommand || 'pnpm test',
-  };
-
-  return template(data);
-}
-
-export async function generateCoverageWorkflow(options: GenerateCoverageWorkflowOptions): Promise<string> {
-  const { projectType, coverageCommand, uploadTo, coverageFile = './coverage/coverage-final.json' } = options;
-
-  const coverageActions = {
-    codecov: 'codecov/codecov-action@v4',
-    coveralls: 'coverallsapp/github-action@v2',
-    codeclimate: 'paambaati/codeclimate-action@v5',
-  };
-
-  const templatePath = path.join(__dirname, 'templates', 'test-workflow.yml');
-  const templateContent = await fs.readFile(templatePath, 'utf-8');
-  const template = Handlebars.compile(templateContent);
-
-  const data = {
-    workflowName: 'Coverage',
-    branches: 'main, dev',
-    nodejs: projectType === 'nodejs',
-    nodeVersion: '20',
-    testCommand: coverageCommand,
-    coverage: true,
-    coverageAction: coverageActions[uploadTo],
-    coverageFile,
-  };
-
-  return template(data);
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/ci/github-actions-generator.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/ci/ tests/testing/ci/
-git commit -m "feat(testing): add GitHub Actions CI/CD workflow generator for automated testing"
-```
-
----
-
-## Task 5: Ralph Mode Testing Loop Integration
-
-**Files:**
-- Create: `src/testing/integrations/ralph-testing.ts`
-- Create: `tests/testing/integrations/ralph-testing.test.ts`
-- Modify: `src/skills/ralph/index.ts` (add testing hook)
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/integrations/ralph-testing.test.ts`:
-
-```typescript
-import { describe, it, expect, vi } from 'vitest';
-import { injectTestingIntoRalph, generateTestsForIteration } from '../../../src/testing/integrations/ralph-testing';
-
-describe('Ralph Testing Integration', () => {
-  it('should inject testing into Ralph verify cycle', async () => {
-    const mockRalphState = {
-      currentIteration: 1,
-      modifiedFiles: ['src/utils/helper.ts', 'src/api/users.ts'],
-      verifyPhase: 'pre-verify',
-    };
-
-    const result = await injectTestingIntoRalph(mockRalphState);
-
-    expect(result.testingEnabled).toBe(true);
-    expect(result.testGenerationPhase).toBe('pre-verify');
-    expect(result.filesToTest).toEqual(mockRalphState.modifiedFiles);
-  });
-
-  it('should generate tests for Ralph iteration', async () => {
-    const result = await generateTestsForIteration({
-      modifiedFiles: ['src/utils/validation.ts'],
-      iterationNumber: 2,
-      previousTestResults: { passed: 5, failed: 1 },
-    });
-
-    expect(result.generatedTests).toHaveLength(1);
-    expect(result.generatedTests[0].file).toBe('src/utils/validation.ts');
-    expect(result.shouldRunTests).toBe(true);
-  });
-
-  it('should skip test generation if no code changes', async () => {
-    const result = await generateTestsForIteration({
-      modifiedFiles: [],
-      iterationNumber: 3,
-      previousTestResults: { passed: 10, failed: 0 },
-    });
-
-    expect(result.generatedTests).toHaveLength(0);
-    expect(result.shouldRunTests).toBe(false);
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/integrations/ralph-testing.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement Ralph testing integration**
-
-Create `src/testing/integrations/ralph-testing.ts`:
-
-```typescript
-interface RalphState {
-  currentIteration: number;
-  modifiedFiles: string[];
-  verifyPhase: 'pre-verify' | 'post-verify' | 'fix';
-}
-
-interface RalphTestingConfig {
-  testingEnabled: boolean;
-  testGenerationPhase: string;
-  filesToTest: string[];
-}
-
-interface GenerateTestsForIterationOptions {
-  modifiedFiles: string[];
-  iterationNumber: number;
-  previousTestResults: { passed: number; failed: number };
-}
-
-interface IterationTestResult {
-  generatedTests: Array<{ file: string; testFile: string }>;
-  shouldRunTests: boolean;
-}
-
-export async function injectTestingIntoRalph(state: RalphState): Promise<RalphTestingConfig> {
-  return {
-    testingEnabled: true,
-    testGenerationPhase: state.verifyPhase,
-    filesToTest: state.modifiedFiles,
-  };
-}
-
-export async function generateTestsForIteration(
-  options: GenerateTestsForIterationOptions
-): Promise<IterationTestResult> {
-  const { modifiedFiles, iterationNumber, previousTestResults } = options;
-
-  if (modifiedFiles.length === 0) {
-    return {
-      generatedTests: [],
-      shouldRunTests: false,
-    };
-  }
-
-  const generatedTests = modifiedFiles.map((file) => ({
-    file,
-    testFile: file.replace(/\.(ts|js|py|go)$/, '.test.$1'),
-  }));
-
-  return {
-    generatedTests,
-    shouldRunTests: true,
-  };
-}
-
-export async function runTestsInRalphCycle(testFiles: string[]): Promise<{ passed: number; failed: number }> {
-  // Integration point for running tests during Ralph cycle
-  // This will be called by Ralph's verify phase
-  return {
-    passed: testFiles.length,
-    failed: 0,
-  };
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/integrations/ralph-testing.test.ts`
-Expected: PASS
-
-**Step 5: Add hook to Ralph skill**
-
-Modify `src/skills/ralph/index.ts` to add testing hook (pseudo-code):
-
-```typescript
-// Add to Ralph's verify phase
-import { injectTestingIntoRalph, generateTestsForIteration } from '../../testing/integrations/ralph-testing';
-
-// In verify phase:
-const testingConfig = await injectTestingIntoRalph(ralphState);
-if (testingConfig.testingEnabled) {
-  const testResult = await generateTestsForIteration({
-    modifiedFiles: testingConfig.filesToTest,
-    iterationNumber: ralphState.currentIteration,
-    previousTestResults: ralphState.testResults,
-  });
-  // Run generated tests
-}
-```
-
-**Step 6: Commit**
-
-```bash
-git add src/testing/integrations/ralph-testing.ts tests/testing/integrations/ralph-testing.test.ts src/skills/ralph/
-git commit -m "feat(testing): integrate test generation into Ralph mode verify cycle"
-```
-
----
-
-## Task 6: Autopilot Automatic Testing Phase
-
-**Files:**
-- Create: `src/testing/integrations/autopilot-testing.ts`
-- Create: `tests/testing/integrations/autopilot-testing.test.ts`
-- Modify: `src/skills/autopilot/index.ts` (add testing phase)
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/integrations/autopilot-testing.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { injectTestingIntoAutopilot, generateTestsForPhase } from '../../../src/testing/integrations/autopilot-testing';
-
-describe('Autopilot Testing Integration', () => {
-  it('should inject testing phase into Autopilot workflow', async () => {
-    const mockAutopilotState = {
-      currentPhase: 'implementation',
-      generatedFiles: ['src/components/Button.tsx', 'src/utils/format.ts'],
-      requirements: 'Build a button component with formatting utilities',
-    };
-
-    const result = await injectTestingIntoAutopilot(mockAutopilotState);
-
-    expect(result.testingPhaseEnabled).toBe(true);
-    expect(result.testingPhase).toBe('post-implementation');
-    expect(result.filesToTest).toEqual(mockAutopilotState.generatedFiles);
-  });
-
-  it('should generate tests for Autopilot phase', async () => {
-    const result = await generateTestsForPhase({
-      phase: 'implementation',
-      generatedFiles: ['src/api/auth.ts'],
-      requirements: 'Implement authentication API',
-    });
-
-    expect(result.tests).toHaveLength(1);
-    expect(result.tests[0].file).toBe('src/api/auth.ts');
-    expect(result.tests[0].testType).toBe('unit');
-  });
-
-  it('should generate E2E tests for UI components', async () => {
-    const result = await generateTestsForPhase({
-      phase: 'implementation',
-      generatedFiles: ['src/pages/Login.tsx'],
-      requirements: 'Build login page',
-    });
-
-    expect(result.tests).toHaveLength(2); // unit + e2e
-    expect(result.tests.some((t) => t.testType === 'e2e')).toBe(true);
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/integrations/autopilot-testing.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement Autopilot testing integration**
-
-Create `src/testing/integrations/autopilot-testing.ts`:
-
-```typescript
-interface AutopilotState {
-  currentPhase: 'planning' | 'implementation' | 'verification' | 'deployment';
-  generatedFiles: string[];
-  requirements: string;
-}
-
-interface AutopilotTestingConfig {
-  testingPhaseEnabled: boolean;
-  testingPhase: 'post-implementation' | 'pre-verification';
-  filesToTest: string[];
-}
-
-interface GenerateTestsForPhaseOptions {
-  phase: string;
-  generatedFiles: string[];
-  requirements: string;
-}
-
-interface PhaseTestResult {
-  tests: Array<{
-    file: string;
-    testFile: string;
-    testType: 'unit' | 'integration' | 'e2e';
-  }>;
-}
-
-export async function injectTestingIntoAutopilot(state: AutopilotState): Promise<AutopilotTestingConfig> {
-  return {
-    testingPhaseEnabled: true,
-    testingPhase: state.currentPhase === 'implementation' ? 'post-implementation' : 'pre-verification',
-    filesToTest: state.generatedFiles,
-  };
-}
-
-export async function generateTestsForPhase(options: GenerateTestsForPhaseOptions): Promise<PhaseTestResult> {
-  const { phase, generatedFiles, requirements } = options;
-  const tests: PhaseTestResult['tests'] = [];
-
-  for (const file of generatedFiles) {
-    // Determine test type based on file type
-    const isUIComponent = file.includes('components/') || file.includes('pages/');
-    const isAPI = file.includes('api/') || file.includes('routes/');
-
-    // Always generate unit tests
-    tests.push({
-      file,
-      testFile: file.replace(/\.(tsx?|jsx?)$/, '.test.$1'),
-      testType: 'unit',
-    });
-
-    // Generate E2E tests for UI components
-    if (isUIComponent) {
-      tests.push({
-        file,
-        testFile: file.replace(/\.(tsx?|jsx?)$/, '.e2e.spec.ts'),
-        testType: 'e2e',
-      });
-    }
-
-    // Generate integration tests for APIs
-    if (isAPI) {
-      tests.push({
-        file,
-        testFile: file.replace(/\.(ts|js)$/, '.integration.test.$1'),
-        testType: 'integration',
-      });
-    }
-  }
-
-  return { tests };
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/integrations/autopilot-testing.test.ts`
-Expected: PASS
-
-**Step 5: Add hook to Autopilot skill**
-
-Modify `src/skills/autopilot/index.ts` to add testing phase (pseudo-code):
-
-```typescript
-// Add to Autopilot workflow after implementation phase
-import { injectTestingIntoAutopilot, generateTestsForPhase } from '../../testing/integrations/autopilot-testing';
-
-// After implementation phase:
-const testingConfig = await injectTestingIntoAutopilot(autopilotState);
-if (testingConfig.testingPhaseEnabled) {
-  const testResult = await generateTestsForPhase({
-    phase: autopilotState.currentPhase,
-    generatedFiles: testingConfig.filesToTest,
-    requirements: autopilotState.requirements,
-  });
-  // Generate and run tests
-}
-```
-
-**Step 6: Commit**
-
-```bash
-git add src/testing/integrations/autopilot-testing.ts tests/testing/integrations/autopilot-testing.test.ts src/skills/autopilot/
-git commit -m "feat(testing): add automatic test generation phase to Autopilot workflow"
-```
-
----
-
-## Task 7: Test Quality Scoring System
-
-**Files:**
-- Create: `src/testing/quality/test-scorer.ts`
-- Create: `src/testing/quality/metrics.ts`
-- Create: `tests/testing/quality/test-scorer.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/quality/test-scorer.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { scoreTest, calculateTestQuality } from '../../../src/testing/quality/test-scorer';
-
-describe('Test Quality Scorer', () => {
-  it('should score test completeness', async () => {
-    const testCode = `
-      test('should add two numbers', () => {
-        expect(add(1, 2)).toBe(3);
-        expect(add(-1, 1)).toBe(0);
-        expect(add(0, 0)).toBe(0);
-      });
-    `;
-
-    const result = await scoreTest({ testCode, testType: 'unit' });
-
-    expect(result.completenessScore).toBeGreaterThan(70);
-    expect(result.hasEdgeCases).toBe(true);
-    expect(result.assertionCount).toBe(3);
-  });
-
-  it('should penalize tests without assertions', async () => {
-    const testCode = `
-      test('should do something', () => {
-        const result = doSomething();
-      });
-    `;
-
-    const result = await scoreTest({ testCode, testType: 'unit' });
-
-    expect(result.completenessScore).toBeLessThan(30);
-    expect(result.hasAssertions).toBe(false);
-  });
-
-  it('should calculate overall test quality', async () => {
-    const tests = [
-      { file: 'test1.test.ts', score: 85, assertions: 5 },
-      { file: 'test2.test.ts', score: 70, assertions: 3 },
-      { file: 'test3.test.ts', score: 90, assertions: 7 },
-    ];
-
-    const result = await calculateTestQuality({ tests });
-
-    expect(result.averageScore).toBeCloseTo(81.67, 1);
-    expect(result.totalAssertions).toBe(15);
-    expect(result.qualityGrade).toBe('B');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/quality/test-scorer.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement test quality scorer**
-
-Create `src/testing/quality/metrics.ts`:
-
-```typescript
-export interface TestMetrics {
-  assertionCount: number;
-  hasEdgeCases: boolean;
-  hasAssertions: boolean;
-  hasMocks: boolean;
-  hasSetup: boolean;
-  hasTeardown: boolean;
-  testComplexity: number;
-}
-
-export interface TestScore {
-  completenessScore: number;
-  assertionCount: number;
-  hasEdgeCases: boolean;
-  hasAssertions: boolean;
-  metrics: TestMetrics;
-}
-
-export interface QualityReport {
-  averageScore: number;
-  totalAssertions: number;
-  qualityGrade: 'A' | 'B' | 'C' | 'D' | 'F';
-  recommendations: string[];
-}
-
-export function calculateGrade(score: number): 'A' | 'B' | 'C' | 'D' | 'F' {
-  if (score >= 90) return 'A';
-  if (score >= 80) return 'B';
-  if (score >= 70) return 'C';
-  if (score >= 60) return 'D';
-  return 'F';
-}
-```
-
-Create `src/testing/quality/test-scorer.ts`:
-
-```typescript
-import type { TestScore, TestMetrics, QualityReport } from './metrics';
-import { calculateGrade } from './metrics';
-
-interface ScoreTestOptions {
-  testCode: string;
-  testType: 'unit' | 'integration' | 'e2e';
-}
-
-interface CalculateQualityOptions {
-  tests: Array<{ file: string; score: number; assertions: number }>;
-}
-
-export async function scoreTest(options: ScoreTestOptions): Promise<TestScore> {
-  const { testCode, testType } = options;
-
-  // Count assertions
-  const assertionCount = (testCode.match(/expect\(/g) || []).length;
-  const hasAssertions = assertionCount > 0;
-
-  // Check for edge cases
-  const hasEdgeCases =
-    testCode.includes('null') ||
-    testCode.includes('undefined') ||
-    testCode.includes('0') ||
-    testCode.includes('empty') ||
-    testCode.includes('-1');
-
-  // Check for mocks
-  const hasMocks = testCode.includes('mock') || testCode.includes('spy') || testCode.includes('stub');
-
-  // Check for setup/teardown
-  const hasSetup = testCode.includes('beforeEach') || testCode.includes('beforeAll');
-  const hasTeardown = testCode.includes('afterEach') || testCode.includes('afterAll');
-
-  // Calculate complexity (simple heuristic)
-  const testComplexity = (testCode.match(/test\(/g) || []).length;
-
-  const metrics: TestMetrics = {
-    assertionCount,
-    hasEdgeCases,
-    hasAssertions,
-    hasMocks,
-    hasSetup,
-    hasTeardown,
-    testComplexity,
-  };
-
-  // Calculate completeness score
-  let score = 0;
-  if (hasAssertions) score += 40;
-  score += Math.min(assertionCount * 10, 30); // Up to 30 points for assertions
-  if (hasEdgeCases) score += 15;
-  if (hasMocks) score += 10;
-  if (hasSetup || hasTeardown) score += 5;
-
-  return {
-    completenessScore: Math.min(score, 100),
-    assertionCount,
-    hasEdgeCases,
-    hasAssertions,
-    metrics,
-  };
-}
-
-export async function calculateTestQuality(options: CalculateQualityOptions): Promise<QualityReport> {
-  const { tests } = options;
-
-  const totalScore = tests.reduce((sum, test) => sum + test.score, 0);
-  const averageScore = totalScore / tests.length;
-  const totalAssertions = tests.reduce((sum, test) => sum + test.assertions, 0);
-
-  const qualityGrade = calculateGrade(averageScore);
-
-  const recommendations: string[] = [];
-  if (averageScore < 70) {
-    recommendations.push('Increase test coverage with more assertions');
-  }
-  if (totalAssertions / tests.length < 3) {
-    recommendations.push('Add more edge case testing');
-  }
-
-  return {
-    averageScore,
-    totalAssertions,
-    qualityGrade,
-    recommendations,
-  };
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/quality/test-scorer.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/quality/ tests/testing/quality/
-git commit -m "feat(testing): add test quality scoring system for completeness and effectiveness"
-```
-
----
-
-## Task 8: Performance Optimization Layer
-
-**Files:**
-- Create: `src/testing/performance/cache-manager.ts`
-- Create: `src/testing/performance/parallel-generator.ts`
-- Create: `tests/testing/performance/cache-manager.test.ts`
-- Create: `tests/testing/performance/parallel-generator.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/performance/cache-manager.test.ts`:
-
-```typescript
-import { describe, it, expect, beforeEach } from 'vitest';
-import { CacheManager, getCachedAnalysis, setCachedAnalysis } from '../../../src/testing/performance/cache-manager';
-
-describe('Cache Manager', () => {
-  let cacheManager: CacheManager;
-
-  beforeEach(() => {
-    cacheManager = new CacheManager({ ttl: 3600 });
-  });
-
-  it('should cache tech stack detection results', async () => {
-    const projectPath = '/test/project';
-    const techStack = { language: 'typescript', framework: 'react', testRunner: 'vitest' };
-
-    await cacheManager.set(`techstack:${projectPath}`, techStack);
-    const cached = await cacheManager.get(`techstack:${projectPath}`);
-
-    expect(cached).toEqual(techStack);
-  });
-
-  it('should invalidate cache after TTL', async () => {
-    const cacheWithShortTTL = new CacheManager({ ttl: 1 }); // 1 second
-    await cacheWithShortTTL.set('test-key', 'test-value');
-
-    // Wait for TTL to expire
-    await new Promise((resolve) => setTimeout(resolve, 1100));
-
-    const cached = await cacheWithShortTTL.get('test-key');
-    expect(cached).toBeNull();
-  });
-
-  it('should cache coverage analysis results', async () => {
-    const coverageData = { totalCoverage: 75, lineCoverage: 80 };
-    await setCachedAnalysis('coverage:project1', coverageData);
-
-    const cached = await getCachedAnalysis('coverage:project1');
-    expect(cached).toEqual(coverageData);
-  });
-});
-```
-
-Create `tests/testing/performance/parallel-generator.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generateTestsInParallel, ParallelGenerator } from '../../../src/testing/performance/parallel-generator';
-
-describe('Parallel Test Generator', () => {
-  it('should generate tests for multiple files in parallel', async () => {
-    const files = [
-      'src/utils/format.ts',
-      'src/utils/validation.ts',
-      'src/api/users.ts',
-      'src/api/auth.ts',
-    ];
-
-    const result = await generateTestsInParallel({
-      files,
-      maxConcurrency: 2,
-    });
-
-    expect(result.generatedTests).toHaveLength(4);
-    expect(result.totalTime).toBeLessThan(10000); // Should be faster than sequential
-  });
-
-  it('should respect max concurrency limit', async () => {
-    const generator = new ParallelGenerator({ maxConcurrency: 2 });
-    const files = ['file1.ts', 'file2.ts', 'file3.ts', 'file4.ts'];
-
-    const result = await generator.generate(files);
-
-    expect(result.maxConcurrentTasks).toBe(2);
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/performance/`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement performance optimization**
-
-Create `src/testing/performance/cache-manager.ts`:
-
-```typescript
-interface CacheOptions {
-  ttl: number; // Time to live in seconds
-}
-
-interface CacheEntry<T> {
-  value: T;
-  expiresAt: number;
-}
-
-export class CacheManager {
-  private cache: Map<string, CacheEntry<any>>;
-  private ttl: number;
-
-  constructor(options: CacheOptions) {
-    this.cache = new Map();
-    this.ttl = options.ttl * 1000; // Convert to milliseconds
-  }
-
-  async get<T>(key: string): Promise<T | null> {
-    const entry = this.cache.get(key);
-    if (!entry) return null;
-
-    if (Date.now() > entry.expiresAt) {
-      this.cache.delete(key);
-      return null;
-    }
-
-    return entry.value;
-  }
-
-  async set<T>(key: string, value: T): Promise<void> {
-    this.cache.set(key, {
-      value,
-      expiresAt: Date.now() + this.ttl,
-    });
-  }
-
-  async clear(): Promise<void> {
-    this.cache.clear();
-  }
-}
-
-// Global cache instance
-const globalCache = new CacheManager({ ttl: 3600 });
-
-export async function getCachedAnalysis<T>(key: string): Promise<T | null> {
-  return globalCache.get<T>(key);
-}
-
-export async function setCachedAnalysis<T>(key: string, value: T): Promise<void> {
-  return globalCache.set(key, value);
-}
-```
-
-Create `src/testing/performance/parallel-generator.ts`:
-
-```typescript
-interface GenerateInParallelOptions {
-  files: string[];
-  maxConcurrency: number;
-}
-
-interface ParallelResult {
-  generatedTests: Array<{ file: string; testFile: string }>;
-  totalTime: number;
-  maxConcurrentTasks: number;
-}
-
-export class ParallelGenerator {
-  private maxConcurrency: number;
-
-  constructor(options: { maxConcurrency: number }) {
-    this.maxConcurrency = options.maxConcurrency;
-  }
-
-  async generate(files: string[]): Promise<ParallelResult> {
-    const startTime = Date.now();
-    const results: Array<{ file: string; testFile: string }> = [];
-
-    // Process files in batches
-    for (let i = 0; i < files.length; i += this.maxConcurrency) {
-      const batch = files.slice(i, i + this.maxConcurrency);
-      const batchResults = await Promise.all(
-        batch.map(async (file) => ({
-          file,
-          testFile: file.replace(/\.(ts|js)$/, '.test.$1'),
-        }))
-      );
-      results.push(...batchResults);
-    }
-
-    return {
-      generatedTests: results,
-      totalTime: Date.now() - startTime,
-      maxConcurrentTasks: this.maxConcurrency,
-    };
-  }
-}
-
-export async function generateTestsInParallel(options: GenerateInParallelOptions): Promise<ParallelResult> {
-  const generator = new ParallelGenerator({ maxConcurrency: options.maxConcurrency });
-  return generator.generate(options.files);
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/performance/`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/performance/ tests/testing/performance/
-git commit -m "feat(testing): add performance optimization with caching and parallel generation"
-```
-
----
-
-## Task 9: CLI Integration and Documentation
-
-**Files:**
-- Modify: `src/cli/commands/test.ts` (add Phase 3 commands)
-- Create: `docs/testing/phase3-guide.md`
-- Create: `tests/cli/test-phase3.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/cli/test-phase3.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { execSync } from 'child_process';
-
-describe('CLI Phase 3 Commands', () => {
-  it('should run promptfoo test generation', () => {
-    const output = execSync('omc test promptfoo --prompt src/prompts/test.txt --help', {
-      encoding: 'utf-8',
-    });
-
-    expect(output).toContain('Generate Promptfoo config');
-  });
-
-  it('should run behavioral tests', () => {
-    const output = execSync('omc test behavioral --help', { encoding: 'utf-8' });
-
-    expect(output).toContain('Generate behavioral tests with Giskard');
-  });
-
-  it('should generate E2E tests', () => {
-    const output = execSync('omc test e2e --help', { encoding: 'utf-8' });
-
-    expect(output).toContain('Generate Playwright E2E tests');
-  });
-
-  it('should generate CI/CD workflow', () => {
-    const output = execSync('omc test ci --help', { encoding: 'utf-8' });
-
-    expect(output).toContain('Generate GitHub Actions workflow');
-  });
-
-  it('should score test quality', () => {
-    const output = execSync('omc test score --help', { encoding: 'utf-8' });
-
-    expect(output).toContain('Score test quality');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/cli/test-phase3.test.ts`
-Expected: FAIL with commands not found
-
-**Step 3: Implement CLI commands**
-
-Modify `src/cli/commands/test.ts`:
-
-```typescript
-import { Command } from 'commander';
-import { generatePromptfooConfig } from '../../testing/integrations/promptfoo/config-generator';
-import { generatePerturbationTests } from '../../testing/integrations/giskard/behavioral-tests';
-import { generateFromUserFlow } from '../../testing/generators/e2e-generator';
-import { generateTestWorkflow } from '../../testing/ci/github-actions-generator';
-import { scoreTest, calculateTestQuality } from '../../testing/quality/test-scorer';
-
-export function registerPhase3Commands(program: Command): void {
-  const testCommand = program.command('test');
-
-  // Promptfoo command
-  testCommand
-    .command('promptfoo')
-    .description('Generate Promptfoo config for LLM prompt testing')
-    .option('--prompt <file>', 'Prompt file path')
-    .option('--provider <provider>', 'LLM provider', 'anthropic:claude-3-5-sonnet-20241022')
-    .option('--output <file>', 'Output config file', 'promptfoo.config.yml')
-    .action(async (options) => {
-      const config = await generatePromptfooConfig({
-        promptFile: options.prompt,
-        testCases: [],
-        provider: options.provider,
-        outputPath: options.output,
-      });
-      console.log('Promptfoo config generated:', options.output);
-    });
-
-  // Behavioral testing command
-  testCommand
-    .command('behavioral')
-    .description('Generate behavioral tests with Giskard')
-    .option('--input <file>', 'Input test cases file')
-    .option('--perturbations <types>', 'Perturbation types (comma-separated)', 'typo,negation,synonym')
-    .action(async (options) => {
-      const perturbations = options.perturbations.split(',');
-      const result = await generatePerturbationTests({
-        testCases: [],
-        perturbations: perturbations as any,
-      });
-      console.log(`Generated ${result.totalTests} behavioral tests`);
-    });
-
-  // E2E test generation command
-  testCommand
-    .command('e2e')
-    .description('Generate Playwright E2E tests from user flow')
-    .option('--flow <description>', 'User flow description')
-    .option('--base-url <url>', 'Base URL', 'http://localhost:3000')
-    .option('--output <file>', 'Output test file')
-    .action(async (options) => {
-      const result = await generateFromUserFlow({
-        flowDescription: options.flow,
-        baseUrl: options.baseUrl,
-        testName: 'Generated E2E Test',
-      });
-      console.log('E2E test generated with', result.steps.length, 'steps');
-    });
-
-  // CI/CD workflow generation command
-  testCommand
-    .command('ci')
-    .description('Generate GitHub Actions workflow for testing')
-    .option('--type <type>', 'Project type', 'nodejs')
-    .option('--output <file>', 'Output workflow file', '.github/workflows/test.yml')
-    .action(async (options) => {
-      const workflow = await generateTestWorkflow({
-        projectType: options.type as any,
-        testCommand: 'pnpm test',
-      });
-      console.log('GitHub Actions workflow generated:', options.output);
-    });
-
-  // Test quality scoring command
-  testCommand
-    .command('score')
-    .description('Score test quality and completeness')
-    .option('--file <file>', 'Test file to score')
-    .action(async (options) => {
-      const testCode = ''; // Read from file
-      const result = await scoreTest({ testCode, testType: 'unit' });
-      console.log('Test quality score:', result.completenessScore);
-    });
-}
-```
-
-**Step 4: Create documentation**
-
-Create `docs/testing/phase3-guide.md`:
-
-```markdown
-# Phase 3: Advanced Testing Features
-
-## Overview
-
-Phase 3 completes the LLM Testing System with advanced features including Promptfoo integration, Giskard behavioral testing, Playwright E2E generation, CI/CD templates, and performance optimization.
-
-## Features
-
-### 1. Promptfoo Integration
-
-Generate Promptfoo configs for testing LLM prompts:
-
-\`\`\`bash
-omc test promptfoo --prompt src/prompts/code-review.txt --provider anthropic:claude-3-5-sonnet-20241022
-\`\`\`
-
-### 2. Giskard Behavioral Testing
-
-Generate perturbation and robustness tests:
-
-\`\`\`bash
-omc test behavioral --input test-cases.json --perturbations typo,negation,synonym
-\`\`\`
-
-### 3. Playwright E2E Generation
-
-Generate E2E tests from user flow descriptions:
-
-\`\`\`bash
-omc test e2e --flow "User logs in, navigates to dashboard, clicks settings" --base-url http://localhost:3000
-\`\`\`
-
-### 4. CI/CD Integration
-
-Generate GitHub Actions workflows:
-
-\`\`\`bash
-omc test ci --type nodejs --output .github/workflows/test.yml
-\`\`\`
-
-### 5. Test Quality Scoring
-
-Score test completeness and effectiveness:
-
-\`\`\`bash
-omc test score --file tests/utils/validation.test.ts
-\`\`\`
-
-### 6. Ralph Mode Integration
-
-Tests are automatically generated during Ralph's verify cycle.
-
-### 7. Autopilot Integration
-
-Tests are automatically generated after code implementation in Autopilot mode.
-
-## Performance Optimization
-
-- Caching: Tech stack detection and coverage analysis results are cached
-- Parallel Generation: Multiple tests generated concurrently
-- Incremental Analysis: Only analyze changed files
-
-## Next Steps
-
-- Run tests: `pnpm test`
-- Generate coverage: `pnpm test --coverage`
-- Run E2E tests: `pnpm test:e2e`
-```
-
-**Step 5: Run test to verify it passes**
-
-Run: `pnpm test tests/cli/test-phase3.test.ts`
-Expected: PASS
-
-**Step 6: Commit**
-
-```bash
-git add src/cli/commands/test.ts docs/testing/phase3-guide.md tests/cli/test-phase3.test.ts
-git commit -m "feat(testing): add Phase 3 CLI commands and documentation"
-```
-
----
-
-## Final Integration and Verification
-
-**Step 1: Run all Phase 3 tests**
-
-```bash
-pnpm test tests/testing/integrations/
-pnpm test tests/testing/generators/e2e-generator.test.ts
-pnpm test tests/testing/ci/
-pnpm test tests/testing/quality/
-pnpm test tests/testing/performance/
-pnpm test tests/cli/test-phase3.test.ts
-```
-
-**Step 2: Verify integration with existing phases**
-
-```bash
-# Test that Phase 3 works with Phase 1 and Phase 2
-pnpm test tests/testing/
-```
-
-**Step 3: Update main documentation**
-
-Update `docs/testing/README.md` to include Phase 3 features.
-
-**Step 4: Final commit**
-
-```bash
-git add .
-git commit -m "feat(testing): complete Phase 3 implementation with all advanced features"
-```
-
----
-
-## Success Criteria
-
-- ✅ Promptfoo integration working
-- ✅ Giskard behavioral tests generating
-- ✅ Playwright E2E tests generating from user flows
-- ✅ GitHub Actions workflows generating
-- ✅ Ralph mode testing loop integrated
-- ✅ Autopilot testing phase integrated
-- ✅ Test quality scoring functional
-- ✅ Performance optimization (caching, parallel generation) working
-- ✅ All tests passing
-- ✅ Documentation complete
-
-## Estimated Time
-
-- Task 1-2: 2-3 days (Promptfoo + Giskard)
-- Task 3-4: 2-3 days (E2E + CI/CD)
-- Task 5-6: 3-4 days (Ralph + Autopilot integration)
-- Task 7-8: 2-3 days (Quality scoring + Performance)
-- Task 9: 1-2 days (CLI + Documentation)
-
-**Total: 10-15 days**
-
-## Notes
-
-- Use Haiku for simple test generation to reduce costs
-- Use Sonnet for complex behavioral and E2E tests
-- Cache tech stack detection results to avoid repeated analysis
-- Generate tests in parallel when possible
-- Integrate with existing OMC workflows (Ralph, Autopilot, Ultraqa)
-