@agentic-qe/v3 3.0.0-alpha.3

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

@@ -0,0 +1,2750 @@
+/**
+ * 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
+    );
+  }
+}