claudecode-omc 4.9.4 → 5.0.0

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

@@ -1,1268 +0,0 @@
-# LLM Testing System - Phase 1 Implementation Plan
-
-> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
-
-**Goal:** Build core testing infrastructure with tech stack detection, basic test generation for React + Node.js, and `/test-gen` skill integration.
-
-**Architecture:** Extend oh-my-claudecode with a new `src/testing/` module containing CLI commands, test generators, and tech stack detection. Integrate via new skill that delegates to enhanced test-engineer agent.
-
-**Tech Stack:** TypeScript, Node.js, Promptfoo, Vitest, Jest, React Testing Library
-
----
-
-## Task 1: Project Structure Setup
-
-**Files:**
-- Create: `src/testing/index.ts`
-- Create: `src/testing/cli/index.ts`
-- Create: `src/testing/types.ts`
-- Create: `tests/testing/setup.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/setup.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { TestingModule } from '../../src/testing';
-
-describe('TestingModule', () => {
-  it('should export core testing functions', () => {
-    expect(TestingModule).toBeDefined();
-    expect(TestingModule.detectStack).toBeDefined();
-    expect(TestingModule.generateTests).toBeDefined();
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/setup.test.ts`
-Expected: FAIL with "Cannot find module '../../src/testing'"
-
-**Step 3: Create basic module structure**
-
-Create `src/testing/types.ts`:
-
-```typescript
-export interface TechStack {
-  frontend?: {
-    framework: 'react' | 'vue' | 'svelte' | 'none';
-    testFramework?: 'vitest' | 'jest' | 'none';
-  };
-  backend?: {
-    language: 'nodejs' | 'python' | 'go' | 'rust';
-    testFramework?: string;
-  };
-  databases?: string[];
-  apis?: ('rest' | 'graphql' | 'grpc')[];
-}
-
-export interface TestGenerationOptions {
-  filePath: string;
-  techStack: TechStack;
-  complexity?: 'simple' | 'complex';
-}
-
-export interface TestGenerationResult {
-  testFilePath: string;
-  testCode: string;
-  framework: string;
-}
-```
-
-Create `src/testing/index.ts`:
-
-```typescript
-export * from './types';
-
-export const TestingModule = {
-  detectStack: async () => {
-    throw new Error('Not implemented');
-  },
-  generateTests: async () => {
-    throw new Error('Not implemented');
-  },
-};
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/setup.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/ tests/testing/
-git commit -m "feat(testing): add basic module structure and types
-
-- Add TechStack and TestGenerationOptions types
-- Create TestingModule with placeholder functions
-- Add initial test suite
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 2: Tech Stack Detection
-
-**Files:**
-- Create: `src/testing/detectors/index.ts`
-- Create: `src/testing/detectors/package-json.ts`
-- Create: `tests/testing/detectors/package-json.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/detectors/package-json.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { detectFromPackageJson } from '../../../src/testing/detectors/package-json';
-
-describe('detectFromPackageJson', () => {
-  it('should detect React + Vitest stack', async () => {
-    const mockPackageJson = {
-      dependencies: { react: '^18.0.0' },
-      devDependencies: { vitest: '^1.0.0', '@testing-library/react': '^14.0.0' },
-    };
-
-    const result = await detectFromPackageJson(mockPackageJson);
-
-    expect(result.frontend?.framework).toBe('react');
-    expect(result.frontend?.testFramework).toBe('vitest');
-  });
-
-  it('should detect Node.js backend', async () => {
-    const mockPackageJson = {
-      dependencies: { express: '^4.18.0' },
-      devDependencies: { jest: '^29.0.0' },
-    };
-
-    const result = await detectFromPackageJson(mockPackageJson);
-
-    expect(result.backend?.language).toBe('nodejs');
-    expect(result.backend?.testFramework).toBe('jest');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/detectors/package-json.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement package.json detection**
-
-Create `src/testing/detectors/package-json.ts`:
-
-```typescript
-import type { TechStack } from '../types';
-
-export async function detectFromPackageJson(packageJson: any): Promise<TechStack> {
-  const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-  const stack: TechStack = {};
-
-  // Detect frontend framework
-  if (deps.react) {
-    stack.frontend = {
-      framework: 'react',
-      testFramework: deps.vitest ? 'vitest' : deps.jest ? 'jest' : 'none',
-    };
-  } else if (deps.vue) {
-    stack.frontend = {
-      framework: 'vue',
-      testFramework: deps.vitest ? 'vitest' : 'none',
-    };
-  } else if (deps.svelte) {
-    stack.frontend = {
-      framework: 'svelte',
-      testFramework: deps.vitest ? 'vitest' : 'none',
-    };
-  }
-
-  // Detect backend
-  if (deps.express || deps.fastify || deps.koa) {
-    stack.backend = {
-      language: 'nodejs',
-      testFramework: deps.vitest ? 'vitest' : deps.jest ? 'jest' : undefined,
-    };
-  }
-
-  // Detect databases
-  const databases: string[] = [];
-  if (deps.pg || deps.postgres) databases.push('postgresql');
-  if (deps.mysql || deps.mysql2) databases.push('mysql');
-  if (deps.mongodb || deps.mongoose) databases.push('mongodb');
-  if (databases.length > 0) stack.databases = databases;
-
-  // Detect API types
-  const apis: ('rest' | 'graphql' | 'grpc')[] = [];
-  if (deps.express || deps.fastify) apis.push('rest');
-  if (deps.graphql || deps['@apollo/server']) apis.push('graphql');
-  if (deps['@grpc/grpc-js']) apis.push('grpc');
-  if (apis.length > 0) stack.apis = apis;
-
-  return stack;
-}
-```
-
-Create `src/testing/detectors/index.ts`:
-
-```typescript
-import fs from 'fs/promises';
-import path from 'path';
-import { detectFromPackageJson } from './package-json';
-import type { TechStack } from '../types';
-
-export async function detectTechStack(projectRoot: string): Promise<TechStack> {
-  const packageJsonPath = path.join(projectRoot, 'package.json');
-
-  try {
-    const content = await fs.readFile(packageJsonPath, 'utf-8');
-    const packageJson = JSON.parse(content);
-    return await detectFromPackageJson(packageJson);
-  } catch (error) {
-    return {};
-  }
-}
-
-export { detectFromPackageJson };
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/detectors/package-json.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/detectors/ tests/testing/detectors/
-git commit -m "feat(testing): add tech stack detection from package.json
-
-- Detect React/Vue/Svelte frontend frameworks
-- Detect Node.js backend with Express/Fastify/Koa
-- Detect test frameworks (Vitest/Jest)
-- Detect databases (PostgreSQL/MySQL/MongoDB)
-- Detect API types (REST/GraphQL/gRPC)
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 3: React Test Generator
-
-**Files:**
-- Create: `src/testing/generators/react.ts`
-- Create: `tests/testing/generators/react.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/generators/react.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generateReactTest } from '../../../src/testing/generators/react';
-
-describe('generateReactTest', () => {
-  it('should generate test for simple React component', async () => {
-    const componentCode = `
-export function Button({ onClick, children }) {
-  return <button onClick={onClick}>{children}</button>;
-}
-`;
-
-    const result = await generateReactTest({
-      filePath: 'src/components/Button.tsx',
-      code: componentCode,
-      testFramework: 'vitest',
-    });
-
-    expect(result.testCode).toContain('import { render, screen }');
-    expect(result.testCode).toContain('describe(\'Button\'');
-    expect(result.testCode).toContain('it(\'renders children\'');
-    expect(result.testFilePath).toBe('src/components/Button.test.tsx');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/generators/react.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement React test generator**
-
-Create `src/testing/generators/react.ts`:
-
-```typescript
-interface ReactTestOptions {
-  filePath: string;
-  code: string;
-  testFramework: 'vitest' | 'jest';
-}
-
-interface ReactTestResult {
-  testFilePath: string;
-  testCode: string;
-}
-
-export async function generateReactTest(options: ReactTestOptions): Promise<ReactTestResult> {
-  const { filePath, code, testFramework } = options;
-
-  // Extract component name from file path
-  const fileName = filePath.split('/').pop()?.replace(/\.(tsx?|jsx?)$/, '') || 'Component';
-
-  // Generate test file path
-  const testFilePath = filePath.replace(/\.(tsx?|jsx?)$/, '.test.$1');
-
-  // Parse component to understand props and behavior
-  const hasOnClick = code.includes('onClick');
-  const hasChildren = code.includes('children');
-
-  // Generate test code
-  const testCode = `import { describe, it, expect${testFramework === 'vitest' ? ', vi' : ''} } from '${testFramework}';
-import { render, screen${hasOnClick ? ', fireEvent' : ''} } from '@testing-library/react';
-import { ${fileName} } from './${fileName}';
-
-describe('${fileName}', () => {
-  it('renders children', () => {
-    render(<${fileName}>Click me</${fileName}>);
-    expect(screen.getByText('Click me')).toBeInTheDocument();
-  });
-${hasOnClick ? `
-  it('calls onClick when clicked', () => {
-    const handleClick = ${testFramework === 'vitest' ? 'vi.fn()' : 'jest.fn()'};
-    render(<${fileName} onClick={handleClick}>Click me</${fileName}>);
-    fireEvent.click(screen.getByText('Click me'));
-    expect(handleClick).toHaveBeenCalledTimes(1);
-  });
-` : ''}
-});
-`;
-
-  return { testFilePath, testCode };
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/generators/react.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/generators/ tests/testing/generators/
-git commit -m "feat(testing): add React component test generator
-
-- Generate tests for React components
-- Support Vitest and Jest frameworks
-- Auto-detect onClick handlers and children props
-- Generate appropriate test file paths
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 4: Node.js Test Generator
-
-**Files:**
-- Create: `src/testing/generators/nodejs.ts`
-- Create: `tests/testing/generators/nodejs.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/generators/nodejs.test.ts`:
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { generateNodeJsTest } from '../../../src/testing/generators/nodejs';
-
-describe('generateNodeJsTest', () => {
-  it('should generate test for simple function', async () => {
-    const functionCode = `
-export function add(a: number, b: number): number {
-  return a + b;
-}
-`;
-
-    const result = await generateNodeJsTest({
-      filePath: 'src/utils/math.ts',
-      code: functionCode,
-      testFramework: 'vitest',
-    });
-
-    expect(result.testCode).toContain('import { describe, it, expect }');
-    expect(result.testCode).toContain('describe(\'add\'');
-    expect(result.testCode).toContain('it(\'adds two numbers\'');
-    expect(result.testFilePath).toBe('src/utils/math.test.ts');
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/generators/nodejs.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement Node.js test generator**
-
-Create `src/testing/generators/nodejs.ts`:
-
-```typescript
-interface NodeJsTestOptions {
-  filePath: string;
-  code: string;
-  testFramework: 'vitest' | 'jest';
-}
-
-interface NodeJsTestResult {
-  testFilePath: string;
-  testCode: string;
-}
-
-export async function generateNodeJsTest(options: NodeJsTestOptions): Promise<NodeJsTestResult> {
-  const { filePath, code, testFramework } = options;
-
-  // Extract function names from code
-  const functionMatches = code.matchAll(/export\s+(?:async\s+)?function\s+(\w+)/g);
-  const functions = Array.from(functionMatches).map(match => match[1]);
-
-  // Generate test file path
-  const testFilePath = filePath.replace(/\.ts$/, '.test.ts');
-
-  // Extract file name for import
-  const fileName = filePath.split('/').pop()?.replace(/\.ts$/, '') || 'module';
-
-  // Generate test code for each function
-  const testCases = functions.map(funcName => {
-    // Simple heuristic: if function name suggests math operation, generate math test
-    if (funcName === 'add') {
-      return `  it('adds two numbers', () => {
-    expect(add(2, 3)).toBe(5);
-    expect(add(-1, 1)).toBe(0);
-    expect(add(0, 0)).toBe(0);
-  });`;
-    }
-
-    // Generic test template
-    return `  it('${funcName} works correctly', () => {
-    // TODO: Add specific test cases for ${funcName}
-    expect(${funcName}).toBeDefined();
-  });`;
-  }).join('\n\n');
-
-  const testCode = `import { describe, it, expect } from '${testFramework}';
-import { ${functions.join(', ')} } from './${fileName}';
-
-describe('${fileName}', () => {
-${testCases}
-});
-`;
-
-  return { testFilePath, testCode };
-}
-```
-
-**Step 4: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/generators/nodejs.test.ts`
-Expected: PASS
-
-**Step 5: Commit**
-
-```bash
-git add src/testing/generators/nodejs.ts tests/testing/generators/nodejs.test.ts
-git commit -m "feat(testing): add Node.js function test generator
-
-- Generate tests for exported functions
-- Support Vitest and Jest frameworks
-- Auto-detect function names from code
-- Generate appropriate test cases
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 5: CLI Commands
-
-**Files:**
-- Create: `src/testing/cli/commands.ts`
-- Modify: `src/cli/index.ts` (add test subcommands)
-- Create: `tests/testing/cli/commands.test.ts`
-
-**Step 1: Write the failing test**
-
-Create `tests/testing/cli/commands.test.ts`:
-
-```typescript
-import { describe, it, expect, vi } from 'vitest';
-import { testGenCommand, testDetectStackCommand } from '../../../src/testing/cli/commands';
-
-describe('CLI Commands', () => {
-  it('testGenCommand should generate tests for a file', async () => {
-    const mockFs = vi.fn();
-    const result = await testGenCommand({
-      filePath: 'src/components/Button.tsx',
-      output: 'src/components/Button.test.tsx',
-    });
-
-    expect(result.success).toBe(true);
-    expect(result.testFilePath).toBeDefined();
-  });
-
-  it('testDetectStackCommand should detect tech stack', async () => {
-    const result = await testDetectStackCommand({
-      projectRoot: process.cwd(),
-    });
-
-    expect(result.stack).toBeDefined();
-  });
-});
-```
-
-**Step 2: Run test to verify it fails**
-
-Run: `pnpm test tests/testing/cli/commands.test.ts`
-Expected: FAIL with "Cannot find module"
-
-**Step 3: Implement CLI commands**
-
-Create `src/testing/cli/commands.ts`:
-
-```typescript
-import fs from 'fs/promises';
-import path from 'path';
-import { detectTechStack } from '../detectors';
-import { generateReactTest } from '../generators/react';
-import { generateNodeJsTest } from '../generators/nodejs';
-import type { TechStack } from '../types';
-
-interface TestGenOptions {
-  filePath: string;
-  output?: string;
-}
-
-interface TestGenResult {
-  success: boolean;
-  testFilePath?: string;
-  error?: string;
-}
-
-export async function testGenCommand(options: TestGenOptions): Promise<TestGenResult> {
-  try {
-    const { filePath, output } = options;
-
-    // Read source file
-    const code = await fs.readFile(filePath, 'utf-8');
-
-    // Detect tech stack
-    const projectRoot = process.cwd();
-    const stack = await detectTechStack(projectRoot);
-
-    // Determine generator based on file type and stack
-    let result;
-    if (filePath.match(/\.(tsx|jsx)$/) && stack.frontend?.framework === 'react') {
-      result = await generateReactTest({
-        filePath,
-        code,
-        testFramework: stack.frontend.testFramework || 'vitest',
-      });
-    } else if (filePath.match(/\.ts$/)) {
-      result = await generateNodeJsTest({
-        filePath,
-        code,
-        testFramework: stack.backend?.testFramework || 'vitest',
-      });
-    } else {
-      return {
-        success: false,
-        error: 'Unsupported file type',
-      };
-    }
-
-    // Write test file
-    const testFilePath = output || result.testFilePath;
-    await fs.writeFile(testFilePath, result.testCode, 'utf-8');
-
-    return {
-      success: true,
-      testFilePath,
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error',
-    };
-  }
-}
-
-interface DetectStackOptions {
-  projectRoot: string;
-}
-
-interface DetectStackResult {
-  stack: TechStack;
-}
-
-export async function testDetectStackCommand(options: DetectStackOptions): Promise<DetectStackResult> {
-  const stack = await detectTechStack(options.projectRoot);
-  return { stack };
-}
-```
-
-**Step 4: Add CLI integration**
-
-Modify `src/cli/index.ts` to add test subcommands (exact location depends on existing CLI structure):
-
-```typescript
-// Add to existing CLI command structure
-program
-  .command('test')
-  .description('Testing utilities')
-  .command('gen <file>')
-  .description('Generate tests for a file')
-  .option('-o, --output <path>', 'Output test file path')
-  .action(async (file, options) => {
-    const { testGenCommand } = await import('../testing/cli/commands');
-    const result = await testGenCommand({
-      filePath: file,
-      output: options.output,
-    });
-
-    if (result.success) {
-      console.log(`✅ Test generated: ${result.testFilePath}`);
-    } else {
-      console.error(`❌ Error: ${result.error}`);
-      process.exit(1);
-    }
-  });
-
-program
-  .command('test')
-  .command('detect-stack')
-  .description('Detect project tech stack')
-  .action(async () => {
-    const { testDetectStackCommand } = await import('../testing/cli/commands');
-    const result = await testDetectStackCommand({
-      projectRoot: process.cwd(),
-    });
-
-    console.log('📊 Detected Tech Stack:');
-    console.log(JSON.stringify(result.stack, null, 2));
-  });
-```
-
-**Step 5: Run test to verify it passes**
-
-Run: `pnpm test tests/testing/cli/commands.test.ts`
-Expected: PASS
-
-**Step 6: Test CLI manually**
-
-Run: `pnpm build && omc test detect-stack`
-Expected: Output showing detected tech stack
-
-**Step 7: Commit**
-
-```bash
-git add src/testing/cli/ src/cli/index.ts tests/testing/cli/
-git commit -m "feat(testing): add CLI commands for test generation
-
-- Add 'omc test gen' command to generate tests
-- Add 'omc test detect-stack' command
-- Integrate with existing CLI structure
-- Support React and Node.js test generation
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 6: Test-Gen Skill
-
-**Files:**
-- Create: `skills/test-gen.md`
-- Create: `tests/skills/test-gen.test.ts`
-
-**Step 1: Write the skill document**
-
-Create `skills/test-gen.md`:
-
-```markdown
----
-name: test-gen
-description: Generate tests for code files using LLM-driven test generation. Detects tech stack, analyzes code complexity, and generates appropriate tests. Use when user asks to "generate tests", "add tests", "create test coverage", or explicitly invokes /test-gen.
----
-
-# Test Generation Skill
-
-Generate comprehensive tests for code files with automatic tech stack detection and complexity analysis.
-
-## Usage
-
-```
-/test-gen <file-path>
-/test-gen src/components/Button.tsx
-/test-gen src/utils/math.ts --coverage-analysis
-```
-
-## Workflow
-
-### Step 1: Detect Tech Stack
-
-Use the `omc test detect-stack` command to identify:
-- Frontend framework (React/Vue/Svelte)
-- Backend language (Node.js/Python/Go/Rust)
-- Test frameworks (Vitest/Jest/pytest)
-- Databases and API types
-
-### Step 2: Analyze Code Complexity
-
-Determine if code is "simple" or "complex":
-
-**Simple (auto-generate tests)**:
-- Function lines < 50
-- Cyclomatic complexity < 10
-- Nesting level < 3
-- No external dependencies
-
-**Complex (generate framework + prompt for details)**:
-- Payment/auth logic
-- Multi-step workflows
-- External service dependencies
-- Async/concurrent scenarios
-
-### Step 3: Generate Tests
-
-For simple code:
-- Call `omc test gen <file>` directly
-- Review generated tests
-- Commit
-
-For complex code:
-- Generate test framework with `omc test gen <file>`
-- Delegate to enhanced `test-engineer` agent for detailed test cases
-- Prompt user for business logic validation
-
-### Step 4: Coverage Analysis (Optional)
-
-If `--coverage-analysis` flag is provided:
-- Run coverage tools
-- Identify missing test scenarios
-- Generate supplementary tests
-
-## Integration with Other Skills
-
-- Works with `/tdd` for test-first development
-- Integrates with `/ultraqa` for test-verify-fix loops
-- Called automatically by `/autopilot` when generating code
-
-## Examples
-
-### Example 1: Simple React Component
-
-```
-User: /test-gen src/components/Button.tsx
-Agent: Detecting tech stack...
-✅ Detected: React + Vitest
-
-Agent: Analyzing complexity...
-✅ Simple component (25 lines, no external deps)
-
-Agent: Generating tests...
-✅ Generated: src/components/Button.test.tsx
-
-Tests include:
-- Renders children correctly
-- Handles onClick events
-- Accessibility checks
-
-Would you like me to commit these tests?
-```
-
-### Example 2: Complex Payment Service
-
-```
-User: /test-gen src/services/payment.ts
-
-Agent: Detecting tech stack...
-✅ Detected: Node.js + Express + PostgreSQL + Vitest
-
-Agent: Analyzing complexity...
-⚠️  Complex code detected:
-- Payment processing logic
-- External Stripe API calls
-- Database transactions
-- Error handling for multiple scenarios
-
-Agent: Generating test framework...
-✅ Generated: src/services/payment.test.ts (framework)
-
-Agent: Delegating to test-engineer for detailed test cases...
-
-Test-Engineer: I'll need some information:
-1. What are the expected payment flows? (success, failure, retry)
-2. Should I mock Stripe API calls?
-3. What database states should I test?
-4. Are there specific edge cases to cover?
-
-[User provides details]
-
-Test-Engineer: Generating comprehensive test suite...
-✅ Generated 15 test cases covering:
-- Happy path payment processing
-- Stripe API failure scenarios
-- Database transaction rollbacks
-- Idempotency checks
-- Concurrent payment handling
-
-Would you like me to commit these tests?
-```
-
-### Example 3: Coverage Analysis
-
-```
-User: /test-gen src/utils/validation.ts --coverage-analysis
-
-Agent: Generating initial tests...
-✅ Generated: src/utils/validation.test.ts
-
-Agent: Running coverage analysis...
-📊 Current coverage: 65%
-
-Missing coverage:
-- Line 42-48: Error handling for invalid email formats
-- Line 67-72: Edge case for international phone numbers
-- Line 89: Null check branch
-
-Agent: Generating supplementary tests...
-✅ Added 5 additional test cases
-
-Agent: Re-running coverage...
-📊 New coverage: 92%
-
-Would you like me to commit these tests?
-```
-
-## Integration Notes
-
-### With Test-Engineer Agent
-
-The `/test-gen` skill enhances the existing `test-engineer` agent by:
-
-1. **Automatic invocation**: When user asks to "generate tests", invoke `/test-gen` instead of directly calling `test-engineer`
-2. **Context enrichment**: Pass detected tech stack and complexity analysis to `test-engineer`
-3. **Workflow guidance**: Provide structured workflow for test generation
-
-Update `agents/test-engineer.md` to reference `/test-gen`:
-
-```markdown
-## When to Use
-
-- User explicitly asks for test generation → Use `/test-gen` skill first
-- User asks for test strategy/planning → Use test-engineer directly
-- User asks for test debugging → Use test-engineer directly
-```
-
-### With Autopilot
-
-Update `skills/autopilot.md` to include test generation:
-
-```markdown
-## Phase 4: Testing
-
-After implementation:
-1. Run `/test-gen` on all new source files
-2. Verify tests pass
-3. Check coverage meets threshold (default: 80%)
-```
-
-### With TDD Skill
-
-Update `skills/tdd.md` to integrate:
-
-```markdown
-## Red Phase
-
-Instead of manually writing tests, use:
-```
-/test-gen <file> --tdd-mode
-```
-
-This generates failing tests based on function signatures.
-```
-
-## Success Criteria
-
-- [ ] Tech stack detection works for React + Node.js projects
-- [ ] Test generation produces valid, runnable tests
-- [ ] CLI commands (`omc test gen`, `omc test detect-stack`) work correctly
-- [ ] `/test-gen` skill integrates with existing agent workflows
-- [ ] All tests pass: `pnpm test tests/testing/**`
-- [ ] Documentation is complete and accurate
-
-**Step 2: Write integration test**
-
-Create `tests/skills/test-gen.test.ts`:
-
-```typescript
-import { describe, it, expect, vi } from 'vitest';
-import { execSync } from 'child_process';
-import fs from 'fs/promises';
-import path from 'path';
-
-describe('test-gen skill integration', () => {
-  it('should generate tests via CLI', async () => {
-    // Create a temporary test file
-    const tmpDir = path.join(process.cwd(), 'tmp-test-gen');
-    await fs.mkdir(tmpDir, { recursive: true });
-
-    const componentPath = path.join(tmpDir, 'Button.tsx');
-    await fs.writeFile(componentPath, `
-export function Button({ onClick, children }) {
-  return <button onClick={onClick}>{children}</button>;
-}
-    `);
-
-    // Run CLI command
-    const result = execSync(`pnpm omc test gen ${componentPath}`, {
-      encoding: 'utf-8',
-    });
-
-    expect(result).toContain('✅ Test generated');
-
-    // Verify test file exists
-    const testPath = path.join(tmpDir, 'Button.test.tsx');
-    const testContent = await fs.readFile(testPath, 'utf-8');
-    expect(testContent).toContain('describe(\'Button\'');
-
-    // Cleanup
-    await fs.rm(tmpDir, { recursive: true });
-  });
-});
-```
-
-**Step 3: Run test to verify it fails**
-
-Run: `pnpm test tests/skills/test-gen.test.ts`
-Expected: FAIL (skill not yet integrated)
-
-**Step 4: Verify skill document is complete**
-
-The skill document should be complete and ready for use.
-
-**Step 5: Commit**
-
-```bash
-git add skills/test-gen.md tests/skills/test-gen.test.ts
-git commit -m "feat(skills): add test-gen skill for LLM-driven test generation
-
-- Add /test-gen skill with tech stack detection
-- Support simple and complex code analysis
-- Integrate with test-engineer agent
-- Add coverage analysis support
-- Include comprehensive examples
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Task 7: Documentation and Integration
-
-**Files:**
-- Create: `docs/testing/README.md`
-- Update: `README.md` (add testing section)
-- Update: `agents/test-engineer.md` (reference test-gen)
-
-**Step 1: Create testing documentation**
-
-Create `docs/testing/README.md`:
-
-```markdown
-# LLM Testing System
-
-Intelligent test generation system for oh-my-claudecode.
-
-## Quick Start
-
-Generate tests for a file:
-
-```bash
-omc test gen src/components/Button.tsx
-```
-
-Or use the skill:
-
-```bash
-/test-gen src/components/Button.tsx
-```
-
-## Features
-
-- **Automatic tech stack detection**: Identifies React, Vue, Svelte, Node.js, and more
-- **Complexity analysis**: Determines if code is simple or complex
-- **Smart test generation**: Creates appropriate tests based on code patterns
-- **Coverage analysis**: Identifies missing test scenarios
-- **Framework support**: Vitest, Jest, React Testing Library
-
-## Architecture
-
-```
-src/testing/
-├── index.ts              # Main module exports
-├── types.ts              # TypeScript interfaces
-├── cli/
-│   └── commands.ts       # CLI command implementations
-├── detectors/
-│   ├── index.ts          # Tech stack detection orchestrator
-│   └── package-json.ts   # package.json parser
-└── generators/
-    ├── react.ts          # React component test generator
-    └── nodejs.ts         # Node.js function test generator
-```
-
-## CLI Commands
-
-### Generate Tests
-
-```bash
-omc test gen <file> [--output <path>]
-```
-
-Generates tests for the specified file.
-
-### Detect Tech Stack
-
-```bash
-omc test detect-stack
-```
-
-Displays the detected tech stack for the current project.
-
-## Skill Usage
-
-The `/test-gen` skill provides a higher-level interface:
-
-```bash
-/test-gen src/components/Button.tsx
-/test-gen src/services/payment.ts --coverage-analysis
-```
-
-## Supported Tech Stacks
-
-### Frontend
-- React (with Vitest or Jest)
-- Vue (with Vitest)
-- Svelte (with Vitest)
-
-### Backend
-- Node.js (with Vitest or Jest)
-
-### Coming Soon (Phase 2)
-- Python (pytest)
-- Go (testing package)
-- Rust (cargo test)
-
-## Examples
-
-See `skills/test-gen.md` for detailed examples.
-
-## Development
-
-Run tests:
-
-```bash
-pnpm test tests/testing/**
-```
-
-Build:
-
-```bash
-pnpm build
-```
-```
-
-**Step 2: Update main README**
-
-Add to `README.md` (in appropriate section):
-
-```markdown
-## Testing
-
-oh-my-claudecode includes an intelligent test generation system:
-
-```bash
-# Generate tests for a file
-omc test gen src/components/Button.tsx
-
-# Detect project tech stack
-omc test detect-stack
-
-# Use the skill for advanced features
-/test-gen src/services/payment.ts --coverage-analysis
-```
-
-See [Testing Documentation](docs/testing/README.md) for details.
-```
-
-**Step 3: Update test-engineer agent**
-
-Update `agents/test-engineer.md` to add:
-
-```markdown
-## Integration with Test-Gen Skill
-
-When user asks to "generate tests" or "add tests", prefer using the `/test-gen` skill:
-
-- `/test-gen` handles tech stack detection and complexity analysis automatically
-- For complex code, `/test-gen` will delegate to test-engineer with enriched context
-- For test strategy and planning, use test-engineer directly
-```
-
-**Step 4: Commit**
-
-```bash
-git add docs/testing/ README.md agents/test-engineer.md
-git commit -m "docs(testing): add comprehensive testing documentation
-
-- Add testing system README with architecture overview
-- Update main README with testing section
-- Integrate test-gen skill with test-engineer agent
-- Include usage examples and CLI reference
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>"
-```
-
----
-
-## Phase 1 Summary
-
-### Deliverables Checklist
-
-- [x] **Core Infrastructure**
-  - [x] Project structure (`src/testing/`)
-  - [x] TypeScript types and interfaces
-  - [x] Module exports and organization
-
-- [x] **Tech Stack Detection**
-  - [x] package.json parser
-  - [x] Frontend framework detection (React/Vue/Svelte)
-  - [x] Backend language detection (Node.js)
-  - [x] Test framework detection (Vitest/Jest)
-  - [x] Database and API detection
-
-- [x] **Test Generators**
-  - [x] React component test generator
-  - [x] Node.js function test generator
-  - [x] Support for Vitest and Jest
-  - [x] Automatic test file path generation
-
-- [x] **CLI Integration**
-  - [x] `omc test gen` command
-  - [x] `omc test detect-stack` command
-  - [x] CLI command tests
-
-- [x] **Skill Integration**
-  - [x] `/test-gen` skill document
-  - [x] Workflow for simple vs complex code
-  - [x] Integration with test-engineer agent
-  - [x] Coverage analysis support
-
-- [x] **Documentation**
-  - [x] Testing system README
-  - [x] Main README updates
-  - [x] Agent integration docs
-  - [x] Usage examples
-
-- [x] **Testing**
-  - [x] Unit tests for all modules
-  - [x] Integration tests for CLI
-  - [x] Skill integration tests
-
-### Estimated Timeline
-
-- **Task 1**: Project Structure Setup - 30 minutes
-- **Task 2**: Tech Stack Detection - 1 hour
-- **Task 3**: React Test Generator - 1.5 hours
-- **Task 4**: Node.js Test Generator - 1 hour
-- **Task 5**: CLI Commands - 1.5 hours
-- **Task 6**: Test-Gen Skill - 1 hour
-- **Task 7**: Documentation - 1 hour
-
-**Total**: ~7.5 hours
-
-### Next Steps
-
-**Phase 2: Advanced Features**
-1. Python test generation (pytest)
-2. Go test generation (testing package)
-3. Rust test generation (cargo test)
-4. Integration test generation
-5. E2E test generation (Playwright/Cypress)
-6. Advanced complexity analysis with AST parsing
-7. LLM-powered test case suggestions
-8. Test quality scoring
-
-**Phase 3: Promptfoo Integration**
-1. Promptfoo configuration generation
-2. LLM evaluation test generation
-3. Regression test suite for prompts
-4. Performance benchmarking
-5. Multi-model comparison
-
-**Immediate Actions**
-1. Review this plan with team
-2. Create GitHub issues for each task
-3. Set up project board
-4. Begin Task 1 implementation
-
----
-
-## Implementation Notes
-
-### TDD Approach
-
-Each task follows strict TDD:
-1. Write failing test
-2. Run test to verify failure
-3. Implement minimal code to pass
-4. Run test to verify pass
-5. Commit with descriptive message
-
-### Code Quality
-
-- All code must pass TypeScript type checking
-- All tests must pass before committing
-- Follow existing code style and conventions
-- Use meaningful variable and function names
-- Add comments for complex logic
-
-### Git Workflow
-
-- Create feature branch from `dev`: `git checkout -b feature/llm-testing-phase1 dev`
-- Commit after each task completion
-- Use conventional commit format: `feat(testing): description`
-- Include co-author tag: `Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>`
-- Create PR targeting `dev` branch when complete
-
-### Testing Strategy
-
-- Unit tests for all functions
-- Integration tests for CLI commands
-- Mock external dependencies (file system, APIs)
-- Use Vitest for all tests
-- Aim for >80% code coverage
-
----
-
-**Plan Status**: ✅ Complete and ready for implementation
-
-**Next Action**: Begin Task 1 - Project Structure Setup