codeguard-testgen 1.0.0

package/dist/index.js

@@ -0,0 +1,2720 @@
+#!/usr/bin/env node
+"use strict";
+/** //This version has lefitimate failure detection and reporting.
+ * AI-Powered Unit Test Generator with AST Analysis
+ * Supports OpenAI, Gemini, and Claude with function calling
+ *
+ * Usage: npx ts-node src/testgen.ts
+ *
+ * Required packages: npm install @babel/parser @babel/traverse ts-node
+ *
+ * Required environment variables:
+ * - OPENAI_API_KEY (for OpenAI)
+ * - GEMINI_API_KEY (for Gemini)
+ * - ANTHROPIC_API_KEY (for Claude)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOLS = exports.CodebaseIndexer = void 0;
+exports.main = main;
+exports.generateTests = generateTests;
+exports.generateTestsForFolder = generateTestsForFolder;
+exports.generateTestsForFunction = generateTestsForFunction;
+exports.generateTestsForFunctions = generateTestsForFunctions;
+exports.executeTool = executeTool;
+exports.analyzeFileAST = analyzeFileAST;
+exports.getFunctionAST = getFunctionAST;
+exports.getImportsAST = getImportsAST;
+exports.getTypeDefinitions = getTypeDefinitions;
+exports.getClassMethods = getClassMethods;
+exports.replaceFunctionTests = replaceFunctionTests;
+exports.deleteLines = deleteLines;
+exports.insertLines = insertLines;
+exports.replaceLines = replaceLines;
+const fs = require("fs/promises");
+const fsSync = require("fs");
+const path = require("path");
+const child_process_1 = require("child_process");
+const readline = require("readline");
+// AST parsers
+const babelParser = require("@babel/parser");
+const traverse = require('@babel/traverse').default;
+// Codebase indexer (optional)
+const codebaseIndexer_1 = require("./codebaseIndexer");
+Object.defineProperty(exports, "CodebaseIndexer", { enumerable: true, get: function () { return codebaseIndexer_1.CodebaseIndexer; } });
+// Configuration loader
+const config_1 = require("./config");
+// Configuration - will be loaded from codeguard.json
+let CONFIG;
+// Global indexer instance (optional - only initialized if user chooses to index)
+let globalIndexer = null;
+// AI Provider configurations - models will be set from CONFIG
+function getAIProviders() {
+    return {
+        openai: {
+            url: 'https://api.openai.com/v1/chat/completions',
+            model: CONFIG.models.openai,
+            headers: (apiKey) => ({
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`
+            })
+        },
+        gemini: {
+            url: (apiKey) => `https://generativelanguage.googleapis.com/v1beta/models/${CONFIG.models.gemini}:generateContent?key=${apiKey}`,
+            model: CONFIG.models.gemini,
+            headers: () => ({
+                'Content-Type': 'application/json'
+            })
+        },
+        claude: {
+            url: 'https://api.anthropic.com/v1/messages',
+            model: CONFIG.models.claude,
+            headers: (apiKey) => ({
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey || '',
+                'anthropic-version': '2023-06-01'
+            })
+        }
+    };
+}
+// Tools available to AI
+const TOOLS = [
+    {
+        name: 'read_file',
+        description: 'Read the contents of a file from the repository',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The relative path to the file from the repository root'
+                }
+            },
+            required: ['file_path']
+        }
+    },
+    {
+        name: 'analyze_file_ast',
+        description: 'Parse file using AST and extract detailed information about all functions, classes, types, and exports',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The relative path to the source file'
+                }
+            },
+            required: ['file_path']
+        }
+    },
+    {
+        name: 'get_function_ast',
+        description: 'Get detailed AST analysis of a specific function including parameters, return type, body, and dependencies',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The relative path to the file'
+                },
+                function_name: {
+                    type: 'string',
+                    description: 'The name of the function to analyze'
+                }
+            },
+            required: ['file_path', 'function_name']
+        }
+    },
+    {
+        name: 'get_imports_ast',
+        description: 'Extract all import statements with detailed information using AST parsing',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The relative path to the file'
+                }
+            },
+            required: ['file_path']
+        }
+    },
+    {
+        name: 'get_type_definitions',
+        description: 'Extract TypeScript type definitions, interfaces, and type aliases from a file',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The relative path to the file'
+                }
+            },
+            required: ['file_path']
+        }
+    },
+    {
+        name: 'resolve_import_path',
+        description: 'Resolve a relative import path to an absolute path',
+        input_schema: {
+            type: 'object',
+            properties: {
+                from_file: {
+                    type: 'string',
+                    description: 'The file containing the import'
+                },
+                import_path: {
+                    type: 'string',
+                    description: 'The import path to resolve'
+                }
+            },
+            required: ['from_file', 'import_path']
+        }
+    },
+    {
+        name: 'get_class_methods',
+        description: 'Extract all methods from a class using AST',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The relative path to the file'
+                },
+                class_name: {
+                    type: 'string',
+                    description: 'The name of the class'
+                }
+            },
+            required: ['file_path', 'class_name']
+        }
+    },
+    {
+        name: 'write_test_file',
+        description: 'Write the complete test file content. This will OVERWRITE the entire file! Only use this for NEW test files or when regenerating ALL tests. If test file exists and you only need to update specific functions, use replace_function_tests instead!',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path where the test file should be written'
+                },
+                content: {
+                    type: 'string',
+                    description: 'The complete content of the test file'
+                },
+                source_file: {
+                    type: 'string',
+                    description: 'The path to the source file being tested (used to validate all functions are tested)'
+                }
+            },
+            required: ['file_path', 'content']
+        }
+    },
+    {
+        name: 'edit_test_file',
+        description: 'Edit an existing test file by replacing specific sections. If this fails, use write_test_file to overwrite the entire file instead.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path to the test file'
+                },
+                old_content: {
+                    type: 'string',
+                    description: 'The content to be replaced (whitespace-normalized matching). Can be empty to overwrite entire file.'
+                },
+                new_content: {
+                    type: 'string',
+                    description: 'The new content to insert'
+                }
+            },
+            required: ['file_path', 'old_content', 'new_content']
+        }
+    },
+    {
+        name: 'replace_function_tests',
+        description: 'Replace or add tests for a specific function in an existing test file. This tool PRESERVES all other existing tests! Use this when test file exists and you want to update only specific function tests without affecting other tests.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                test_file_path: {
+                    type: 'string',
+                    description: 'The path to the test file'
+                },
+                function_name: {
+                    type: 'string',
+                    description: 'The name of the function whose tests should be replaced'
+                },
+                new_test_content: {
+                    type: 'string',
+                    description: 'The complete describe block for the function tests (e.g., describe("functionName", () => { test(...) }))'
+                }
+            },
+            required: ['test_file_path', 'function_name', 'new_test_content']
+        }
+    },
+    {
+        name: 'run_tests',
+        description: 'Run Jest tests for a specific test file',
+        input_schema: {
+            type: 'object',
+            properties: {
+                test_file_path: {
+                    type: 'string',
+                    description: 'The path to the test file to run'
+                }
+            },
+            required: ['test_file_path']
+        }
+    },
+    {
+        name: 'list_directory',
+        description: 'List all files and directories in a given path to discover available modules',
+        input_schema: {
+            type: 'object',
+            properties: {
+                directory_path: {
+                    type: 'string',
+                    description: 'The directory path to list (e.g., "src/models", "src/helpers")'
+                }
+            },
+            required: ['directory_path']
+        }
+    },
+    {
+        name: 'find_file',
+        description: 'Search for a file by name in the repository to find its exact path',
+        input_schema: {
+            type: 'object',
+            properties: {
+                filename: {
+                    type: 'string',
+                    description: 'The filename to search for (e.g., "agent.helper.ts", "response-wrapper.ts")'
+                }
+            },
+            required: ['filename']
+        }
+    },
+    {
+        name: 'calculate_relative_path',
+        description: 'Calculate the correct relative import path from one file to another',
+        input_schema: {
+            type: 'object',
+            properties: {
+                from_file: {
+                    type: 'string',
+                    description: 'The file that will contain the import (e.g., "src/tests/index.test.ts")'
+                },
+                to_file: {
+                    type: 'string',
+                    description: 'The file being imported (e.g., "src/models/serviceDesk.models.ts")'
+                }
+            },
+            required: ['from_file', 'to_file']
+        }
+    },
+    {
+        name: 'report_legitimate_failure',
+        description: 'Report that test failures are legitimate due to bugs in the source code, not issues with the test itself. Use this when tests are correctly written but fail because the source code has bugs.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                test_file_path: {
+                    type: 'string',
+                    description: 'The path to the test file'
+                },
+                failing_tests: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'List of test names that are legitimately failing'
+                },
+                reason: {
+                    type: 'string',
+                    description: 'Explanation of why the failures are legitimate (e.g., "Function returns undefined instead of expected object", "Missing null check causes TypeError")'
+                },
+                source_code_issue: {
+                    type: 'string',
+                    description: 'Description of the bug in the source code that causes the failure'
+                }
+            },
+            required: ['test_file_path', 'failing_tests', 'reason', 'source_code_issue']
+        }
+    },
+    {
+        name: 'delete_lines',
+        description: 'Delete specific lines from a file by line number range. Useful for removing incorrect imports, mocks, or test code. Use this after reading the file to know exact line numbers.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path to the file to edit'
+                },
+                start_line: {
+                    type: 'number',
+                    description: 'The starting line number to delete (1-indexed, inclusive)'
+                },
+                end_line: {
+                    type: 'number',
+                    description: 'The ending line number to delete (1-indexed, inclusive)'
+                }
+            },
+            required: ['file_path', 'start_line', 'end_line']
+        }
+    },
+    {
+        name: 'insert_lines',
+        description: 'Insert new lines at a specific position in a file. Useful for adding missing imports, mocks, or test cases. Use this after reading the file to know exact line numbers.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path to the file to edit'
+                },
+                line_number: {
+                    type: 'number',
+                    description: 'The line number where content should be inserted (1-indexed). New content will be inserted BEFORE this line. Use 1 to insert at the beginning, or file length + 1 to append.'
+                },
+                content: {
+                    type: 'string',
+                    description: 'The content to insert (can be multiple lines separated by \\n)'
+                }
+            },
+            required: ['file_path', 'line_number', 'content']
+        }
+    },
+    {
+        name: 'replace_lines',
+        description: 'Replace a range of lines with new content. Combines delete and insert for efficient line-based edits. Use this after reading the file to know exact line numbers.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path to the file to edit'
+                },
+                start_line: {
+                    type: 'number',
+                    description: 'The starting line number to replace (1-indexed, inclusive)'
+                },
+                end_line: {
+                    type: 'number',
+                    description: 'The ending line number to replace (1-indexed, inclusive)'
+                },
+                new_content: {
+                    type: 'string',
+                    description: 'The new content to insert in place of the deleted lines'
+                }
+            },
+            required: ['file_path', 'start_line', 'end_line', 'new_content']
+        }
+    }
+];
+exports.TOOLS = TOOLS;
+// AST Parsing utilities
+function parseFileToAST(filePath, content) {
+    const ext = path.extname(filePath);
+    try {
+        // Use Babel parser for all files (it handles TypeScript via plugin)
+        return babelParser.parse(content, {
+            sourceType: 'module',
+            plugins: [
+                'typescript',
+                ext === '.tsx' || ext === '.jsx' ? 'jsx' : null,
+                'decorators-legacy',
+                'classProperties',
+                'objectRestSpread',
+                'asyncGenerators',
+                'dynamicImport',
+                'optionalChaining',
+                'nullishCoalescingOperator'
+            ].filter(Boolean)
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ${filePath}: ${error.message}`);
+    }
+}
+function analyzeFileAST(filePath) {
+    try {
+        const content = fsSync.readFileSync(filePath, 'utf-8');
+        const ast = parseFileToAST(filePath, content);
+        if (!ast || !ast.program) {
+            throw new Error('Failed to parse AST: no program node found');
+        }
+        const analysis = {
+            functions: [],
+            classes: [],
+            exports: [],
+            imports: [],
+            types: [],
+            constants: []
+        };
+        traverse(ast, {
+            // Function declarations
+            FunctionDeclaration(path) {
+                const node = path.node;
+                analysis.functions.push({
+                    name: node.id?.name,
+                    type: 'function',
+                    async: node.async,
+                    generator: node.generator,
+                    params: node.params.map(p => extractParamInfo(p)),
+                    returnType: node.returnType ? getTypeAnnotation(node.returnType) : null,
+                    line: node.loc?.start.line,
+                    exported: path.parent.type === 'ExportNamedDeclaration' ||
+                        path.parent.type === 'ExportDefaultDeclaration'
+                });
+            },
+            // Arrow functions and function expressions
+            VariableDeclarator(path) {
+                const node = path.node;
+                if (node.init && (node.init.type === 'ArrowFunctionExpression' ||
+                    node.init.type === 'FunctionExpression')) {
+                    analysis.functions.push({
+                        name: node.id.name,
+                        type: node.init.type === 'ArrowFunctionExpression' ? 'arrow' : 'function',
+                        async: node.init.async,
+                        params: node.init.params.map(p => extractParamInfo(p)),
+                        returnType: node.init.returnType ? getTypeAnnotation(node.init.returnType) : null,
+                        line: node.loc?.start.line,
+                        exported: path.parentPath.parent.type === 'ExportNamedDeclaration'
+                    });
+                }
+                else if (node.init) {
+                    // Constants
+                    analysis.constants.push({
+                        name: node.id.name,
+                        type: node.id.typeAnnotation ? getTypeAnnotation(node.id.typeAnnotation) : null,
+                        line: node.loc?.start.line
+                    });
+                }
+            },
+            // Classes
+            ClassDeclaration(path) {
+                const node = path.node;
+                const methods = [];
+                if (node.body && node.body.body) {
+                    node.body.body.forEach(member => {
+                        if (member.type === 'ClassMethod' || member.type === 'MethodDefinition') {
+                            methods.push({
+                                name: member.key.name,
+                                kind: member.kind, // constructor, method, get, set
+                                static: member.static,
+                                async: member.async,
+                                params: member.params ? member.params.map(p => extractParamInfo(p)) : [],
+                                returnType: member.returnType ? getTypeAnnotation(member.returnType) : null
+                            });
+                        }
+                    });
+                }
+                analysis.classes.push({
+                    name: node.id?.name,
+                    methods,
+                    superClass: node.superClass?.name,
+                    line: node.loc?.start.line,
+                    exported: path.parent.type === 'ExportNamedDeclaration' ||
+                        path.parent.type === 'ExportDefaultDeclaration'
+                });
+            },
+            // Type definitions
+            TSTypeAliasDeclaration(path) {
+                analysis.types.push({
+                    name: path.node.id.name,
+                    kind: 'type',
+                    line: path.node.loc?.start.line
+                });
+            },
+            TSInterfaceDeclaration(path) {
+                analysis.types.push({
+                    name: path.node.id.name,
+                    kind: 'interface',
+                    line: path.node.loc?.start.line
+                });
+            },
+            // Exports
+            ExportNamedDeclaration(path) {
+                if (path.node.specifiers) {
+                    path.node.specifiers.forEach(spec => {
+                        analysis.exports.push({
+                            name: spec.exported.name,
+                            local: spec.local.name,
+                            type: 'named'
+                        });
+                    });
+                }
+            },
+            ExportDefaultDeclaration(path) {
+                const declaration = path.node.declaration;
+                let name = 'default';
+                if (declaration.id) {
+                    name = declaration.id.name;
+                }
+                else if (declaration.name) {
+                    name = declaration.name;
+                }
+                analysis.exports.push({
+                    name,
+                    type: 'default'
+                });
+            }
+        });
+        return {
+            success: true,
+            analysis,
+            summary: {
+                functionCount: analysis.functions.length,
+                classCount: analysis.classes.length,
+                exportCount: analysis.exports.length,
+                typeCount: analysis.types.length
+            }
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+function extractParamInfo(param) {
+    if (param.type === 'Identifier') {
+        return {
+            name: param.name,
+            type: param.typeAnnotation ? getTypeAnnotation(param.typeAnnotation) : null,
+            optional: param.optional
+        };
+    }
+    else if (param.type === 'RestElement') {
+        return {
+            name: param.argument.name,
+            rest: true,
+            type: param.typeAnnotation ? getTypeAnnotation(param.typeAnnotation) : null
+        };
+    }
+    else if (param.type === 'AssignmentPattern') {
+        return {
+            name: param.left.name,
+            defaultValue: true,
+            type: param.left.typeAnnotation ? getTypeAnnotation(param.left.typeAnnotation) : null
+        };
+    }
+    return { name: 'unknown' };
+}
+function getTypeAnnotation(typeNode) {
+    if (!typeNode)
+        return null;
+    // Handle different type annotation formats
+    if (typeNode.typeAnnotation) {
+        typeNode = typeNode.typeAnnotation;
+    }
+    if (typeNode.type === 'TSStringKeyword')
+        return 'string';
+    if (typeNode.type === 'TSNumberKeyword')
+        return 'number';
+    if (typeNode.type === 'TSBooleanKeyword')
+        return 'boolean';
+    if (typeNode.type === 'TSAnyKeyword')
+        return 'any';
+    if (typeNode.type === 'TSVoidKeyword')
+        return 'void';
+    if (typeNode.type === 'TSUndefinedKeyword')
+        return 'undefined';
+    if (typeNode.type === 'TSNullKeyword')
+        return 'null';
+    if (typeNode.type === 'TSTypeReference' && typeNode.typeName) {
+        return typeNode.typeName.name || 'unknown';
+    }
+    if (typeNode.type === 'TSArrayType') {
+        const elementType = getTypeAnnotation(typeNode.elementType);
+        return `${elementType}[]`;
+    }
+    return 'unknown';
+}
+function getFunctionAST(filePath, functionName) {
+    try {
+        const content = fsSync.readFileSync(filePath, 'utf-8');
+        const ast = parseFileToAST(filePath, content);
+        const lines = content.split('\n');
+        let functionInfo = null;
+        traverse(ast, {
+            FunctionDeclaration(path) {
+                if (path.node.id?.name === functionName) {
+                    functionInfo = extractFunctionDetails(path, lines);
+                    path.stop();
+                }
+            },
+            VariableDeclarator(path) {
+                if (path.node.id.name === functionName &&
+                    (path.node.init?.type === 'ArrowFunctionExpression' ||
+                        path.node.init?.type === 'FunctionExpression')) {
+                    functionInfo = extractFunctionDetails(path, lines, true);
+                    path.stop();
+                }
+            },
+            ClassMethod(path) {
+                if (path.node.key.name === functionName) {
+                    functionInfo = extractFunctionDetails(path, lines);
+                    path.stop();
+                }
+            }
+        });
+        if (!functionInfo) {
+            return { success: false, error: `Function ${functionName} not found` };
+        }
+        return Object.assign({ success: true }, functionInfo);
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+function extractFunctionDetails(path, lines, isVariable = false) {
+    const node = isVariable ? path.node.init : path.node;
+    const startLine = node.loc.start.line - 1;
+    const endLine = node.loc.end.line - 1;
+    const code = lines.slice(startLine, endLine + 1).join('\n');
+    // Extract basic info without deep traversal (to avoid scope issues)
+    return {
+        name: isVariable ? path.node.id.name : node.id?.name,
+        code,
+        startLine: startLine + 1,
+        endLine: endLine + 1,
+        params: node.params.map((p) => extractParamInfo(p)),
+        returnType: node.returnType ? getTypeAnnotation(node.returnType) : null,
+        async: node.async,
+        complexity: 1 // Simplified complexity
+    };
+}
+// Removed estimateComplexity to avoid scope/parentPath traversal issues
+// Complexity is now hardcoded to 1 in extractFunctionDetails
+function getImportsAST(filePath) {
+    try {
+        const content = fsSync.readFileSync(filePath, 'utf-8');
+        const ast = parseFileToAST(filePath, content);
+        const imports = [];
+        traverse(ast, {
+            ImportDeclaration(path) {
+                const node = path.node;
+                const imported = [];
+                node.specifiers.forEach(spec => {
+                    if (spec.type === 'ImportDefaultSpecifier') {
+                        imported.push({ name: spec.local.name, type: 'default' });
+                    }
+                    else if (spec.type === 'ImportSpecifier') {
+                        imported.push({
+                            name: spec.local.name,
+                            imported: spec.imported.name,
+                            type: 'named'
+                        });
+                    }
+                    else if (spec.type === 'ImportNamespaceSpecifier') {
+                        imported.push({ name: spec.local.name, type: 'namespace' });
+                    }
+                });
+                imports.push({
+                    source: node.source.value,
+                    imported,
+                    line: node.loc.start.line
+                });
+            },
+            // Handle require statements
+            CallExpression(path) {
+                if (path.node.callee.name === 'require' &&
+                    path.node.arguments[0]?.type === 'StringLiteral') {
+                    const parent = path.parent;
+                    let variableName = null;
+                    if (parent.type === 'VariableDeclarator') {
+                        variableName = parent.id.name;
+                    }
+                    imports.push({
+                        source: path.node.arguments[0].value,
+                        imported: variableName ? [{ name: variableName, type: 'require' }] : [],
+                        type: 'require',
+                        line: path.node.loc.start.line
+                    });
+                }
+            }
+        });
+        return { success: true, imports };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+function getTypeDefinitions(filePath) {
+    try {
+        const content = fsSync.readFileSync(filePath, 'utf-8');
+        const ast = parseFileToAST(filePath, content);
+        const lines = content.split('\n');
+        const types = [];
+        traverse(ast, {
+            TSTypeAliasDeclaration(path) {
+                const node = path.node;
+                const startLine = node.loc.start.line - 1;
+                const endLine = node.loc.end.line - 1;
+                types.push({
+                    name: node.id.name,
+                    kind: 'type',
+                    code: lines.slice(startLine, endLine + 1).join('\n'),
+                    line: startLine + 1,
+                    exported: path.parent.type === 'ExportNamedDeclaration'
+                });
+            },
+            TSInterfaceDeclaration(path) {
+                const node = path.node;
+                const startLine = node.loc.start.line - 1;
+                const endLine = node.loc.end.line - 1;
+                const properties = [];
+                if (node.body && node.body.body) {
+                    node.body.body.forEach(member => {
+                        if (member.type === 'TSPropertySignature') {
+                            properties.push({
+                                name: member.key.name,
+                                type: member.typeAnnotation ?
+                                    getTypeAnnotation(member.typeAnnotation) : null,
+                                optional: member.optional
+                            });
+                        }
+                    });
+                }
+                types.push({
+                    name: node.id.name,
+                    kind: 'interface',
+                    code: lines.slice(startLine, endLine + 1).join('\n'),
+                    properties,
+                    line: startLine + 1,
+                    exported: path.parent.type === 'ExportNamedDeclaration'
+                });
+            },
+            TSEnumDeclaration(path) {
+                const node = path.node;
+                const startLine = node.loc.start.line - 1;
+                const endLine = node.loc.end.line - 1;
+                types.push({
+                    name: node.id.name,
+                    kind: 'enum',
+                    code: lines.slice(startLine, endLine + 1).join('\n'),
+                    line: startLine + 1,
+                    exported: path.parent.type === 'ExportNamedDeclaration'
+                });
+            }
+        });
+        return { success: true, types };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+function getClassMethods(filePath, className) {
+    try {
+        const content = fsSync.readFileSync(filePath, 'utf-8');
+        const ast = parseFileToAST(filePath, content);
+        const lines = content.split('\n');
+        let classInfo = null;
+        traverse(ast, {
+            ClassDeclaration(path) {
+                if (path.node.id?.name === className) {
+                    const methods = [];
+                    if (path.node.body && path.node.body.body) {
+                        path.node.body.body.forEach(member => {
+                            if (member.type === 'ClassMethod' || member.type === 'MethodDefinition') {
+                                const startLine = member.loc.start.line - 1;
+                                const endLine = member.loc.end.line - 1;
+                                methods.push({
+                                    name: member.key.name,
+                                    kind: member.kind,
+                                    static: member.static,
+                                    async: member.async,
+                                    params: member.params ? member.params.map(p => extractParamInfo(p)) : [],
+                                    returnType: member.returnType ? getTypeAnnotation(member.returnType) : null,
+                                    code: lines.slice(startLine, endLine + 1).join('\n'),
+                                    line: startLine + 1
+                                });
+                            }
+                        });
+                    }
+                    classInfo = {
+                        name: className,
+                        methods,
+                        superClass: path.node.superClass?.name
+                    };
+                    path.stop();
+                }
+            }
+        });
+        if (!classInfo) {
+            return { success: false, error: `Class ${className} not found` };
+        }
+        return { success: true, ...classInfo };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+// Other tool implementations
+async function readFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        return { success: true, content };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+function resolveImportPath(fromFile, importPath) {
+    try {
+        if (importPath.startsWith('.')) {
+            const dir = path.dirname(fromFile);
+            const resolved = path.resolve(dir, importPath);
+            const extensions = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.js'];
+            for (const ext of extensions) {
+                const withExt = resolved + ext;
+                if (fsSync.existsSync(withExt)) {
+                    return { success: true, resolvedPath: withExt };
+                }
+            }
+            if (fsSync.existsSync(resolved)) {
+                return { success: true, resolvedPath: resolved };
+            }
+        }
+        return {
+            success: true,
+            resolvedPath: importPath,
+            isExternal: true
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+async function writeTestFile(filePath, content, sourceFilePath) {
+    try {
+        // VALIDATE: Check for incomplete/placeholder tests BEFORE writing
+        const invalidPatterns = [
+            /\/\/\s*(Mock setup|Assertions|Call function|Add test|Further test|Additional test)/i,
+            /\/\/\s*(Add more|write more|Similarly|write tests for)/i,
+            /\/\/\s*TODO/i,
+            /\/\/\s*\.\.\./,
+            /\/\/.*etc\./i,
+            /expect\(\).*\/\//, // expect() followed by comment
+        ];
+        const hasPlaceholders = invalidPatterns.some(pattern => pattern.test(content));
+        if (hasPlaceholders) {
+            // Extract the actual placeholder comment for the error message
+            const foundPlaceholder = content.match(invalidPatterns.find(p => p.test(content)) || /\/\/.*/);
+            return {
+                success: false,
+                error: `REJECTED: Test file contains placeholder comment: "${foundPlaceholder?.[0]}"\n\nYou must write COMPLETE tests with actual code for ALL functions, not comments like "// Add more tests", "// Similarly", "// Further tests". Write the FULL implementation for EVERY function!`
+            };
+        }
+        // VALIDATE: Check if file has actual expect() statements
+        const expectCount = (content.match(/expect\(/g) || []).length;
+        const testCount = (content.match(/test\(|it\(/g) || []).length;
+        const describeCount = (content.match(/describe\(/g) || []).length;
+        if (testCount > 0 && expectCount === 0) {
+            return {
+                success: false,
+                error: 'REJECTED: Test file has test cases but NO expect() assertions! Every test MUST have at least one expect() statement. Write actual assertions!'
+            };
+        }
+        // VALIDATE: Compare against source file if provided
+        let expectedFunctionCount = 3; // Default minimum
+        if (sourceFilePath && fsSync.existsSync(sourceFilePath)) {
+            const analysis = analyzeFileAST(sourceFilePath);
+            if (analysis.success) {
+                const exportedFunctions = analysis.analysis.functions.filter((f) => f.exported);
+                expectedFunctionCount = exportedFunctions.length;
+                if (describeCount < expectedFunctionCount) {
+                    return {
+                        success: false,
+                        error: `REJECTED: Source file has ${expectedFunctionCount} exported functions but test file only has ${describeCount} describe blocks!\n\nMissing tests for: ${exportedFunctions.slice(describeCount).map((f) => f.name).join(', ')}\n\nWrite a describe block with tests for EVERY function!`
+                    };
+                }
+            }
+        }
+        else if (describeCount < 3) {
+            return {
+                success: false,
+                error: `REJECTED: Test file has only ${describeCount} describe blocks! The source file has multiple exported functions. You must write a describe block for EACH function, not just some of them. Write tests for ALL functions!`
+            };
+        }
+        if (testCount < Math.max(4, expectedFunctionCount * 2)) {
+            return {
+                success: false,
+                error: `REJECTED: Test file has only ${testCount} tests for ${expectedFunctionCount} functions! Write at least 2-3 test cases per function (happy path, edge cases, errors). You need at least ${expectedFunctionCount * 2} tests total!`
+            };
+        }
+        const dir = path.dirname(filePath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(filePath, content, 'utf-8');
+        return {
+            success: true,
+            path: filePath,
+            stats: {
+                tests: testCount,
+                expectations: expectCount
+            }
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+async function editTestFile(filePath, oldContent, newContent) {
+    try {
+        // Ensure directory exists
+        const dir = path.dirname(filePath);
+        await fs.mkdir(dir, { recursive: true });
+        let content = await fs.readFile(filePath, 'utf-8');
+        // Normalize whitespace for comparison (more forgiving)
+        const normalizeWhitespace = (str) => str.replace(/\s+/g, ' ').trim();
+        const normalizedContent = normalizeWhitespace(content);
+        const normalizedOld = normalizeWhitespace(oldContent);
+        // First try: Exact match
+        if (content.includes(oldContent)) {
+            content = content.replace(oldContent, newContent);
+            await fs.writeFile(filePath, content, 'utf-8');
+            return { success: true, message: 'File edited successfully (exact match)' };
+        }
+        // Second try: Normalized whitespace match
+        if (normalizedContent.includes(normalizedOld)) {
+            // Find the original position and replace
+            const lines = content.split('\n');
+            const oldLines = oldContent.split('\n');
+            // Try to find the section
+            for (let i = 0; i <= lines.length - oldLines.length; i++) {
+                const section = lines.slice(i, i + oldLines.length).join('\n');
+                if (normalizeWhitespace(section) === normalizedOld) {
+                    lines.splice(i, oldLines.length, newContent);
+                    content = lines.join('\n');
+                    await fs.writeFile(filePath, content, 'utf-8');
+                    return { success: true, message: 'File edited successfully (normalized match)' };
+                }
+            }
+        }
+        // Third try: If oldContent is empty or very short, just overwrite the file
+        if (!oldContent || oldContent.trim().length < 10) {
+            await fs.writeFile(filePath, newContent, 'utf-8');
+            return { success: true, message: 'File overwritten (old content was empty/short)' };
+        }
+        // If all fails, show helpful error with file preview
+        const preview = content.substring(0, 500);
+        return {
+            success: false,
+            error: `Old content not found. Current file preview:\n${preview}\n...\n\nHint: Use write_test_file to overwrite the entire file instead.`,
+            currentContent: preview
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+async function replaceFunctionTests(testFilePath, functionName, newTestContent) {
+    try {
+        // Ensure directory exists
+        const dir = path.dirname(testFilePath);
+        await fs.mkdir(dir, { recursive: true });
+        if (!fsSync.existsSync(testFilePath)) {
+            // File doesn't exist, create it
+            return await writeTestFile(testFilePath, newTestContent);
+        }
+        const content = await fs.readFile(testFilePath, 'utf-8');
+        // Try to find the describe block for this function
+        // Patterns to match: describe('functionName', ...) or describe("functionName", ...)
+        const describePattern = new RegExp(`describe\\s*\\(['"]\s*${functionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*['"]\\s*,.*?\\n\\}\\);?`, 'gs');
+        const match = content.match(describePattern);
+        if (match && match.length > 0) {
+            // Replace the existing describe block
+            const updatedContent = content.replace(describePattern, newTestContent);
+            await fs.writeFile(testFilePath, updatedContent, 'utf-8');
+            return {
+                success: true,
+                message: `Replaced tests for function '${functionName}'`,
+                replaced: true
+            };
+        }
+        else {
+            // Function tests don't exist, append them
+            // Find the last closing bracket or append at the end
+            const lines = content.split('\n');
+            let insertIndex = lines.length;
+            // Try to insert before the last line if it's just whitespace or closing bracket
+            for (let i = lines.length - 1; i >= 0; i--) {
+                const line = lines[i].trim();
+                if (line && line !== '}' && line !== '});') {
+                    insertIndex = i + 1;
+                    break;
+                }
+            }
+            lines.splice(insertIndex, 0, '', newTestContent);
+            await fs.writeFile(testFilePath, lines.join('\n'), 'utf-8');
+            return {
+                success: true,
+                message: `Added tests for function '${functionName}'`,
+                replaced: false,
+                appended: true
+            };
+        }
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+function runTests(testFilePath) {
+    try {
+        const output = (0, child_process_1.execSync)(`npx jest ${testFilePath} --no-coverage`, {
+            encoding: 'utf-8',
+            stdio: 'pipe'
+        });
+        return {
+            success: true,
+            output,
+            passed: true
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            output: error.stdout + error.stderr,
+            passed: false,
+            error: error.message
+        };
+    }
+}
+function listDirectory(directoryPath) {
+    try {
+        if (!fsSync.existsSync(directoryPath)) {
+            return { success: false, error: `Directory not found: ${directoryPath}` };
+        }
+        const items = fsSync.readdirSync(directoryPath);
+        const details = items.map(item => {
+            const fullPath = path.join(directoryPath, item);
+            const stats = fsSync.statSync(fullPath);
+            return {
+                name: item,
+                path: fullPath,
+                type: stats.isDirectory() ? 'directory' : 'file',
+                isDirectory: stats.isDirectory()
+            };
+        });
+        return {
+            success: true,
+            path: directoryPath,
+            items: details,
+            files: details.filter(d => !d.isDirectory).map(d => d.name),
+            directories: details.filter(d => d.isDirectory).map(d => d.name)
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+function findFile(filename) {
+    try {
+        const searchDirs = ['src', 'tests', '.'];
+        const found = [];
+        function searchRecursive(dir) {
+            if (!fsSync.existsSync(dir))
+                return;
+            const items = fsSync.readdirSync(dir);
+            for (const item of items) {
+                const fullPath = path.join(dir, item);
+                const stats = fsSync.statSync(fullPath);
+                if (stats.isDirectory()) {
+                    if (!['node_modules', 'dist', 'build', '.git', 'coverage'].includes(item)) {
+                        searchRecursive(fullPath);
+                    }
+                }
+                else {
+                    // Check both full path and filename for matches
+                    const normalizedFullPath = fullPath.replace(/\\/g, '/');
+                    const normalizedSearch = filename.replace(/\\/g, '/');
+                    if (normalizedFullPath === normalizedSearch || // Exact full path match
+                        normalizedFullPath.includes(normalizedSearch) || // Partial path match
+                        normalizedFullPath.endsWith(normalizedSearch) || // Ends with search term
+                        item === filename || // Exact filename match
+                        item.includes(filename) // Partial filename match
+                    ) {
+                        found.push(fullPath);
+                    }
+                }
+            }
+        }
+        for (const dir of searchDirs) {
+            searchRecursive(dir);
+        }
+        if (found.length === 0) {
+            return {
+                success: false,
+                error: `File "${filename}" not found in repository`
+            };
+        }
+        return {
+            success: true,
+            filename,
+            found: found,
+            count: found.length,
+            primaryMatch: found[0]
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+function calculateRelativePath(fromFile, toFile) {
+    try {
+        const fromDir = path.dirname(fromFile);
+        let relativePath = path.relative(fromDir, toFile);
+        // Remove .ts, .tsx, .js, .jsx extensions for imports
+        relativePath = relativePath.replace(/\.(ts|tsx|js|jsx)$/, '');
+        // Ensure it starts with ./ or ../
+        if (!relativePath.startsWith('.')) {
+            relativePath = './' + relativePath;
+        }
+        // Convert backslashes to forward slashes (Windows compatibility)
+        relativePath = relativePath.replace(/\\/g, '/');
+        return {
+            success: true,
+            from: fromFile,
+            to: toFile,
+            relativePath,
+            importStatement: `import { ... } from '${relativePath}';`
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+function reportLegitimateFailure(testFilePath, failingTests, reason, sourceCodeIssue) {
+    console.log('\n⚠️  LEGITIMATE TEST FAILURE REPORTED');
+    console.log(`   Test file: ${testFilePath}`);
+    console.log(`   Failing tests: ${failingTests.join(', ')}`);
+    console.log(`   Reason: ${reason}`);
+    console.log(`   Source code issue: ${sourceCodeIssue}`);
+    return {
+        success: true,
+        acknowledged: true,
+        message: 'Legitimate failure reported. Tests have been written correctly but source code has bugs.',
+        testFilePath,
+        failingTests,
+        reason,
+        sourceCodeIssue,
+        recommendation: 'Fix the source code to resolve these test failures.'
+    };
+}
+async function deleteLines(filePath, startLine, endLine) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        // Validate line numbers (1-indexed)
+        if (startLine < 1 || endLine < 1 || startLine > lines.length || endLine > lines.length) {
+            return {
+                success: false,
+                error: `Invalid line range: ${startLine}-${endLine}. File has ${lines.length} lines.`
+            };
+        }
+        if (startLine > endLine) {
+            return {
+                success: false,
+                error: `Start line (${startLine}) must be <= end line (${endLine})`
+            };
+        }
+        // Delete lines (convert to 0-indexed)
+        const deletedLines = lines.splice(startLine - 1, endLine - startLine + 1);
+        await fs.writeFile(filePath, lines.join('\n'), 'utf-8');
+        return {
+            success: true,
+            message: `Deleted lines ${startLine}-${endLine}`,
+            deletedCount: deletedLines.length,
+            deletedContent: deletedLines.join('\n')
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+async function insertLines(filePath, lineNumber, content) {
+    try {
+        const fileContent = await fs.readFile(filePath, 'utf-8');
+        const lines = fileContent.split('\n');
+        // Validate line number (1-indexed)
+        if (lineNumber < 1 || lineNumber > lines.length + 1) {
+            return {
+                success: false,
+                error: `Invalid line number: ${lineNumber}. File has ${lines.length} lines (use 1-${lines.length + 1}).`
+            };
+        }
+        // Split content into lines and insert (convert to 0-indexed)
+        const newLines = content.split('\n');
+        lines.splice(lineNumber - 1, 0, ...newLines);
+        await fs.writeFile(filePath, lines.join('\n'), 'utf-8');
+        return {
+            success: true,
+            message: `Inserted ${newLines.length} line(s) at line ${lineNumber}`,
+            insertedCount: newLines.length
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+async function replaceLines(filePath, startLine, endLine, newContent) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        // Validate line numbers (1-indexed)
+        if (startLine < 1 || endLine < 1 || startLine > lines.length || endLine > lines.length) {
+            return {
+                success: false,
+                error: `Invalid line range: ${startLine}-${endLine}. File has ${lines.length} lines.`
+            };
+        }
+        if (startLine > endLine) {
+            return {
+                success: false,
+                error: `Start line (${startLine}) must be <= end line (${endLine})`
+            };
+        }
+        // Replace lines (convert to 0-indexed)
+        const oldLines = lines.splice(startLine - 1, endLine - startLine + 1, ...newContent.split('\n'));
+        await fs.writeFile(filePath, lines.join('\n'), 'utf-8');
+        return {
+            success: true,
+            message: `Replaced lines ${startLine}-${endLine}`,
+            oldContent: oldLines.join('\n'),
+            newLineCount: newContent.split('\n').length
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+// User-friendly messages for each tool
+const TOOL_MESSAGES = {
+    'read_file': '📖 Reading source file',
+    'analyze_file_ast': '🔍 Analyzing codebase structure',
+    'get_function_ast': '🔎 Examining function details',
+    'get_imports_ast': '📦 Analyzing dependencies',
+    'get_type_definitions': '📋 Extracting type definitions',
+    'get_class_methods': '🏗️  Analyzing class structure',
+    'resolve_import_path': '🔗 Resolving import paths',
+    'write_test_file': '✍️  Writing test cases to file',
+    'edit_test_file': '✏️  Updating test file',
+    'replace_function_tests': '🔄 Replacing test cases for specific functions',
+    'run_tests': '🧪 Running tests',
+    'list_directory': '📂 Exploring directory structure',
+    'find_file': '🔍 Locating file in repository',
+    'calculate_relative_path': '🧭 Calculating import path',
+    'report_legitimate_failure': '⚠️  Reporting legitimate test failures',
+    'delete_lines': '🗑️  Deleting lines from file',
+    'insert_lines': '➕ Inserting lines into file',
+    'replace_lines': '🔄 Replacing lines in file'
+};
+// Tool execution router
+async function executeTool(toolName, args) {
+    // Show user-friendly message with dynamic context
+    let friendlyMessage = TOOL_MESSAGES[toolName] || `🔧 ${toolName}`;
+    // Add specific details for certain tools
+    if (toolName === 'replace_function_tests' && args.function_name) {
+        friendlyMessage = `🔄 Replacing test cases for function: ${args.function_name}`;
+    }
+    else if (toolName === 'delete_lines' && args.start_line && args.end_line) {
+        friendlyMessage = `🗑️  Deleting lines ${args.start_line}-${args.end_line}`;
+    }
+    else if (toolName === 'insert_lines' && args.line_number) {
+        friendlyMessage = `➕ Inserting lines at line ${args.line_number}`;
+    }
+    else if (toolName === 'replace_lines' && args.start_line && args.end_line) {
+        friendlyMessage = `🔄 Replacing lines ${args.start_line}-${args.end_line}`;
+    }
+    console.log(`\n${friendlyMessage}...`);
+    let result;
+    try {
+        switch (toolName) {
+            case 'read_file':
+                result = await readFile(args.file_path);
+                break;
+            case 'analyze_file_ast':
+                // Try cache first if indexer is available
+                if (globalIndexer) {
+                    // Check if file has been modified since caching
+                    if (globalIndexer.isFileStale(args.file_path)) {
+                        console.log('   🔄 File modified, re-analyzing...');
+                        result = analyzeFileAST(args.file_path);
+                        // Update cache with new analysis
+                        if (result.success) {
+                            await globalIndexer.updateIndex([args.file_path], analyzeFileAST);
+                        }
+                        break;
+                    }
+                    const cached = globalIndexer.getFileAnalysis(args.file_path);
+                    if (cached) {
+                        console.log('   📦 Using cached analysis');
+                        result = {
+                            success: true,
+                            analysis: cached,
+                            summary: {
+                                functionCount: cached.functions.length,
+                                classCount: cached.classes.length,
+                                exportCount: cached.exports.length,
+                                typeCount: cached.types.length
+                            }
+                        };
+                        break;
+                    }
+                }
+                // Fall back to actual analysis
+                result = analyzeFileAST(args.file_path);
+                break;
+            case 'get_function_ast':
+                result = getFunctionAST(args.file_path, args.function_name);
+                break;
+            case 'get_imports_ast':
+                result = getImportsAST(args.file_path);
+                break;
+            case 'get_type_definitions':
+                result = getTypeDefinitions(args.file_path);
+                break;
+            case 'get_class_methods':
+                result = getClassMethods(args.file_path, args.class_name);
+                break;
+            case 'resolve_import_path':
+                result = resolveImportPath(args.from_file, args.import_path);
+                break;
+            case 'write_test_file':
+                result = await writeTestFile(args.file_path, args.content, args.source_file);
+                break;
+            case 'edit_test_file':
+                result = await editTestFile(args.file_path, args.old_content, args.new_content);
+                break;
+            case 'replace_function_tests':
+                result = await replaceFunctionTests(args.test_file_path, args.function_name, args.new_test_content);
+                break;
+            case 'run_tests':
+                result = runTests(args.test_file_path);
+                break;
+            case 'list_directory':
+                result = listDirectory(args.directory_path);
+                break;
+            case 'find_file':
+                result = findFile(args.filename);
+                break;
+            case 'calculate_relative_path':
+                result = calculateRelativePath(args.from_file, args.to_file);
+                break;
+            case 'report_legitimate_failure':
+                result = reportLegitimateFailure(args.test_file_path, args.failing_tests, args.reason, args.source_code_issue);
+                break;
+            case 'delete_lines':
+                result = await deleteLines(args.file_path, args.start_line, args.end_line);
+                break;
+            case 'insert_lines':
+                result = await insertLines(args.file_path, args.line_number, args.content);
+                break;
+            case 'replace_lines':
+                result = await replaceLines(args.file_path, args.start_line, args.end_line, args.new_content);
+                break;
+            default:
+                result = { success: false, error: `Unknown tool: ${toolName}` };
+        }
+    }
+    catch (error) {
+        result = { success: false, error: error.message, stack: error.stack };
+    }
+    // Show result with friendly message
+    if (result.success) {
+        console.log(`   ✅ Done`);
+    }
+    else if (result.error) {
+        console.log(`   ❌ ${result.error.substring(0, 100)}${result.error.length > 100 ? '...' : ''}`);
+    }
+    return result;
+}
+// File system utilities
+async function listFilesRecursive(dir, fileList = []) {
+    const files = await fs.readdir(dir);
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stat = await fs.stat(filePath);
+        if (stat.isDirectory()) {
+            // Skip excluded directories and cache directories
+            const shouldExclude = CONFIG.excludeDirs.includes(file) ||
+                file.startsWith('.') || // Hidden directories
+                file === 'tests' || // Test directories
+                file === '__tests__' ||
+                file === 'test';
+            if (!shouldExclude) {
+                await listFilesRecursive(filePath, fileList);
+            }
+        }
+        else {
+            const ext = path.extname(file);
+            // Filter files: must have valid extension and NOT be a test file
+            const isTestFile = file.endsWith('.test.ts') ||
+                file.endsWith('.test.tsx') ||
+                file.endsWith('.test.js') ||
+                file.endsWith('.test.jsx') ||
+                file.endsWith('.spec.ts') ||
+                file.endsWith('.spec.tsx') ||
+                file.endsWith('.spec.js') ||
+                file.endsWith('.spec.jsx');
+            if (CONFIG.extensions.includes(ext) && !isTestFile && !file.startsWith('.')) {
+                fileList.push(filePath);
+            }
+        }
+    }
+    return fileList;
+}
+// Generate test file path preserving directory structure
+function getTestFilePath(sourceFile) {
+    const testFileName = path.basename(sourceFile).replace(/\.(ts|js)x?$/, '.test.ts');
+    // Normalize path separators
+    const normalizedSource = sourceFile.replace(/\\/g, '/');
+    // Check if source file is in src directory
+    if (normalizedSource.includes('src/')) {
+        // Extract the relative path after 'src/'
+        const srcIndex = normalizedSource.indexOf('src/');
+        const relativePath = normalizedSource.substring(srcIndex + 4); // Skip 'src/'
+        const subDir = path.dirname(relativePath);
+        // Preserve subdirectory structure in test directory
+        if (subDir && subDir !== '.') {
+            const testPath = path.join(CONFIG.testDir, subDir, testFileName);
+            console.log(`  📁 Test file path: ${testPath}`);
+            return testPath;
+        }
+    }
+    // Fallback: just use testDir + filename
+    const testPath = path.join(CONFIG.testDir, testFileName);
+    console.log(`  📁 Test file path: ${testPath}`);
+    return testPath;
+}
+// AI Provider implementations
+async function callOpenAI(messages, tools) {
+    const apiKey = CONFIG.apiKeys.openai;
+    if (!apiKey)
+        throw new Error('OpenAI API key not configured in codeguard.json');
+    const AI_PROVIDERS = getAIProviders();
+    const response = await fetch(AI_PROVIDERS.openai.url, {
+        method: 'POST',
+        headers: AI_PROVIDERS.openai.headers(apiKey),
+        body: JSON.stringify({
+            model: AI_PROVIDERS.openai.model,
+            messages,
+            tools: tools.map(t => ({
+                type: 'function',
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.input_schema
+                }
+            })),
+            tool_choice: 'auto'
+        })
+    });
+    const data = await response.json();
+    // Check for API errors
+    if (data.error) {
+        throw new Error(`OpenAI API error: ${data.error.message || JSON.stringify(data.error)}`);
+    }
+    if (!data.choices || data.choices.length === 0) {
+        throw new Error(`OpenAI API returned no choices. Response: ${JSON.stringify(data)}`);
+    }
+    const message = data.choices[0].message;
+    return {
+        content: message.content,
+        toolCalls: message.tool_calls?.map((tc) => ({
+            id: tc.id,
+            name: tc.function.name,
+            input: JSON.parse(tc.function.arguments)
+        }))
+    };
+}
+async function callGemini(messages, tools) {
+    const apiKey = CONFIG.apiKeys.gemini;
+    if (!apiKey)
+        throw new Error('Gemini API key not configured in codeguard.json');
+    // Convert messages to Gemini format with proper function call handling
+    const contents = messages.map(m => {
+        const role = m.role === 'assistant' || m.role === 'model' ? 'model' : 'user';
+        // Handle function calls from model
+        if (m.functionCall) {
+            return {
+                role: 'model',
+                parts: [{
+                        functionCall: {
+                            name: m.functionCall.name,
+                            args: m.functionCall.args
+                        }
+                    }]
+            };
+        }
+        // Handle function responses from user
+        if (m.functionResponse) {
+            return {
+                role: 'user',
+                parts: [{
+                        functionResponse: {
+                            name: m.functionResponse.name,
+                            response: m.functionResponse.response
+                        }
+                    }]
+            };
+        }
+        // Regular text message
+        return {
+            role,
+            parts: [{ text: m.content || '' }]
+        };
+    });
+    const AI_PROVIDERS = getAIProviders();
+    const url = typeof AI_PROVIDERS.gemini.url === 'function' ? AI_PROVIDERS.gemini.url(apiKey) : AI_PROVIDERS.gemini.url;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: AI_PROVIDERS.gemini.headers(),
+        body: JSON.stringify({
+            contents,
+            tools: [{
+                    functionDeclarations: tools.map(t => ({
+                        name: t.name,
+                        description: t.description,
+                        parameters: t.input_schema
+                    }))
+                }]
+        })
+    });
+    const data = await response.json();
+    // Check for API errors
+    if (data.error) {
+        const errorMsg = data.error.message || JSON.stringify(data.error);
+        // Check for quota/rate limit errors
+        if (errorMsg.includes('quota') || errorMsg.includes('rate limit')) {
+            throw new Error(`Gemini API quota exceeded. Please wait or use a different provider (Claude or OpenAI). Error: ${errorMsg}`);
+        }
+        throw new Error(`Gemini API error: ${errorMsg}`);
+    }
+    if (!data.candidates || data.candidates.length === 0) {
+        throw new Error(`Gemini API returned no candidates. Response: ${JSON.stringify(data)}`);
+    }
+    const candidate = data.candidates[0];
+    const parts = candidate.content.parts;
+    // Check for function calls
+    const functionCalls = parts.filter((p) => p.functionCall);
+    if (functionCalls.length > 0) {
+        return {
+            toolCalls: functionCalls.map((fc) => ({
+                id: `gemini-${fc.functionCall.name}-${Date.now()}`,
+                name: fc.functionCall.name,
+                input: fc.functionCall.args
+            }))
+        };
+    }
+    // Return text content
+    const textPart = parts.find((p) => p.text);
+    return { content: textPart?.text || '' };
+}
+async function callClaude(messages, tools) {
+    const apiKey = CONFIG.apiKeys.claude;
+    if (!apiKey)
+        throw new Error('Claude API key not configured in codeguard.json');
+    const AI_PROVIDERS = getAIProviders();
+    const response = await fetch(AI_PROVIDERS.claude.url, {
+        method: 'POST',
+        headers: AI_PROVIDERS.claude.headers(apiKey),
+        body: JSON.stringify({
+            model: AI_PROVIDERS.claude.model,
+            max_tokens: 4096,
+            messages,
+            tools
+        })
+    });
+    const data = await response.json();
+    // Check for API errors
+    if (data.error) {
+        throw new Error(`Claude API error: ${data.error.message || JSON.stringify(data.error)}`);
+    }
+    if (!data.content || !Array.isArray(data.content)) {
+        throw new Error(`Claude API returned invalid content. Response: ${JSON.stringify(data)}`);
+    }
+    const textContent = data.content.find((c) => c.type === 'text');
+    const toolUse = data.content.filter((c) => c.type === 'tool_use');
+    return {
+        content: textContent?.text,
+        toolCalls: toolUse.map((tu) => ({
+            id: tu.id,
+            name: tu.name,
+            input: tu.input
+        })),
+        stopReason: data.stop_reason
+    };
+}
+async function callAI(messages, tools, provider = CONFIG.aiProvider) {
+    switch (provider) {
+        case 'openai':
+            return await callOpenAI(messages, tools);
+        case 'gemini':
+            return await callGemini(messages, tools);
+        case 'claude':
+            return await callClaude(messages, tools);
+        default:
+            throw new Error(`Unknown AI provider: ${provider}`);
+    }
+}
+// Main conversation loop
+async function generateTests(sourceFile) {
+    console.log(`\n📝 Generating tests for: ${sourceFile}\n`);
+    const testFilePath = getTestFilePath(sourceFile);
+    const messages = [
+        {
+            role: 'user',
+            content: `You are a senior software engineer tasked with writing comprehensive Jest unit tests for a TypeScript file.
+
+Source file: ${sourceFile}
+Test file path: ${testFilePath}
+
+IMPORTANT: You MUST use the provided tools to complete this task. Do not just respond with text.
+
+Your task (you MUST complete ALL steps):
+1. FIRST: Use analyze_file_ast tool to get a complete AST analysis of the source file (functions, classes, types, exports)
+2. Use get_imports_ast tool to understand all dependencies
+3. For each dependency, use find_file to locate it and calculate_relative_path to get correct import paths for the test file
+4. For complex functions, use get_function_ast tool to get detailed information including parameters, return types, and cyclomatic complexity
+5. For classes, use get_class_methods tool to extract all methods
+6. Use get_type_definitions tool to understand TypeScript types and interfaces
+7. Generate comprehensive Jest unit tests with:
+   - CRITICAL: Mock ALL imports BEFORE importing the source file to prevent initialization errors
+   - Mock database modules like '../database' or '../database/index' 
+   - Mock models, services, and any modules that access config/database
+   - Use jest.mock() calls at the TOP of the file before any imports
+   - Test suites for each function/class
+   - Multiple test cases covering:
+     * Happy path scenarios  
+     * Edge cases (null, undefined, empty arrays, etc.)
+     * Error conditions
+     * Async behavior (if applicable)
+   - Proper TypeScript types
+   - Clear, descriptive test names
+   - Complete test implementations (NO placeholder comments!)
+8. REQUIRED: Write the COMPLETE test file using write_test_file tool with REAL test code (NOT placeholders!)
+   - CRITICAL: Include source_file parameter with path to source file (e.g., source_file: "${sourceFile}")
+   - DO NOT use ANY placeholder comments like:
+     * "// Mock setup", "// Assertions", "// Call function"  
+     * "// Further tests...", "// Additional tests..."  
+     * "// Similarly, write tests for..."
+     * "// Add more tests...", "// TODO", "// ..."
+   - Write ACTUAL working test code with real mocks, real assertions, real function calls
+   - Every test MUST have:
+     * Real setup code (mock functions, create test data)
+     * Real execution (call the function being tested)
+     * Real expect() assertions (at least one per test)
+   - Write tests for EVERY exported function (minimum 2-3 tests per function)
+   - If source has 4 functions, test file MUST have 4 describe blocks with actual tests
+   - Example of COMPLETE test structure:
+     * Setup: Create mocks and test data
+     * Execute: Call the function being tested  
+     * Assert: Use expect() to verify results
+9. REQUIRED: Run the tests using run_tests tool
+10. REQUIRED: If tests fail with import errors:
+    - Use find_file tool to locate the missing module
+    - Use calculate_relative_path tool to get correct import path
+    - PRIMARY METHOD (once test file exists): Use line-based editing:
+      * read_file to get current test file with line numbers
+      * insert_lines to add missing imports at correct position (e.g., line 3)
+      * delete_lines to remove incorrect imports
+      * replace_lines to fix import paths
+    - FALLBACK: Only use edit_test_file or write_test_file if line-based editing isn't suitable
+11. REQUIRED: If tests fail with other errors, analyze if they are FIXABLE or LEGITIMATE:
+    
+    FIXABLE ERRORS (you should fix these):
+    - Wrong import paths
+    - Missing mocks
+    - Incorrect mock implementations
+    - Wrong assertions or test logic
+    - TypeScript compilation errors
+    - Missing test setup/teardown
+    - Cannot read properties of undefined
+    
+    LEGITIMATE FAILURES (source code bugs - DO NOT try to fix):
+    - Function returns wrong type (e.g., undefined instead of object)
+    - Missing null/undefined checks in source code
+    - Logic errors in source code
+    - Unhandled promise rejections in source code
+    - Source code throws unexpected errors
+    
+12. If errors are FIXABLE (AFTER test file is written): 
+    - ✅ PRIMARY METHOD: Use line-based editing tools (RECOMMENDED):
+      * read_file to get current test file with line numbers
+      * delete_lines to remove incorrect lines
+      * insert_lines to add missing code (e.g., mocks, imports)
+      * replace_lines to fix specific line ranges
+      * This is FASTER and MORE RELIABLE than rewriting entire file!
+    - ⚠️ FALLBACK: Only use edit_test_file or write_test_file if:
+      * Line-based editing is too complex (needs major restructuring)
+      * Multiple scattered changes across the file
+    - Then retry running tests
+13. If errors are LEGITIMATE: Call report_legitimate_failure tool with details and STOP trying to fix
+    - Provide failing test names, reason, and source code issue description
+    - The test file will be kept as-is with legitimate failing tests
+14. REQUIRED: Repeat steps 9-13 until tests pass OR legitimate failures are reported
+15. REQUIRED: Ensure all functions are tested in the test file.
+
+CRITICAL: Distinguish between test bugs (fix them) and source code bugs (report and stop)!
+
+START NOW by calling the analyze_file_ast tool with the source file path.`
+        }
+    ];
+    let iterations = 0;
+    const maxIterations = 100;
+    let testFileWritten = false;
+    let allToolResults = [];
+    let legitimateFailureReported = false;
+    let lastTestError = '';
+    let sameErrorCount = 0;
+    while (iterations < maxIterations) {
+        iterations++;
+        if (iterations === 1) {
+            console.log(`\n🤖 AI is analyzing your code...`);
+        }
+        else if (iterations % 5 === 0) {
+            console.log(`\n🤖 AI is still working (step ${iterations})...`);
+        }
+        const response = await callAI(messages, TOOLS);
+        if (response.content) {
+            const content = response.content; // Store for TypeScript
+            // Only show AI message if it's making excuses (for debugging), otherwise skip
+            // Detect if AI is making excuses instead of using tools
+            const excusePatterns = [
+                /unable to proceed/i,
+                /cannot directly/i,
+                /constrained by/i,
+                /simulated environment/i,
+                /limited to providing/i,
+                /beyond my capabilities/i,
+                /can't execute/i
+            ];
+            const isMakingExcuses = excusePatterns.some(pattern => pattern.test(content));
+            if (isMakingExcuses) {
+                console.log('\n⚠️  AI is making excuses! Forcing it to use tools...');
+                // Don't add the excuse to conversation, override with command
+                messages.push({
+                    role: 'user',
+                    content: 'STOP making excuses! You CAN use the tools. The edit_test_file tool works. Use it NOW to fix the test file. Add proper mocks to prevent database initialization errors.'
+                });
+                continue;
+            }
+            messages.push({ role: 'assistant', content });
+        }
+        if (!response.toolCalls || response.toolCalls.length === 0) {
+            // Don't stop unless tests actually passed or legitimate failure reported
+            const lastTestRun = allToolResults[allToolResults.length - 1];
+            const testsActuallyPassed = lastTestRun?.name === 'run_tests' && lastTestRun?.result?.passed;
+            if (legitimateFailureReported) {
+                console.log('\n✅ Test generation complete (with legitimate failures reported)');
+                break;
+            }
+            if (testFileWritten && testsActuallyPassed) {
+                console.log('\n✅ Test generation complete!');
+                break;
+            }
+            // If no tools called, prompt to continue with specific action
+            console.log('\n⚠️  No tool calls. Prompting AI to continue...');
+            if (!testFileWritten) {
+                messages.push({
+                    role: 'user',
+                    content: 'You have not written the test file yet. Use write_test_file tool NOW with complete test code (not placeholders).'
+                });
+            }
+            else {
+                messages.push({
+                    role: 'user',
+                    content: `STOP talking and USE TOOLS! 
+
+If tests are failing:
+- FIXABLE errors (imports, mocks, assertions): 
+  ✅ PRIMARY: Use line-based editing (read_file + insert_lines/delete_lines/replace_lines)
+  ⚠️ FALLBACK: Use edit_test_file or write_test_file
+- LEGITIMATE failures (source code bugs): Call report_legitimate_failure tool
+
+Start with read_file to see line numbers, then fix specific lines!`
+                });
+            }
+            continue;
+        }
+        // Execute all tool calls
+        const toolResults = [];
+        for (const toolCall of response.toolCalls) {
+            const result = await executeTool(toolCall.name, toolCall.input);
+            const toolResult = {
+                id: toolCall.id,
+                name: toolCall.name,
+                result
+            };
+            toolResults.push(toolResult);
+            allToolResults.push(toolResult);
+            // Track if legitimate failure was reported
+            if (toolCall.name === 'report_legitimate_failure' && result.success) {
+                legitimateFailureReported = true;
+                console.log('\n✅ Legitimate failure acknowledged. Stopping test fixes.');
+                console.log(`   Recommendation: ${result.recommendation}`);
+            }
+            // Track if test file was written
+            if (toolCall.name === 'write_test_file') {
+                if (result.success) {
+                    testFileWritten = true;
+                    console.log(`\n📝 Test file written: ${result.path}`);
+                    if (result.stats) {
+                        console.log(`   Tests: ${result.stats.tests}, Expectations: ${result.stats.expectations}`);
+                    }
+                }
+                else {
+                    // Test file was REJECTED due to validation
+                    console.log(`\n❌ Test file REJECTED: ${result.error}`);
+                    testFileWritten = false; // Make sure we track it wasn't written
+                    // Give very specific instructions based on rejection reason
+                    if (result.error.includes('placeholder')) {
+                        messages.push({
+                            role: 'user',
+                            content: `Your test file was REJECTED because it contains placeholder comments. 
+
+You MUST rewrite it with COMPLETE code:
+- Remove ALL comments like "// Further tests", "// Add test", "// Mock setup"
+- Write the ACTUAL test implementation for EVERY function
+- Each test needs: real setup, real function call, real expect() assertions
+
+Try again with write_test_file and provide COMPLETE test implementations!`
+                        });
+                    }
+                    else if (result.error.includes('NO expect()')) {
+                        messages.push({
+                            role: 'user',
+                            content: `Your test file was REJECTED because tests have no assertions!
+
+Every test MUST have expect() statements. Example:
+expect(functionName).toHaveBeenCalled();
+expect(result).toEqual(expectedValue);
+
+Rewrite with write_test_file and add actual expect() assertions to ALL tests!`
+                        });
+                    }
+                    else if (result.error.includes('too few tests')) {
+                        messages.push({
+                            role: 'user',
+                            content: `Your test file was REJECTED because it has too few tests!
+
+You analyzed ${toolResults.length > 0 ? 'multiple' : 'several'} functions in the source file. Write tests for ALL of them!
+- Minimum 2-3 test cases per function
+- Cover: happy path, edge cases, error cases
+
+Rewrite with write_test_file and include tests for EVERY function!`
+                        });
+                    }
+                }
+            }
+            // Detect if edit_test_file failed
+            if (toolCall.name === 'edit_test_file' && !result.success) {
+                console.log('\n⚠️  edit_test_file failed. Redirecting to line-based tools...');
+                messages.push({
+                    role: 'user',
+                    content: `❌ edit_test_file failed due to content mismatch. 
+
+✅ SWITCH TO LINE-BASED EDITING (Primary Method):
+
+Step 1: Call read_file tool to see the test file with line numbers
+Step 2: Identify which lines need changes
+Step 3: Use the appropriate tool:
+   - insert_lines: Add missing imports/mocks (e.g., line 5)
+   - delete_lines: Remove incorrect code (e.g., lines 10-12)
+   - replace_lines: Fix specific sections (e.g., lines 20-25)
+
+Examples:
+  insert_lines({ file_path: "${testFilePath}", line_number: 5, content: "jest.mock('../database');" })
+  replace_lines({ file_path: "${testFilePath}", start_line: 10, end_line: 15, new_content: "const mockData = { id: 1 };" })
+
+⚠️ Only use write_test_file as LAST RESORT (full file rewrite).
+
+Start with read_file NOW to see line numbers!`
+                });
+            }
+            // Detect repeated errors (suggests legitimate failure)
+            if (toolCall.name === 'run_tests' && !result.success) {
+                const errorOutput = result.output || result.error || '';
+                const currentError = errorOutput.substring(0, 300); // First 300 chars as signature
+                if (currentError === lastTestError) {
+                    sameErrorCount++;
+                    console.log(`\n⚠️  Same error repeated ${sameErrorCount} times`);
+                    if (sameErrorCount >= 3) {
+                        console.log('\n🚨 Same error repeated 3+ times! Likely a legitimate source code issue.');
+                        messages.push({
+                            role: 'user',
+                            content: `The same test error has occurred ${sameErrorCount} times in a row!
+
+This suggests the failure is LEGITIMATE (source code bug), not a test issue.
+
+Analyze the error and determine:
+1. Is this a FIXABLE test issue (wrong mocks, imports, assertions)?
+2. Or is this a LEGITIMATE source code bug?
+
+If LEGITIMATE: Call report_legitimate_failure tool NOW with details.
+If FIXABLE: Make one more attempt to fix it.`
+                        });
+                    }
+                }
+                else {
+                    lastTestError = currentError;
+                    sameErrorCount = 1;
+                }
+            }
+            // Detect import path errors
+            if (toolCall.name === 'run_tests' && !result.success) {
+                const errorOutput = result.output || result.error || '';
+                // Check for module not found errors
+                const moduleNotFoundMatch = errorOutput.match(/Cannot find module ['"]([^'"]+)['"]/);
+                const tsModuleErrorMatch = errorOutput.match(/TS2307.*Cannot find module ['"]([^'"]+)['"]/);
+                if (moduleNotFoundMatch || tsModuleErrorMatch) {
+                    const missingModule = moduleNotFoundMatch?.[1] || tsModuleErrorMatch?.[1];
+                    console.log(`\n🔍 Import error detected: Cannot find module "${missingModule}"`);
+                    // Extract filename from the path
+                    const filename = missingModule?.split('/').pop();
+                    messages.push({
+                        role: 'user',
+                        content: `Import path error detected! Module not found: "${missingModule}"
+
+✅ FIX WITH LINE-BASED EDITING:
+
+Step 1: find_file tool to search for "${filename}" in the repository
+Step 2: calculate_relative_path tool to get correct import path
+Step 3: Fix using line-based tools:
+   a) read_file to see the test file with line numbers
+   b) Find the incorrect import line (search for "${missingModule}")
+   c) replace_lines to fix just that import line with correct path
+
+Example workflow:
+1. find_file({ filename: "${filename}.ts" })
+2. calculate_relative_path({ from_file: "${testFilePath}", to_file: (found path) })
+3. read_file({ file_path: "${testFilePath}" })
+4. replace_lines({ file_path: "${testFilePath}", start_line: X, end_line: X, new_content: "import ... from 'correct-path';" })
+
+Start NOW with find_file!`
+                    });
+                }
+                // Check for database initialization errors
+                const isDatabaseError = /Cannot read properties of undefined.*reading|database|config|SSL|CA|HOST/i.test(errorOutput);
+                if (isDatabaseError) {
+                    console.log('\n🔍 Database initialization error detected! Need to add mocks...');
+                    messages.push({
+                        role: 'user',
+                        content: `The test is failing because the source file imports modules that initialize database connections.
+
+✅ FIX WITH LINE-BASED EDITING:
+
+Step 1: read_file to see current test file structure
+Step 2: insert_lines to add mocks at the TOP of the file (before any imports)
+
+Required mocks to add:
+   jest.mock('../database', () => ({ default: {} }));
+   jest.mock('../database/index', () => ({ default: {} }));
+   jest.mock('../models/serviceDesk.models');
+
+Example:
+1. read_file({ file_path: "${testFilePath}" })
+2. Find where imports start (usually line 1-3)
+3. insert_lines({ 
+     file_path: "${testFilePath}", 
+     line_number: 1, 
+     content: "jest.mock('../database', () => ({ default: {} }));\njest.mock('../models/serviceDesk.models');\n"
+   })
+
+⚠️ Mocks MUST be at the TOP before any imports!
+
+Start NOW with read_file to see current structure!`
+                    });
+                }
+            }
+        }
+        // Add tool results to conversation based on provider
+        if (CONFIG.aiProvider === 'claude') {
+            messages.push({
+                role: 'assistant',
+                content: response.toolCalls.map(tc => ({
+                    type: 'tool_use',
+                    id: tc.id,
+                    name: tc.name,
+                    input: tc.input
+                }))
+            });
+            messages.push({
+                role: 'user',
+                content: toolResults.map(tr => ({
+                    type: 'tool_result',
+                    tool_use_id: tr.id,
+                    content: JSON.stringify(tr.result)
+                }))
+            });
+        }
+        else if (CONFIG.aiProvider === 'openai') {
+            messages.push({
+                role: 'assistant',
+                tool_calls: response.toolCalls.map(tc => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: {
+                        name: tc.name,
+                        arguments: JSON.stringify(tc.input)
+                    }
+                }))
+            });
+            for (const tr of toolResults) {
+                messages.push({
+                    role: 'tool',
+                    tool_call_id: tr.id,
+                    content: JSON.stringify(tr.result)
+                });
+            }
+        }
+        else {
+            // Gemini - use proper function call format
+            for (const toolCall of response.toolCalls) {
+                // Add model's function call
+                messages.push({
+                    role: 'model',
+                    functionCall: {
+                        name: toolCall.name,
+                        args: toolCall.input
+                    }
+                });
+                // Add user's function response
+                const result = toolResults.find(tr => tr.name === toolCall.name);
+                messages.push({
+                    role: 'user',
+                    functionResponse: {
+                        name: toolCall.name,
+                        response: result?.result
+                    }
+                });
+            }
+        }
+        // Check if legitimate failure was reported
+        if (legitimateFailureReported) {
+            console.log('\n✅ Stopping iteration: Legitimate failure reported.');
+            break;
+        }
+        // Check if tests were run and passed
+        const testRun = toolResults.find(tr => tr.name === 'run_tests');
+        if (testRun?.result.passed) {
+            console.log('\n🎉 All tests passed!');
+            break;
+        }
+    }
+    if (iterations >= maxIterations) {
+        console.log('\n⚠️  Reached maximum iterations. Tests may not be complete.');
+    }
+    if (!testFileWritten) {
+        console.log('\n❌ WARNING: Test file was never written! The AI may not have used the tools correctly.');
+        console.log('   Try running again or check your API key and connectivity.');
+    }
+    else if (legitimateFailureReported) {
+        console.log('\n📋 Test file created with legitimate failures documented.');
+        console.log('   These failures indicate bugs in the source code that need to be fixed.');
+    }
+    return testFilePath;
+}
+// Interactive CLI
+async function promptUser(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+// Get all directories recursively
+async function listDirectories(dir, dirList = []) {
+    const items = await fs.readdir(dir);
+    for (const item of items) {
+        const itemPath = path.join(dir, item);
+        const stat = await fs.stat(itemPath);
+        if (stat.isDirectory() && !CONFIG.excludeDirs.includes(item)) {
+            dirList.push(itemPath);
+            await listDirectories(itemPath, dirList);
+        }
+    }
+    return dirList;
+}
+// Folder-wise test generation
+async function generateTestsForFolder() {
+    console.log('\n📂 Folder-wise Test Generation\n');
+    // Get all directories
+    const directories = await listDirectories('.');
+    if (directories.length === 0) {
+        console.log('No directories found!');
+        return;
+    }
+    console.log('Select a folder to generate tests for all files:\n');
+    directories.forEach((dir, index) => {
+        console.log(`${index + 1}. ${dir}`);
+    });
+    const choice = await promptUser('\nEnter folder number: ');
+    const selectedDir = directories[parseInt(choice) - 1];
+    if (!selectedDir) {
+        console.log('Invalid selection!');
+        return;
+    }
+    // Get all files in the selected directory (recursive)
+    const files = await listFilesRecursive(selectedDir);
+    if (files.length === 0) {
+        console.log(`No source files found in ${selectedDir}!`);
+        return;
+    }
+    console.log(`\n📝 Found ${files.length} files to process in ${selectedDir}\n`);
+    // Process each file
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const testFilePath = getTestFilePath(file);
+        console.log(`\n[${i + 1}/${files.length}] Processing: ${file}`);
+        // Check if test file already exists
+        if (fsSync.existsSync(testFilePath)) {
+            const answer = await promptUser(`  Test file already exists: ${testFilePath}\n  Regenerate? (y/n): `);
+            if (answer.toLowerCase() !== 'y') {
+                console.log('  Skipped.');
+                continue;
+            }
+        }
+        try {
+            await generateTests(file);
+            console.log(`  ✅ Completed: ${testFilePath}`);
+        }
+        catch (error) {
+            console.error(`  ❌ Failed: ${error.message}`);
+        }
+    }
+    console.log(`\n✨ Folder processing complete! Processed ${files.length} files.`);
+}
+// Function-wise test generation
+async function generateTestsForFunctions(sourceFile, functionNames) {
+    console.log(`\n📝 Generating tests for selected functions in: ${sourceFile}\n`);
+    const testFilePath = getTestFilePath(sourceFile);
+    const testFileExists = fsSync.existsSync(testFilePath);
+    const messages = [
+        {
+            role: 'user',
+            content: `You are a senior software engineer tasked with writing comprehensive Jest unit tests for specific functions in a TypeScript file.
+
+Source file: ${sourceFile}
+Test file path: ${testFilePath}
+Test file exists: ${testFileExists}
+Selected functions to test: ${functionNames.join(', ')}
+
+IMPORTANT: You MUST use the provided tools to complete this task. Do not just respond with text.
+
+${testFileExists ? `
+🚨 CRITICAL WARNING: Test file ALREADY EXISTS at ${testFilePath}! 🚨
+
+You MUST use the replace_function_tests tool to update ONLY the selected function tests!
+DO NOT use write_test_file as it will OVERWRITE THE ENTIRE FILE and DELETE all other tests!
+
+Other tests in this file for different functions MUST be preserved!
+` : ''}
+
+Your task (you MUST complete ALL steps):
+1. FIRST: Use analyze_file_ast tool to get information about the selected functions: ${functionNames.join(', ')}
+2. Use get_function_ast tool for each selected function to get detailed information
+3. Use get_imports_ast tool to understand dependencies
+4. For each dependency, use find_file to locate it and calculate_relative_path to get correct import paths
+5. Generate comprehensive Jest unit tests ONLY for these functions: ${functionNames.join(', ')}
+   - CRITICAL: Mock ALL imports BEFORE importing the source file to prevent initialization errors
+   - Mock database modules, models, services, and config modules
+   - Use jest.mock() calls at the TOP of the file before any imports
+   - Test suites for each selected function
+   - Multiple test cases covering:
+     * Happy path scenarios
+     * Edge cases (null, undefined, empty arrays, etc.)
+     * Error conditions
+     * Async behavior (if applicable)
+   - Proper TypeScript types
+   - Clear, descriptive test names
+   - Complete test implementations (NO placeholder comments!)
+${testFileExists ? `
+6. 🚨 CRITICAL: Test file EXISTS! Call replace_function_tests tool for EACH function: ${functionNames.join(', ')}
+   - Call replace_function_tests ONCE for each function
+   - Pass the complete describe block as new_test_content parameter
+   - Example: replace_function_tests(test_file_path: "${testFilePath}", function_name: "${functionNames[0]}", new_test_content: "describe('${functionNames[0]}', () => { ... })")
+   - This preserves ALL other existing tests in the file
+   - DO NOT use write_test_file! It will DELETE all other tests!
+   - DO NOT use edit_test_file! Use replace_function_tests instead!` : `
+6. REQUIRED: Test file does NOT exist. Use write_test_file tool with tests for: ${functionNames.join(', ')}
+   - Create a new test file with complete test implementation`}
+7. REQUIRED: Run the tests using run_tests tool
+8. REQUIRED: If tests fail, analyze if errors are FIXABLE or LEGITIMATE:
+   
+   FIXABLE ERRORS (fix these):
+   - Wrong import paths → use find_file + calculate_relative_path + edit tools
+   - Missing mocks → add proper jest.mock() calls
+   - Incorrect mock implementations → update mock return values
+   - Wrong test assertions → fix expect() statements
+   - TypeScript errors → fix types and imports
+   
+   LEGITIMATE FAILURES (report these):
+   - Function returns wrong type (source code bug)
+   - Missing null checks in source code
+   - Logic errors in source code
+   - Source code throws unexpected errors
+   
+9. If FIXABLE (AFTER test file is written/updated): 
+   ${testFileExists ? `- ✅ PRIMARY METHOD: Use line-based editing tools (RECOMMENDED):
+     * read_file to see current test file with line numbers
+     * delete_lines to remove incorrect lines
+     * insert_lines to add missing mocks, imports, or test cases
+     * replace_lines to fix specific sections
+     * This preserves ALL other tests and is more reliable!
+   - ⚠️ SECONDARY: replace_function_tests for specific function updates
+   - ❌ AVOID: write_test_file (will DELETE all other tests!)` : `- Use write_test_file to create the test file
+   - Once written, use line-based tools for fixes (read_file + insert/delete/replace_lines)`}
+   - Then retry tests
+10. If LEGITIMATE: Call report_legitimate_failure with details and STOP
+11. REQUIRED: Repeat steps 7-10 until tests pass OR legitimate failures reported
+
+${testFileExists ? `
+🚨 REMINDER: The test file EXISTS! Use replace_function_tests, NOT write_test_file! 🚨
+` : ''}
+
+CRITICAL: Fix test bugs but REPORT source code bugs (don't try to make broken code pass)!
+
+START NOW by calling the analyze_file_ast tool with the source file path.`
+        }
+    ];
+    let iterations = 0;
+    const maxIterations = 100;
+    let testFileWritten = false;
+    let allToolResults = [];
+    let legitimateFailureReported = false;
+    let lastTestError = '';
+    let sameErrorCount = 0;
+    while (iterations < maxIterations) {
+        iterations++;
+        if (iterations === 1) {
+            console.log(`\n🤖 AI is analyzing selected functions...`);
+        }
+        else if (iterations % 5 === 0) {
+            console.log(`\n🤖 AI is still working (step ${iterations})...`);
+        }
+        const response = await callAI(messages, TOOLS);
+        if (response.content) {
+            const content = response.content;
+            // Only show AI message if it's making excuses (for debugging), otherwise skip
+            // Detect if AI is making excuses
+            const excusePatterns = [
+                /unable to proceed/i,
+                /cannot directly/i,
+                /constrained by/i,
+                /simulated environment/i,
+                /limited to providing/i,
+                /beyond my capabilities/i,
+                /can't execute/i
+            ];
+            const isMakingExcuses = excusePatterns.some(pattern => pattern.test(content));
+            if (isMakingExcuses) {
+                console.log('\n⚠️  AI is making excuses! Forcing it to use tools...');
+                messages.push({
+                    role: 'user',
+                    content: 'STOP making excuses! You CAN use the tools. Use replace_function_tests or write_test_file NOW to fix the test file.'
+                });
+                continue;
+            }
+            messages.push({ role: 'assistant', content });
+        }
+        if (!response.toolCalls || response.toolCalls.length === 0) {
+            const lastTestRun = allToolResults[allToolResults.length - 1];
+            const testsActuallyPassed = lastTestRun?.name === 'run_tests' && lastTestRun?.result?.passed;
+            if (legitimateFailureReported) {
+                console.log('\n✅ Test generation complete (with legitimate failures reported)');
+                break;
+            }
+            if (testFileWritten && testsActuallyPassed) {
+                console.log('\n✅ Test generation complete!');
+                break;
+            }
+            console.log('\n⚠️  No tool calls. Prompting AI to continue...');
+            if (!testFileWritten) {
+                messages.push({
+                    role: 'user',
+                    content: testFileExists
+                        ? `🚨 STOP TALKING! The test file EXISTS at ${testFilePath}!
+
+Call replace_function_tests tool NOW for EACH function: ${functionNames.join(', ')}
+
+Example:
+replace_function_tests({
+  test_file_path: "${testFilePath}",
+  function_name: "${functionNames[0]}",
+  new_test_content: "describe('${functionNames[0]}', () => { test('should...', () => { ... }) })"
+})
+
+DO NOT use write_test_file! It will DELETE all other tests!`
+                        : `Use write_test_file tool NOW with complete test code for: ${functionNames.join(', ')}`
+                });
+            }
+            else {
+                messages.push({
+                    role: 'user',
+                    content: testFileExists
+                        ? `STOP talking and USE TOOLS! 
+
+✅ PRIMARY METHOD: Fix using line-based editing:
+   1. read_file to see test file with line numbers
+   2. insert_lines/delete_lines/replace_lines to fix specific issues
+   
+⚠️ SECONDARY: Use replace_function_tests for function-level updates
+❌ NEVER: Use write_test_file (will delete all other tests!)
+
+Start NOW with read_file!`
+                        : `STOP talking and USE TOOLS! 
+
+- If test file doesn't exist: write_test_file
+- If test file exists: read_file + line-based editing tools
+
+Act NOW!`
+                });
+            }
+            continue;
+        }
+        // Execute all tool calls
+        const toolResults = [];
+        for (const toolCall of response.toolCalls) {
+            const result = await executeTool(toolCall.name, toolCall.input);
+            const toolResult = {
+                id: toolCall.id,
+                name: toolCall.name,
+                result
+            };
+            toolResults.push(toolResult);
+            allToolResults.push(toolResult);
+            // Track if legitimate failure was reported
+            if (toolCall.name === 'report_legitimate_failure' && result.success) {
+                legitimateFailureReported = true;
+                console.log('\n✅ Legitimate failure acknowledged. Stopping test fixes.');
+                console.log(`   Recommendation: ${result.recommendation}`);
+            }
+            // Detect repeated errors (suggests legitimate failure)
+            if (toolCall.name === 'run_tests' && !result.success) {
+                const errorOutput = result.output || result.error || '';
+                const currentError = errorOutput.substring(0, 300);
+                if (currentError === lastTestError) {
+                    sameErrorCount++;
+                    console.log(`\n⚠️  Same error repeated ${sameErrorCount} times`);
+                    if (sameErrorCount >= 3) {
+                        console.log('\n🚨 Same error repeated 3+ times! Likely a legitimate source code issue.');
+                        messages.push({
+                            role: 'user',
+                            content: `The same test error has occurred ${sameErrorCount} times in a row!
+
+This suggests the failure is LEGITIMATE (source code bug), not a test issue.
+
+If this is a source code bug: Call report_legitimate_failure tool NOW.
+If this is still fixable: Make ONE final attempt to fix it.`
+                        });
+                    }
+                }
+                else {
+                    lastTestError = currentError;
+                    sameErrorCount = 1;
+                }
+            }
+            // Track if test file was written
+            if (toolCall.name === 'write_test_file' || toolCall.name === 'replace_function_tests') {
+                if (result.success) {
+                    testFileWritten = true;
+                    console.log(`\n📝 Test file ${result.replaced ? 'updated' : 'written'}: ${testFilePath}`);
+                }
+            }
+            // Detect if AI incorrectly used write_test_file when file exists
+            if (toolCall.name === 'write_test_file' && testFileExists) {
+                console.log('\n⚠️  WARNING: AI used write_test_file on existing file! This overwrites all other tests!');
+                messages.push({
+                    role: 'user',
+                    content: `❌ CRITICAL ERROR: You used write_test_file but the test file ALREADY EXISTS!
+
+This OVERWROTE the entire file and DELETED all other tests! This is WRONG!
+
+You MUST use replace_function_tests instead. For future fixes, call it for EACH function:
+
+${functionNames.map(fname => `replace_function_tests({
+  test_file_path: "${testFilePath}",
+  function_name: "${fname}",
+  new_test_content: "describe('${fname}', () => { /* your tests */ })"
+})`).join('\n\n')}
+
+DO NOT use write_test_file when the file exists! Always use replace_function_tests!`
+                });
+            }
+        }
+        // Add tool results to conversation based on provider
+        if (CONFIG.aiProvider === 'claude') {
+            messages.push({
+                role: 'assistant',
+                content: response.toolCalls.map(tc => ({
+                    type: 'tool_use',
+                    id: tc.id,
+                    name: tc.name,
+                    input: tc.input
+                }))
+            });
+            messages.push({
+                role: 'user',
+                content: toolResults.map(tr => ({
+                    type: 'tool_result',
+                    tool_use_id: tr.id,
+                    content: JSON.stringify(tr.result)
+                }))
+            });
+        }
+        else if (CONFIG.aiProvider === 'openai') {
+            messages.push({
+                role: 'assistant',
+                tool_calls: response.toolCalls.map(tc => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: {
+                        name: tc.name,
+                        arguments: JSON.stringify(tc.input)
+                    }
+                }))
+            });
+            for (const tr of toolResults) {
+                messages.push({
+                    role: 'tool',
+                    tool_call_id: tr.id,
+                    content: JSON.stringify(tr.result)
+                });
+            }
+        }
+        else {
+            for (const toolCall of response.toolCalls) {
+                messages.push({
+                    role: 'model',
+                    functionCall: {
+                        name: toolCall.name,
+                        args: toolCall.input
+                    }
+                });
+                const result = toolResults.find(tr => tr.name === toolCall.name);
+                messages.push({
+                    role: 'user',
+                    functionResponse: {
+                        name: toolCall.name,
+                        response: result?.result
+                    }
+                });
+            }
+        }
+        // Check if legitimate failure was reported
+        if (legitimateFailureReported) {
+            console.log('\n✅ Stopping iteration: Legitimate failure reported.');
+            break;
+        }
+        // Check if tests passed
+        const testRun = toolResults.find(tr => tr.name === 'run_tests');
+        if (testRun?.result.passed) {
+            console.log('\n🎉 All tests passed!');
+            break;
+        }
+    }
+    if (iterations >= maxIterations) {
+        console.log('\n⚠️  Reached maximum iterations. Tests may not be complete.');
+    }
+    if (legitimateFailureReported) {
+        console.log('\n📋 Test file updated with legitimate failures documented.');
+        console.log('   These failures indicate bugs in the source code that need to be fixed.');
+    }
+    return testFilePath;
+}
+async function generateTestsForFunction() {
+    console.log('\n🎯 Function-wise Test Generation\n');
+    // List all files
+    console.log('📂 Scanning repository...\n');
+    const files = await listFilesRecursive('.');
+    if (files.length === 0) {
+        console.log('No source files found!');
+        return;
+    }
+    console.log('Select a file:\n');
+    files.forEach((file, index) => {
+        console.log(`${index + 1}. ${file}`);
+    });
+    const fileChoice = await promptUser('\nEnter file number: ');
+    const selectedFile = files[parseInt(fileChoice) - 1];
+    if (!selectedFile) {
+        console.log('Invalid selection!');
+        return;
+    }
+    // Analyze file to get functions
+    const analysis = analyzeFileAST(selectedFile);
+    if (!analysis.success) {
+        console.error(`Failed to analyze file: ${analysis.error}`);
+        return;
+    }
+    const functions = analysis.analysis.functions.filter((f) => f.exported);
+    if (functions.length === 0) {
+        console.log('No exported functions found in the file!');
+        return;
+    }
+    console.log(`\nFound ${functions.length} exported functions:\n`);
+    functions.forEach((func, index) => {
+        console.log(`${index + 1}. ${func.name} (${func.type}, ${func.async ? 'async' : 'sync'})`);
+    });
+    const functionsChoice = await promptUser('\nEnter function numbers (comma-separated, e.g., 1,3,4): ');
+    const selectedIndices = functionsChoice.split(',').map(s => parseInt(s.trim()) - 1);
+    const selectedFunctions = selectedIndices
+        .filter(i => i >= 0 && i < functions.length)
+        .map(i => functions[i].name);
+    if (selectedFunctions.length === 0) {
+        console.log('No valid functions selected!');
+        return;
+    }
+    console.log(`\n✅ Selected functions: ${selectedFunctions.join(', ')}\n`);
+    await generateTestsForFunctions(selectedFile, selectedFunctions);
+    console.log('\n✨ Done!');
+}
+async function main() {
+    console.log('🧪 AI-Powered Unit Test Generator with AST Analysis\n');
+    // Load configuration from codeguard.json
+    try {
+        CONFIG = (0, config_1.loadConfig)();
+        (0, config_1.validateConfig)(CONFIG);
+    }
+    catch (error) {
+        console.error('❌ Configuration Error:', error.message);
+        console.error('\nPlease create a codeguard.json file in your project root.');
+        console.error('Example:\n');
+        console.error('{\n  "aiProvider": "claude",\n  "apiKeys": {\n    "claude": "sk-ant-..."\n  }\n}');
+        process.exit(1);
+    }
+    // Check for required packages
+    try {
+        require('@babel/parser');
+        require('@babel/traverse');
+    }
+    catch (error) {
+        console.error('❌ Missing required packages. Please install:');
+        console.error('npm install @babel/parser @babel/traverse ts-node\n');
+        process.exit(1);
+    }
+    // Optional: Codebase Indexing
+    globalIndexer = new codebaseIndexer_1.CodebaseIndexer();
+    const hasExistingIndex = globalIndexer.hasIndex();
+    if (hasExistingIndex) {
+        // Index exists - automatically use it
+        console.log('📦 Loading codebase index...');
+        const loaded = await globalIndexer.loadIndex();
+        if (loaded) {
+            const stats = globalIndexer.getStats();
+            console.log(`✅ Loaded cached index (${stats?.fileCount} files indexed)`);
+            // Check for stale files (modified since last index)
+            const staleFiles = globalIndexer.getStaleFiles();
+            if (staleFiles.length > 0) {
+                console.log(`🔄 Updating ${staleFiles.length} modified file(s)...`);
+                // Show which files are being updated (if not too many)
+                if (staleFiles.length <= 5) {
+                    staleFiles.forEach(f => console.log(`   📝 ${path.basename(f)}`));
+                }
+                else {
+                    console.log(`   📝 Updating ${staleFiles.length} files...`);
+                }
+                await globalIndexer.updateIndex(staleFiles, analyzeFileAST);
+                console.log(`✅ Index updated!\n`);
+            }
+            else {
+                console.log('✅ All files up to date!\n');
+            }
+        }
+        else {
+            // Index file exists but failed to load - clear it
+            console.log('⚠️  Cache corrupted, will rebuild on next run.\n');
+            globalIndexer = null;
+        }
+    }
+    else {
+        // No index exists - offer to create one (first time only)
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('📦 Codebase Indexing (First Time Setup)\n');
+        console.log('Indexing analyzes your codebase once and caches the results.');
+        console.log('This makes test generation 100x+ faster on subsequent runs!\n');
+        console.log('Benefits:');
+        console.log('  ✓ Much faster analysis (cached AST parsing)');
+        console.log('  ✓ Instant dependency lookups');
+        console.log('  ✓ Better AI context\n');
+        console.log('Note: Takes ~15 seconds now, saves time on every future run.');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+        const useIndexing = await promptUser('Enable codebase indexing? (y/n, default=n): ');
+        if (useIndexing.toLowerCase() === 'y' || useIndexing.toLowerCase() === 'yes') {
+            console.log('\n✅ Building codebase index...');
+            console.log('This is a one-time process. Future runs will be instant!\n');
+            // Determine which directory to scan
+            // Priority: src/ if exists, otherwise current directory
+            let scanDir = '.';
+            if (fsSync.existsSync('src') && fsSync.statSync('src').isDirectory()) {
+                scanDir = 'src';
+                console.log('📂 Scanning src/ directory...\n');
+            }
+            else {
+                console.log('📂 Scanning current directory...\n');
+            }
+            await globalIndexer.buildIndex(scanDir, analyzeFileAST, (current, total, file) => {
+                const percent = Math.round((current / total) * 100);
+                const barLength = 30;
+                const filled = Math.round((current / total) * barLength);
+                const bar = '█'.repeat(filled) + '░'.repeat(barLength - filled);
+                process.stdout.write(`\r[${bar}] ${percent}% (${current}/${total}) ${path.basename(file)}${' '.repeat(20)}`);
+            });
+            console.log(); // New line after progress
+        }
+        else {
+            console.log('\n⏭️  Skipping indexing. You can enable it later by running with an empty cache.\n');
+            globalIndexer = null;
+        }
+    }
+    // Display selected AI provider from config
+    console.log(`\n✅ Using ${CONFIG.aiProvider.toUpperCase()} (${CONFIG.models[CONFIG.aiProvider]}) with AST-powered analysis\n`);
+    // Select test generation mode
+    console.log('Select Test Generation Mode:');
+    console.log('1. File-wise - Generate tests for a single file');
+    console.log('2. Folder-wise - Generate tests for all files in a folder');
+    console.log('3. Function-wise - Generate tests for specific functions in a file');
+    const modeChoice = await promptUser('\nEnter mode choice (1-3): ');
+    switch (modeChoice) {
+        case '2':
+            await generateTestsForFolder();
+            break;
+        case '3':
+            await generateTestsForFunction();
+            break;
+        case '1':
+        default:
+            // File-wise mode (original functionality)
+            console.log('\n📂 Scanning repository...\n');
+            const files = await listFilesRecursive('.');
+            if (files.length === 0) {
+                console.log('No source files found!');
+                return;
+            }
+            console.log('Select a file to generate tests:\n');
+            files.forEach((file, index) => {
+                console.log(`${index + 1}. ${file}`);
+            });
+            const choice = await promptUser('\nEnter file number: ');
+            const selectedFile = files[parseInt(choice) - 1];
+            if (!selectedFile) {
+                console.log('Invalid selection!');
+                return;
+            }
+            await generateTests(selectedFile);
+            console.log('\n✨ Done!');
+            break;
+    }
+}
+// Run if executed directly
+if (require.main === module) {
+    main().catch(console.error);
+}
+//# sourceMappingURL=index.js.map