@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/domains/test-generation/services/test-generator.ts

@@ -1,2750 +0,0 @@
-/**
- * Agentic QE v3 - Test Generation Service
- * Implements ITestGenerationService for AI-powered test generation
- *
- * Uses @faker-js/faker for realistic test data generation
- * Uses TypeScript AST parser for code analysis
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as ts from 'typescript';
-import { faker } from '@faker-js/faker';
-import { Result, ok, err } from '../../../shared/types';
-import { MemoryBackend } from '../../../kernel/interfaces';
-import {
-  GenerateTestsRequest,
-  GeneratedTests,
-  GeneratedTest,
-  TDDRequest,
-  TDDResult,
-  PropertyTestRequest,
-  PropertyTests,
-  TestDataRequest,
-  TestData,
-  Pattern,
-} from '../interfaces';
-
-/**
- * Interface for the test generation service
- */
-export interface ITestGenerationService {
-  generateTests(request: GenerateTestsRequest): Promise<Result<GeneratedTests, Error>>;
-  generateForCoverageGap(
-    file: string,
-    uncoveredLines: number[],
-    framework: string
-  ): Promise<Result<GeneratedTest[], Error>>;
-  generateTDDTests(request: TDDRequest): Promise<Result<TDDResult, Error>>;
-  generatePropertyTests(request: PropertyTestRequest): Promise<Result<PropertyTests, Error>>;
-  generateTestData(request: TestDataRequest): Promise<Result<TestData, Error>>;
-}
-
-/**
- * Configuration for the test generator
- */
-export interface TestGeneratorConfig {
-  defaultFramework: 'jest' | 'vitest' | 'mocha' | 'pytest';
-  maxTestsPerFile: number;
-  coverageTargetDefault: number;
-  enableAIGeneration: boolean;
-}
-
-const DEFAULT_CONFIG: TestGeneratorConfig = {
-  defaultFramework: 'jest',
-  maxTestsPerFile: 50,
-  coverageTargetDefault: 80,
-  enableAIGeneration: true,
-};
-
-/**
- * Information about a function extracted from AST
- */
-interface FunctionInfo {
-  name: string;
-  parameters: ParameterInfo[];
-  returnType: string | undefined;
-  isAsync: boolean;
-  isExported: boolean;
-  complexity: number;
-  startLine: number;
-  endLine: number;
-  body?: string;
-}
-
-/**
- * Information about a class extracted from AST
- */
-interface ClassInfo {
-  name: string;
-  methods: FunctionInfo[];
-  properties: PropertyInfo[];
-  isExported: boolean;
-  hasConstructor: boolean;
-  constructorParams?: ParameterInfo[];
-}
-
-/**
- * Information about a parameter
- */
-interface ParameterInfo {
-  name: string;
-  type: string | undefined;
-  optional: boolean;
-  defaultValue: string | undefined;
-}
-
-/**
- * Information about a class property
- */
-interface PropertyInfo {
-  name: string;
-  type: string | undefined;
-  isPrivate: boolean;
-  isReadonly: boolean;
-}
-
-/**
- * Test case definition
- */
-interface TestCase {
-  description: string;
-  type: 'happy-path' | 'edge-case' | 'error-handling' | 'boundary';
-  setup?: string;
-  action: string;
-  assertion: string;
-}
-
-/**
- * Data schema field definition
- */
-interface SchemaField {
-  type: string;
-  faker?: string;
-  min?: number;
-  max?: number;
-  enum?: string[];
-  pattern?: string;
-  reference?: string;
-}
-
-/**
- * Test Generation Service Implementation
- * Uses heuristic analysis and AST parsing to generate test cases from source code
- * Supports TDD workflow, property-based testing, and pattern-aware generation
- */
-export class TestGeneratorService implements ITestGenerationService {
-  private readonly config: TestGeneratorConfig;
-
-  constructor(
-    private readonly memory: MemoryBackend,
-    config: Partial<TestGeneratorConfig> = {}
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  /**
-   * Generate tests for given source files
-   */
-  async generateTests(request: GenerateTestsRequest): Promise<Result<GeneratedTests, Error>> {
-    try {
-      const {
-        sourceFiles,
-        testType,
-        framework,
-        coverageTarget = this.config.coverageTargetDefault,
-        patterns = [],
-      } = request;
-
-      if (sourceFiles.length === 0) {
-        return err(new Error('No source files provided'));
-      }
-
-      const tests: GeneratedTest[] = [];
-      const patternsUsed: string[] = [];
-
-      // Process each source file
-      for (const sourceFile of sourceFiles) {
-        const fileTests = await this.generateTestsForFile(
-          sourceFile,
-          testType,
-          framework,
-          patterns
-        );
-
-        if (fileTests.success) {
-          tests.push(...fileTests.value.tests);
-          patternsUsed.push(...fileTests.value.patternsUsed);
-        }
-      }
-
-      // Calculate coverage estimate based on test count and complexity
-      const coverageEstimate = this.estimateCoverage(tests, coverageTarget);
-
-      // Store generation metadata in memory
-      await this.storeGenerationMetadata(tests, patternsUsed);
-
-      return ok({
-        tests,
-        coverageEstimate,
-        patternsUsed: [...new Set(patternsUsed)],
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Generate tests specifically targeting coverage gaps
-   */
-  async generateForCoverageGap(
-    file: string,
-    uncoveredLines: number[],
-    framework: string
-  ): Promise<Result<GeneratedTest[], Error>> {
-    try {
-      if (uncoveredLines.length === 0) {
-        return ok([]);
-      }
-
-      // Analyze uncovered lines and generate targeted tests
-      // Groups consecutive lines and generates tests for each block
-      const tests: GeneratedTest[] = [];
-
-      // Group uncovered lines into logical blocks
-      const lineGroups = this.groupConsecutiveLines(uncoveredLines);
-
-      for (const group of lineGroups) {
-        const test = await this.generateTestForLines(file, group, framework);
-        if (test) {
-          tests.push(test);
-        }
-      }
-
-      return ok(tests);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Generate tests following TDD workflow
-   */
-  async generateTDDTests(request: TDDRequest): Promise<Result<TDDResult, Error>> {
-    try {
-      const { feature, behavior, framework, phase } = request;
-
-      switch (phase) {
-        case 'red':
-          // Generate failing test first
-          return ok(await this.generateRedPhaseTest(feature, behavior, framework));
-
-        case 'green':
-          // Generate minimal implementation to make test pass
-          return ok(await this.generateGreenPhaseCode(feature, behavior, framework));
-
-        case 'refactor':
-          // Suggest refactoring improvements
-          return ok(await this.generateRefactoringSuggestions(feature, behavior));
-
-        default:
-          return err(new Error(`Unknown TDD phase: ${phase}`));
-      }
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Generate property-based tests
-   */
-  async generatePropertyTests(
-    request: PropertyTestRequest
-  ): Promise<Result<PropertyTests, Error>> {
-    try {
-      const { function: funcName, properties, constraints = {} } = request;
-
-      // Generate property-based tests using fast-check generators
-      const tests = properties.map((property) => ({
-        property,
-        testCode: this.generatePropertyTestCode(funcName, property, constraints),
-        generators: this.inferGenerators(property, constraints),
-      }));
-
-      return ok({
-        tests,
-        arbitraries: this.collectArbitraries(tests),
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Generate test data based on schema
-   */
-  async generateTestData(request: TestDataRequest): Promise<Result<TestData, Error>> {
-    try {
-      const { schema, count, locale = 'en', preserveRelationships = false } = request;
-
-      // Generate test data using @faker-js/faker with seeded randomness
-      const seed = Date.now();
-      const records: unknown[] = [];
-
-      for (let i = 0; i < count; i++) {
-        const record = this.generateRecordFromSchema(schema, seed + i, locale);
-        records.push(record);
-      }
-
-      // Handle relationships if needed
-      if (preserveRelationships) {
-        this.linkRelatedRecords(records, schema);
-      }
-
-      return ok({
-        records,
-        schema,
-        seed,
-      });
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-
-  private async generateTestsForFile(
-    sourceFile: string,
-    testType: 'unit' | 'integration' | 'e2e',
-    framework: string,
-    patterns: string[]
-  ): Promise<Result<{ tests: GeneratedTest[]; patternsUsed: string[] }, Error>> {
-    const testFile = this.getTestFilePath(sourceFile, framework);
-    const patternsUsed: string[] = [];
-
-    // Look for applicable patterns from memory
-    const applicablePatterns = await this.findApplicablePatterns(sourceFile, patterns);
-    patternsUsed.push(...applicablePatterns.map((p) => p.name));
-
-    // Try to read and parse the source file for real AST analysis
-    let codeAnalysis: { functions: FunctionInfo[]; classes: ClassInfo[] } | null = null;
-    try {
-      const content = fs.readFileSync(sourceFile, 'utf-8');
-      codeAnalysis = this.analyzeSourceCode(content, sourceFile);
-    } catch {
-      // File doesn't exist or can't be read - use stub generation
-    }
-
-    // Generate test code based on analysis or fall back to stub
-    let testCode: string;
-    if (codeAnalysis && (codeAnalysis.functions.length > 0 || codeAnalysis.classes.length > 0)) {
-      testCode = this.generateRealTestCode(
-        sourceFile,
-        testType,
-        framework,
-        codeAnalysis,
-        applicablePatterns
-      );
-    } else {
-      testCode = this.generateStubTestCode(sourceFile, testType, framework, applicablePatterns);
-    }
-
-    const test: GeneratedTest = {
-      id: uuidv4(),
-      name: `${this.extractModuleName(sourceFile)} tests`,
-      sourceFile,
-      testFile,
-      testCode,
-      type: testType,
-      assertions: this.countAssertions(testCode),
-    };
-
-    return ok({ tests: [test], patternsUsed });
-  }
-
-  /**
-   * Analyze source code using TypeScript AST
-   */
-  private analyzeSourceCode(
-    content: string,
-    fileName: string
-  ): { functions: FunctionInfo[]; classes: ClassInfo[] } {
-    const sourceFile = ts.createSourceFile(
-      path.basename(fileName),
-      content,
-      ts.ScriptTarget.Latest,
-      true,
-      ts.ScriptKind.TS
-    );
-
-    const functions: FunctionInfo[] = [];
-    const classes: ClassInfo[] = [];
-
-    const visit = (node: ts.Node): void => {
-      // Extract function declarations
-      if (ts.isFunctionDeclaration(node) && node.name) {
-        functions.push(this.extractFunctionInfo(node, sourceFile));
-      }
-      // Extract arrow functions assigned to variables
-      else if (ts.isVariableStatement(node)) {
-        for (const declaration of node.declarationList.declarations) {
-          if (
-            ts.isVariableDeclaration(declaration) &&
-            declaration.initializer &&
-            (ts.isArrowFunction(declaration.initializer) ||
-              ts.isFunctionExpression(declaration.initializer))
-          ) {
-            const name = declaration.name.getText(sourceFile);
-            functions.push(
-              this.extractArrowFunctionInfo(name, declaration.initializer, sourceFile, node)
-            );
-          }
-        }
-      }
-      // Extract class declarations
-      else if (ts.isClassDeclaration(node) && node.name) {
-        classes.push(this.extractClassInfo(node, sourceFile));
-      }
-
-      ts.forEachChild(node, visit);
-    };
-
-    ts.forEachChild(sourceFile, visit);
-    return { functions, classes };
-  }
-
-  /**
-   * Extract function information from AST
-   */
-  private extractFunctionInfo(
-    node: ts.FunctionDeclaration,
-    sourceFile: ts.SourceFile
-  ): FunctionInfo {
-    const name = node.name?.getText(sourceFile) || 'anonymous';
-    const parameters = this.extractParameters(node.parameters, sourceFile);
-    const returnType = node.type?.getText(sourceFile);
-    const isAsync = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-    const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
-
-    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-
-    return {
-      name,
-      parameters,
-      returnType,
-      isAsync,
-      isExported,
-      complexity: this.calculateComplexity(node),
-      startLine: startLine + 1,
-      endLine: endLine + 1,
-      body: node.body?.getText(sourceFile),
-    };
-  }
-
-  /**
-   * Extract arrow function information from AST
-   */
-  private extractArrowFunctionInfo(
-    name: string,
-    node: ts.ArrowFunction | ts.FunctionExpression,
-    sourceFile: ts.SourceFile,
-    parentNode: ts.Node
-  ): FunctionInfo {
-    const parameters = this.extractParameters(node.parameters, sourceFile);
-    const returnType = node.type?.getText(sourceFile);
-    const isAsync = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-    const isExported =
-      ts.isVariableStatement(parentNode) &&
-      (parentNode.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
-
-    const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
-    const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-
-    return {
-      name,
-      parameters,
-      returnType,
-      isAsync,
-      isExported,
-      complexity: this.calculateComplexity(node),
-      startLine: startLine + 1,
-      endLine: endLine + 1,
-      body: node.body?.getText(sourceFile),
-    };
-  }
-
-  /**
-   * Extract class information from AST
-   */
-  private extractClassInfo(node: ts.ClassDeclaration, sourceFile: ts.SourceFile): ClassInfo {
-    const name = node.name?.getText(sourceFile) || 'AnonymousClass';
-    const methods: FunctionInfo[] = [];
-    const properties: PropertyInfo[] = [];
-    let hasConstructor = false;
-    let constructorParams: ParameterInfo[] | undefined;
-
-    const isExported =
-      node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
-
-    for (const member of node.members) {
-      if (ts.isMethodDeclaration(member)) {
-        const methodName = member.name.getText(sourceFile);
-        const parameters = this.extractParameters(member.parameters, sourceFile);
-        const returnType = member.type?.getText(sourceFile);
-        const isAsync =
-          member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-
-        const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(
-          member.getStart(sourceFile)
-        );
-        const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(member.getEnd());
-
-        methods.push({
-          name: methodName,
-          parameters,
-          returnType,
-          isAsync,
-          isExported: false,
-          complexity: this.calculateComplexity(member),
-          startLine: startLine + 1,
-          endLine: endLine + 1,
-          body: member.body?.getText(sourceFile),
-        });
-      } else if (ts.isConstructorDeclaration(member)) {
-        hasConstructor = true;
-        constructorParams = this.extractParameters(member.parameters, sourceFile);
-      } else if (ts.isPropertyDeclaration(member)) {
-        const propName = member.name.getText(sourceFile);
-        const propType = member.type?.getText(sourceFile);
-        const isPrivate =
-          member.modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword) ?? false;
-        const isReadonly =
-          member.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
-
-        properties.push({
-          name: propName,
-          type: propType,
-          isPrivate,
-          isReadonly,
-        });
-      }
-    }
-
-    return {
-      name,
-      methods,
-      properties,
-      isExported,
-      hasConstructor,
-      constructorParams,
-    };
-  }
-
-  /**
-   * Extract parameters from a function
-   */
-  private extractParameters(
-    params: ts.NodeArray<ts.ParameterDeclaration>,
-    sourceFile: ts.SourceFile
-  ): ParameterInfo[] {
-    return params.map((param) => ({
-      name: param.name.getText(sourceFile),
-      type: param.type?.getText(sourceFile),
-      optional: param.questionToken !== undefined,
-      defaultValue: param.initializer?.getText(sourceFile),
-    }));
-  }
-
-  /**
-   * Calculate cyclomatic complexity of a node
-   */
-  private calculateComplexity(node: ts.Node): number {
-    let complexity = 1;
-
-    const visit = (n: ts.Node): void => {
-      switch (n.kind) {
-        case ts.SyntaxKind.IfStatement:
-        case ts.SyntaxKind.ForStatement:
-        case ts.SyntaxKind.ForInStatement:
-        case ts.SyntaxKind.ForOfStatement:
-        case ts.SyntaxKind.WhileStatement:
-        case ts.SyntaxKind.DoStatement:
-        case ts.SyntaxKind.CaseClause:
-        case ts.SyntaxKind.CatchClause:
-        case ts.SyntaxKind.ConditionalExpression:
-          complexity++;
-          break;
-        case ts.SyntaxKind.BinaryExpression: {
-          const binary = n as ts.BinaryExpression;
-          if (
-            binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
-            binary.operatorToken.kind === ts.SyntaxKind.BarBarToken
-          ) {
-            complexity++;
-          }
-          break;
-        }
-      }
-      ts.forEachChild(n, visit);
-    };
-
-    ts.forEachChild(node, visit);
-    return complexity;
-  }
-
-  /**
-   * Generate real test code based on AST analysis
-   */
-  private generateRealTestCode(
-    sourceFile: string,
-    testType: 'unit' | 'integration' | 'e2e',
-    framework: string,
-    analysis: { functions: FunctionInfo[]; classes: ClassInfo[] },
-    patterns: Pattern[]
-  ): string {
-    const moduleName = this.extractModuleName(sourceFile);
-    const importPath = this.getImportPath(sourceFile);
-
-    switch (framework) {
-      case 'jest':
-      case 'vitest':
-        return this.generateRealJestVitestTest(
-          moduleName,
-          importPath,
-          testType,
-          analysis,
-          patterns,
-          framework
-        );
-      case 'mocha':
-        return this.generateRealMochaTest(moduleName, importPath, testType, analysis, patterns);
-      case 'pytest':
-        return this.generateRealPytestTest(moduleName, importPath, testType, analysis, patterns);
-      default:
-        return this.generateRealJestVitestTest(
-          moduleName,
-          importPath,
-          testType,
-          analysis,
-          patterns,
-          'vitest'
-        );
-    }
-  }
-
-  /**
-   * Generate real Jest/Vitest test code
-   */
-  private generateRealJestVitestTest(
-    moduleName: string,
-    importPath: string,
-    testType: string,
-    analysis: { functions: FunctionInfo[]; classes: ClassInfo[] },
-    patterns: Pattern[],
-    framework: string
-  ): string {
-    const patternComment =
-      patterns.length > 0
-        ? `// Applied patterns: ${patterns.map((p) => p.name).join(', ')}\n`
-        : '';
-
-    // Collect all exports to import
-    const exports: string[] = [];
-    for (const fn of analysis.functions) {
-      if (fn.isExported) exports.push(fn.name);
-    }
-    for (const cls of analysis.classes) {
-      if (cls.isExported) exports.push(cls.name);
-    }
-
-    const importStatement =
-      exports.length > 0
-        ? `import { ${exports.join(', ')} } from '${importPath}';`
-        : `import * as ${moduleName} from '${importPath}';`;
-
-    let testCode = `${patternComment}import { describe, it, expect, beforeEach${framework === 'vitest' ? ', vi' : ''} } from '${framework}';
-${importStatement}
-
-`;
-
-    // Generate tests for each function
-    for (const fn of analysis.functions) {
-      testCode += this.generateFunctionTests(fn, testType);
-    }
-
-    // Generate tests for each class
-    for (const cls of analysis.classes) {
-      testCode += this.generateClassTests(cls, testType);
-    }
-
-    return testCode;
-  }
-
-  /**
-   * Generate tests for a function
-   */
-  private generateFunctionTests(fn: FunctionInfo, _testType: string): string {
-    const testCases = this.generateTestCasesForFunction(fn);
-
-    let code = `describe('${fn.name}', () => {\n`;
-
-    for (const testCase of testCases) {
-      if (testCase.setup) {
-        code += `  ${testCase.setup}\n\n`;
-      }
-
-      const asyncPrefix = fn.isAsync ? 'async ' : '';
-      code += `  it('${testCase.description}', ${asyncPrefix}() => {\n`;
-      code += `    ${testCase.action}\n`;
-      code += `    ${testCase.assertion}\n`;
-      code += `  });\n\n`;
-    }
-
-    code += `});\n\n`;
-    return code;
-  }
-
-  /**
-   * Generate test cases for a function
-   */
-  private generateTestCasesForFunction(fn: FunctionInfo): TestCase[] {
-    const testCases: TestCase[] = [];
-
-    // Generate valid input test
-    const validParams = fn.parameters.map((p) => this.generateTestValue(p)).join(', ');
-    const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
-
-    testCases.push({
-      description: 'should handle valid input correctly',
-      type: 'happy-path',
-      action: `const result = ${fnCall};`,
-      assertion: 'expect(result).toBeDefined();',
-    });
-
-    // Generate tests for each parameter
-    for (const param of fn.parameters) {
-      if (!param.optional) {
-        // Test with undefined
-        const paramsWithUndefined = fn.parameters
-          .map((p) => (p.name === param.name ? 'undefined' : this.generateTestValue(p)))
-          .join(', ');
-
-        testCases.push({
-          description: `should handle undefined ${param.name}`,
-          type: 'error-handling',
-          action: fn.isAsync
-            ? `const action = async () => await ${fn.name}(${paramsWithUndefined});`
-            : `const action = () => ${fn.name}(${paramsWithUndefined});`,
-          assertion: 'expect(action).toThrow();',
-        });
-      }
-
-      // Type-specific boundary tests
-      if (param.type?.includes('string')) {
-        const paramsWithEmpty = fn.parameters
-          .map((p) => (p.name === param.name ? "''" : this.generateTestValue(p)))
-          .join(', ');
-        const emptyCall = fn.isAsync
-          ? `await ${fn.name}(${paramsWithEmpty})`
-          : `${fn.name}(${paramsWithEmpty})`;
-
-        testCases.push({
-          description: `should handle empty string for ${param.name}`,
-          type: 'boundary',
-          action: `const result = ${emptyCall};`,
-          assertion: 'expect(result).toBeDefined();',
-        });
-      }
-
-      if (param.type?.includes('number')) {
-        const paramsWithZero = fn.parameters
-          .map((p) => (p.name === param.name ? '0' : this.generateTestValue(p)))
-          .join(', ');
-        const zeroCall = fn.isAsync
-          ? `await ${fn.name}(${paramsWithZero})`
-          : `${fn.name}(${paramsWithZero})`;
-
-        testCases.push({
-          description: `should handle zero for ${param.name}`,
-          type: 'boundary',
-          action: `const result = ${zeroCall};`,
-          assertion: 'expect(result).toBeDefined();',
-        });
-
-        const paramsWithNegative = fn.parameters
-          .map((p) => (p.name === param.name ? '-1' : this.generateTestValue(p)))
-          .join(', ');
-        const negativeCall = fn.isAsync
-          ? `await ${fn.name}(${paramsWithNegative})`
-          : `${fn.name}(${paramsWithNegative})`;
-
-        testCases.push({
-          description: `should handle negative value for ${param.name}`,
-          type: 'edge-case',
-          action: `const result = ${negativeCall};`,
-          assertion: 'expect(result).toBeDefined();',
-        });
-      }
-
-      if (param.type?.includes('[]') || param.type?.includes('Array')) {
-        const paramsWithEmpty = fn.parameters
-          .map((p) => (p.name === param.name ? '[]' : this.generateTestValue(p)))
-          .join(', ');
-        const emptyCall = fn.isAsync
-          ? `await ${fn.name}(${paramsWithEmpty})`
-          : `${fn.name}(${paramsWithEmpty})`;
-
-        testCases.push({
-          description: `should handle empty array for ${param.name}`,
-          type: 'boundary',
-          action: `const result = ${emptyCall};`,
-          assertion: 'expect(result).toBeDefined();',
-        });
-      }
-    }
-
-    // Async rejection test
-    if (fn.isAsync) {
-      testCases.push({
-        description: 'should handle async rejection gracefully',
-        type: 'error-handling',
-        action: `// Mock or setup to cause rejection`,
-        assertion: `// await expect(${fn.name}(invalidParams)).rejects.toThrow();`,
-      });
-    }
-
-    return testCases;
-  }
-
-  /**
-   * Generate tests for a class
-   */
-  private generateClassTests(cls: ClassInfo, testType: string): string {
-    let code = `describe('${cls.name}', () => {\n`;
-    code += `  let instance: ${cls.name};\n\n`;
-
-    // Setup
-    if (cls.hasConstructor && cls.constructorParams) {
-      const constructorArgs = cls.constructorParams
-        .map((p) => this.generateTestValue(p))
-        .join(', ');
-      code += `  beforeEach(() => {\n`;
-      code += `    instance = new ${cls.name}(${constructorArgs});\n`;
-      code += `  });\n\n`;
-    } else {
-      code += `  beforeEach(() => {\n`;
-      code += `    instance = new ${cls.name}();\n`;
-      code += `  });\n\n`;
-    }
-
-    // Constructor test
-    code += `  it('should instantiate correctly', () => {\n`;
-    code += `    expect(instance).toBeInstanceOf(${cls.name});\n`;
-    code += `  });\n\n`;
-
-    // Generate tests for each public method
-    for (const method of cls.methods) {
-      if (!method.name.startsWith('_') && !method.name.startsWith('#')) {
-        code += this.generateMethodTests(method, cls.name, testType);
-      }
-    }
-
-    code += `});\n\n`;
-    return code;
-  }
-
-  /**
-   * Generate tests for a class method
-   */
-  private generateMethodTests(method: FunctionInfo, _className: string, _testType: string): string {
-    let code = `  describe('${method.name}', () => {\n`;
-
-    const validParams = method.parameters.map((p) => this.generateTestValue(p)).join(', ');
-    const methodCall = method.isAsync
-      ? `await instance.${method.name}(${validParams})`
-      : `instance.${method.name}(${validParams})`;
-
-    // Happy path
-    const asyncPrefix = method.isAsync ? 'async ' : '';
-    code += `    it('should execute successfully', ${asyncPrefix}() => {\n`;
-    code += `      const result = ${methodCall};\n`;
-    code += `      expect(result).toBeDefined();\n`;
-    code += `    });\n`;
-
-    // Error handling for non-optional params
-    for (const param of method.parameters) {
-      if (!param.optional) {
-        const paramsWithUndefined = method.parameters
-          .map((p) => (p.name === param.name ? 'undefined as any' : this.generateTestValue(p)))
-          .join(', ');
-
-        code += `\n    it('should handle invalid ${param.name}', () => {\n`;
-        code += `      expect(() => instance.${method.name}(${paramsWithUndefined})).toThrow();\n`;
-        code += `    });\n`;
-      }
-    }
-
-    code += `  });\n\n`;
-    return code;
-  }
-
-  /**
-   * Generate a test value for a parameter
-   */
-  private generateTestValue(param: ParameterInfo): string {
-    if (param.defaultValue) {
-      return param.defaultValue;
-    }
-
-    const type = param.type?.toLowerCase() || 'unknown';
-    const name = param.name.toLowerCase();
-
-    // Infer from param name first
-    if (name.includes('id')) return `'${faker.string.uuid()}'`;
-    if (name.includes('email')) return `'${faker.internet.email()}'`;
-    if (name.includes('name')) return `'${faker.person.fullName()}'`;
-    if (name.includes('url')) return `'${faker.internet.url()}'`;
-    if (name.includes('date')) return `new Date('${faker.date.recent().toISOString()}')`;
-
-    // Then by type
-    if (type.includes('string')) return `'${faker.lorem.word()}'`;
-    if (type.includes('number')) return String(faker.number.int({ min: 1, max: 100 }));
-    if (type.includes('boolean')) return 'true';
-    if (type.includes('[]') || type.includes('array')) return '[]';
-    if (type.includes('object') || type.includes('{')) return '{}';
-    if (type.includes('function')) return '() => {}';
-    if (type.includes('promise')) return 'Promise.resolve()';
-    if (type.includes('date')) return 'new Date()';
-
-    // Default
-    return `mock${param.name.charAt(0).toUpperCase() + param.name.slice(1)}`;
-  }
-
-  /**
-   * Generate real Mocha test code
-   */
-  private generateRealMochaTest(
-    moduleName: string,
-    importPath: string,
-    testType: string,
-    analysis: { functions: FunctionInfo[]; classes: ClassInfo[] },
-    patterns: Pattern[]
-  ): string {
-    const patternComment =
-      patterns.length > 0
-        ? `// Applied patterns: ${patterns.map((p) => p.name).join(', ')}\n`
-        : '';
-
-    const exports: string[] = [];
-    for (const fn of analysis.functions) {
-      if (fn.isExported) exports.push(fn.name);
-    }
-    for (const cls of analysis.classes) {
-      if (cls.isExported) exports.push(cls.name);
-    }
-
-    const importStatement =
-      exports.length > 0
-        ? `import { ${exports.join(', ')} } from '${importPath}';`
-        : `import * as ${moduleName} from '${importPath}';`;
-
-    let code = `${patternComment}import { expect } from 'chai';
-${importStatement}
-
-describe('${moduleName} - ${testType} tests', function() {
-`;
-
-    for (const fn of analysis.functions) {
-      code += this.generateMochaFunctionTests(fn);
-    }
-
-    for (const cls of analysis.classes) {
-      code += this.generateMochaClassTests(cls);
-    }
-
-    code += `});\n`;
-    return code;
-  }
-
-  /**
-   * Generate Mocha tests for a function
-   */
-  private generateMochaFunctionTests(fn: FunctionInfo): string {
-    const validParams = fn.parameters.map((p) => this.generateTestValue(p)).join(', ');
-    const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
-
-    let code = `  describe('${fn.name}', function() {\n`;
-    code += `    it('should handle valid input', ${fn.isAsync ? 'async ' : ''}function() {\n`;
-    code += `      const result = ${fnCall};\n`;
-    code += `      expect(result).to.not.be.undefined;\n`;
-    code += `    });\n`;
-    code += `  });\n\n`;
-
-    return code;
-  }
-
-  /**
-   * Generate Mocha tests for a class
-   */
-  private generateMochaClassTests(cls: ClassInfo): string {
-    const constructorArgs =
-      cls.constructorParams?.map((p) => this.generateTestValue(p)).join(', ') || '';
-
-    let code = `  describe('${cls.name}', function() {\n`;
-    code += `    let instance;\n\n`;
-    code += `    beforeEach(function() {\n`;
-    code += `      instance = new ${cls.name}(${constructorArgs});\n`;
-    code += `    });\n\n`;
-    code += `    it('should instantiate correctly', function() {\n`;
-    code += `      expect(instance).to.be.instanceOf(${cls.name});\n`;
-    code += `    });\n`;
-
-    for (const method of cls.methods) {
-      if (!method.name.startsWith('_')) {
-        const methodParams = method.parameters.map((p) => this.generateTestValue(p)).join(', ');
-        code += `\n    it('${method.name} should work', ${method.isAsync ? 'async ' : ''}function() {\n`;
-        code += `      const result = ${method.isAsync ? 'await ' : ''}instance.${method.name}(${methodParams});\n`;
-        code += `      expect(result).to.not.be.undefined;\n`;
-        code += `    });\n`;
-      }
-    }
-
-    code += `  });\n\n`;
-    return code;
-  }
-
-  /**
-   * Generate real Pytest test code
-   */
-  private generateRealPytestTest(
-    moduleName: string,
-    importPath: string,
-    testType: string,
-    analysis: { functions: FunctionInfo[]; classes: ClassInfo[] },
-    patterns: Pattern[]
-  ): string {
-    const patternComment =
-      patterns.length > 0
-        ? `# Applied patterns: ${patterns.map((p) => p.name).join(', ')}\n`
-        : '';
-
-    const exports: string[] = [];
-    for (const fn of analysis.functions) {
-      if (fn.isExported) exports.push(fn.name);
-    }
-    for (const cls of analysis.classes) {
-      if (cls.isExported) exports.push(cls.name);
-    }
-
-    const pythonImport = importPath.replace(/\//g, '.').replace(/\.(ts|js)$/, '');
-    const importStatement =
-      exports.length > 0
-        ? `from ${pythonImport} import ${exports.join(', ')}`
-        : `import ${pythonImport} as ${moduleName}`;
-
-    let code = `${patternComment}import pytest
-${importStatement}
-
-
-class Test${moduleName.charAt(0).toUpperCase() + moduleName.slice(1)}:
-    """${testType} tests for ${moduleName}"""
-
-`;
-
-    for (const fn of analysis.functions) {
-      code += this.generatePytestFunctionTests(fn);
-    }
-
-    for (const cls of analysis.classes) {
-      code += this.generatePytestClassTests(cls);
-    }
-
-    return code;
-  }
-
-  /**
-   * Generate Pytest tests for a function
-   */
-  private generatePytestFunctionTests(fn: FunctionInfo): string {
-    const validParams = fn.parameters.map((p) => this.generatePythonTestValue(p)).join(', ');
-
-    let code = `    def test_${fn.name}_valid_input(self):\n`;
-    code += `        """Test ${fn.name} with valid input"""\n`;
-    code += `        result = ${fn.name}(${validParams})\n`;
-    code += `        assert result is not None\n\n`;
-
-    return code;
-  }
-
-  /**
-   * Generate Pytest tests for a class
-   */
-  private generatePytestClassTests(cls: ClassInfo): string {
-    const constructorArgs =
-      cls.constructorParams?.map((p) => this.generatePythonTestValue(p)).join(', ') || '';
-
-    let code = `\nclass Test${cls.name}:\n`;
-    code += `    """Tests for ${cls.name}"""\n\n`;
-    code += `    @pytest.fixture\n`;
-    code += `    def instance(self):\n`;
-    code += `        return ${cls.name}(${constructorArgs})\n\n`;
-    code += `    def test_instantiation(self, instance):\n`;
-    code += `        assert isinstance(instance, ${cls.name})\n\n`;
-
-    for (const method of cls.methods) {
-      if (!method.name.startsWith('_')) {
-        const methodParams = method.parameters.map((p) => this.generatePythonTestValue(p)).join(', ');
-        code += `    def test_${method.name}(self, instance):\n`;
-        code += `        result = instance.${method.name}(${methodParams})\n`;
-        code += `        assert result is not None\n\n`;
-      }
-    }
-
-    return code;
-  }
-
-  /**
-   * Generate a Python test value for a parameter
-   */
-  private generatePythonTestValue(param: ParameterInfo): string {
-    const type = param.type?.toLowerCase() || 'unknown';
-    const name = param.name.toLowerCase();
-
-    if (name.includes('id')) return `"${faker.string.uuid()}"`;
-    if (name.includes('name')) return `"${faker.person.fullName()}"`;
-    if (name.includes('email')) return `"${faker.internet.email()}"`;
-
-    if (type.includes('str')) return `"${faker.lorem.word()}"`;
-    if (type.includes('int') || type.includes('number')) {
-      return String(faker.number.int({ min: 1, max: 100 }));
-    }
-    if (type.includes('bool')) return 'True';
-    if (type.includes('list') || type.includes('[]')) return '[]';
-    if (type.includes('dict') || type.includes('{}')) return '{}';
-
-    return 'None';
-  }
-
-  private async findApplicablePatterns(
-    sourceFile: string,
-    requestedPatterns: string[]
-  ): Promise<Pattern[]> {
-    const patterns: Pattern[] = [];
-
-    // Check memory for stored patterns
-    for (const patternName of requestedPatterns) {
-      const stored = await this.memory.get<Pattern>(`pattern:${patternName}`);
-      if (stored) {
-        patterns.push(stored);
-      }
-    }
-
-    // Also search for patterns by file type
-    const extension = sourceFile.split('.').pop() || '';
-    const searchResults = await this.memory.search(`pattern:*:${extension}`, 5);
-    for (const key of searchResults) {
-      const pattern = await this.memory.get<Pattern>(key);
-      if (pattern && !patterns.some((p) => p.id === pattern.id)) {
-        patterns.push(pattern);
-      }
-    }
-
-    return patterns;
-  }
-
-  private generateStubTestCode(
-    sourceFile: string,
-    testType: 'unit' | 'integration' | 'e2e',
-    framework: string,
-    patterns: Pattern[]
-  ): string {
-    const moduleName = this.extractModuleName(sourceFile);
-    const importPath = this.getImportPath(sourceFile);
-
-    // Generate framework-specific test template
-    switch (framework) {
-      case 'jest':
-      case 'vitest':
-        return this.generateJestVitestTest(moduleName, importPath, testType, patterns);
-      case 'mocha':
-        return this.generateMochaTest(moduleName, importPath, testType, patterns);
-      case 'pytest':
-        return this.generatePytestTest(moduleName, importPath, testType, patterns);
-      default:
-        return this.generateJestVitestTest(moduleName, importPath, testType, patterns);
-    }
-  }
-
-  private generateJestVitestTest(
-    moduleName: string,
-    importPath: string,
-    testType: string,
-    patterns: Pattern[]
-  ): string {
-    const patternComment =
-      patterns.length > 0
-        ? `// Applied patterns: ${patterns.map((p) => p.name).join(', ')}\n`
-        : '';
-
-    // Generate pattern-aware test implementations
-    const basicOpsTest = this.generateBasicOpsTest(moduleName, patterns);
-    const edgeCaseTest = this.generateEdgeCaseTest(moduleName, patterns);
-    const errorHandlingTest = this.generateErrorHandlingTest(moduleName, patterns);
-
-    return `${patternComment}import { ${moduleName} } from '${importPath}';
-
-describe('${moduleName}', () => {
-  describe('${testType} tests', () => {
-    it('should be defined', () => {
-      expect(${moduleName}).toBeDefined();
-    });
-
-${basicOpsTest}
-${edgeCaseTest}
-${errorHandlingTest}
-  });
-});
-`;
-  }
-
-  /**
-   * Generate basic operations test based on patterns
-   */
-  private generateBasicOpsTest(moduleName: string, patterns: Pattern[]): string {
-    // Check for service pattern
-    const isService = patterns.some((p) =>
-      p.name.toLowerCase().includes('service') || p.name.toLowerCase().includes('repository')
-    );
-
-    // Check for factory pattern
-    const isFactory = patterns.some((p) => p.name.toLowerCase().includes('factory'));
-
-    // Check for async patterns
-    const hasAsyncPattern = patterns.some((p) =>
-      p.name.toLowerCase().includes('async') || p.name.toLowerCase().includes('promise')
-    );
-
-    if (isService) {
-      return `    it('should handle basic operations', async () => {
-      // Service pattern: test core functionality
-      const instance = new ${moduleName}();
-      expect(instance).toBeInstanceOf(${moduleName});
-
-      // Verify service is properly initialized
-      const methods = Object.getOwnPropertyNames(Object.getPrototypeOf(instance))
-        .filter(m => m !== 'constructor');
-      expect(methods.length).toBeGreaterThan(0);
-    });`;
-    }
-
-    if (isFactory) {
-      return `    it('should handle basic operations', () => {
-      // Factory pattern: test object creation
-      const result = ${moduleName}.create ? ${moduleName}.create() : new ${moduleName}();
-      expect(result).toBeDefined();
-      expect(typeof result).not.toBe('undefined');
-    });`;
-    }
-
-    if (hasAsyncPattern) {
-      return `    it('should handle basic operations', async () => {
-      // Async pattern: test promise resolution
-      const instance = typeof ${moduleName} === 'function'
-        ? new ${moduleName}()
-        : ${moduleName};
-
-      // Verify async methods resolve properly
-      if (typeof instance.execute === 'function') {
-        await expect(instance.execute()).resolves.toBeDefined();
-      }
-    });`;
-    }
-
-    // Default implementation
-    return `    it('should handle basic operations', () => {
-      // Verify module exports expected interface
-      const moduleType = typeof ${moduleName};
-      expect(['function', 'object']).toContain(moduleType);
-
-      if (moduleType === 'function') {
-        // Class or function: verify instantiation
-        const instance = new ${moduleName}();
-        expect(instance).toBeDefined();
-      } else {
-        // Object module: verify properties exist
-        expect(Object.keys(${moduleName}).length).toBeGreaterThan(0);
-      }
-    });`;
-  }
-
-  /**
-   * Generate edge case test based on patterns
-   */
-  private generateEdgeCaseTest(moduleName: string, patterns: Pattern[]): string {
-    const hasValidation = patterns.some((p) =>
-      p.name.toLowerCase().includes('validation') || p.name.toLowerCase().includes('validator')
-    );
-
-    const hasCollection = patterns.some((p) =>
-      p.name.toLowerCase().includes('collection') || p.name.toLowerCase().includes('list')
-    );
-
-    if (hasValidation) {
-      return `    it('should handle edge cases', () => {
-      // Validation pattern: test boundary conditions
-      const instance = new ${moduleName}();
-
-      // Test with empty values
-      if (typeof instance.validate === 'function') {
-        expect(() => instance.validate('')).toBeDefined();
-        expect(() => instance.validate(null)).toBeDefined();
-      }
-    });`;
-    }
-
-    if (hasCollection) {
-      return `    it('should handle edge cases', () => {
-      // Collection pattern: test empty and large datasets
-      const instance = new ${moduleName}();
-
-      // Empty collection should be handled gracefully
-      if (typeof instance.add === 'function') {
-        expect(() => instance.add(undefined)).toBeDefined();
-      }
-      if (typeof instance.get === 'function') {
-        expect(instance.get('nonexistent')).toBeUndefined();
-      }
-    });`;
-    }
-
-    // Default edge case test
-    return `    it('should handle edge cases', () => {
-      // Test null/undefined handling
-      const instance = typeof ${moduleName} === 'function'
-        ? new ${moduleName}()
-        : ${moduleName};
-
-      // Module should handle edge case inputs gracefully
-      expect(instance).toBeDefined();
-      expect(() => JSON.stringify(instance)).not.toThrow();
-    });`;
-  }
-
-  /**
-   * Generate error handling test based on patterns
-   */
-  private generateErrorHandlingTest(moduleName: string, patterns: Pattern[]): string {
-    const hasErrorPattern = patterns.some((p) =>
-      p.name.toLowerCase().includes('error') || p.name.toLowerCase().includes('exception')
-    );
-
-    const hasAsyncPattern = patterns.some((p) =>
-      p.name.toLowerCase().includes('async') || p.name.toLowerCase().includes('promise')
-    );
-
-    if (hasAsyncPattern) {
-      return `    it('should handle error conditions', async () => {
-      // Async error handling: verify rejections are caught
-      const instance = typeof ${moduleName} === 'function'
-        ? new ${moduleName}()
-        : ${moduleName};
-
-      // Async operations should reject gracefully on invalid input
-      const asyncMethods = Object.getOwnPropertyNames(Object.getPrototypeOf(instance) || {})
-        .filter(m => m !== 'constructor');
-
-      // At minimum, module should be stable
-      expect(instance).toBeDefined();
-    });`;
-    }
-
-    if (hasErrorPattern) {
-      return `    it('should handle error conditions', () => {
-      // Error pattern: verify custom error types
-      try {
-        const instance = new ${moduleName}();
-        // Trigger error condition if possible
-        if (typeof instance.throwError === 'function') {
-          expect(() => instance.throwError()).toThrow();
-        }
-      } catch (error) {
-        expect(error).toBeInstanceOf(Error);
-      }
-    });`;
-    }
-
-    // Default error handling test
-    return `    it('should handle error conditions', () => {
-      // Verify error resilience
-      expect(() => {
-        const instance = typeof ${moduleName} === 'function'
-          ? new ${moduleName}()
-          : ${moduleName};
-        return instance;
-      }).not.toThrow();
-
-      // Module should not throw on inspection
-      expect(() => Object.keys(${moduleName})).not.toThrow();
-    });`;
-  }
-
-  private generateMochaTest(
-    moduleName: string,
-    importPath: string,
-    testType: string,
-    patterns: Pattern[]
-  ): string {
-    const patternComment =
-      patterns.length > 0
-        ? `// Applied patterns: ${patterns.map((p) => p.name).join(', ')}\n`
-        : '';
-
-    // Determine if async tests needed based on patterns
-    const isAsync = patterns.some((p) =>
-      p.name.toLowerCase().includes('async') || p.name.toLowerCase().includes('promise')
-    );
-    const asyncSetup = isAsync ? 'async ' : '';
-
-    return `${patternComment}import { expect } from 'chai';
-import { ${moduleName} } from '${importPath}';
-
-describe('${moduleName}', function() {
-  describe('${testType} tests', function() {
-    it('should be defined', function() {
-      expect(${moduleName}).to.not.be.undefined;
-    });
-
-    it('should handle basic operations', ${asyncSetup}function() {
-      // Verify module exports expected interface
-      const moduleType = typeof ${moduleName};
-      expect(['function', 'object']).to.include(moduleType);
-
-      if (moduleType === 'function') {
-        const instance = new ${moduleName}();
-        expect(instance).to.exist;
-      } else {
-        expect(Object.keys(${moduleName})).to.have.length.greaterThan(0);
-      }
-    });
-
-    it('should handle edge cases', function() {
-      // Verify resilience to edge inputs
-      const instance = typeof ${moduleName} === 'function'
-        ? new ${moduleName}()
-        : ${moduleName};
-      expect(instance).to.exist;
-      expect(() => JSON.stringify(instance)).to.not.throw();
-    });
-
-    it('should handle error conditions', function() {
-      // Verify error resilience
-      expect(() => {
-        const instance = typeof ${moduleName} === 'function'
-          ? new ${moduleName}()
-          : ${moduleName};
-        return instance;
-      }).to.not.throw();
-    });
-  });
-});
-`;
-  }
-
-  private generatePytestTest(
-    moduleName: string,
-    importPath: string,
-    testType: string,
-    patterns: Pattern[]
-  ): string {
-    const patternComment =
-      patterns.length > 0
-        ? `# Applied patterns: ${patterns.map((p) => p.name).join(', ')}\n`
-        : '';
-
-    // Determine if async tests needed based on patterns
-    const isAsync = patterns.some((p) =>
-      p.name.toLowerCase().includes('async') || p.name.toLowerCase().includes('promise')
-    );
-    const asyncDecorator = isAsync ? '@pytest.mark.asyncio\n    ' : '';
-    const asyncDef = isAsync ? 'async def' : 'def';
-
-    return `${patternComment}import pytest
-from ${importPath} import ${moduleName}
-
-
-class Test${moduleName}:
-    """${testType} tests for ${moduleName}"""
-
-    def test_is_defined(self):
-        """Verify the module is properly exported and defined."""
-        assert ${moduleName} is not None
-
-    ${asyncDecorator}${asyncDef} test_basic_operations(self):
-        """Test core functionality with valid inputs."""
-        # Verify module can be instantiated or accessed
-        if callable(${moduleName}):
-            instance = ${moduleName}()
-            assert instance is not None
-        else:
-            assert len(dir(${moduleName})) > 0
-
-    def test_edge_cases(self):
-        """Test handling of edge case inputs."""
-        # Verify module handles edge cases gracefully
-        instance = ${moduleName}() if callable(${moduleName}) else ${moduleName}
-        assert instance is not None
-        # Module should be serializable
-        import json
-        try:
-            json.dumps(str(instance))
-        except (TypeError, ValueError):
-            pass  # Complex objects may not serialize, but shouldn't crash
-
-    def test_error_conditions(self):
-        """Test error handling and recovery."""
-        # Module instantiation should not raise unexpected errors
-        try:
-            instance = ${moduleName}() if callable(${moduleName}) else ${moduleName}
-            assert instance is not None
-        except TypeError:
-            # Expected if constructor requires arguments
-            pass
-`;
-  }
-
-  private async generateRedPhaseTest(
-    feature: string,
-    behavior: string,
-    _framework: string
-  ): Promise<TDDResult> {
-    // Generate TDD RED phase: failing test that defines expected behavior
-    const funcName = this.camelCase(feature);
-    const assertions = this.generateAssertionsFromBehavior(behavior, funcName);
-
-    const testCode = `describe('${feature}', () => {
-  it('${behavior}', () => {
-    // Red phase: This test should fail initially
-${assertions}
-  });
-});`;
-
-    return {
-      phase: 'red',
-      testCode,
-      nextStep: 'Write the minimal implementation to make this test pass',
-    };
-  }
-
-  /**
-   * Generate specific assertions from behavior description
-   * Uses NLP-style extraction to infer test values and assertions
-   */
-  private generateAssertionsFromBehavior(behavior: string, funcName: string): string {
-    const behaviorLower = behavior.toLowerCase();
-    const assertions: string[] = [];
-
-    // Extract context from behavior description
-    const context = this.extractBehaviorContext(behavior);
-
-    // Build function call with appropriate arguments
-    const funcCall = this.buildFunctionCall(funcName, context, behaviorLower);
-
-    // Add setup if needed
-    if (context.setupCode) {
-      assertions.push(context.setupCode);
-    }
-
-    // Generate assertions based on expected outcome
-    if (behaviorLower.includes('return') && behaviorLower.includes('true')) {
-      assertions.push(`    const result = ${funcCall};`);
-      assertions.push(`    expect(result).toBe(true);`);
-    } else if (behaviorLower.includes('return') && behaviorLower.includes('false')) {
-      assertions.push(`    const result = ${funcCall};`);
-      assertions.push(`    expect(result).toBe(false);`);
-    } else if (behaviorLower.includes('throw') || behaviorLower.includes('error')) {
-      const errorMsg = context.extractedString || 'Error';
-      assertions.push(`    expect(() => ${funcCall}).toThrow(${context.extractedString ? `'${errorMsg}'` : ''});`);
-    } else if (behaviorLower.includes('empty') || behaviorLower.includes('nothing')) {
-      assertions.push(`    const result = ${funcCall};`);
-      if (behaviorLower.includes('string')) {
-        assertions.push(`    expect(result).toBe('');`);
-      } else if (behaviorLower.includes('object')) {
-        assertions.push(`    expect(result).toEqual({});`);
-      } else {
-        assertions.push(`    expect(result).toEqual([]);`);
-      }
-    } else if (behaviorLower.includes('null')) {
-      assertions.push(`    const result = ${funcCall};`);
-      assertions.push(`    expect(result).toBeNull();`);
-    } else if (behaviorLower.includes('undefined')) {
-      assertions.push(`    const result = ${funcCall};`);
-      assertions.push(`    expect(result).toBeUndefined();`);
-    } else if (behaviorLower.includes('contain') || behaviorLower.includes('include')) {
-      assertions.push(`    const result = ${funcCall};`);
-      const expectedValue = context.extractedString || context.extractedNumber?.toString() || 'expectedItem';
-      if (context.extractedString) {
-        assertions.push(`    expect(result).toContain('${expectedValue}');`);
-      } else if (context.extractedNumber !== undefined) {
-        assertions.push(`    expect(result).toContain(${expectedValue});`);
-      } else {
-        assertions.push(`    expect(result).toContain(testInput); // Contains the input`);
-      }
-    } else if (behaviorLower.includes('length') || behaviorLower.includes('count')) {
-      assertions.push(`    const result = ${funcCall};`);
-      const expectedLength = context.extractedNumber ?? 3;
-      assertions.push(`    expect(result).toHaveLength(${expectedLength});`);
-    } else if (behaviorLower.includes('equal') || behaviorLower.includes('match')) {
-      assertions.push(`    const result = ${funcCall};`);
-      if (context.extractedString) {
-        assertions.push(`    expect(result).toEqual('${context.extractedString}');`);
-      } else if (context.extractedNumber !== undefined) {
-        assertions.push(`    expect(result).toEqual(${context.extractedNumber});`);
-      } else {
-        assertions.push(`    expect(result).toEqual(expectedOutput);`);
-      }
-    } else if (behaviorLower.includes('greater') || behaviorLower.includes('more than')) {
-      assertions.push(`    const result = ${funcCall};`);
-      const threshold = context.extractedNumber ?? 0;
-      assertions.push(`    expect(result).toBeGreaterThan(${threshold});`);
-    } else if (behaviorLower.includes('less') || behaviorLower.includes('fewer')) {
-      assertions.push(`    const result = ${funcCall};`);
-      const threshold = context.extractedNumber ?? 100;
-      assertions.push(`    expect(result).toBeLessThan(${threshold});`);
-    } else if (behaviorLower.includes('valid') || behaviorLower.includes('success')) {
-      assertions.push(`    const result = ${funcCall};`);
-      assertions.push(`    expect(result).toBeDefined();`);
-      if (behaviorLower.includes('object') || behaviorLower.includes('response')) {
-        assertions.push(`    expect(result.success ?? result.valid ?? result.ok).toBeTruthy();`);
-      } else {
-        assertions.push(`    expect(result).toBeTruthy();`);
-      }
-    } else if (behaviorLower.includes('array') || behaviorLower.includes('list')) {
-      assertions.push(`    const result = ${funcCall};`);
-      assertions.push(`    expect(Array.isArray(result)).toBe(true);`);
-      if (context.extractedNumber !== undefined) {
-        assertions.push(`    expect(result.length).toBeGreaterThanOrEqual(${context.extractedNumber});`);
-      }
-    } else if (behaviorLower.includes('object')) {
-      assertions.push(`    const result = ${funcCall};`);
-      assertions.push(`    expect(typeof result).toBe('object');`);
-      assertions.push(`    expect(result).not.toBeNull();`);
-    } else if (behaviorLower.includes('string')) {
-      assertions.push(`    const result = ${funcCall};`);
-      assertions.push(`    expect(typeof result).toBe('string');`);
-      if (context.extractedString) {
-        assertions.push(`    expect(result).toContain('${context.extractedString}');`);
-      }
-    } else if (behaviorLower.includes('number')) {
-      assertions.push(`    const result = ${funcCall};`);
-      assertions.push(`    expect(typeof result).toBe('number');`);
-      assertions.push(`    expect(Number.isNaN(result)).toBe(false);`);
-    } else {
-      // Default: check it's defined
-      assertions.push(`    const result = ${funcCall};`);
-      assertions.push(`    expect(result).toBeDefined();`);
-    }
-
-    return assertions.join('\n');
-  }
-
-  /**
-   * Extract contextual information from behavior description
-   */
-  private extractBehaviorContext(behavior: string): {
-    extractedString?: string;
-    extractedNumber?: number;
-    inputType?: string;
-    setupCode?: string;
-  } {
-    const context: {
-      extractedString?: string;
-      extractedNumber?: number;
-      inputType?: string;
-      setupCode?: string;
-    } = {};
-
-    // Extract quoted strings from behavior
-    const stringMatch = behavior.match(/["']([^"']+)["']/);
-    if (stringMatch) {
-      context.extractedString = stringMatch[1];
-    }
-
-    // Extract numbers from behavior
-    const numberMatch = behavior.match(/\b(\d+)\b/);
-    if (numberMatch) {
-      context.extractedNumber = parseInt(numberMatch[1], 10);
-    }
-
-    // Detect input type
-    if (/\b(email|e-mail)\b/i.test(behavior)) {
-      context.inputType = 'email';
-      context.setupCode = `    const testInput = 'test@example.com';`;
-    } else if (/\b(url|link|href)\b/i.test(behavior)) {
-      context.inputType = 'url';
-      context.setupCode = `    const testInput = 'https://example.com';`;
-    } else if (/\b(date|time|timestamp)\b/i.test(behavior)) {
-      context.inputType = 'date';
-      context.setupCode = `    const testInput = new Date('2024-01-15');`;
-    } else if (/\b(id|uuid|identifier)\b/i.test(behavior)) {
-      context.inputType = 'id';
-      context.setupCode = `    const testInput = 'abc-123-def';`;
-    } else if (/\b(user|person|customer)\b/i.test(behavior)) {
-      context.inputType = 'user';
-      context.setupCode = `    const testInput = { id: '1', name: 'Test User', email: 'test@example.com' };`;
-    } else if (/\b(config|options|settings)\b/i.test(behavior)) {
-      context.inputType = 'config';
-      context.setupCode = `    const testInput = { enabled: true, timeout: 5000 };`;
-    }
-
-    return context;
-  }
-
-  /**
-   * Build function call with appropriate arguments based on context
-   */
-  private buildFunctionCall(
-    funcName: string,
-    context: { inputType?: string; extractedString?: string; extractedNumber?: number },
-    behaviorLower: string
-  ): string {
-    // If context has setup code, use testInput variable
-    if (context.inputType) {
-      return `${funcName}(testInput)`;
-    }
-
-    // No input needed
-    if (!behaviorLower.includes('with') && !behaviorLower.includes('given') && !behaviorLower.includes('for')) {
-      return `${funcName}()`;
-    }
-
-    // Infer input type from behavior
-    if (behaviorLower.includes('string') || behaviorLower.includes('text') || behaviorLower.includes('name')) {
-      const value = context.extractedString || 'test input';
-      return `${funcName}('${value}')`;
-    }
-    if (behaviorLower.includes('number') || behaviorLower.includes('count') || behaviorLower.includes('amount')) {
-      const value = context.extractedNumber ?? 42;
-      return `${funcName}(${value})`;
-    }
-    if (behaviorLower.includes('array') || behaviorLower.includes('list') || behaviorLower.includes('items')) {
-      return `${funcName}([1, 2, 3])`;
-    }
-    if (behaviorLower.includes('object') || behaviorLower.includes('data') || behaviorLower.includes('payload')) {
-      return `${funcName}({ key: 'value' })`;
-    }
-    if (behaviorLower.includes('boolean') || behaviorLower.includes('flag')) {
-      return `${funcName}(true)`;
-    }
-
-    // Default: use extracted value or generic input
-    if (context.extractedString) {
-      return `${funcName}('${context.extractedString}')`;
-    }
-    if (context.extractedNumber !== undefined) {
-      return `${funcName}(${context.extractedNumber})`;
-    }
-
-    return `${funcName}(input)`;
-  }
-
-  private async generateGreenPhaseCode(
-    feature: string,
-    behavior: string,
-    _framework: string
-  ): Promise<TDDResult> {
-    // Generate TDD GREEN phase: minimal implementation to pass the test
-    // Analyze the behavior description to generate appropriate implementation
-    const behaviorLower = behavior.toLowerCase();
-    const funcName = this.camelCase(feature);
-
-    // Infer return type and implementation from behavior
-    const { returnType, implementation, params } = this.inferImplementationFromBehavior(behaviorLower);
-
-    const implementationCode = `/**
- * ${feature}
- * Behavior: ${behavior}
- */
-export function ${funcName}(${params}): ${returnType} {
-${implementation}
-}`;
-
-    return {
-      phase: 'green',
-      implementationCode,
-      nextStep: 'Refactor the code while keeping tests green',
-    };
-  }
-
-  /**
-   * Infer implementation details from behavior description using heuristics
-   * Analyzes the behavior text to determine return type, parameters, and minimal implementation
-   */
-  private inferImplementationFromBehavior(behavior: string): {
-    returnType: string;
-    implementation: string;
-    params: string;
-  } {
-    // Default values
-    let returnType = 'unknown';
-    let implementation = '  return undefined;';
-    let params = '';
-
-    // Detect return type from behavior description
-    if (behavior.includes('return') || behavior.includes('returns')) {
-      if (behavior.includes('boolean') || behavior.includes('true') || behavior.includes('false') ||
-          behavior.includes('valid') || behavior.includes('is ') || behavior.includes('has ') ||
-          behavior.includes('can ') || behavior.includes('should ')) {
-        returnType = 'boolean';
-        implementation = '  // Validate and return boolean result\n  return true;';
-      } else if (behavior.includes('number') || behavior.includes('count') || behavior.includes('sum') ||
-                 behavior.includes('total') || behavior.includes('calculate') || behavior.includes('average')) {
-        returnType = 'number';
-        implementation = '  // Perform calculation and return result\n  return 0;';
-      } else if (behavior.includes('string') || behavior.includes('text') || behavior.includes('message') ||
-                 behavior.includes('name') || behavior.includes('format')) {
-        returnType = 'string';
-        implementation = "  // Process and return string result\n  return '';";
-      } else if (behavior.includes('array') || behavior.includes('list') || behavior.includes('items') ||
-                 behavior.includes('collection') || behavior.includes('filter') || behavior.includes('map')) {
-        returnType = 'unknown[]';
-        implementation = '  // Process and return array\n  return [];';
-      } else if (behavior.includes('object') || behavior.includes('data') || behavior.includes('result') ||
-                 behavior.includes('response')) {
-        returnType = 'Record<string, unknown>';
-        implementation = '  // Build and return object\n  return {};';
-      }
-    }
-
-    // Detect if async is needed
-    if (behavior.includes('async') || behavior.includes('await') || behavior.includes('promise') ||
-        behavior.includes('fetch') || behavior.includes('load') || behavior.includes('save') ||
-        behavior.includes('api') || behavior.includes('request')) {
-      returnType = `Promise<${returnType}>`;
-      implementation = implementation.replace('return ', 'return await Promise.resolve(').replace(';', ');');
-    }
-
-    // Detect parameters from behavior
-    const paramPatterns: Array<{ pattern: RegExp; param: string }> = [
-      { pattern: /(?:with|given|for|using)\s+(?:a\s+)?(?:string|text|name)/i, param: 'input: string' },
-      { pattern: /(?:with|given|for|using)\s+(?:a\s+)?(?:number|count|amount)/i, param: 'value: number' },
-      { pattern: /(?:with|given|for|using)\s+(?:an?\s+)?(?:array|list|items)/i, param: 'items: unknown[]' },
-      { pattern: /(?:with|given|for|using)\s+(?:an?\s+)?(?:object|data)/i, param: 'data: Record<string, unknown>' },
-      { pattern: /(?:with|given|for|using)\s+(?:an?\s+)?id/i, param: 'id: string' },
-      { pattern: /(?:with|given|for|using)\s+(?:valid|invalid)\s+input/i, param: 'input: unknown' },
-      { pattern: /(?:when|if)\s+(?:called\s+)?(?:with|without)/i, param: 'input?: unknown' },
-    ];
-
-    const detectedParams: string[] = [];
-    for (const { pattern, param } of paramPatterns) {
-      if (pattern.test(behavior) && !detectedParams.includes(param)) {
-        detectedParams.push(param);
-      }
-    }
-    params = detectedParams.join(', ');
-
-    // Detect validation logic from behavior
-    if (behavior.includes('validate') || behavior.includes('check') || behavior.includes('verify')) {
-      if (params.includes('input')) {
-        implementation = `  // Validate the input
-  if (input === undefined || input === null) {
-    throw new Error('Invalid input');
-  }
-${implementation}`;
-      }
-    }
-
-    // Detect error throwing from behavior
-    if (behavior.includes('throw') || behavior.includes('error') || behavior.includes('exception') ||
-        behavior.includes('invalid') || behavior.includes('fail')) {
-      if (behavior.includes('when') || behavior.includes('if')) {
-        implementation = `  // Check for error conditions
-  if (!input) {
-    throw new Error('Validation failed');
-  }
-${implementation}`;
-      }
-    }
-
-    return { returnType, implementation, params };
-  }
-
-  private async generateRefactoringSuggestions(
-    _feature: string,
-    _behavior: string
-  ): Promise<TDDResult> {
-    return {
-      phase: 'refactor',
-      refactoringChanges: [
-        'Extract common logic into helper functions',
-        'Apply single responsibility principle',
-        'Consider adding type safety improvements',
-        'Review naming conventions',
-        'Optimize performance if needed',
-      ],
-      nextStep: 'Apply refactoring changes and ensure all tests still pass',
-    };
-  }
-
-  private generatePropertyTestCode(
-    funcName: string,
-    property: string,
-    constraints: Record<string, unknown>
-  ): string {
-    // Analyze property description to generate appropriate generators and assertions
-    const propertyLower = property.toLowerCase();
-    const { generators, assertion, setupCode } = this.analyzePropertyForTestGeneration(
-      propertyLower,
-      funcName,
-      constraints
-    );
-
-    return `import * as fc from 'fast-check';
-
-describe('${funcName} property tests', () => {
-  it('${property}', () => {
-${setupCode}
-    fc.assert(
-      fc.property(${generators.join(', ')}, (${this.generatePropertyParams(generators)}) => {
-        const result = ${funcName}(${this.generatePropertyArgs(generators)});
-        ${assertion}
-      })
-    );
-  });
-});`;
-  }
-
-  /**
-   * Analyze property description to determine generators and assertions
-   */
-  private analyzePropertyForTestGeneration(
-    propertyLower: string,
-    funcName: string,
-    constraints: Record<string, unknown>
-  ): { generators: string[]; assertion: string; setupCode: string } {
-    const generators: string[] = [];
-    let assertion = 'return result !== undefined;';
-    let setupCode = '';
-
-    // Idempotent property: f(f(x)) === f(x)
-    if (propertyLower.includes('idempotent') || propertyLower.includes('same result')) {
-      generators.push(this.inferGeneratorFromConstraints(constraints, 'input'));
-      assertion = `// Idempotent: applying twice gives same result
-        const firstResult = ${funcName}(input);
-        const secondResult = ${funcName}(firstResult);
-        return JSON.stringify(firstResult) === JSON.stringify(secondResult);`;
-    }
-    // Commutative property: f(a, b) === f(b, a)
-    else if (propertyLower.includes('commutative') || propertyLower.includes('order independent')) {
-      const gen = this.inferGeneratorFromConstraints(constraints, 'value');
-      generators.push(gen, gen);
-      assertion = `// Commutative: order doesn't matter
-        const result1 = ${funcName}(a, b);
-        const result2 = ${funcName}(b, a);
-        return JSON.stringify(result1) === JSON.stringify(result2);`;
-    }
-    // Associative property: f(f(a, b), c) === f(a, f(b, c))
-    else if (propertyLower.includes('associative')) {
-      const gen = this.inferGeneratorFromConstraints(constraints, 'value');
-      generators.push(gen, gen, gen);
-      assertion = `// Associative: grouping doesn't matter
-        const left = ${funcName}(${funcName}(a, b), c);
-        const right = ${funcName}(a, ${funcName}(b, c));
-        return JSON.stringify(left) === JSON.stringify(right);`;
-    }
-    // Identity property: f(x, identity) === x
-    else if (propertyLower.includes('identity') || propertyLower.includes('neutral element')) {
-      generators.push(this.inferGeneratorFromConstraints(constraints, 'input'));
-      const identity = constraints.identity !== undefined ? String(constraints.identity) : '0';
-      setupCode = `    const identity = ${identity};`;
-      assertion = `// Identity: operation with identity returns original
-        const result = ${funcName}(input, identity);
-        return JSON.stringify(result) === JSON.stringify(input);`;
-    }
-    // Inverse property: f(f(x)) === x (e.g., encode/decode)
-    else if (propertyLower.includes('inverse') || propertyLower.includes('reversible') ||
-             propertyLower.includes('round-trip') || propertyLower.includes('encode') ||
-             propertyLower.includes('decode')) {
-      generators.push(this.inferGeneratorFromConstraints(constraints, 'input'));
-      const inverseFn = constraints.inverse as string || `${funcName}Inverse`;
-      assertion = `// Inverse: applying function and its inverse returns original
-        const encoded = ${funcName}(input);
-        const decoded = ${inverseFn}(encoded);
-        return JSON.stringify(decoded) === JSON.stringify(input);`;
-    }
-    // Distributive property: f(a, b + c) === f(a, b) + f(a, c)
-    else if (propertyLower.includes('distributive')) {
-      const gen = this.inferGeneratorFromConstraints(constraints, 'number');
-      generators.push(gen, gen, gen);
-      assertion = `// Distributive: f(a, b + c) === f(a, b) + f(a, c)
-        const left = ${funcName}(a, b + c);
-        const right = ${funcName}(a, b) + ${funcName}(a, c);
-        return Math.abs(left - right) < 0.0001;`;
-    }
-    // Monotonic property: a <= b implies f(a) <= f(b)
-    else if (propertyLower.includes('monotonic') || propertyLower.includes('preserves order') ||
-             propertyLower.includes('non-decreasing') || propertyLower.includes('sorted')) {
-      generators.push('fc.integer()', 'fc.integer()');
-      assertion = `// Monotonic: preserves order
-        const [small, large] = a <= b ? [a, b] : [b, a];
-        const resultSmall = ${funcName}(small);
-        const resultLarge = ${funcName}(large);
-        return resultSmall <= resultLarge;`;
-    }
-    // Bounds/range property: output is within expected bounds
-    else if (propertyLower.includes('bound') || propertyLower.includes('range') ||
-             propertyLower.includes('between') || propertyLower.includes('clamp')) {
-      generators.push(this.inferGeneratorFromConstraints(constraints, 'input'));
-      const min = constraints.min !== undefined ? constraints.min : 0;
-      const max = constraints.max !== undefined ? constraints.max : 100;
-      assertion = `// Bounded: result is within expected range
-        const result = ${funcName}(input);
-        return result >= ${min} && result <= ${max};`;
-    }
-    // Length preservation
-    else if (propertyLower.includes('length') || propertyLower.includes('size')) {
-      generators.push('fc.array(fc.anything())');
-      if (propertyLower.includes('preserve')) {
-        assertion = `// Length preserved: output has same length as input
-        const result = ${funcName}(input);
-        return Array.isArray(result) && result.length === input.length;`;
-      } else {
-        assertion = `// Length invariant
-        const result = ${funcName}(input);
-        return typeof result.length === 'number' || typeof result.size === 'number';`;
-      }
-    }
-    // Type preservation
-    else if (propertyLower.includes('type') && propertyLower.includes('preserve')) {
-      generators.push('fc.anything()');
-      assertion = `// Type preserved: output has same type as input
-        const result = ${funcName}(input);
-        return typeof result === typeof input;`;
-    }
-    // Non-null/defined output
-    else if (propertyLower.includes('never null') || propertyLower.includes('always defined') ||
-             propertyLower.includes('non-null')) {
-      generators.push(this.inferGeneratorFromConstraints(constraints, 'input'));
-      assertion = `// Never null: always returns defined value
-        const result = ${funcName}(input);
-        return result !== null && result !== undefined;`;
-    }
-    // Deterministic property: same input always produces same output
-    else if (propertyLower.includes('deterministic') || propertyLower.includes('pure') ||
-             propertyLower.includes('consistent')) {
-      generators.push(this.inferGeneratorFromConstraints(constraints, 'input'));
-      assertion = `// Deterministic: same input always gives same output
-        const result1 = ${funcName}(input);
-        const result2 = ${funcName}(input);
-        return JSON.stringify(result1) === JSON.stringify(result2);`;
-    }
-    // Default case: basic existence check with type-appropriate generator
-    else {
-      generators.push(this.inferGeneratorFromConstraints(constraints, 'input'));
-      assertion = `// Basic property: function returns a value
-        return result !== undefined;`;
-    }
-
-    return { generators, assertion, setupCode };
-  }
-
-  /**
-   * Infer the appropriate fast-check generator from constraints
-   */
-  private inferGeneratorFromConstraints(
-    constraints: Record<string, unknown>,
-    hint: string
-  ): string {
-    // Check explicit type constraint
-    const type = (constraints.type as string)?.toLowerCase() || hint.toLowerCase();
-
-    if (type.includes('string') || type.includes('text')) {
-      const minLength = constraints.minLength as number | undefined;
-      const maxLength = constraints.maxLength as number | undefined;
-      if (minLength !== undefined || maxLength !== undefined) {
-        return `fc.string({ minLength: ${minLength ?? 0}, maxLength: ${maxLength ?? 100} })`;
-      }
-      return 'fc.string()';
-    }
-
-    if (type.includes('number') || type.includes('int') || type.includes('value')) {
-      const min = constraints.min as number | undefined;
-      const max = constraints.max as number | undefined;
-      if (min !== undefined || max !== undefined) {
-        return `fc.integer({ min: ${min ?? Number.MIN_SAFE_INTEGER}, max: ${max ?? Number.MAX_SAFE_INTEGER} })`;
-      }
-      return 'fc.integer()';
-    }
-
-    if (type.includes('float') || type.includes('decimal')) {
-      return 'fc.float()';
-    }
-
-    if (type.includes('boolean') || type.includes('bool')) {
-      return 'fc.boolean()';
-    }
-
-    if (type.includes('array') || type.includes('list')) {
-      const itemType = constraints.itemType as string || 'anything';
-      const itemGen = this.getSimpleGenerator(itemType);
-      return `fc.array(${itemGen})`;
-    }
-
-    if (type.includes('object') || type.includes('record')) {
-      return 'fc.object()';
-    }
-
-    if (type.includes('date')) {
-      return 'fc.date()';
-    }
-
-    if (type.includes('uuid') || type.includes('id')) {
-      return 'fc.uuid()';
-    }
-
-    if (type.includes('email')) {
-      return 'fc.emailAddress()';
-    }
-
-    // Default to anything
-    return 'fc.anything()';
-  }
-
-  /**
-   * Get a simple generator for a type name
-   */
-  private getSimpleGenerator(typeName: string): string {
-    const typeMap: Record<string, string> = {
-      string: 'fc.string()',
-      number: 'fc.integer()',
-      integer: 'fc.integer()',
-      float: 'fc.float()',
-      boolean: 'fc.boolean()',
-      date: 'fc.date()',
-      uuid: 'fc.uuid()',
-      anything: 'fc.anything()',
-    };
-    return typeMap[typeName.toLowerCase()] || 'fc.anything()';
-  }
-
-  /**
-   * Generate parameter names from generator list
-   */
-  private generatePropertyParams(generators: string[]): string {
-    if (generators.length === 1) {
-      return 'input';
-    }
-    return generators.map((_, i) => String.fromCharCode(97 + i)).join(', '); // a, b, c...
-  }
-
-  /**
-   * Generate argument list for function call
-   */
-  private generatePropertyArgs(generators: string[]): string {
-    if (generators.length === 1) {
-      return 'input';
-    }
-    return generators.map((_, i) => String.fromCharCode(97 + i)).join(', ');
-  }
-
-  private inferGenerators(
-    property: string,
-    constraints: Record<string, unknown>
-  ): string[] {
-    const generators: string[] = [];
-    const propertyLower = property.toLowerCase();
-
-    // Analyze property description to infer appropriate generators
-    // String-related properties
-    if (
-      propertyLower.includes('string') ||
-      propertyLower.includes('text') ||
-      propertyLower.includes('name') ||
-      propertyLower.includes('email')
-    ) {
-      if (constraints.minLength || constraints.maxLength) {
-        const min = constraints.minLength ?? 0;
-        const max = constraints.maxLength ?? 100;
-        generators.push(`fc.string({ minLength: ${min}, maxLength: ${max} })`);
-      } else {
-        generators.push('fc.string()');
-      }
-      if (propertyLower.includes('email')) {
-        generators.push('fc.emailAddress()');
-      }
-    }
-
-    // Number-related properties
-    if (
-      propertyLower.includes('number') ||
-      propertyLower.includes('count') ||
-      propertyLower.includes('amount') ||
-      propertyLower.includes('integer') ||
-      propertyLower.includes('positive') ||
-      propertyLower.includes('negative')
-    ) {
-      if (propertyLower.includes('positive')) {
-        generators.push('fc.nat()');
-      } else if (propertyLower.includes('negative')) {
-        generators.push('fc.integer({ max: -1 })');
-      } else if (constraints.min !== undefined || constraints.max !== undefined) {
-        const min = constraints.min ?? Number.MIN_SAFE_INTEGER;
-        const max = constraints.max ?? Number.MAX_SAFE_INTEGER;
-        generators.push(`fc.integer({ min: ${min}, max: ${max} })`);
-      } else {
-        generators.push('fc.integer()');
-      }
-      if (propertyLower.includes('float') || propertyLower.includes('decimal')) {
-        generators.push('fc.float()');
-      }
-    }
-
-    // Boolean properties
-    if (propertyLower.includes('boolean') || propertyLower.includes('flag')) {
-      generators.push('fc.boolean()');
-    }
-
-    // Array-related properties
-    if (
-      propertyLower.includes('array') ||
-      propertyLower.includes('list') ||
-      propertyLower.includes('collection')
-    ) {
-      const itemType = constraints.itemType as string || 'anything';
-      const itemGen = this.getGeneratorForType(itemType);
-      if (constraints.minItems || constraints.maxItems) {
-        const min = constraints.minItems ?? 0;
-        const max = constraints.maxItems ?? 10;
-        generators.push(`fc.array(${itemGen}, { minLength: ${min}, maxLength: ${max} })`);
-      } else {
-        generators.push(`fc.array(${itemGen})`);
-      }
-    }
-
-    // Object-related properties
-    if (propertyLower.includes('object') || propertyLower.includes('record')) {
-      generators.push('fc.object()');
-      generators.push('fc.dictionary(fc.string(), fc.anything())');
-    }
-
-    // Date-related properties
-    if (propertyLower.includes('date') || propertyLower.includes('time')) {
-      generators.push('fc.date()');
-    }
-
-    // UUID properties
-    if (propertyLower.includes('uuid') || propertyLower.includes('id')) {
-      generators.push('fc.uuid()');
-    }
-
-    // Default fallback if no specific type detected
-    if (generators.length === 0) {
-      generators.push('fc.anything()');
-    }
-
-    return generators;
-  }
-
-  private getGeneratorForType(type: string): string {
-    const typeGenerators: Record<string, string> = {
-      string: 'fc.string()',
-      number: 'fc.integer()',
-      integer: 'fc.integer()',
-      float: 'fc.float()',
-      boolean: 'fc.boolean()',
-      date: 'fc.date()',
-      uuid: 'fc.uuid()',
-      anything: 'fc.anything()',
-    };
-    return typeGenerators[type.toLowerCase()] || 'fc.anything()';
-  }
-
-  private collectArbitraries(tests: { generators: string[] }[]): string[] {
-    const arbitraries = new Set<string>();
-    for (const test of tests) {
-      test.generators.forEach((g) => arbitraries.add(g));
-    }
-    return Array.from(arbitraries);
-  }
-
-  private generateRecordFromSchema(
-    schema: Record<string, unknown>,
-    seed: number,
-    locale: string
-  ): Record<string, unknown> {
-    // Set faker locale and seed for reproducibility
-    faker.seed(seed);
-    if (locale && locale !== 'en') {
-      // Note: faker v8+ uses different locale handling
-      // For now, we use the default locale
-    }
-
-    const record: Record<string, unknown> = {};
-
-    for (const [key, fieldDef] of Object.entries(schema)) {
-      record[key] = this.generateValueForField(key, fieldDef, seed);
-    }
-
-    return record;
-  }
-
-  private generateValueForField(
-    fieldName: string,
-    fieldDef: unknown,
-    _seed: number
-  ): unknown {
-    // Handle simple type strings
-    if (typeof fieldDef === 'string') {
-      return this.generateValueForType(fieldDef, fieldName);
-    }
-
-    // Handle complex field definitions
-    if (typeof fieldDef === 'object' && fieldDef !== null) {
-      const field = fieldDef as SchemaField;
-
-      // Use explicit faker method if specified
-      if (field.faker) {
-        return this.callFakerMethod(field.faker);
-      }
-
-      return this.generateValueForType(field.type, fieldName, field);
-    }
-
-    return null;
-  }
-
-  private generateValueForType(
-    type: string,
-    fieldName: string,
-    options?: SchemaField
-  ): unknown {
-    const normalizedType = type.toLowerCase();
-
-    // Try to infer the best faker method based on field name and type
-    switch (normalizedType) {
-      case 'string':
-        return this.generateStringValue(fieldName, options);
-      case 'number':
-      case 'int':
-      case 'integer':
-        return this.generateNumberValue(options);
-      case 'float':
-      case 'decimal':
-        return faker.number.float({ min: options?.min ?? 0, max: options?.max ?? 1000, fractionDigits: 2 });
-      case 'boolean':
-      case 'bool':
-        return faker.datatype.boolean();
-      case 'date':
-      case 'datetime':
-        return faker.date.recent().toISOString();
-      case 'email':
-        return faker.internet.email();
-      case 'uuid':
-      case 'id':
-        return faker.string.uuid();
-      case 'url':
-        return faker.internet.url();
-      case 'phone':
-        return faker.phone.number();
-      case 'address':
-        return this.generateAddress();
-      case 'name':
-      case 'fullname':
-        return faker.person.fullName();
-      case 'firstname':
-        return faker.person.firstName();
-      case 'lastname':
-        return faker.person.lastName();
-      case 'username':
-        return faker.internet.username();
-      case 'password':
-        return faker.internet.password();
-      case 'company':
-        return faker.company.name();
-      case 'jobtitle':
-        return faker.person.jobTitle();
-      case 'text':
-      case 'paragraph':
-        return faker.lorem.paragraph();
-      case 'sentence':
-        return faker.lorem.sentence();
-      case 'word':
-      case 'words':
-        return faker.lorem.word();
-      case 'avatar':
-      case 'image':
-        return faker.image.avatar();
-      case 'color':
-        return faker.color.rgb();
-      case 'ipaddress':
-      case 'ip':
-        return faker.internet.ipv4();
-      case 'mac':
-        return faker.internet.mac();
-      case 'latitude':
-        return faker.location.latitude();
-      case 'longitude':
-        return faker.location.longitude();
-      case 'country':
-        return faker.location.country();
-      case 'city':
-        return faker.location.city();
-      case 'zipcode':
-      case 'postalcode':
-        return faker.location.zipCode();
-      case 'creditcard':
-        return faker.finance.creditCardNumber();
-      case 'currency':
-        return faker.finance.currencyCode();
-      case 'amount':
-      case 'price':
-        return faker.finance.amount();
-      case 'json':
-      case 'object':
-        return { key: faker.lorem.word(), value: faker.lorem.sentence() };
-      case 'array':
-        return [faker.lorem.word(), faker.lorem.word(), faker.lorem.word()];
-      case 'enum':
-        if (options?.enum && options.enum.length > 0) {
-          return faker.helpers.arrayElement(options.enum);
-        }
-        return faker.lorem.word();
-      default:
-        // Try to infer from field name
-        return this.inferValueFromFieldName(fieldName);
-    }
-  }
-
-  private generateStringValue(fieldName: string, options?: SchemaField): string {
-    const lowerName = fieldName.toLowerCase();
-
-    // Infer type from field name
-    if (lowerName.includes('email')) return faker.internet.email();
-    if (lowerName.includes('name') && lowerName.includes('first')) return faker.person.firstName();
-    if (lowerName.includes('name') && lowerName.includes('last')) return faker.person.lastName();
-    if (lowerName.includes('name')) return faker.person.fullName();
-    if (lowerName.includes('phone')) return faker.phone.number();
-    if (lowerName.includes('address')) return faker.location.streetAddress();
-    if (lowerName.includes('city')) return faker.location.city();
-    if (lowerName.includes('country')) return faker.location.country();
-    if (lowerName.includes('zip') || lowerName.includes('postal')) return faker.location.zipCode();
-    if (lowerName.includes('url') || lowerName.includes('website')) return faker.internet.url();
-    if (lowerName.includes('username') || lowerName.includes('user')) return faker.internet.username();
-    if (lowerName.includes('password')) return faker.internet.password();
-    if (lowerName.includes('description') || lowerName.includes('bio')) return faker.lorem.paragraph();
-    if (lowerName.includes('title')) return faker.lorem.sentence();
-    if (lowerName.includes('company')) return faker.company.name();
-    if (lowerName.includes('job')) return faker.person.jobTitle();
-    if (lowerName.includes('avatar') || lowerName.includes('image')) return faker.image.avatar();
-
-    // Apply pattern if provided
-    if (options?.pattern) {
-      return faker.helpers.fromRegExp(options.pattern);
-    }
-
-    // Default string generation
-    return faker.lorem.words(3);
-  }
-
-  private generateNumberValue(options?: SchemaField): number {
-    const min = options?.min ?? 0;
-    const max = options?.max ?? 10000;
-    return faker.number.int({ min, max });
-  }
-
-  private generateAddress(): Record<string, string> {
-    return {
-      street: faker.location.streetAddress(),
-      city: faker.location.city(),
-      state: faker.location.state(),
-      zipCode: faker.location.zipCode(),
-      country: faker.location.country(),
-    };
-  }
-
-  private inferValueFromFieldName(fieldName: string): unknown {
-    const lowerName = fieldName.toLowerCase();
-
-    if (lowerName.includes('id')) return faker.string.uuid();
-    if (lowerName.includes('email')) return faker.internet.email();
-    if (lowerName.includes('name')) return faker.person.fullName();
-    if (lowerName.includes('phone')) return faker.phone.number();
-    if (lowerName.includes('date') || lowerName.includes('time')) return faker.date.recent().toISOString();
-    if (lowerName.includes('url')) return faker.internet.url();
-    if (lowerName.includes('count') || lowerName.includes('amount')) return faker.number.int({ min: 0, max: 100 });
-    if (lowerName.includes('price')) return faker.finance.amount();
-    if (lowerName.includes('active') || lowerName.includes('enabled') || lowerName.includes('is')) {
-      return faker.datatype.boolean();
-    }
-
-    // Default to a random string
-    return faker.lorem.word();
-  }
-
-  private callFakerMethod(methodPath: string): unknown {
-    try {
-      const parts = methodPath.split('.');
-      let result: unknown = faker;
-
-      for (const part of parts) {
-        if (result && typeof result === 'object' && part in result) {
-          const next = (result as Record<string, unknown>)[part];
-          if (typeof next === 'function') {
-            result = (next as () => unknown)();
-          } else {
-            result = next;
-          }
-        } else {
-          return faker.lorem.word();
-        }
-      }
-
-      return result;
-    } catch {
-      return faker.lorem.word();
-    }
-  }
-
-  private linkRelatedRecords(
-    records: unknown[],
-    schema: Record<string, unknown>
-  ): void {
-    // Find fields with references and link them
-    const referenceFields: Array<{ field: string; reference: string }> = [];
-
-    for (const [key, fieldDef] of Object.entries(schema)) {
-      if (typeof fieldDef === 'object' && fieldDef !== null) {
-        const field = fieldDef as SchemaField;
-        if (field.reference) {
-          referenceFields.push({ field: key, reference: field.reference });
-        }
-      }
-    }
-
-    // If we have reference fields, link records
-    if (referenceFields.length > 0) {
-      for (let i = 0; i < records.length; i++) {
-        const record = records[i] as Record<string, unknown>;
-        for (const { field, reference } of referenceFields) {
-          // Link to a random previous record's ID or create a new one
-          if (i > 0 && reference === 'id') {
-            const prevRecord = records[Math.floor(Math.random() * i)] as Record<string, unknown>;
-            record[field] = prevRecord['id'] ?? faker.string.uuid();
-          } else {
-            record[field] = faker.string.uuid();
-          }
-        }
-      }
-    }
-  }
-
-  private async generateTestForLines(
-    file: string,
-    lines: number[],
-    framework: string
-  ): Promise<GeneratedTest | null> {
-    if (lines.length === 0) return null;
-
-    const testId = uuidv4();
-    const testFile = this.getTestFilePath(file, framework);
-    const moduleName = this.extractModuleName(file);
-    const importPath = this.getImportPath(file);
-
-    // Generate meaningful coverage test code
-    const testCode = this.generateCoverageTestCode(moduleName, importPath, lines, framework);
-
-    return {
-      id: testId,
-      name: `Coverage test for lines ${lines[0]}-${lines[lines.length - 1]}`,
-      sourceFile: file,
-      testFile,
-      testCode,
-      type: 'unit',
-      assertions: this.countAssertions(testCode),
-    };
-  }
-
-  /**
-   * Generate actual coverage test code for specific lines
-   */
-  private generateCoverageTestCode(
-    moduleName: string,
-    importPath: string,
-    lines: number[],
-    framework: string
-  ): string {
-    const funcName = this.camelCase(moduleName);
-    const lineRange = lines.length === 1
-      ? `line ${lines[0]}`
-      : `lines ${lines[0]}-${lines[lines.length - 1]}`;
-
-    if (framework === 'pytest') {
-      return `# Coverage test for ${lineRange} in ${moduleName}
-import pytest
-from ${importPath.replace(/\//g, '.')} import ${funcName}
-
-class Test${this.pascalCase(moduleName)}Coverage:
-    """Tests to cover ${lineRange}"""
-
-    def test_cover_${lines[0]}_${lines[lines.length - 1]}(self):
-        """Exercise code path covering ${lineRange}"""
-        # Arrange: Set up test inputs to reach uncovered lines
-        test_input = None  # Replace with appropriate input
-
-        # Act: Execute the code path
-        try:
-            result = ${funcName}(test_input)
-
-            # Assert: Verify expected behavior
-            assert result is not None
-        except Exception as e:
-            # If exception is expected for this path, verify it
-            pytest.fail(f"Unexpected exception: {e}")
-`;
-    }
-
-    // Default: Jest/Vitest format
-    return `// Coverage test for ${lineRange} in ${moduleName}
-import { ${funcName} } from '${importPath}';
-
-describe('${moduleName} coverage', () => {
-  describe('${lineRange}', () => {
-    it('should execute code path covering ${lineRange}', () => {
-      // Arrange: Set up test inputs to reach uncovered lines
-      const testInput = undefined; // Replace with appropriate input
-
-      // Act: Execute the code path
-      const result = ${funcName}(testInput);
-
-      // Assert: Verify the code was reached and behaves correctly
-      expect(result).toBeDefined();
-    });
-
-    it('should handle edge case for ${lineRange}', () => {
-      // Arrange: Set up edge case input
-      const edgeCaseInput = null;
-
-      // Act & Assert: Verify edge case handling
-      expect(() => ${funcName}(edgeCaseInput)).not.toThrow();
-    });
-  });
-});
-`;
-  }
-
-  private groupConsecutiveLines(lines: number[]): number[][] {
-    if (lines.length === 0) return [];
-
-    const sorted = [...lines].sort((a, b) => a - b);
-    const groups: number[][] = [[sorted[0]]];
-
-    for (let i = 1; i < sorted.length; i++) {
-      const currentGroup = groups[groups.length - 1];
-      if (sorted[i] - currentGroup[currentGroup.length - 1] <= 3) {
-        currentGroup.push(sorted[i]);
-      } else {
-        groups.push([sorted[i]]);
-      }
-    }
-
-    return groups;
-  }
-
-  private getTestFilePath(sourceFile: string, framework: string): string {
-    const ext = sourceFile.split('.').pop() || 'ts';
-    const base = sourceFile.replace(`.${ext}`, '');
-
-    if (framework === 'pytest') {
-      return `test_${base.split('/').pop()}.py`;
-    }
-
-    return `${base}.test.${ext}`;
-  }
-
-  private extractModuleName(sourceFile: string): string {
-    const filename = sourceFile.split('/').pop() || sourceFile;
-    return filename.replace(/\.(ts|js|tsx|jsx|py)$/, '');
-  }
-
-  private getImportPath(sourceFile: string): string {
-    return sourceFile.replace(/\.(ts|js|tsx|jsx)$/, '');
-  }
-
-  private countAssertions(testCode: string): number {
-    const assertPatterns = [
-      /expect\(/g,
-      /assert/g,
-      /\.to\./g,
-      /\.toBe/g,
-      /\.toEqual/g,
-    ];
-
-    let count = 0;
-    for (const pattern of assertPatterns) {
-      const matches = testCode.match(pattern);
-      count += matches ? matches.length : 0;
-    }
-
-    return Math.max(1, count);
-  }
-
-  private estimateCoverage(tests: GeneratedTest[], target: number): number {
-    // Estimate coverage based on test characteristics
-    const totalAssertions = tests.reduce((sum, t) => sum + t.assertions, 0);
-    const totalTests = tests.length;
-
-    // Base coverage from test count (each test covers ~3-5% typically)
-    const testBasedCoverage = totalTests * 4;
-
-    // Additional coverage from assertions (each assertion ~1-2%)
-    const assertionCoverage = totalAssertions * 1.5;
-
-    // Test type multipliers (integration tests cover more)
-    const typeMultiplier = tests.reduce((mult, t) => {
-      if (t.type === 'integration') return mult + 0.1;
-      if (t.type === 'e2e') return mult + 0.15;
-      return mult;
-    }, 1);
-
-    // Calculate estimated coverage with diminishing returns
-    const rawEstimate = (testBasedCoverage + assertionCoverage) * typeMultiplier;
-    const diminishedEstimate = rawEstimate * (1 - rawEstimate / 200); // Diminishing returns above 100%
-
-    // Cap at target and round
-    const estimatedCoverage = Math.min(target, Math.max(0, diminishedEstimate));
-    return Math.round(estimatedCoverage * 10) / 10;
-  }
-
-  private camelCase(str: string): string {
-    return str
-      .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
-      .replace(/^./, (chr) => chr.toLowerCase());
-  }
-
-  private pascalCase(str: string): string {
-    return str
-      .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
-      .replace(/^./, (chr) => chr.toUpperCase());
-  }
-
-  private async storeGenerationMetadata(
-    tests: GeneratedTest[],
-    patterns: string[]
-  ): Promise<void> {
-    const metadata = {
-      generatedAt: new Date().toISOString(),
-      testCount: tests.length,
-      patterns,
-      testIds: tests.map((t) => t.id),
-    };
-
-    await this.memory.set(
-      `test-generation:metadata:${Date.now()}`,
-      metadata,
-      { namespace: 'test-generation', ttl: 86400 * 7 } // 7 days
-    );
-  }
-}