@agentic-qe/v3 3.0.0-alpha.3

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

@@ -0,0 +1,2230 @@
+/**
+ * Agentic QE v3 - Test Generation Service
+ * Implements ITestGenerationService for AI-powered test generation
+ *
+ * Uses @faker-js/faker for realistic test data generation
+ * Uses TypeScript AST parser for code analysis
+ */
+import { v4 as uuidv4 } from 'uuid';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as ts from 'typescript';
+import { faker } from '@faker-js/faker';
+import { ok, err } from '../../../shared/types';
+const DEFAULT_CONFIG = {
+    defaultFramework: 'jest',
+    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
+ */
+export class TestGeneratorService {
+    memory;
+    config;
+    constructor(memory, config = {}) {
+        this.memory = memory;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Generate tests for given source files
+     */
+    async generateTests(request) {
+        try {
+            const { sourceFiles, testType, framework, coverageTarget = this.config.coverageTargetDefault, patterns = [], } = request;
+            if (sourceFiles.length === 0) {
+                return err(new Error('No source files provided'));
+            }
+            const tests = [];
+            const patternsUsed = [];
+            // Process each source file
+            for (const sourceFile of sourceFiles) {
+                const fileTests = await this.generateTestsForFile(sourceFile, testType, framework, patterns);
+                if (fileTests.success) {
+                    tests.push(...fileTests.value.tests);
+                    patternsUsed.push(...fileTests.value.patternsUsed);
+                }
+            }
+            // Calculate coverage estimate based on test count and complexity
+            const coverageEstimate = this.estimateCoverage(tests, coverageTarget);
+            // Store generation metadata in memory
+            await this.storeGenerationMetadata(tests, patternsUsed);
+            return ok({
+                tests,
+                coverageEstimate,
+                patternsUsed: [...new Set(patternsUsed)],
+            });
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Generate tests specifically targeting coverage gaps
+     */
+    async generateForCoverageGap(file, uncoveredLines, framework) {
+        try {
+            if (uncoveredLines.length === 0) {
+                return ok([]);
+            }
+            // Analyze uncovered lines and generate targeted tests
+            // Groups consecutive lines and generates tests for each block
+            const tests = [];
+            // Group uncovered lines into logical blocks
+            const lineGroups = this.groupConsecutiveLines(uncoveredLines);
+            for (const group of lineGroups) {
+                const test = await this.generateTestForLines(file, group, framework);
+                if (test) {
+                    tests.push(test);
+                }
+            }
+            return ok(tests);
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Generate tests following TDD workflow
+     */
+    async generateTDDTests(request) {
+        try {
+            const { feature, behavior, framework, phase } = request;
+            switch (phase) {
+                case 'red':
+                    // Generate failing test first
+                    return ok(await this.generateRedPhaseTest(feature, behavior, framework));
+                case 'green':
+                    // Generate minimal implementation to make test pass
+                    return ok(await this.generateGreenPhaseCode(feature, behavior, framework));
+                case 'refactor':
+                    // Suggest refactoring improvements
+                    return ok(await this.generateRefactoringSuggestions(feature, behavior));
+                default:
+                    return err(new Error(`Unknown TDD phase: ${phase}`));
+            }
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Generate property-based tests
+     */
+    async generatePropertyTests(request) {
+        try {
+            const { function: funcName, properties, constraints = {} } = request;
+            // Generate property-based tests using fast-check generators
+            const tests = properties.map((property) => ({
+                property,
+                testCode: this.generatePropertyTestCode(funcName, property, constraints),
+                generators: this.inferGenerators(property, constraints),
+            }));
+            return ok({
+                tests,
+                arbitraries: this.collectArbitraries(tests),
+            });
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+     * Generate test data based on schema
+     */
+    async generateTestData(request) {
+        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,
+            });
+        }
+        catch (error) {
+            return err(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    // ============================================================================
+    // Private Helper Methods
+    // ============================================================================
+    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');
+            codeAnalysis = this.analyzeSourceCode(content, sourceFile);
+        }
+        catch {
+            // File doesn't exist or can't be read - use stub generation
+        }
+        // Generate test code based on analysis or fall back to stub
+        let testCode;
+        if (codeAnalysis && (codeAnalysis.functions.length > 0 || codeAnalysis.classes.length > 0)) {
+            testCode = this.generateRealTestCode(sourceFile, testType, framework, codeAnalysis, applicablePatterns);
+        }
+        else {
+            testCode = this.generateStubTestCode(sourceFile, testType, framework, applicablePatterns);
+        }
+        const test = {
+            id: uuidv4(),
+            name: `${this.extractModuleName(sourceFile)} tests`,
+            sourceFile,
+            testFile,
+            testCode,
+            type: testType,
+            assertions: this.countAssertions(testCode),
+        };
+        return ok({ tests: [test], patternsUsed });
+    }
+    /**
+     * Analyze source code using TypeScript AST
+     */
+    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) &&
+                        declaration.initializer &&
+                        (ts.isArrowFunction(declaration.initializer) ||
+                            ts.isFunctionExpression(declaration.initializer))) {
+                        const name = declaration.name.getText(sourceFile);
+                        functions.push(this.extractArrowFunctionInfo(name, declaration.initializer, sourceFile, node));
+                    }
+                }
+            }
+            // Extract class declarations
+            else if (ts.isClassDeclaration(node) && node.name) {
+                classes.push(this.extractClassInfo(node, sourceFile));
+            }
+            ts.forEachChild(node, visit);
+        };
+        ts.forEachChild(sourceFile, visit);
+        return { functions, classes };
+    }
+    /**
+     * Extract function information from AST
+     */
+    extractFunctionInfo(node, sourceFile) {
+        const name = node.name?.getText(sourceFile) || 'anonymous';
+        const parameters = this.extractParameters(node.parameters, sourceFile);
+        const returnType = node.type?.getText(sourceFile);
+        const isAsync = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+        const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+        return {
+            name,
+            parameters,
+            returnType,
+            isAsync,
+            isExported,
+            complexity: this.calculateComplexity(node),
+            startLine: startLine + 1,
+            endLine: endLine + 1,
+            body: node.body?.getText(sourceFile),
+        };
+    }
+    /**
+     * Extract arrow function information from AST
+     */
+    extractArrowFunctionInfo(name, node, sourceFile, parentNode) {
+        const parameters = this.extractParameters(node.parameters, sourceFile);
+        const returnType = node.type?.getText(sourceFile);
+        const isAsync = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        const isExported = ts.isVariableStatement(parentNode) &&
+            (parentNode.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false);
+        const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
+        return {
+            name,
+            parameters,
+            returnType,
+            isAsync,
+            isExported,
+            complexity: this.calculateComplexity(node),
+            startLine: startLine + 1,
+            endLine: endLine + 1,
+            body: node.body?.getText(sourceFile),
+        };
+    }
+    /**
+     * Extract class information from AST
+     */
+    extractClassInfo(node, sourceFile) {
+        const name = node.name?.getText(sourceFile) || 'AnonymousClass';
+        const methods = [];
+        const properties = [];
+        let hasConstructor = false;
+        let constructorParams;
+        const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+        for (const member of node.members) {
+            if (ts.isMethodDeclaration(member)) {
+                const methodName = member.name.getText(sourceFile);
+                const parameters = this.extractParameters(member.parameters, sourceFile);
+                const returnType = member.type?.getText(sourceFile);
+                const isAsync = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+                const { line: startLine } = sourceFile.getLineAndCharacterOfPosition(member.getStart(sourceFile));
+                const { line: endLine } = sourceFile.getLineAndCharacterOfPosition(member.getEnd());
+                methods.push({
+                    name: methodName,
+                    parameters,
+                    returnType,
+                    isAsync,
+                    isExported: false,
+                    complexity: this.calculateComplexity(member),
+                    startLine: startLine + 1,
+                    endLine: endLine + 1,
+                    body: member.body?.getText(sourceFile),
+                });
+            }
+            else if (ts.isConstructorDeclaration(member)) {
+                hasConstructor = true;
+                constructorParams = this.extractParameters(member.parameters, sourceFile);
+            }
+            else if (ts.isPropertyDeclaration(member)) {
+                const propName = member.name.getText(sourceFile);
+                const propType = member.type?.getText(sourceFile);
+                const isPrivate = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword) ?? false;
+                const isReadonly = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword) ?? false;
+                properties.push({
+                    name: propName,
+                    type: propType,
+                    isPrivate,
+                    isReadonly,
+                });
+            }
+        }
+        return {
+            name,
+            methods,
+            properties,
+            isExported,
+            hasConstructor,
+            constructorParams,
+        };
+    }
+    /**
+     * Extract parameters from a function
+     */
+    extractParameters(params, sourceFile) {
+        return params.map((param) => ({
+            name: param.name.getText(sourceFile),
+            type: param.type?.getText(sourceFile),
+            optional: param.questionToken !== undefined,
+            defaultValue: param.initializer?.getText(sourceFile),
+        }));
+    }
+    /**
+     * Calculate cyclomatic complexity of a node
+     */
+    calculateComplexity(node) {
+        let complexity = 1;
+        const visit = (n) => {
+            switch (n.kind) {
+                case ts.SyntaxKind.IfStatement:
+                case ts.SyntaxKind.ForStatement:
+                case ts.SyntaxKind.ForInStatement:
+                case ts.SyntaxKind.ForOfStatement:
+                case ts.SyntaxKind.WhileStatement:
+                case ts.SyntaxKind.DoStatement:
+                case ts.SyntaxKind.CaseClause:
+                case ts.SyntaxKind.CatchClause:
+                case ts.SyntaxKind.ConditionalExpression:
+                    complexity++;
+                    break;
+                case ts.SyntaxKind.BinaryExpression: {
+                    const binary = n;
+                    if (binary.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
+                        binary.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+                        complexity++;
+                    }
+                    break;
+                }
+            }
+            ts.forEachChild(n, visit);
+        };
+        ts.forEachChild(node, visit);
+        return complexity;
+    }
+    /**
+     * Generate real test code based on AST analysis
+     */
+    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';
+    }
+    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) {
+            const pattern = await this.memory.get(key);
+            if (pattern && !patterns.some((p) => p.id === pattern.id)) {
+                patterns.push(pattern);
+            }
+        }
+        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 [];
+        const sorted = [...lines].sort((a, b) => a - b);
+        const groups = [[sorted[0]]];
+        for (let i = 1; i < sorted.length; i++) {
+            const currentGroup = groups[groups.length - 1];
+            if (sorted[i] - currentGroup[currentGroup.length - 1] <= 3) {
+                currentGroup.push(sorted[i]);
+            }
+            else {
+                groups.push([sorted[i]]);
+            }
+        }
+        return groups;
+    }
+    getTestFilePath(sourceFile, framework) {
+        const ext = sourceFile.split('.').pop() || 'ts';
+        const base = sourceFile.replace(`.${ext}`, '');
+        if (framework === 'pytest') {
+            return `test_${base.split('/').pop()}.py`;
+        }
+        return `${base}.test.${ext}`;
+    }
+    extractModuleName(sourceFile) {
+        const filename = sourceFile.split('/').pop() || sourceFile;
+        return filename.replace(/\.(ts|js|tsx|jsx|py)$/, '');
+    }
+    getImportPath(sourceFile) {
+        return sourceFile.replace(/\.(ts|js|tsx|jsx)$/, '');
+    }
+    countAssertions(testCode) {
+        const assertPatterns = [
+            /expect\(/g,
+            /assert/g,
+            /\.to\./g,
+            /\.toBe/g,
+            /\.toEqual/g,
+        ];
+        let count = 0;
+        for (const pattern of assertPatterns) {
+            const matches = testCode.match(pattern);
+            count += matches ? matches.length : 0;
+        }
+        return Math.max(1, count);
+    }
+    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;
+            if (t.type === 'e2e')
+                return mult + 0.15;
+            return mult;
+        }, 1);
+        // Calculate estimated coverage with diminishing returns
+        const rawEstimate = (testBasedCoverage + assertionCoverage) * typeMultiplier;
+        const diminishedEstimate = rawEstimate * (1 - rawEstimate / 200); // Diminishing returns above 100%
+        // Cap at target and round
+        const estimatedCoverage = Math.min(target, Math.max(0, diminishedEstimate));
+        return Math.round(estimatedCoverage * 10) / 10;
+    }
+    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(),
+            testCount: tests.length,
+            patterns,
+            testIds: tests.map((t) => t.id),
+        };
+        await this.memory.set(`test-generation:metadata:${Date.now()}`, metadata, { namespace: 'test-generation', ttl: 86400 * 7 } // 7 days
+        );
+    }
+}
+//# sourceMappingURL=test-generator.js.map