claudecode-omc 4.7.4 → 4.8.0

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

@@ -0,0 +1,1830 @@
+# 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)
+