agentic-qe 3.2.3 → 3.3.1

package/v3/dist/domains/test-generation/services/test-generator.js

@@ -2,32 +2,46 @@
  * Agentic QE v3 - Test Generation Service
  * Implements ITestGenerationService for AI-powered test generation
  *
- * Uses @faker-js/faker for realistic test data generation
+ * Uses Strategy Pattern generators for framework-specific code generation
  * Uses TypeScript AST parser for code analysis
+ * Delegates to specialized services for TDD, property tests, and test data
  */
 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 { ok, err } from '../../../shared/types';
+import { TestGeneratorFactory } from '../factories/test-generator-factory';
+import { TDDGeneratorService } from './tdd-generator';
+import { PropertyTestGeneratorService } from './property-test-generator';
+import { TestDataGeneratorService } from './test-data-generator';
 const DEFAULT_CONFIG = {
-    defaultFramework: 'jest',
+    defaultFramework: 'vitest',
     maxTestsPerFile: 50,
     coverageTargetDefault: 80,
     enableAIGeneration: true,
 };
 /**
  * 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
+ * Uses Strategy Pattern generators for framework-specific test generation
+ * Delegates TDD, property testing, and test data to specialized services
+ *
+ * ADR-XXX: Refactored to use Dependency Injection for better testability and flexibility
  */
 export class TestGeneratorService {
-    memory;
     config;
-    constructor(memory, config = {}) {
-        this.memory = memory;
+    memory;
+    generatorFactory;
+    tddGenerator;
+    propertyTestGenerator;
+    testDataGenerator;
+    constructor(dependencies, config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
+        this.memory = dependencies.memory;
+        this.generatorFactory = dependencies.generatorFactory || new TestGeneratorFactory();
+        this.tddGenerator = dependencies.tddGenerator || new TDDGeneratorService();
+        this.propertyTestGenerator = dependencies.propertyTestGenerator || new PropertyTestGeneratorService();
+        this.testDataGenerator = dependencies.testDataGenerator || new TestDataGeneratorService();
     }
     /**
      * Generate tests for given source files
@@ -40,7 +54,6 @@ export class TestGeneratorService {
             }
             const tests = [];
             const patternsUsed = [];
-            // Process each source file
             for (const sourceFile of sourceFiles) {
                 const fileTests = await this.generateTestsForFile(sourceFile, testType, framework, patterns);
                 if (fileTests.success) {
@@ -48,14 +61,12 @@ export class TestGeneratorService {
                     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)],
+                patternsUsed: Array.from(new Set(patternsUsed)),
             });
         }
         catch (error) {
@@ -70,13 +81,13 @@ export class TestGeneratorService {
             if (uncoveredLines.length === 0) {
                 return ok([]);
             }
-            // Analyze uncovered lines and generate targeted tests
-            // Groups consecutive lines and generates tests for each block
             const tests = [];
-            // Group uncovered lines into logical blocks
             const lineGroups = this.groupConsecutiveLines(uncoveredLines);
+            const frameworkType = this.generatorFactory.supports(framework)
+                ? framework
+                : this.config.defaultFramework;
             for (const group of lineGroups) {
-                const test = await this.generateTestForLines(file, group, framework);
+                const test = await this.generateTestForLines(file, group, frameworkType);
                 if (test) {
                     tests.push(test);
                 }
@@ -88,87 +99,49 @@ export class TestGeneratorService {
         }
     }
     /**
-     * Generate tests following TDD workflow
+     * Generate tests following TDD workflow - delegates to TDDGeneratorService
      */
     async generateTDDTests(request) {
         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}`));
-            }
+            const result = await this.tddGenerator.generateTDDTests(request);
+            return ok(result);
         }
         catch (error) {
             return err(error instanceof Error ? error : new Error(String(error)));
         }
     }
     /**
-     * Generate property-based tests
+     * Generate property-based tests - delegates to PropertyTestGeneratorService
      */
     async generatePropertyTests(request) {
         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),
-            });
+            const result = await this.propertyTestGenerator.generatePropertyTests(request);
+            return ok(result);
         }
         catch (error) {
             return err(error instanceof Error ? error : new Error(String(error)));
         }
     }
     /**
-     * Generate test data based on schema
+     * Generate test data based on schema - delegates to TestDataGeneratorService
      */
     async generateTestData(request) {
         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 = [];
-            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,
-            });
+            const result = await this.testDataGenerator.generateTestData(request);
+            return ok(result);
         }
         catch (error) {
             return err(error instanceof Error ? error : new Error(String(error)));
         }
     }
     // ============================================================================
-    // Private Helper Methods
+    // Private Helper Methods - Core Test Generation
     // ============================================================================
     async generateTestsForFile(sourceFile, testType, framework, patterns) {
         const testFile = this.getTestFilePath(sourceFile, framework);
         const patternsUsed = [];
-        // 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 = null;
         try {
             const content = fs.readFileSync(sourceFile, 'utf-8');
@@ -177,17 +150,20 @@ export class TestGeneratorService {
         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;
-        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 generator = this.generatorFactory.create(framework);
+        const moduleName = this.extractModuleName(sourceFile);
+        const importPath = this.getImportPath(sourceFile);
+        const context = {
+            moduleName,
+            importPath,
+            testType,
+            patterns: applicablePatterns,
+            analysis: codeAnalysis ?? undefined,
+        };
+        const testCode = generator.generateTests(context);
         const test = {
             id: uuidv4(),
-            name: `${this.extractModuleName(sourceFile)} tests`,
+            name: `${moduleName} tests`,
             sourceFile,
             testFile,
             testCode,
@@ -196,19 +172,36 @@ export class TestGeneratorService {
         };
         return ok({ tests: [test], patternsUsed });
     }
-    /**
-     * Analyze source code using TypeScript AST
-     */
+    async generateTestForLines(file, lines, framework) {
+        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);
+        const generator = this.generatorFactory.create(framework);
+        const testCode = generator.generateCoverageTests(moduleName, importPath, lines);
+        return {
+            id: testId,
+            name: `Coverage test for lines ${lines[0]}-${lines[lines.length - 1]}`,
+            sourceFile: file,
+            testFile,
+            testCode,
+            type: 'unit',
+            assertions: this.countAssertions(testCode),
+        };
+    }
+    // ============================================================================
+    // Private Helper Methods - AST Analysis
+    // ============================================================================
     analyzeSourceCode(content, fileName) {
         const sourceFile = ts.createSourceFile(path.basename(fileName), content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
         const functions = [];
         const classes = [];
         const visit = (node) => {
-            // 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) &&
@@ -220,7 +213,6 @@ export class TestGeneratorService {
                     }
                 }
             }
-            // Extract class declarations
             else if (ts.isClassDeclaration(node) && node.name) {
                 classes.push(this.extractClassInfo(node, sourceFile));
             }
@@ -229,9 +221,6 @@ export class TestGeneratorService {
         ts.forEachChild(sourceFile, visit);
         return { functions, classes };
     }
-    /**
-     * Extract function information from AST
-     */
     extractFunctionInfo(node, sourceFile) {
         const name = node.name?.getText(sourceFile) || 'anonymous';
         const parameters = this.extractParameters(node.parameters, sourceFile);
@@ -252,9 +241,6 @@ export class TestGeneratorService {
             body: node.body?.getText(sourceFile),
         };
     }
-    /**
-     * Extract arrow function information from AST
-     */
     extractArrowFunctionInfo(name, node, sourceFile, parentNode) {
         const parameters = this.extractParameters(node.parameters, sourceFile);
         const returnType = node.type?.getText(sourceFile);
@@ -275,9 +261,6 @@ export class TestGeneratorService {
             body: node.body?.getText(sourceFile),
         };
     }
-    /**
-     * Extract class information from AST
-     */
     extractClassInfo(node, sourceFile) {
         const name = node.name?.getText(sourceFile) || 'AnonymousClass';
         const methods = [];
@@ -331,9 +314,6 @@ export class TestGeneratorService {
             constructorParams,
         };
     }
-    /**
-     * Extract parameters from a function
-     */
     extractParameters(params, sourceFile) {
         return params.map((param) => ({
             name: param.name.getText(sourceFile),
@@ -342,9 +322,6 @@ export class TestGeneratorService {
             defaultValue: param.initializer?.getText(sourceFile),
         }));
     }
-    /**
-     * Calculate cyclomatic complexity of a node
-     */
     calculateComplexity(node) {
         let complexity = 1;
         const visit = (n) => {
@@ -374,452 +351,17 @@ export class TestGeneratorService {
         ts.forEachChild(node, visit);
         return complexity;
     }
-    /**
-     * Generate real test code based on AST analysis
-     */
-    generateRealTestCode(sourceFile, testType, framework, analysis, patterns) {
-        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
-     */
-    generateRealJestVitestTest(moduleName, importPath, testType, analysis, patterns, framework) {
-        const patternComment = patterns.length > 0
-            ? `// Applied patterns: ${patterns.map((p) => p.name).join(', ')}\n`
-            : '';
-        // Collect all exports to import
-        const exports = [];
-        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
-     */
-    generateFunctionTests(fn, _testType) {
-        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
-     */
-    generateTestCasesForFunction(fn) {
-        const testCases = [];
-        // 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
-     */
-    generateClassTests(cls, testType) {
-        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
-     */
-    generateMethodTests(method, _className, _testType) {
-        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
-     */
-    generateTestValue(param) {
-        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
-     */
-    generateRealMochaTest(moduleName, importPath, testType, analysis, patterns) {
-        const patternComment = patterns.length > 0
-            ? `// Applied patterns: ${patterns.map((p) => p.name).join(', ')}\n`
-            : '';
-        const exports = [];
-        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
-     */
-    generateMochaFunctionTests(fn) {
-        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
-     */
-    generateMochaClassTests(cls) {
-        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
-     */
-    generateRealPytestTest(moduleName, importPath, testType, analysis, patterns) {
-        const patternComment = patterns.length > 0
-            ? `# Applied patterns: ${patterns.map((p) => p.name).join(', ')}\n`
-            : '';
-        const exports = [];
-        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
-     */
-    generatePytestFunctionTests(fn) {
-        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
-     */
-    generatePytestClassTests(cls) {
-        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
-     */
-    generatePythonTestValue(param) {
-        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 Helper Methods - Utility Functions
+    // ============================================================================
     async findApplicablePatterns(sourceFile, requestedPatterns) {
         const patterns = [];
-        // Check memory for stored patterns
         for (const patternName of requestedPatterns) {
             const stored = await this.memory.get(`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) {
@@ -830,1313 +372,6 @@ class Test${moduleName.charAt(0).toUpperCase() + moduleName.slice(1)}:
         }
         return patterns;
     }
-    generateStubTestCode(sourceFile, testType, framework, patterns) {
-        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);
-        }
-    }
-    generateJestVitestTest(moduleName, importPath, testType, patterns) {
-        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
-     */
-    generateBasicOpsTest(moduleName, patterns) {
-        // 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
-     */
-    generateEdgeCaseTest(moduleName, patterns) {
-        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
-     */
-    generateErrorHandlingTest(moduleName, patterns) {
-        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();
-    });`;
-    }
-    generateMochaTest(moduleName, importPath, testType, patterns) {
-        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();
-    });
-  });
-});
-`;
-    }
-    generatePytestTest(moduleName, importPath, testType, patterns) {
-        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
-`;
-    }
-    async generateRedPhaseTest(feature, behavior, _framework) {
-        // 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
-     */
-    generateAssertionsFromBehavior(behavior, funcName) {
-        const behaviorLower = behavior.toLowerCase();
-        const assertions = [];
-        // 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
-     */
-    extractBehaviorContext(behavior) {
-        const context = {};
-        // 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
-     */
-    buildFunctionCall(funcName, context, behaviorLower) {
-        // 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)`;
-    }
-    async generateGreenPhaseCode(feature, behavior, _framework) {
-        // 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
-     */
-    inferImplementationFromBehavior(behavior) {
-        // 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 = [
-            { 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 = [];
-        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 };
-    }
-    async generateRefactoringSuggestions(_feature, _behavior) {
-        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',
-        };
-    }
-    generatePropertyTestCode(funcName, property, constraints) {
-        // 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
-     */
-    analyzePropertyForTestGeneration(propertyLower, funcName, constraints) {
-        const generators = [];
-        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 || `${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
-     */
-    inferGeneratorFromConstraints(constraints, hint) {
-        // Check explicit type constraint
-        const type = constraints.type?.toLowerCase() || hint.toLowerCase();
-        if (type.includes('string') || type.includes('text')) {
-            const minLength = constraints.minLength;
-            const maxLength = constraints.maxLength;
-            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;
-            const max = constraints.max;
-            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 || '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
-     */
-    getSimpleGenerator(typeName) {
-        const typeMap = {
-            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
-     */
-    generatePropertyParams(generators) {
-        if (generators.length === 1) {
-            return 'input';
-        }
-        return generators.map((_, i) => String.fromCharCode(97 + i)).join(', '); // a, b, c...
-    }
-    /**
-     * Generate argument list for function call
-     */
-    generatePropertyArgs(generators) {
-        if (generators.length === 1) {
-            return 'input';
-        }
-        return generators.map((_, i) => String.fromCharCode(97 + i)).join(', ');
-    }
-    inferGenerators(property, constraints) {
-        const generators = [];
-        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 || '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;
-    }
-    getGeneratorForType(type) {
-        const typeGenerators = {
-            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()';
-    }
-    collectArbitraries(tests) {
-        const arbitraries = new Set();
-        for (const test of tests) {
-            test.generators.forEach((g) => arbitraries.add(g));
-        }
-        return Array.from(arbitraries);
-    }
-    generateRecordFromSchema(schema, seed, locale) {
-        // 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 = {};
-        for (const [key, fieldDef] of Object.entries(schema)) {
-            record[key] = this.generateValueForField(key, fieldDef, seed);
-        }
-        return record;
-    }
-    generateValueForField(fieldName, fieldDef, _seed) {
-        // 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;
-            // Use explicit faker method if specified
-            if (field.faker) {
-                return this.callFakerMethod(field.faker);
-            }
-            return this.generateValueForType(field.type, fieldName, field);
-        }
-        return null;
-    }
-    generateValueForType(type, fieldName, options) {
-        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);
-        }
-    }
-    generateStringValue(fieldName, options) {
-        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);
-    }
-    generateNumberValue(options) {
-        const min = options?.min ?? 0;
-        const max = options?.max ?? 10000;
-        return faker.number.int({ min, max });
-    }
-    generateAddress() {
-        return {
-            street: faker.location.streetAddress(),
-            city: faker.location.city(),
-            state: faker.location.state(),
-            zipCode: faker.location.zipCode(),
-            country: faker.location.country(),
-        };
-    }
-    inferValueFromFieldName(fieldName) {
-        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();
-    }
-    callFakerMethod(methodPath) {
-        try {
-            const parts = methodPath.split('.');
-            let result = faker;
-            for (const part of parts) {
-                if (result && typeof result === 'object' && part in result) {
-                    const next = result[part];
-                    if (typeof next === 'function') {
-                        result = next();
-                    }
-                    else {
-                        result = next;
-                    }
-                }
-                else {
-                    return faker.lorem.word();
-                }
-            }
-            return result;
-        }
-        catch {
-            return faker.lorem.word();
-        }
-    }
-    linkRelatedRecords(records, schema) {
-        // Find fields with references and link them
-        const referenceFields = [];
-        for (const [key, fieldDef] of Object.entries(schema)) {
-            if (typeof fieldDef === 'object' && fieldDef !== null) {
-                const field = fieldDef;
-                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];
-                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)];
-                        record[field] = prevRecord['id'] ?? faker.string.uuid();
-                    }
-                    else {
-                        record[field] = faker.string.uuid();
-                    }
-                }
-            }
-        }
-    }
-    async generateTestForLines(file, lines, framework) {
-        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
-     */
-    generateCoverageTestCode(moduleName, importPath, lines, framework) {
-        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();
-    });
-  });
-});
-`;
-    }
     groupConsecutiveLines(lines) {
         if (lines.length === 0)
             return [];
@@ -2184,14 +419,10 @@ describe('${moduleName} coverage', () => {
         return Math.max(1, count);
     }
     estimateCoverage(tests, target) {
-        // 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;
@@ -2199,23 +430,11 @@ describe('${moduleName} coverage', () => {
                 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 diminishedEstimate = rawEstimate * (1 - rawEstimate / 200);
         const estimatedCoverage = Math.min(target, Math.max(0, diminishedEstimate));
         return Math.round(estimatedCoverage * 10) / 10;
     }
-    camelCase(str) {
-        return str
-            .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
-            .replace(/^./, (chr) => chr.toLowerCase());
-    }
-    pascalCase(str) {
-        return str
-            .replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase())
-            .replace(/^./, (chr) => chr.toUpperCase());
-    }
     async storeGenerationMetadata(tests, patterns) {
         const metadata = {
             generatedAt: new Date().toISOString(),
@@ -2223,8 +442,32 @@ describe('${moduleName} coverage', () => {
             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
-        );
+        await this.memory.set(`test-generation:metadata:${Date.now()}`, metadata, { namespace: 'test-generation', ttl: 86400 * 7 });
     }
 }
+// ============================================================================
+// Factory Functions
+// ============================================================================
+/**
+ * Create a TestGeneratorService instance with default dependencies
+ * Maintains backward compatibility with existing code
+ *
+ * @param memory - Memory backend for pattern storage
+ * @param config - Optional configuration overrides
+ * @returns Configured TestGeneratorService instance
+ */
+export function createTestGeneratorService(memory, config = {}) {
+    return new TestGeneratorService({ memory }, config);
+}
+/**
+ * Create a TestGeneratorService instance with custom dependencies
+ * Used for testing or when custom implementations are needed
+ *
+ * @param dependencies - All service dependencies
+ * @param config - Optional configuration overrides
+ * @returns Configured TestGeneratorService instance
+ */
+export function createTestGeneratorServiceWithDependencies(dependencies, config = {}) {
+    return new TestGeneratorService(dependencies, config);
+}
 //# sourceMappingURL=test-generator.js.map