codeguard-testgen 1.0.6 → 1.0.8

package/dist/index.js

@@ -20,6 +20,7 @@ exports.generateTests = generateTests;
 exports.generateTestsForFolder = generateTestsForFolder;
 exports.generateTestsForFunction = generateTestsForFunction;
 exports.generateTestsForFunctions = generateTestsForFunctions;
+exports.validateAndFixCompleteTestFile = validateAndFixCompleteTestFile;
 exports.executeTool = executeTool;
 exports.analyzeFileAST = analyzeFileAST;
 exports.getFunctionAST = getFunctionAST;
@@ -27,6 +28,8 @@ exports.getImportsAST = getImportsAST;
 exports.getTypeDefinitions = getTypeDefinitions;
 exports.getClassMethods = getClassMethods;
 exports.replaceFunctionTests = replaceFunctionTests;
+exports.searchReplaceBlock = searchReplaceBlock;
+exports.insertAtPosition = insertAtPosition;
 exports.deleteLines = deleteLines;
 exports.insertLines = insertLines;
 exports.replaceLines = replaceLines;
@@ -43,6 +46,8 @@ const codebaseIndexer_1 = require("./codebaseIndexer");
 Object.defineProperty(exports, "CodebaseIndexer", { enumerable: true, get: function () { return codebaseIndexer_1.CodebaseIndexer; } });
 // Configuration loader
 const config_1 = require("./config");
+// Fuzzy matcher for search-replace operations
+const fuzzyMatcher_1 = require("./fuzzyMatcher");
 // Configuration - will be loaded from codeguard.json
 let CONFIG;
 // Global indexer instance (optional - only initialized if user chooses to index)
@@ -80,7 +85,7 @@ function getAIProviders() {
 const TOOLS = [
     {
         name: 'read_file',
-        description: 'Read the contents of a file from the repository',
+        description: '⚠️ WARNING: Reads ENTIRE file content. For source files, prefer analyze_file_ast + get_function_ast instead to avoid token waste. Only use this for small config files, test files, or when you absolutely need full file context. Limited to 5000 lines max.',
         input_schema: {
             type: 'object',
             properties: {
@@ -92,6 +97,28 @@ const TOOLS = [
             required: ['file_path']
         }
     },
+    {
+        name: 'read_file_lines',
+        description: 'Read a specific portion of a file by line numbers. Useful for examining syntax errors, bracket mismatches, or specific sections that need fixing. Returns lines with line numbers for easy reference.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The relative path to the file from the repository root'
+                },
+                start_line: {
+                    type: 'number',
+                    description: 'The starting line number (1-indexed)'
+                },
+                end_line: {
+                    type: 'number',
+                    description: 'The ending line number (1-indexed)'
+                }
+            },
+            required: ['file_path', 'start_line', 'end_line']
+        }
+    },
     {
         name: 'analyze_file_ast',
         description: 'Parse file using AST and extract detailed information about all functions, classes, types, and exports',
@@ -100,7 +127,7 @@ const TOOLS = [
             properties: {
                 file_path: {
                     type: 'string',
-                    description: 'The relative path to the source file'
+                    description: 'The relative path to the source file.'
                 }
             },
             required: ['file_path']
@@ -108,7 +135,7 @@ const TOOLS = [
     },
     {
         name: 'get_function_ast',
-        description: 'Get detailed AST analysis of a specific function including parameters, return type, body, and dependencies',
+        description: 'Get detailed AST analysis of a specific function including full code with JSDoc comments, parameters, return type, async flag, and lists of called functions/methods. Use this instead of read_file for analyzing specific functions.',
         input_schema: {
             type: 'object',
             properties: {
@@ -118,7 +145,7 @@ const TOOLS = [
                 },
                 function_name: {
                     type: 'string',
-                    description: 'The name of the function to analyze'
+                    description: 'The name of the function to analyze, this tool must be used for functions information'
                 }
             },
             required: ['file_path', 'function_name']
@@ -152,6 +179,20 @@ const TOOLS = [
             required: ['file_path']
         }
     },
+    {
+        name: 'get_file_preamble',
+        description: 'Extract top-level code (imports, jest.mocks, setup blocks, module-level variables) from a file. Captures complete multi-line statements. Perfect for understanding large test files without reading entire content.',
+        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',
@@ -189,56 +230,8 @@ const TOOLS = [
         }
     },
     {
-        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)'
-                },
-                function_mode: {
-                    type: 'boolean',
-                    description: 'Whether the tests are being generated function wise.'
-                }
-            },
-            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.',
+        name: 'upsert_function_tests',
+        description: 'Write or update tests for a specific function. If test file doesn\'t exist, creates it. If file exists, replaces only the specific function\'s describe block while PRESERVING all other tests. If the function does not exist, the tool will write it to the test file. This is the PRIMARY tool for writing tests!',
         input_schema: {
             type: 'object',
             properties: {
@@ -248,7 +241,7 @@ const TOOLS = [
                 },
                 function_name: {
                     type: 'string',
-                    description: 'The name of the function whose tests should be replaced'
+                    description: 'The name of the function whose tests should be written/updated'
                 },
                 new_test_content: {
                     type: 'string',
@@ -260,13 +253,18 @@ const TOOLS = [
     },
     {
         name: 'run_tests',
-        description: 'Run Jest tests for a specific test file',
+        description: 'Run Jest tests for a specific test file. In function-wise mode, only runs tests for specified functions to avoid interference from other failing tests.',
         input_schema: {
             type: 'object',
             properties: {
                 test_file_path: {
                     type: 'string',
                     description: 'The path to the test file to run'
+                },
+                function_names: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional: Array of function names to test. When provided, only runs tests matching these function names using Jest -t flag. Use this in function-wise mode to isolate specific function tests.'
                 }
             },
             required: ['test_file_path']
@@ -346,8 +344,8 @@ const TOOLS = [
         }
     },
     {
-        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.',
+        name: 'search_replace_block',
+        description: '🚀 RECOMMENDED: Search for a code block and replace it with new content. Uses intelligent fuzzy matching to handle whitespace/indentation differences. 10x more reliable than line-based editing! Include 3-5 lines of context before/after the target to make the search unique.',
         input_schema: {
             type: 'object',
             properties: {
@@ -355,66 +353,50 @@ const TOOLS = [
                     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: {
+                search: {
                     type: 'string',
-                    description: 'The path to the file to edit'
+                    description: 'The code block to search for. IMPORTANT: Include enough surrounding context (3-5 lines before/after the part you want to change) to make it unique. The tool handles whitespace/indentation differences automatically.'
                 },
-                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.'
+                replace: {
+                    type: 'string',
+                    description: 'The new code to replace the search block with. Can be different length than search block.'
                 },
-                content: {
+                match_mode: {
                     type: 'string',
-                    description: 'The content to insert (can be multiple lines separated by \\n)'
+                    enum: ['exact', 'normalized', 'fuzzy'],
+                    description: 'Matching strategy. Default: "normalized" (recommended - handles whitespace/indentation). Use "exact" only for very precise matches, "fuzzy" for typo tolerance.'
                 }
             },
-            required: ['file_path', 'line_number', 'content']
+            required: ['file_path', 'search', 'replace']
         }
     },
     {
-        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.',
+        name: 'insert_at_position',
+        description: 'Insert content at a specific position in the file (beginning, end, after imports, etc). Simpler than search_replace_block for adding new content.',
         input_schema: {
             type: 'object',
             properties: {
                 file_path: {
                     type: 'string',
-                    description: 'The path to the file to edit'
+                    description: 'The path to the file'
                 },
-                start_line: {
-                    type: 'number',
-                    description: 'The starting line number to replace (1-indexed, inclusive)'
+                content: {
+                    type: 'string',
+                    description: 'The content to insert'
                 },
-                end_line: {
-                    type: 'number',
-                    description: 'The ending line number to replace (1-indexed, inclusive)'
+                position: {
+                    type: 'string',
+                    enum: ['beginning', 'end', 'after_imports', 'before_first_describe'],
+                    description: 'Where to insert: beginning (top of file), end (bottom), after_imports (after last import), before_first_describe (before first test block)'
                 },
-                new_content: {
+                after_marker: {
                     type: 'string',
-                    description: 'The new content to insert in place of the deleted lines'
+                    description: 'Optional: Instead of position, insert after this specific text marker (uses fuzzy search)'
                 }
             },
-            required: ['file_path', 'start_line', 'end_line', 'new_content']
+            required: ['file_path', 'content']
         }
-    }
+    },
 ];
 exports.TOOLS = TOOLS;
 // AST Parsing utilities
@@ -635,62 +617,157 @@ function getTypeAnnotation(typeNode) {
     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();
+    // Helper to search for function in a file
+    const searchInFile = (targetPath) => {
+        try {
+            const content = fsSync.readFileSync(targetPath, 'utf-8');
+            const ast = parseFileToAST(targetPath, 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();
+                    }
                 }
+            });
+            // console.log(`   ✅ Found functionInfo: ${JSON.stringify(functionInfo)}`);
+            // console.log(`   ✅ Found targetPath: ${JSON.stringify(targetPath)}`);
+            if (functionInfo) {
+                return { success: true, ...functionInfo, filePath: targetPath };
             }
-        });
-        if (!functionInfo) {
-            return { success: false, error: `Function ${functionName} not found` };
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    // Try the provided file path first
+    try {
+        const result = searchInFile(filePath);
+        if (result) {
+            return result;
         }
-        return Object.assign({ success: true }, functionInfo);
     }
     catch (error) {
-        return { success: false, error: error.message };
+        // File not found or other error - continue to fallback
+    }
+    // Fallback: If we have an indexer, search for the function in the index
+    if (globalIndexer) {
+        console.log(`   🔍 Function not found in ${filePath}, searching index...`);
+        // Search through all indexed files
+        const indexData = globalIndexer.index;
+        if (indexData && indexData.files) {
+            for (const [indexedFilePath, fileData] of Object.entries(indexData.files)) {
+                const analysis = fileData.analysis;
+                // Check if this file contains the function
+                const hasFunction = analysis.functions?.some((fn) => fn.name === functionName);
+                const hasMethod = analysis.classes?.some((cls) => cls.methods?.some((method) => method.name === functionName));
+                if (hasFunction || hasMethod) {
+                    console.log(`   ✅ Found ${functionName} in ${indexedFilePath}`);
+                    const result = searchInFile(indexedFilePath);
+                    if (result) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return {
+            success: false,
+            error: `Function ${functionName} not found in ${filePath} or any indexed files`
+        };
     }
+    // No indexer available and not found in provided path
+    return {
+        success: false,
+        error: `Function ${functionName} not found in ${filePath}. Tip: Enable indexing for better function lookup across files.`
+    };
 }
 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)
+    // Look backwards for JSDoc/comments (up to 20 lines)
+    let commentStartLine = startLine;
+    let lookbackLimit = Math.max(0, startLine - 20);
+    while (commentStartLine > lookbackLimit) {
+        const prevLine = lines[commentStartLine - 1]?.trim() || '';
+        if (prevLine.startsWith('*') ||
+            prevLine.startsWith('//') ||
+            prevLine.startsWith('/**') ||
+            prevLine.endsWith('*/') ||
+            prevLine === '') {
+            commentStartLine--;
+        }
+        else {
+            break;
+        }
+    }
+    const code = lines.slice(commentStartLine, endLine + 1).join('\n');
+    // Extract called functions from the function body
+    const calledFunctions = [];
+    const calledMethods = [];
+    try {
+        // Use path.traverse() which has the proper scope/parentPath
+        path.traverse({
+            CallExpression(callPath) {
+                const callee = callPath.node.callee;
+                // Direct function calls: functionName()
+                if (callee.type === 'Identifier') {
+                    const funcName = callee.name;
+                    if (!calledFunctions.includes(funcName)) {
+                        calledFunctions.push(funcName);
+                    }
+                }
+                // Method calls: object.method()
+                if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier') {
+                    const objectName = callee.object.type === 'Identifier' ? callee.object.name :
+                        callee.object.type === 'ThisExpression' ? 'this' : 'unknown';
+                    const methodCall = `${objectName}.${callee.property.name}`;
+                    if (!calledMethods.includes(methodCall)) {
+                        calledMethods.push(methodCall);
+                    }
+                }
+            }
+        });
+    }
+    catch (error) {
+        // If traversal fails, just continue without called functions
+        console.warn('Could not extract called functions:', error);
+    }
+    // console.log(`   ✅ Found code: ${code}`);
     return {
         name: isVariable ? path.node.id.name : node.id?.name,
         code,
-        startLine: startLine + 1,
+        startLine: commentStartLine + 1,
         endLine: endLine + 1,
         params: node.params.map((p) => extractParamInfo(p)),
         returnType: node.returnType ? getTypeAnnotation(node.returnType) : null,
         async: node.async,
+        calledFunctions: calledFunctions.length > 0 ? calledFunctions : undefined,
+        calledMethods: calledMethods.length > 0 ? calledMethods : undefined,
         complexity: 1 // Simplified complexity
     };
 }
 // Removed estimateComplexity to avoid scope/parentPath traversal issues
 // Complexity is now hardcoded to 1 in extractFunctionDetails
 function getImportsAST(filePath) {
+    // Try to read the file
     try {
         const content = fsSync.readFileSync(filePath, 'utf-8');
         const ast = parseFileToAST(filePath, content);
@@ -738,9 +815,55 @@ function getImportsAST(filePath) {
                 }
             }
         });
-        return { success: true, imports };
+        return { success: true, imports, filePath };
     }
     catch (error) {
+        // File not found - try to find similar file in index
+        if (globalIndexer && (error.code === 'ENOENT' || error.message.includes('no such file'))) {
+            console.log(`   🔍 File not found at ${filePath}, searching index for similar files...`);
+            const indexData = globalIndexer.index;
+            if (indexData && indexData.files) {
+                const searchName = path.basename(filePath);
+                const searchDir = path.dirname(filePath);
+                const matches = [];
+                // Find files with matching basename
+                for (const indexedFilePath of Object.keys(indexData.files)) {
+                    if (path.basename(indexedFilePath) === searchName) {
+                        matches.push(indexedFilePath);
+                    }
+                }
+                if (matches.length > 0) {
+                    let suggestion = matches[0];
+                    // If multiple matches, try to find the best one by matching directory structure
+                    if (matches.length > 1) {
+                        const searchParts = searchDir.split(path.sep).filter(p => p && p !== '.');
+                        // Score each match by how many path components match
+                        const scored = matches.map(m => {
+                            const matchParts = path.dirname(m).split(path.sep);
+                            let score = 0;
+                            for (let i = 0; i < searchParts.length; i++) {
+                                const searchPart = searchParts[searchParts.length - 1 - i];
+                                const matchPart = matchParts[matchParts.length - 1 - i];
+                                if (searchPart === matchPart) {
+                                    score += (i + 1); // Weight recent parts higher
+                                }
+                            }
+                            return { path: m, score };
+                        });
+                        // Sort by score (highest first)
+                        scored.sort((a, b) => b.score - a.score);
+                        suggestion = scored[0].path;
+                    }
+                    console.log(`   💡 Did you mean: ${suggestion}?`);
+                    return {
+                        success: false,
+                        error: `File not found: ${filePath}`,
+                        suggestion: suggestion,
+                        allMatches: matches.length > 1 ? matches : undefined
+                    };
+                }
+            }
+        }
         return { success: false, error: error.message };
     }
 }
@@ -802,93 +925,689 @@ function getTypeDefinitions(filePath) {
                 });
             }
         });
-        return { success: true, types };
+        return { success: true, types, filePath };
     }
     catch (error) {
+        // File not found - try to find similar file in index
+        if (globalIndexer && (error.code === 'ENOENT' || error.message.includes('no such file'))) {
+            console.log(`   🔍 File not found at ${filePath}, searching index for similar files...`);
+            const indexData = globalIndexer.index;
+            if (indexData && indexData.files) {
+                const searchName = path.basename(filePath);
+                const searchDir = path.dirname(filePath);
+                const matches = [];
+                // Find files with matching basename
+                for (const indexedFilePath of Object.keys(indexData.files)) {
+                    if (path.basename(indexedFilePath) === searchName) {
+                        matches.push(indexedFilePath);
+                    }
+                }
+                if (matches.length > 0) {
+                    let suggestion = matches[0];
+                    // If multiple matches, try to find the best one by matching directory structure
+                    if (matches.length > 1) {
+                        const searchParts = searchDir.split(path.sep).filter(p => p && p !== '.');
+                        // Score each match by how many path components match
+                        const scored = matches.map(m => {
+                            const matchParts = path.dirname(m).split(path.sep);
+                            let score = 0;
+                            for (let i = 0; i < searchParts.length; i++) {
+                                const searchPart = searchParts[searchParts.length - 1 - i];
+                                const matchPart = matchParts[matchParts.length - 1 - i];
+                                if (searchPart === matchPart) {
+                                    score += (i + 1); // Weight recent parts higher
+                                }
+                            }
+                            return { path: m, score };
+                        });
+                        // Sort by score (highest first)
+                        scored.sort((a, b) => b.score - a.score);
+                        suggestion = scored[0].path;
+                    }
+                    console.log(`   💡 Did you mean: ${suggestion}?`);
+                    return {
+                        success: false,
+                        error: `File not found: ${filePath}`,
+                        suggestion: suggestion,
+                        allMatches: matches.length > 1 ? matches : undefined
+                    };
+                }
+            }
+        }
         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
+function getFilePreamble(filePath) {
+    // Helper to extract preamble from a file
+    const extractPreamble = (targetPath) => {
+        try {
+            const content = fsSync.readFileSync(targetPath, 'utf-8');
+            const ast = parseFileToAST(targetPath, content);
+            const lines = content.split('\n');
+            const imports = [];
+            const mocks = [];
+            const setupBlocks = [];
+            const topLevelVariables = [];
+            // Process only top-level statements in Program.body
+            if (ast.program && ast.program.body) {
+                for (const statement of ast.program.body) {
+                    const startLine = statement.loc?.start.line || 0;
+                    const endLine = statement.loc?.end.line || 0;
+                    const code = lines.slice(startLine - 1, endLine).join('\n');
+                    // Import declarations
+                    if (statement.type === 'ImportDeclaration') {
+                        imports.push({
+                            code,
+                            startLine,
+                            endLine,
+                            source: statement.source?.value || ''
+                        });
+                    }
+                    // Top-level variable declarations
+                    else if (statement.type === 'VariableDeclaration') {
+                        statement.declarations.forEach((decl) => {
+                            topLevelVariables.push({
+                                code,
+                                startLine,
+                                endLine,
+                                name: decl.id?.name || 'unknown',
+                                kind: statement.kind
+                            });
+                        });
+                    }
+                    // Expression statements (could be jest.mock or setup blocks)
+                    else if (statement.type === 'ExpressionStatement' && statement.expression?.type === 'CallExpression') {
+                        const callExpr = statement.expression;
+                        const callee = callExpr.callee;
+                        // Check for jest.mock()
+                        if (callee.type === 'MemberExpression' &&
+                            callee.object?.name === 'jest' &&
+                            callee.property?.name === 'mock') {
+                            const moduleName = callExpr.arguments[0]?.value || 'unknown';
+                            let isVirtual = false;
+                            // Check for virtual flag in second argument
+                            if (callExpr.arguments[1]?.type === 'ObjectExpression') {
+                                const props = callExpr.arguments[1].properties || [];
+                                isVirtual = props.some((prop) => prop.key?.name === 'virtual' && prop.value?.value === true);
+                            }
+                            mocks.push({
+                                code,
+                                startLine,
+                                endLine,
+                                moduleName,
+                                isVirtual
+                            });
+                        }
+                        // Check for setup blocks (beforeAll, beforeEach, etc.)
+                        else if (callee.type === 'Identifier' &&
+                            ['beforeAll', 'beforeEach', 'afterAll', 'afterEach'].includes(callee.name)) {
+                            setupBlocks.push({
+                                code,
+                                startLine,
+                                endLine,
+                                type: callee.name
+                            });
+                        }
+                    }
+                    // Handle require statements
+                    else if (statement.type === 'VariableDeclaration') {
+                        statement.declarations.forEach((decl) => {
+                            if (decl.init?.type === 'CallExpression' &&
+                                decl.init.callee?.name === 'require' &&
+                                decl.init.arguments[0]?.type === 'StringLiteral') {
+                                imports.push({
+                                    code,
+                                    startLine,
+                                    endLine,
+                                    source: decl.init.arguments[0].value,
+                                    type: 'require'
                                 });
                             }
                         });
                     }
-                    classInfo = {
-                        name: className,
-                        methods,
-                        superClass: path.node.superClass?.name
-                    };
-                    path.stop();
                 }
             }
-        });
-        if (!classInfo) {
-            return { success: false, error: `Class ${className} not found` };
+            // Build full code with line markers
+            const allItems = [
+                ...imports.map(i => ({ ...i, category: 'import' })),
+                ...mocks.map(m => ({ ...m, category: 'mock' })),
+                ...setupBlocks.map(s => ({ ...s, category: 'setup' })),
+                ...topLevelVariables.map(v => ({ ...v, category: 'variable' }))
+            ].sort((a, b) => a.startLine - b.startLine);
+            const fullCode = allItems.map(item => `// Lines ${item.startLine}-${item.endLine} (${item.category})\n${item.code}`).join('\n\n');
+            console.log(`   ✅ Found file at ${targetPath}`);
+            // console.log(`   fullCode: ${fullCode}`);
+            // console.log(`   summary: ${JSON.stringify({
+            //   importCount: imports.length,
+            //   mockCount: mocks.length,
+            //   setupBlockCount: setupBlocks.length,
+            //   variableCount: topLevelVariables.length,
+            //   totalLines: allItems.length > 0 ? allItems[allItems.length - 1].endLine : 0
+            // })}`);
+            // console.log(`   imports: ${JSON.stringify({imports,
+            //   mocks,
+            //   setupBlocks,
+            //   topLevelVariables})}`);
+            return {
+                success: true,
+                filePath: targetPath,
+                preamble: {
+                    imports,
+                    mocks,
+                    setupBlocks,
+                    topLevelVariables
+                },
+                fullCode,
+                summary: {
+                    importCount: imports.length,
+                    mockCount: mocks.length,
+                    setupBlockCount: setupBlocks.length,
+                    variableCount: topLevelVariables.length,
+                    totalLines: allItems.length > 0 ? allItems[allItems.length - 1].endLine : 0
+                }
+            };
+        }
+        catch (error) {
+            return null;
         }
-        return { success: true, ...classInfo };
+    };
+    // Try the provided file path first
+    const result = extractPreamble(filePath);
+    if (result) {
+        return result;
     }
-    catch (error) {
-        return { success: false, error: error.message };
+    // Fallback: If we have an indexer, search for file with matching path
+    if (globalIndexer) {
+        console.log(`   🔍 File not found at ${filePath}, searching index...`);
+        const indexData = globalIndexer.index;
+        if (indexData && indexData.files) {
+            const searchName = path.basename(filePath);
+            const searchDir = path.dirname(filePath);
+            const matches = [];
+            // Find files with matching basename
+            for (const indexedFilePath of Object.keys(indexData.files)) {
+                if (path.basename(indexedFilePath) === searchName) {
+                    matches.push(indexedFilePath);
+                }
+            }
+            if (matches.length > 0) {
+                let correctPath = matches[0];
+                // If multiple matches, try to find the best one by matching directory structure
+                if (matches.length > 1) {
+                    const searchParts = searchDir.split(path.sep).filter(p => p && p !== '.');
+                    // Score each match by how many path components match
+                    const scored = matches.map(m => {
+                        const matchParts = path.dirname(m).split(path.sep);
+                        let score = 0;
+                        for (let i = 0; i < searchParts.length; i++) {
+                            const searchPart = searchParts[searchParts.length - 1 - i];
+                            const matchPart = matchParts[matchParts.length - 1 - i];
+                            if (searchPart === matchPart) {
+                                score += (i + 1); // Weight recent parts higher
+                            }
+                        }
+                        return { path: m, score };
+                    });
+                    // Sort by score (highest first)
+                    scored.sort((a, b) => b.score - a.score);
+                    correctPath = scored[0].path;
+                    console.log(`   💡 Multiple matches found, choosing best match: ${correctPath}`);
+                }
+                else {
+                    console.log(`   ✅ Found file at ${correctPath}`);
+                }
+                const retryResult = extractPreamble(correctPath);
+                if (retryResult) {
+                    return retryResult;
+                }
+            }
+            return {
+                success: false,
+                error: `File not found: ${filePath}`,
+                suggestion: matches.length > 0 ? matches[0] : undefined,
+                allMatches: matches.length > 1 ? matches : undefined
+            };
+        }
     }
+    // No indexer available
+    return {
+        success: false,
+        error: `File not found: ${filePath}. Tip: Enable indexing for better file lookup.`
+    };
 }
-// Other tool implementations
-async function readFile(filePath) {
+function getClassMethods(filePath, className) {
+    // Helper to search for class in a file
+    const searchInFile = (targetPath) => {
+        try {
+            const content = fsSync.readFileSync(targetPath, 'utf-8');
+            const ast = parseFileToAST(targetPath, 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,
+                            filePath: targetPath
+                        };
+                        path.stop();
+                    }
+                }
+            });
+            if (classInfo) {
+                return { success: true, ...classInfo };
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    // Try the provided file path first
     try {
-        const content = await fs.readFile(filePath, 'utf-8');
-        return { success: true, content };
+        const result = searchInFile(filePath);
+        if (result) {
+            return result;
+        }
     }
     catch (error) {
-        return { success: false, error: error.message };
+        // File not found or other error - continue to fallback
     }
-}
-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 };
+    // Fallback: If we have an indexer, search for the class in the index
+    if (globalIndexer) {
+        console.log(`   🔍 Class not found in ${filePath}, searching index...`);
+        // Search through all indexed files
+        const indexData = globalIndexer.index;
+        if (indexData && indexData.files) {
+            for (const [indexedFilePath, fileData] of Object.entries(indexData.files)) {
+                const analysis = fileData.analysis;
+                // Check if this file contains the class
+                const hasClass = analysis.classes?.some((cls) => cls.name === className);
+                if (hasClass) {
+                    console.log(`   ✅ Found ${className} in ${indexedFilePath}`);
+                    const result = searchInFile(indexedFilePath);
+                    if (result) {
+                        return result;
+                    }
                 }
             }
-            if (fsSync.existsSync(resolved)) {
-                return { success: true, resolvedPath: resolved };
-            }
         }
         return {
-            success: true,
-            resolvedPath: importPath,
-            isExternal: true
+            success: false,
+            error: `Class ${className} not found in ${filePath} or any indexed files`
+        };
+    }
+    // No indexer available and not found in provided path
+    return {
+        success: false,
+        error: `Class ${className} not found in ${filePath}. Tip: Enable indexing for better class lookup across files.`
+    };
+}
+// Other tool implementations
+async function readFile(filePath) {
+    const MAX_LINES = 2000;
+    // Helper to read and validate file
+    const tryReadFile = async (targetPath) => {
+        try {
+            const content = await fs.readFile(targetPath, 'utf-8');
+            const lines = content.split('\n');
+            if (lines.length > MAX_LINES) {
+                // Check if this is a test file
+                const isTestFile = /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(targetPath);
+                // File is too large - check if we have cached analysis
+                if (globalIndexer) {
+                    const cached = globalIndexer.getFileAnalysis(targetPath);
+                    if (cached) {
+                        console.log(`   📦 File too large (${lines.length} lines), returning cached analysis instead`);
+                        // For test files, also include preamble automatically
+                        let preamble = undefined;
+                        if (isTestFile) {
+                            const preambleResult = getFilePreamble(targetPath);
+                            if (preambleResult.success) {
+                                preamble = preambleResult;
+                                console.log(`   📋 Also extracted preamble (${preambleResult.summary.importCount} imports, ${preambleResult.summary.mockCount} mocks)`);
+                            }
+                        }
+                        return {
+                            success: true,
+                            usedCache: true,
+                            fileSize: lines.length,
+                            filePath: targetPath,
+                            analysis: cached,
+                            preamble: preamble,
+                            message: isTestFile
+                                ? `Test file has ${lines.length} lines (max ${MAX_LINES}). Returned cached analysis + preamble (imports/mocks/setup). Use get_function_ast with proper file path for specific test functions.`
+                                : `File has ${lines.length} lines (max ${MAX_LINES}). Returned cached analysis + preamble (imports/setup). Use read_file_lines to read specific section of file or get_function_ast with proper file path for specific functions.`
+                        };
+                    }
+                }
+                // No cache available
+                return {
+                    success: false,
+                    error: `File too large (${lines.length} lines, max ${MAX_LINES}). Use get_file_preamble for imports/mocks, analyze_file_ast for structure, or get_function_ast for specific functions or read_file_lines to read specific section of file.`,
+                    fileSize: lines.length,
+                    filePath: targetPath,
+                    suggestion: 'For large files: 1) get_file_preamble for imports/mocks/setup, 2) analyze_file_ast for all functions, 3) get_function_ast for specific functions'
+                };
+            }
+            return { success: true, content, filePath: targetPath, fileSize: lines.length };
+        }
+        catch (error) {
+            return null; // Signal to try fallback
+        }
+    };
+    // Try the provided file path first
+    const result = await tryReadFile(filePath);
+    if (result) {
+        return result;
+    }
+    // Fallback: If we have an indexer, search for file with matching path
+    if (globalIndexer) {
+        console.log(`   🔍 File not found at ${filePath}, searching index...`);
+        const indexData = globalIndexer.index;
+        if (indexData && indexData.files) {
+            const searchName = path.basename(filePath);
+            const searchDir = path.dirname(filePath);
+            const matches = [];
+            // Find files with matching basename
+            for (const indexedFilePath of Object.keys(indexData.files)) {
+                if (path.basename(indexedFilePath) === searchName) {
+                    matches.push(indexedFilePath);
+                }
+            }
+            if (matches.length > 0) {
+                let correctPath = matches[0];
+                // If multiple matches, try to find the best one by matching directory structure
+                if (matches.length > 1) {
+                    const searchParts = searchDir.split(path.sep).filter(p => p && p !== '.');
+                    // Score each match by how many path components match
+                    const scored = matches.map(m => {
+                        const matchParts = path.dirname(m).split(path.sep);
+                        let score = 0;
+                        for (let i = 0; i < searchParts.length; i++) {
+                            const searchPart = searchParts[searchParts.length - 1 - i];
+                            const matchPart = matchParts[matchParts.length - 1 - i];
+                            if (searchPart === matchPart) {
+                                score += (i + 1); // Weight recent parts higher
+                            }
+                        }
+                        return { path: m, score };
+                    });
+                    // Sort by score (highest first)
+                    scored.sort((a, b) => b.score - a.score);
+                    correctPath = scored[0].path;
+                    console.log(`   💡 Multiple matches found, choosing best match: ${correctPath}`);
+                }
+                else {
+                    console.log(`   ✅ Found file at ${correctPath}`);
+                }
+                // Try to read from correct path
+                const retryResult = await tryReadFile(correctPath);
+                if (retryResult) {
+                    return retryResult;
+                }
+                // If still failed, at least return the correct path
+                return {
+                    success: false,
+                    error: `Found file at ${correctPath} but failed to read it`,
+                    suggestion: correctPath,
+                    allMatches: matches.length > 1 ? matches : undefined
+                };
+            }
+        }
+        return {
+            success: false,
+            error: `File not found: ${filePath}. No matching files found in index.`
+        };
+    }
+    // No indexer available
+    return {
+        success: false,
+        error: `File not found: ${filePath}. Tip: Enable indexing for better file lookup.`
+    };
+}
+/**
+ * Read specific lines from a file
+ * Useful for examining syntax errors, bracket mismatches, or specific sections
+ */
+async function readFileLines(filePath, startLine, endLine) {
+    // Validate line numbers
+    if (startLine < 1) {
+        return {
+            success: false,
+            error: 'Start line must be >= 1'
+        };
+    }
+    if (endLine < startLine) {
+        return {
+            success: false,
+            error: 'End line must be >= start line'
+        };
+    }
+    if (endLine - startLine > 2000) {
+        return {
+            succes: false,
+            error: 'You are note allowed to read more than 2000 lines at once. End line - start line must be less than 2000'
+        };
+    }
+    // Helper to read lines from a file
+    const tryReadFileLines = async (targetPath) => {
+        try {
+            const content = await fs.readFile(targetPath, 'utf-8');
+            const allLines = content.split('\n');
+            // Check if requested range is valid
+            if (startLine > allLines.length) {
+                return {
+                    success: false,
+                    error: `Start line ${startLine} exceeds file length (${allLines.length} lines)`,
+                    fileLength: allLines.length,
+                    filePath: targetPath
+                };
+            }
+            // Adjust end line if it exceeds file length
+            const actualEndLine = Math.min(endLine, allLines.length);
+            // Extract requested lines (convert to 0-indexed)
+            const requestedLines = allLines.slice(startLine - 1, actualEndLine);
+            // Format lines with line numbers for easy reference
+            const formattedLines = requestedLines.map((line, index) => {
+                const lineNumber = startLine + index;
+                return `${lineNumber.toString().padStart(6, ' ')}|${line}`;
+            }).join('\n');
+            return {
+                success: true,
+                filePath: targetPath,
+                startLine,
+                endLine: actualEndLine,
+                lineCount: requestedLines.length,
+                content: formattedLines,
+                rawLines: requestedLines
+            };
+        }
+        catch (error) {
+            return null; // Signal to try fallback
+        }
+    };
+    // Try the provided file path first
+    const result = await tryReadFileLines(filePath);
+    if (result) {
+        return result;
+    }
+    // Fallback: If we have an indexer, search for file with matching path
+    if (globalIndexer) {
+        console.log(`   🔍 File not found at ${filePath}, searching index...`);
+        const indexData = globalIndexer.index;
+        if (indexData && indexData.files) {
+            const searchName = path.basename(filePath);
+            const searchDir = path.dirname(filePath);
+            const matches = [];
+            // Find files with matching basename
+            for (const indexedFilePath of Object.keys(indexData.files)) {
+                if (path.basename(indexedFilePath) === searchName) {
+                    matches.push(indexedFilePath);
+                }
+            }
+            if (matches.length > 0) {
+                let correctPath = matches[0];
+                // If multiple matches, try to find the best one by matching directory structure
+                if (matches.length > 1) {
+                    const searchParts = searchDir.split(path.sep).filter(p => p && p !== '.');
+                    // Score each match by how many path components match
+                    const scored = matches.map(m => {
+                        const matchParts = path.dirname(m).split(path.sep);
+                        let score = 0;
+                        for (let i = 0; i < searchParts.length; i++) {
+                            const searchPart = searchParts[searchParts.length - 1 - i];
+                            const matchPart = matchParts[matchParts.length - 1 - i];
+                            if (searchPart === matchPart) {
+                                score += (i + 1); // Weight recent parts higher
+                            }
+                        }
+                        return { path: m, score };
+                    });
+                    // Sort by score (highest first)
+                    scored.sort((a, b) => b.score - a.score);
+                    correctPath = scored[0].path;
+                    console.log(`   💡 Multiple matches found, choosing best match: ${correctPath}`);
+                }
+                else {
+                    console.log(`   ✅ Found file at ${correctPath}`);
+                }
+                // Try to read from correct path
+                const retryResult = await tryReadFileLines(correctPath);
+                if (retryResult) {
+                    return retryResult;
+                }
+                // If still failed, return error with suggestion
+                return {
+                    success: false,
+                    error: `Found file at ${correctPath} but failed to read it`,
+                    suggestion: correctPath,
+                    allMatches: matches.length > 1 ? matches : undefined
+                };
+            }
+        }
+        return {
+            success: false,
+            error: `File not found: ${filePath}. No matching files found in index.`
+        };
+    }
+    // No indexer available
+    return {
+        success: false,
+        error: `File not found: ${filePath}. Tip: Enable indexing for better file lookup.`
+    };
+}
+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)) {
+                    // console.log(`resolve_import_path: JSON.stringify(${JSON.stringify({
+                    //   success: true,
+                    //   resolvedPath: withExt
+                    // })})`)
+                    return { success: true, resolvedPath: withExt };
+                }
+            }
+            if (fsSync.existsSync(resolved)) {
+                // console.log(`resolve_import_path: JSON.stringify(${JSON.stringify({
+                //   success: true,
+                //   resolvedPath: resolved
+                // })})`)
+                return { success: true, resolvedPath: resolved };
+            }
+        }
+        // console.log(`resolve_import_path: JSON.stringify(${JSON.stringify({
+        //   success: true,
+        //   resolvedPath: importPath,
+        //   isExternal: true
+        // })})`)
+        return {
+            success: true,
+            resolvedPath: importPath,
+            isExternal: true
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Validate test file syntax using AST parsing
+ * Provides detailed error information for AI to retry
+ */
+async function validateTestFileSyntax(filePath) {
+    try {
+        // Read the file content
+        const content = await fs.readFile(filePath, 'utf-8');
+        // Try to parse with Babel - this will throw if syntax is invalid
+        babelParser.parse(content, {
+            sourceType: 'module',
+            plugins: [
+                'typescript',
+                'jsx',
+                'decorators-legacy'
+            ]
+        });
+        // If parsing succeeded, syntax is valid
+        return { valid: true };
+    }
+    catch (error) {
+        // Extract error details
+        const line = error.loc?.line || error.lineNumber || 0;
+        const column = error.loc?.column || error.column || 0;
+        let errorMessage = error.message || 'Unknown syntax error';
+        // Clean up error message (remove file path prefix if present)
+        errorMessage = errorMessage.replace(/^.*?: /, '');
+        // Generate helpful suggestion based on error type
+        let suggestion = '';
+        if (errorMessage.includes('Unexpected token') || errorMessage.includes('unexpected')) {
+            suggestion = 'Check for missing/extra brackets, parentheses, or commas near this location.';
+        }
+        else if (errorMessage.includes('Unterminated')) {
+            suggestion = 'You have an unclosed string, comment, or template literal.';
+        }
+        else if (errorMessage.includes('Expected')) {
+            suggestion = 'Missing required syntax element. Check if you closed all blocks properly.';
+        }
+        else if (errorMessage.includes('duplicate') || errorMessage.includes('already')) {
+            suggestion = 'Duplicate declaration detected. Check for repeated variable/function names.';
+        }
+        else {
+            suggestion = 'Review the code structure around this line for syntax issues.';
+        }
+        return {
+            valid: false,
+            error: errorMessage,
+            location: { line, column },
+            suggestion
         };
     }
-    catch (error) {
-        return { success: false, error: error.message };
-    }
 }
 async function writeTestFile(filePath, content, sourceFilePath, functionMode = false) {
     try {
@@ -936,18 +1655,12 @@ async function writeTestFile(filePath, content, sourceFilePath, functionMode = f
                     }
                 }
             }
-            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!`
-                };
-            }
+            // 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 });
@@ -1006,7 +1719,7 @@ async function editTestFile(filePath, oldContent, newContent) {
         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.`,
+            error: `Old content not found. Current file preview:\n${preview}\n...\n\nHint: Use search_replace_block with more context to find the correct location.`,
             currentContent: preview
         };
     }
@@ -1090,6 +1803,19 @@ async function replaceFunctionTests(testFilePath, functionName, newTestContent)
             updatedLines.push(...afterBlock);
             const updatedContent = updatedLines.join('\n');
             await fs.writeFile(testFilePath, updatedContent, 'utf-8');
+            // Validate syntax after modification
+            const validation = await validateTestFileSyntax(testFilePath);
+            if (!validation.valid) {
+                // Rollback the change by restoring original content
+                await fs.writeFile(testFilePath, content, 'utf-8');
+                return {
+                    success: false,
+                    error: `Syntax error after modification at line ${validation.location?.line}:${validation.location?.column}\n${validation.error}`,
+                    syntaxError: true,
+                    location: validation.location,
+                    suggestion: validation.suggestion
+                };
+            }
             return {
                 success: true,
                 message: `Replaced existing tests for function '${functionName}' (lines ${describeStartLine + 1}-${describeEndLine + 1})`,
@@ -1133,10 +1859,23 @@ async function replaceFunctionTests(testFilePath, functionName, newTestContent)
             // Validate bracket pairing
             const openCount = (updatedContent.match(/{/g) || []).length;
             const closeCount = (updatedContent.match(/}/g) || []).length;
-            if (openCount !== closeCount) {
-                console.warn(`⚠️  Warning: Bracket mismatch detected (${openCount} opening, ${closeCount} closing). The test file structure may be malformed.`);
-            }
+            // if (openCount !== closeCount) {
+            //   console.warn(`⚠️  Warning: Bracket mismatch detected (${openCount} opening, ${closeCount} closing). The test file structure may be malformed.`);
+            // }
             await fs.writeFile(testFilePath, updatedContent, 'utf-8');
+            // Validate syntax after modification
+            const validation = await validateTestFileSyntax(testFilePath);
+            if (!validation.valid) {
+                // Rollback the change by restoring original content
+                await fs.writeFile(testFilePath, content, 'utf-8');
+                return {
+                    success: false,
+                    error: `Syntax error after modification at line ${validation.location?.line}:${validation.location?.column}\n${validation.error}`,
+                    syntaxError: true,
+                    location: validation.location,
+                    suggestion: validation.suggestion
+                };
+            }
             return {
                 success: true,
                 message: `Added tests for function '${functionName}' at root level (after line ${lastRootLevelClosing + 1})`,
@@ -1150,19 +1889,33 @@ async function replaceFunctionTests(testFilePath, functionName, newTestContent)
         return { success: false, error: error.message };
     }
 }
-function runTests(testFilePath) {
+function runTests(testFilePath, functionNames) {
     try {
-        const output = (0, child_process_1.execSync)(`npx jest ${testFilePath} --no-coverage`, {
+        // Build Jest command with optional function name filter
+        let command = `npx jest ${testFilePath} --no-coverage --verbose=false`;
+        // If function names provided, use Jest -t flag to run only those tests
+        if (functionNames && functionNames.length > 0) {
+            // Create regex pattern to match any of the function names
+            // Escape special regex characters in function names
+            const escapedNames = functionNames.map(name => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+            const pattern = escapedNames.join('|');
+            command += ` -t "${pattern}"`;
+        }
+        const output = (0, child_process_1.execSync)(command, {
             encoding: 'utf-8',
             stdio: 'pipe'
         });
+        console.log(`   Test run output: ${output}`);
         return {
             success: true,
             output,
-            passed: true
+            passed: true,
+            command // Return command for debugging
         };
     }
     catch (error) {
+        console.log(`   Test run error: ${error.message}`);
+        console.log(`output sent to ai: ${error.stdout + error.stderr}`);
         return {
             success: false,
             output: error.stdout + error.stderr,
@@ -1263,6 +2016,13 @@ function calculateRelativePath(fromFile, toFile) {
         }
         // Convert backslashes to forward slashes (Windows compatibility)
         relativePath = relativePath.replace(/\\/g, '/');
+        // console.log(`calculate_relative_path: JSON.stringify(${JSON.stringify({
+        //   success: true,
+        //   from: fromFile,
+        //   to: toFile,
+        //   relativePath,
+        //   importStatement: `import { ... } from '${relativePath}';`
+        // })})`)
         return {
             success: true,
             from: fromFile,
@@ -1379,43 +2139,276 @@ async function replaceLines(filePath, startLine, endLine, newContent) {
         return { success: false, error: error.message };
     }
 }
+/**
+ * Search and replace a code block using fuzzy matching
+ * Much more reliable than line-based editing!
+ */
+async function searchReplaceBlock(filePath, search, replace, matchMode = 'normalized') {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        // Try exact match first if in normalized/fuzzy mode (faster)
+        if (matchMode !== 'exact' && content.includes(search)) {
+            const newContent = content.replace(search, replace);
+            await fs.writeFile(filePath, newContent, 'utf-8');
+            // Validate syntax if this is a test file
+            if (filePath.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/)) {
+                const validation = await validateTestFileSyntax(filePath);
+                if (!validation.valid) {
+                    // Rollback the change by restoring original content
+                    await fs.writeFile(filePath, content, 'utf-8');
+                    return {
+                        success: false,
+                        error: `Syntax error after modification at line ${validation.location?.line}:${validation.location?.column}\n${validation.error}`,
+                        syntaxError: true,
+                        location: validation.location,
+                        suggestion: validation.suggestion
+                    };
+                }
+            }
+            return {
+                success: true,
+                message: 'Replaced block (exact match)',
+                matchMode: 'exact',
+                confidence: 1.0,
+                linesChanged: newContent.split('\n').length - content.split('\n').length
+            };
+        }
+        // Bailout for very large files/searches to prevent hanging
+        const contentSize = content.length;
+        const searchSize = search.length;
+        const isLargeOperation = contentSize > 200000 || searchSize > 2000;
+        // Use smart search (force normalized for large files to skip expensive fuzzy)
+        const searchMode = isLargeOperation ? 'normalized' : matchMode;
+        const result = (0, fuzzyMatcher_1.smartSearch)(content, search, searchMode);
+        if (!result || !result.found) {
+            // Skip expensive similarity search for large files
+            const suggestions = isLargeOperation ? [] : (0, fuzzyMatcher_1.findSimilarBlocks)(content, search, 3);
+            const errorMessage = isLargeOperation
+                ? 'Search block not found. File is large - try including more unique context or use exact match mode.'
+                : (0, fuzzyMatcher_1.getSearchFailureMessage)(content, search);
+            return {
+                success: false,
+                error: errorMessage,
+                searchPreview: search.substring(0, 200) + (search.length > 200 ? '...' : ''),
+                suggestions: suggestions.map(s => ({
+                    text: s.text.substring(0, 150) + (s.text.length > 150 ? '...' : ''),
+                    similarity: Math.round(s.similarity * 100) + '%',
+                    lines: `${s.startLine}-${s.endLine}`
+                })),
+                hint: suggestions.length > 0
+                    ? `Found ${suggestions.length} similar block(s). Check if your search text has typos or try including more context lines.`
+                    : 'No similar blocks found. Make sure your search text matches the file content and includes enough context (3-5 lines around the target).'
+            };
+        }
+        // Perform replacement
+        const newContent = content.substring(0, result.startIndex) +
+            replace +
+            content.substring(result.endIndex);
+        await fs.writeFile(filePath, newContent, 'utf-8');
+        // Validate syntax if this is a test file
+        if (filePath.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/)) {
+            const validation = await validateTestFileSyntax(filePath);
+            if (!validation.valid) {
+                // Rollback the change by restoring original content
+                await fs.writeFile(filePath, content, 'utf-8');
+                return {
+                    success: false,
+                    error: `Syntax error after modification at line ${validation.location?.line}:${validation.location?.column}\n${validation.error}`,
+                    syntaxError: true,
+                    location: validation.location,
+                    suggestion: validation.suggestion
+                };
+            }
+        }
+        // Get lines for context
+        const getLineNumber = (charIndex) => {
+            return content.substring(0, charIndex).split('\n').length;
+        };
+        const startLine = getLineNumber(result.startIndex);
+        const endLine = getLineNumber(result.endIndex);
+        const result1 = { success: true,
+            message: `Replaced block successfully using ${result.matchType} matching`,
+            matchMode: result.matchType,
+            confidence: result.confidence,
+            linesChanged: newContent.split('\n').length - content.split('\n').length,
+            linesReplaced: `${startLine}-${endLine}`,
+            replacedText: result.originalText.substring(0, 200) + (result.originalText.length > 200 ? '...' : '') };
+        // console.log(`SearchReplaceBlock: JSON.stringify(${JSON.stringify(result1)})`)
+        return {
+            success: true,
+            message: `Replaced block successfully using ${result.matchType} matching`,
+            matchMode: result.matchType,
+            confidence: result.confidence,
+            linesChanged: newContent.split('\n').length - content.split('\n').length,
+            linesReplaced: `${startLine}-${endLine}`,
+            replacedText: result.originalText.substring(0, 200) + (result.originalText.length > 200 ? '...' : '')
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Insert content at a specific position in the file
+ * Simpler than search_replace_block for adding new content
+ */
+async function insertAtPosition(filePath, content, position, afterMarker) {
+    try {
+        const fileContent = await fs.readFile(filePath, 'utf-8');
+        const lines = fileContent.split('\n');
+        let insertIndex = 0;
+        let insertionPoint = '';
+        if (afterMarker) {
+            // Use smart search to find marker
+            const result = (0, fuzzyMatcher_1.smartSearch)(fileContent, afterMarker, 'normalized');
+            if (!result || !result.found) {
+                return {
+                    success: false,
+                    error: `Marker not found: "${afterMarker.substring(0, 100)}..."`,
+                    hint: 'Use search_replace_block or specify a position instead'
+                };
+            }
+            // Find line number of marker end
+            let charCount = 0;
+            for (let i = 0; i < lines.length; i++) {
+                charCount += lines[i].length + 1; // +1 for newline
+                if (charCount >= result.endIndex) {
+                    insertIndex = i + 1;
+                    insertionPoint = `after marker at line ${i + 1}`;
+                    break;
+                }
+            }
+        }
+        else {
+            // Use position
+            switch (position) {
+                case 'beginning':
+                    insertIndex = 0;
+                    insertionPoint = 'beginning of file';
+                    break;
+                case 'end':
+                    insertIndex = lines.length;
+                    insertionPoint = 'end of file';
+                    break;
+                case 'after_imports': {
+                    // Find last import statement
+                    let lastImportLine = -1;
+                    for (let i = 0; i < lines.length; i++) {
+                        const trimmed = lines[i].trim();
+                        if (trimmed.startsWith('import ') || trimmed.startsWith('require(') ||
+                            trimmed.startsWith('const ') && trimmed.includes('require(')) {
+                            lastImportLine = i;
+                        }
+                        else if (trimmed && !trimmed.startsWith('//') && !trimmed.startsWith('/*') && lastImportLine >= 0) {
+                            // Stop at first non-import, non-comment line after imports
+                            break;
+                        }
+                    }
+                    if (lastImportLine === -1) {
+                        return {
+                            success: false,
+                            error: 'No import statements found in file',
+                            hint: 'Use position: "beginning" instead or specify after_marker'
+                        };
+                    }
+                    insertIndex = lastImportLine + 1;
+                    insertionPoint = `after imports at line ${lastImportLine + 1}`;
+                    break;
+                }
+                case 'before_first_describe': {
+                    // Find first describe block
+                    let firstDescribe = -1;
+                    for (let i = 0; i < lines.length; i++) {
+                        if (lines[i].trim().startsWith('describe(')) {
+                            firstDescribe = i;
+                            break;
+                        }
+                    }
+                    if (firstDescribe === -1) {
+                        return {
+                            success: false,
+                            error: 'No describe blocks found in file',
+                            hint: 'Use position: "end" instead or specify after_marker'
+                        };
+                    }
+                    insertIndex = firstDescribe;
+                    insertionPoint = `before first describe at line ${firstDescribe + 1}`;
+                    break;
+                }
+                default:
+                    // Default to end
+                    insertIndex = lines.length;
+                    insertionPoint = 'end of file';
+            }
+        }
+        // Insert content
+        const contentLines = content.split('\n');
+        lines.splice(insertIndex, 0, ...contentLines);
+        const newContent = lines.join('\n');
+        await fs.writeFile(filePath, newContent, 'utf-8');
+        // Validate syntax if this is a test file
+        if (filePath.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/)) {
+            const validation = await validateTestFileSyntax(filePath);
+            if (!validation.valid) {
+                // Rollback the change by restoring original content
+                await fs.writeFile(filePath, fileContent, 'utf-8');
+                return {
+                    success: false,
+                    error: `Syntax error after modification at line ${validation.location?.line}:${validation.location?.column}\n${validation.error}`,
+                    syntaxError: true,
+                    location: validation.location,
+                    suggestion: validation.suggestion
+                };
+            }
+        }
+        return {
+            success: true,
+            message: `Inserted ${contentLines.length} line(s) at ${insertionPoint}`,
+            insertedAt: insertionPoint,
+            lineCount: contentLines.length
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
 // User-friendly messages for each tool
 const TOOL_MESSAGES = {
     'read_file': '📖 Reading source file',
+    'read_file_lines': '📖 Reading file section',
     'analyze_file_ast': '🔍 Analyzing codebase structure',
     'get_function_ast': '🔎 Examining function details',
     'get_imports_ast': '📦 Analyzing dependencies',
     'get_type_definitions': '📋 Extracting type definitions',
+    'get_file_preamble': '📋 Extracting file preamble (imports, mocks, setup)',
     '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',
+    'upsert_function_tests': '✍️  Writing/updating test cases for function',
     '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'
+    'search_replace_block': '🔍🔄 Searching and replacing code block',
+    'insert_at_position': '➕ Inserting content at position',
 };
 // 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}`;
+    if (toolName === 'upsert_function_tests' && args.function_name) {
+        friendlyMessage = `✍️  Writing/updating 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 === 'search_replace_block') {
+        const preview = args.search ? args.search.substring(0, 50) + (args.search.length > 50 ? '...' : '') : '';
+        friendlyMessage = `🔍🔄 Searching for: "${preview}"`;
     }
-    else if (toolName === 'insert_lines' && args.line_number) {
-        friendlyMessage = `➕ Inserting lines at line ${args.line_number}`;
+    else if (toolName === 'insert_at_position' && args.position) {
+        friendlyMessage = `➕ Inserting at: ${args.position}`;
     }
-    else if (toolName === 'replace_lines' && args.start_line && args.end_line) {
-        friendlyMessage = `🔄 Replacing lines ${args.start_line}-${args.end_line}`;
+    else if (toolName === 'read_file_lines' && args.start_line && args.end_line) {
+        friendlyMessage = `📖 Reading lines ${args.start_line}-${args.end_line}`;
     }
     console.log(`\n${friendlyMessage}...`);
     let result;
@@ -1424,6 +2417,9 @@ async function executeTool(toolName, args) {
             case 'read_file':
                 result = await readFile(args.file_path);
                 break;
+            case 'read_file_lines':
+                result = await readFileLines(args.file_path, args.start_line, args.end_line);
+                break;
             case 'analyze_file_ast':
                 // Try cache first if indexer is available
                 if (globalIndexer) {
@@ -1468,20 +2464,17 @@ async function executeTool(toolName, args) {
             case 'get_class_methods':
                 result = getClassMethods(args.file_path, args.class_name);
                 break;
+            case 'get_file_preamble':
+                result = getFilePreamble(args.file_path);
+                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, args.function_mode);
-                break;
-            case 'edit_test_file':
-                result = await editTestFile(args.file_path, args.old_content, args.new_content);
-                break;
-            case 'replace_function_tests':
+            case 'upsert_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);
+                result = runTests(args.test_file_path, args.function_names);
                 break;
             case 'list_directory':
                 result = listDirectory(args.directory_path);
@@ -1495,14 +2488,11 @@ async function executeTool(toolName, args) {
             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);
+            case 'search_replace_block':
+                result = await searchReplaceBlock(args.file_path, args.search, args.replace, args.match_mode);
                 break;
-            case 'replace_lines':
-                result = await replaceLines(args.file_path, args.start_line, args.end_line, args.new_content);
+            case 'insert_at_position':
+                result = await insertAtPosition(args.file_path, args.content, args.position, args.after_marker);
                 break;
             default:
                 result = { success: false, error: `Unknown tool: ${toolName}` };
@@ -1513,6 +2503,7 @@ async function executeTool(toolName, args) {
     }
     // Show result with friendly message
     if (result.success) {
+        // console.log('result', JSON.stringify(result, null, 2));
         console.log(`   ✅ Done`);
     }
     else if (result.error) {
@@ -1759,104 +2750,283 @@ async function callAI(messages, tools, provider = CONFIG.aiProvider) {
 // 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 including edge cases 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
-   - REQUIRED: Test cases should include security and input validation tests.
-   - REQUIRED: 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}")
+    // Check file size and switch to function-by-function generation if large
+    try {
+        const fileContent = fsSync.readFileSync(sourceFile, 'utf-8');
+        const lineCount = fileContent.split('\n').length;
+        console.log(`📊 Source file has ${lineCount} lines`);
+        if (lineCount > 200) {
+            console.log(`\n⚡ File has more than 200 lines! Switching to function-by-function generation...\n`);
+            // Analyze file to get all functions
+            const result = analyzeFileAST(sourceFile);
+            if (result && result.success && result.analysis && result.analysis.functions && result.analysis.functions.length > 0) {
+                // Filter to only EXPORTED functions (public API)
+                const exportedFunctions = result.analysis.functions.filter((f) => f.exported);
+                const functionNames = exportedFunctions.map((f) => f.name).filter((name) => name);
+                if (functionNames.length === 0) {
+                    console.log('⚠️  No exported functions found in file. Falling back to regular generation.');
+                    // Fall through to regular generation
+                }
+                else {
+                    const totalFunctions = result.analysis.functions.length;
+                    const internalFunctions = totalFunctions - exportedFunctions.length;
+                    console.log(`✅ Found ${functionNames.length} exported function(s): ${functionNames.join(', ')}`);
+                    if (internalFunctions > 0) {
+                        console.log(`   (Skipping ${internalFunctions} internal/helper function(s) - only testing public API)`);
+                    }
+                    // Use function-by-function generation
+                    try {
+                        return await generateTestsForFunctions(sourceFile, functionNames);
+                    }
+                    catch (funcError) {
+                        // CRITICAL: Check if test file already exists with content
+                        const testFilePath = getTestFilePath(sourceFile);
+                        if (fsSync.existsSync(testFilePath)) {
+                            const existingContent = fsSync.readFileSync(testFilePath, 'utf-8');
+                            const hasExistingTests = existingContent.includes('describe(') || existingContent.includes('test(');
+                            if (hasExistingTests) {
+                                console.error('\n❌ CRITICAL: Function-by-function generation failed, but test file already has tests!');
+                                console.error('   Cannot fall back to file-wise generation as it would OVERWRITE existing tests.');
+                                console.error(`   Error: ${funcError.message}`);
+                                console.error('\n   Options:');
+                                console.error('   1. Fix the issue manually in the test file');
+                                console.error('   2. Delete the test file and regenerate from scratch');
+                                console.error('   3. Run function-wise generation again for remaining functions');
+                                throw new Error(`Function-by-function generation failed with existing tests. Manual intervention required. Original error: ${funcError.message}`);
+                            }
+                        }
+                        // No existing tests, safe to fall back
+                        console.log('⚠️  Function-by-function generation failed, but no existing tests found. Falling back to file-wise generation.');
+                        throw funcError; // Re-throw to be caught by outer try-catch
+                    }
+                }
+            }
+            else {
+                console.log('⚠️  No functions found in file. Falling back to regular generation.');
+                if (result && !result.success) {
+                    console.log(`   Analysis error: ${result.error}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Check if this is the "existing tests" protection error
+        if (error.message && error.message.includes('Manual intervention required')) {
+            // This is a critical error - don't proceed with generation
+            console.error(`\n❌ Aborting: ${error.message}`);
+            throw error; // Re-throw to stop execution
+        }
+        console.log(`⚠️  Could not check file size: ${error}. Proceeding with regular generation.`);
+        // Falls through to regular file-wise generation below
+    }
+    const testFilePath = getTestFilePath(sourceFile);
+    const messages = [
+        {
+            role: 'user',
+            content: `You are a senior software engineer tasked with writing comprehensive Jest unit tests including edge cases 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)
+   - This provides metadata about all code structures without loading full file content
+   - CRITICAL: You have only 50 iterations to complete this task, so make sure you are using the tools efficiently.
+   - Do not over explore, use the tools to get the information you need and start generating tests.
+2. Use get_imports_ast tool to understand all dependencies
+3. For each dependency, use find_file(filePath) to locate the file 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
+   - Returns complete function code WITH JSDoc comments
+   - Includes calledFunctions and calledMethods lists showing what the function calls
+   - Use this to fetch related helper functions if needed
+   - [CRITICAL]: If a function calls other functions from other files, use find_file + get_function_ast tools to locate them and check if they need to mocked, since they can be making api calls to external services.
+5. Use get_function_ast to get detailed information about the functions.
+6. For large test files (>5K lines), use get_file_preamble to see existing imports/mocks/setup blocks
+   - Automatically included when reading large test files
+   - Use before adding new test cases to avoid duplicate mocks/imports
+   - Particularly useful when updating existing test files with upsert_function_tests
+   - Captures complete multi-line mocks including complex jest.mock() statements
+7. For classes, use get_class_methods tool to extract all methods
+8. Use get_type_definitions tool to understand TypeScript types and interfaces
+9. Generate comprehensive Jest unit tests with:
+   - CRITICAL: Mock ALL imports BEFORE importing the source file to prevent initialization errors. Ensure tests fully mock the config module with all expected properties.
+   - If required: 
+    - Mock database modules like '../database' or '../database/index' with virtual:true.
+    - Mock models, and any modules that access config or the database with virtual:true.
+    - Mock config properly with virtual:true.
+    - Mock isEmpty from lodash to return the expected values with virtual:true.
+    - Axios should be mocked with virtual:true.
+    - Use jest.mock() calls at the TOP of the file before any imports
+    - [CRITICAL]: Virtual modules should only be used for db/config/models/services/index/axios/routes files. You should not use virtual:true for any other files or helpers that exist in the source code. The actual helpers should never be mocked with virtual:true.
+9. REQUIRED: Write tests using upsert_function_tests tool for EACH function with REAL test code (NOT placeholders!)
+   - Call upsert_function_tests once for EACH exported function
+   - Ensure comprehensive mocks are included in the first function's test to set up the file
    - 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:
+   - Every test MUST have [MANDATORY]:
      * Real setup code (mock functions, create test data)
      * Real execution (call the function being tested)
      * Real expect() assertions (at least one per test)
+     * null/undefined handling tests for all API responses
+     * Happy path scenarios
+     * Edge cases (null, undefined, empty arrays, etc.)
+     * Error conditions
+     * Async behavior (if applicable)
+   - Proper TypeScript types
    - Write tests for EVERY exported function (minimum 3-5 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
+10. REQUIRED: Run the tests using run_tests tool
+11. REQUIRED: If tests fail with import errors:
+    - Use find_file(filePath) tool to locate the file and calculate_relative_path to get correct import paths for the test file
     - 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:
+    - ✅ PRIMARY METHOD: Use search_replace_block to fix imports:
+      * Include 3-5 lines of context around the import to change
+      * Example: search_replace_block({
+          search: "import { oldImport } from './old-path';\nimport { other } from './other';",
+          replace: "import { oldImport, newImport } from './correct-path';\nimport { other } from './other';"
+        })
+    - 📌 ALTERNATIVE: Use insert_at_position for adding new imports:
+      * insert_at_position({ position: 'after_imports', content: "import { newImport } from './path';" })
+    - ⚠️ AVOID: Line-based tools (deprecated, fragile)
+12. 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
+    - TypeScript compilation errors (syntax errors, bracket mismatches)
     - Missing test setup/teardown
     - Cannot read properties of undefined
+    - Test case failed to run. Use read_file_lines tool to read the specific problematic section and fix the issue.
+    
+    💡 TIP: For syntax errors or bracket mismatches:
+    - Use read_file to see the file content (it includes line numbers)
+    - Use search_replace_block to fix the problematic section
+    - Include 3-5 lines of context around the error to make search unique
+    - Example: search_replace_block({
+        search: "line before error\nproblematic code with syntax error\nline after",
+        replace: "line before error\ncorrected code\nline after"
+      })
     
     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
+13. If errors are FIXABLE (AFTER test file is written): 
+    - ✅ PRIMARY METHOD: Use search_replace_block (RECOMMENDED):
+      * Find the problematic code section
+      * Include 3-5 lines of context before/after to make search unique
+      * Replace with corrected version
+      * Example: search_replace_block({
+          file_path: "test.ts",
+          search: "const mock = jest.fn();\ntest('old test', () => {\n  mock();",
+          replace: "const mock = jest.fn().mockResolvedValue({ data: 'test' });\ntest('fixed test', () => {\n  mock();"
+        })
+      * Handles whitespace/indentation differences automatically!
+    - 📌 ALTERNATIVE: Use insert_at_position for adding mocks/imports at top:
+      * insert_at_position({ position: 'after_imports', content: "jest.mock('../database');" })
+    - ⚠️ AVOID: Line-based tools (deprecated) - they are fragile and prone to errors
     - Then retry running tests
-13. If errors are LEGITIMATE: Call report_legitimate_failure tool with details and STOP trying to fix
+14. 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.
+    - You are not allowed to call this tool for error - Test suite failed to run. You must ensure that test cases get executed. Fix any syntax or linting issues in the test file.
+15. REQUIRED: Repeat steps 10-14 until tests pass OR legitimate failures are reported
+16. REQUIRED: Ensure all functions are tested in the test file.
+17. CRITICAL: config and database modules must be mocked
+
+18. Some known issues when running tests with fixes:
+  Route loading issue: Importing the controller triggered route setup because axios-helper imports from index.ts, which loads all routes. Routes referenced functions that weren't available during test initialization.
+   - Solution: Mocked index.ts to export only whitelistDomainsForHeaders without executing route setup code.
+  Axios mock missing required properties: The axios mock didn't include properties needed by axios-retry (like interceptors).
+   - Solution: Created a createMockAxiosInstance function that returns a mock axios instance with interceptors, defaults, and HTTP methods.
+  axios-retry not mocked: axios-retry was trying to modify axios instances during module initialization.
+   - Solution: Added a mock for axios-retry to prevent it from executing during tests.
+  Routes file execution: The routes file was being executed when the controller was imported.
+   - Solution: Mocked the routes file to return a simple Express router without executing route definitions.
 
 CRITICAL: Distinguish between test bugs (fix them) and source code bugs (report and stop)!
 
+19. [ALWAYS FOLLOW] Write Jest test cases following these MANDATORY patterns to prevent mock pollution:
+
+SECTION 1: Top-Level Mock Setup
+Declare ALL jest.mock() calls at the top of the file, outside any describe blocks
+Mock EVERY function and module the controller/function uses
+Load the controller/module under test ONCE in beforeAll()
+[MANDATORY] Always use calculate_relative_path tool to get the correct import path for the module to be used in jest.mock() calls.
+
+SECTION 2: Module References in Describe Blocks (CRITICAL)
+Declare ALL module references as let variables at the top of each describe block
+NEVER use const for module requires inside describe blocks
+Re-assign these modules inside beforeEach AFTER jest.clearAllMocks()
+This ensures each test gets fresh module references with clean mocks
+
+SECTION 3: BeforeEach Pattern (MANDATORY)
+Pattern Structure:
+
+Declare let variables for all modules at top of describe block
+Load controller once in beforeAll
+In beforeEach: clear mocks first, then re-assign all modules, then reset all mock implementations
+In afterEach: restore all mocks for extra safety
+In individual tests: only override specific mocks needed for that test
+
+Example Pattern:
+
+Declare: let controller, let helperModule, let responseHelper, let otherDependency
+beforeAll: controller = require path to controller
+beforeEach step 1: jest.clearAllMocks()
+beforeEach step 2: Re-assign all modules with require statements
+beforeEach step 3: Set default mock implementations for all mocked functions
+afterEach: jest.restoreAllMocks()
+In tests: Override only what changes for that specific test case
+
+SECTION 4: What to NEVER Do
+
+Never use const for module requires inside describe blocks
+Never rely on top-level module requires for mocking within tests
+Never share module references across multiple describe blocks
+Never skip re-assigning modules in beforeEach
+Never mutate module exports directly, always use mockImplementation instead
+Never forget to clear mocks before getting fresh references
+
+SECTION 5: Key Principles
+
+Isolation: Each test has its own mock instances via fresh requires
+Cleanup: Always clear and restore mocks between tests
+Explicit: Make all dependencies explicit in beforeEach
+Fresh References: Re-require modules after clearing to get clean mocks
+Default Behaviors: Set up sensible defaults in beforeEach, override in individual tests
+
+SECTION 6: Verification Steps
+
+Run tests multiple times with runInBand flag
+Run tests in random order with randomize flag
+Tests should pass consistently regardless of execution order
+Each test should be completely independent
+
+SECTION 7: Critical Reminders
+
+Always add missing mock initializations in relevant beforeEach blocks
+Ensure all mocked functions have default behaviors set in beforeEach
+Re-require modules after jest.clearAllMocks() to get fresh mock references
+Use let not const for all module references inside describe blocks
+Load the actual controller or module under test only once in beforeAll
+
+Apply these patterns to ALL test files to ensure zero mock pollution between test suites and individual test cases.
+
 START NOW by calling the analyze_file_ast tool with the source file path.`
         }
     ];
@@ -1895,7 +3065,7 @@ START NOW by calling the analyze_file_ast tool with the source file path.`
                 // 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.'
+                    content: 'STOP making excuses! You CAN use the tools. Use search_replace_block or insert_at_position NOW to fix the test file. Add proper mocks to prevent database initialization errors.'
                 });
                 continue;
             }
@@ -1918,7 +3088,7 @@ START NOW by calling the analyze_file_ast tool with the source file path.`
             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).'
+                    content: 'You have not written the test file yet. Use upsert_function_tests tool NOW with complete test code (not placeholders) for each function.'
                 });
             }
             else {
@@ -1928,11 +3098,13 @@ START NOW by calling the analyze_file_ast tool with the source file path.`
 
 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
+  ✅ PRIMARY: Use search_replace_block with context (handles whitespace automatically!)
+  📌 ALTERNATIVE: Use insert_at_position for adding imports/mocks
+  ⚠️ AVOID: Line-based tools (deprecated, fragile)
+  run_tests tool to run the tests and check if the tests pass.
 - LEGITIMATE failures (source code bugs): Call report_legitimate_failure tool
 
-Start with read_file to see line numbers, then fix specific lines!`
+Example: search_replace_block({ search: "old code with context...", replace: "new fixed code..." })`
                 });
             }
             continue;
@@ -1955,81 +3127,41 @@ Start with read_file to see line numbers, then fix specific lines!`
                 console.log(`   Recommendation: ${result.recommendation}`);
             }
             // Track if test file was written
-            if (toolCall.name === 'write_test_file') {
+            if (toolCall.name === 'upsert_function_tests') {
                 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!`
-                        });
-                    }
+                    console.log(`\n📝 Test file ${result.replaced ? 'updated' : 'written'}: ${testFilePath}`);
                 }
             }
-            // 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...');
+            // Detect syntax errors from validation
+            if (result.syntaxError && result.location) {
+                console.log(`\n❌ Syntax error introduced at line ${result.location.line}!`);
                 messages.push({
                     role: 'user',
-                    content: `❌ edit_test_file failed due to content mismatch. 
+                    content: `🚨 SYNTAX ERROR DETECTED at line ${result.location.line}:${result.location.column}
+
+${result.error}
 
-✅ SWITCH TO LINE-BASED EDITING (Primary Method):
+💡 ${result.suggestion}
 
-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)
+Your last modification created invalid syntax and was ROLLED BACK automatically.
 
-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 };" })
+To fix this:
+1. Use read_file to see the current file content (includes line numbers)
+2. Find the section you need to modify around line ${result.location.line}
+3. Use search_replace_block with correct syntax:
+   - Include 3-5 lines of context around the target
+   - Ensure your replacement has valid syntax (matching brackets, quotes, etc.)
+   - Double-check for missing semicolons, commas, or closing brackets
 
-⚠️ Only use write_test_file as LAST RESORT (full file rewrite).
+Example:
+search_replace_block({
+  file_path: "${toolCall.input.file_path || toolCall.input.test_file_path || 'test file'}",
+  search: "valid context from file\nline with issue\nmore context",
+  replace: "valid context from file\nCORRECTED line with proper syntax\nmore context"
+})
 
-Start with read_file NOW to see line numbers!`
+Start NOW by reading the file around line ${result.location.line}!`
                 });
             }
             // Detect repeated errors (suggests legitimate failure)
@@ -2040,15 +3172,15 @@ Start with read_file NOW to see line numbers!`
                     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.');
+                        console.log('\n🚨 Same error repeated 3+ times! ');
                         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. Use available tools file read_file_lines to read the current state of file.
 2. Or is this a LEGITIMATE source code bug?
 
 If LEGITIMATE: Call report_legitimate_failure tool NOW with details.
@@ -2076,20 +3208,23 @@ If FIXABLE: Make one more attempt to fix it.`
                         role: 'user',
                         content: `Import path error detected! Module not found: "${missingModule}"
 
-✅ FIX WITH LINE-BASED EDITING:
+✅ FIX WITH SEARCH-REPLACE:
 
 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
+Step 2: calculate_relative_path tool to get correct import path  
+Step 3: Fix using search_replace_block:
+   a) Include the broken import line + 2-3 surrounding lines for context
+   b) Replace with corrected import using the right path
+   c) The tool handles whitespace/indentation automatically!
 
 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';" })
+3. search_replace_block({
+     file_path: "${testFilePath}",
+     search: "import { something } from './other';\nimport { broken } from '${missingModule}';\nimport { another } from './path';",
+     replace: "import { something } from './other';\nimport { fixed } from './correct-path';\nimport { another } from './path';"
+   })
 
 Start NOW with find_file!`
                     });
@@ -2102,28 +3237,25 @@ Start NOW with find_file!`
                         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)
+✅ FIX WITH SEARCH-REPLACE:
 
-Required mocks to add:
-   jest.mock('../database', () => ({ default: {} }));
-   jest.mock('../database/index', () => ({ default: {} }));
-   jest.mock('../models/serviceDesk.models');
+Option 1 (Recommended): Use insert_at_position to add mocks at beginning:
+   insert_at_position({
+     file_path: "${testFilePath}",
+     position: "beginning",
+     content: "jest.mock('../database', () => ({ default: {} }));\njest.mock('../database/index', () => ({ default: {} }));\njest.mock('../models/serviceDesk.models');\n\n"
+   })
 
-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"
+Option 2: If file already has some mocks, use search_replace_block to add more:
+   search_replace_block({
+     file_path: "${testFilePath}",
+     search: "jest.mock('./existing-mock');\n\nimport { something }",
+     replace: "jest.mock('./existing-mock');\njest.mock('../database', () => ({ default: {} }));\njest.mock('../models/serviceDesk.models');\n\nimport { something }"
    })
 
 ⚠️ Mocks MUST be at the TOP before any imports!
 
-Start NOW with read_file to see current structure!`
+Start NOW with insert_at_position!`
                     });
                 }
             }
@@ -2291,97 +3423,240 @@ async function generateTestsForFolder() {
     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);
+/**
+ * Generate tests for a single function
+ * @returns true if tests passed, false if legitimate failure reported
+ */
+async function generateTestForSingleFunction(sourceFile, functionName, testFilePath, testFileExists) {
     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.
+            content: `You are an expert software test engineer. Generate comprehensive Jest unit tests for: ${functionName} in ${sourceFile}. 
 
-Source file: ${sourceFile}
-Test file path: ${testFilePath}
-Test file exists: ${testFileExists}
-Selected functions to test: ${functionNames.join(', ')}
+## CONTEXT
+Test file: ${testFilePath} | Exists: ${testFileExists}
 
-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}! 🚨
+## EXECUTION PLAN
 
-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!
+**Phase 1: Deep Analysis**
+\\\`\\\`\\\`
+1. analyze_file_ast(${sourceFile}) → function metadata.
+2. get_function_ast(${sourceFile},{functionName}) → implementation + dependencies
+3. For each dependency:
+   - Same file: get_function_ast(${sourceFile},{functionName})
+   - Other file [Can take reference from the imports of the ${sourceFile} file for the file name that has the required function]: find_file(filename) to get file path -> get_function_ast({file_path},{functionName}) + check for external calls
+4. get_imports_ast → all dependencies
+5. calculate_relative_path for each import
+6. get_file_preamble → imports and mocks already declared in the file
+\\\`\\\`\\\`
 
-Other tests in this file for different functions MUST be preserved!
-` : ''}
+**Phase 1.1: Execution Path Tracing (CRITICAL FOR SUCCESS)**
+*Before writing tests, map the logic requirements for external calls.*
+1. Identify every external call (e.g., \`analyticsHelper.postEvent\`).
+2. Trace backwards: What \`if\`, \`switch\`, or \`try/catch\` block guards this call?
+3. Identify the dependency that controls that guard.
+4. Plan the Mock Return: Determine exactly what value the dependency must return to enter that block.
 
-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(', ')} with function_mode set to true.
-   - Create a new test file with complete test implementation
-   - [CRITICAL]: Set function_mode parameter to true if using write_test_file tool`}}
-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)!
+**Phase 2: Test Generation**
 
-START NOW by calling the analyze_file_ast tool with the source file path.`
+Mock Pattern (CRITICAL - Top of file, before imports):
+\\\`\\\`\\\`typescript
+// ===== MOCKS (BEFORE IMPORTS) =====
+jest.mock('config', () => ({
+  get: (key: string) => ({
+    AUTH: { JWT_KEY: 'test', COOKIE_DATA_ONE_YEAR: 31536000000 },
+    USER_DEL_SECRET: 'secret'
+  })
+}), { virtual: true });
+
+jest.mock('../path/from/calculate_relative_path');
+// Never virtual:true for actual source helpers!
+// ⚠️ CRITICAL: Mock ALL dependencies at top level, even if unused
+
+// ===== IMPORTS =====
+import { functionName } from '../controller';
+\\\`\\\`\\\`
+
+Requirements (5+ tests minimum):
+- ✅ Happy path
+- 🔸 Edge cases (null, undefined, empty)
+- ❌ Error conditions  
+- ⏱️ Async behavior
+- 🔍 API null/undefined handling
+
+**Phase 3: Anti-Pollution Pattern (MANDATORY)**
+
+### Step 1: Mock Setup (Top of File)
+// ===== MOCKS (BEFORE IMPORTS) =====
+jest.mock('config', () => ({
+  get: () => ({ KEY: 'value' })
+}), { virtual: true }); // virtual:true ONLY for config, db, models
+
+jest.mock('../helpers/dependency'); // NO virtual:true for regular modules
+
+// ===== IMPORTS =====
+import { functionName } from '../controller';
+import { dependencyMethod } from '../helpers/dependency';
+
+// ===== TYPED MOCKS =====
+const mockDependencyMethod = dependencyMethod as jest.MockedFunction<typeof dependencyMethod>;
+
+### Step 2: Test Structure
+describe('functionName', () => {
+  beforeEach(() => {
+    // ALWAYS first line
+    jest.clearAllMocks();
+    
+    // Set defaults for THIS describe block only
+    mockDependencyMethod.mockResolvedValue({ status: 'success' });
+  });
+
+  test('happy path', async () => {
+    // Override default for this test only
+    mockDependencyMethod.mockResolvedValueOnce({ id: 123 });
+    
+    const result = await functionName();
+    
+    expect(result).toEqual({ id: 123 });
+    expect(mockDependencyMethod).toHaveBeenCalledWith(expect.objectContaining({
+      param: 'value'
+    }));
+  });
+
+  test('error case', async () => {
+    mockDependencyMethod.mockRejectedValueOnce(new Error('fail'));
+    
+    const result = await functionName();
+    
+    expect(result).toEqual({});
+  });
+});
+
+describe('anotherFunction', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    // Different defaults for different function
+    mockDependencyMethod.mockResolvedValue({ status: 'pending' });
+  });
+  
+  // ... tests
+});
+
+
+### Step 3: Internal Function Mocking (When Needed)
+
+describe('functionWithInternalCalls', () => {
+  let internalFnSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    const controller = require('../controller');
+    internalFnSpy = jest.spyOn(controller, 'internalFunction')
+      .mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    internalFnSpy.mockRestore();
+  });
+
+  test('calls internal function', async () => {
+    await functionWithInternalCalls();
+    expect(internalFnSpy).toHaveBeenCalled();
+  });
+});
+
+### CRITICAL RULES:
+**DO ✅**
+1. **Mock at file top** - All \`jest.mock()\` calls before any imports
+2. **Import directly** - Use \`import { fn } from 'module'\` (never \`require()\`)
+3. **Type all mocks** - \`const mockFn = fn as jest.MockedFunction<typeof fn>\`
+4. **Clear first always** - \`jest.clearAllMocks()\` as first line in every \`beforeEach()\`
+5. **Isolate describe defaults** - Each \`describe\` block sets its own mock defaults
+6. **Override with mockOnce** - Use \`mockResolvedValueOnce/mockReturnValueOnce\` in tests
+7. **Restore spies** - Use \`jest.spyOn()\` with \`mockRestore()\` for internal function spies
+8. **Use calculate_relative_path** - For all import and mock paths
+
+**DON'T ❌**
+1. **Re-require modules** - Never use \`require()\` in \`beforeEach()\` or tests
+2. **Check mock existence** - Never \`if (!mockFn)\` - indicates broken setup
+3. **Share mock state** - Don't rely on defaults from other \`describe\` blocks
+4. **Skip jest.clearAllMocks()** - Missing this is the #1 cause of pollution
+5. **Use virtual:true everywhere** - Only for: config, db, models, routes, services
+6. **Forget to restore spies** - Always pair \`jest.spyOn()\` with \`mockRestore()\`
+
+### Why This Works:
+- **No pollution**: Each describe block sets its own defaults in beforeEach
+- **No conflicts**: clearAllMocks() resets all mock state
+- **Type safety**: TypeScript catches mock mismatches
+- **Predictable**: Tests run in any order with same results
+
+**Phase 4: Write Tests**
+→ upsert_function_tests({ 
+  test_file_path: "${testFilePath}",
+  function_name: "${functionName}", 
+  new_test_content: "describe('${functionName}', () => {...})"
+})
+This will automatically replace the existing test cases for the function with the new test cases or add new test cases if the function is not found in the test file.
+
+
+
+## PHASE 5: SELF-REVIEW (Before Running Tests)
+
+**Review Checklist:**
+1. ✅ All jest.mock() calls at top of file (before imports)?
+2. ✅ Used calculate_relative_path for all mock paths?
+3. ✅ Functions imported directly (not loaded via require)?
+4. ✅ Mocks typed with \`as jest.MockedFunction<typeof fn>\`?
+5. ✅ beforeEach() has jest.clearAllMocks() as FIRST line?
+6. ✅ Each describe block sets its own default mock values in beforeEach()?
+7. ✅ Used mockResolvedValueOnce/mockReturnValueOnce for test overrides?
+8. ✅ At least 5 test cases (happy/error/edge/async/null)?
+9. ✅ All async functions use async/await in tests?
+10. ✅ Spies on internal functions restored in afterEach()?
+11. ✅ No re-requiring modules or checking if mocks exist?
+12. ✅ No TypeScript type errors in test code?
+
+**Phase 6: Tests - Run & Fix - Loop**
+
+1️⃣ Run: \`run_tests({ test_file_path: "${testFilePath}", function_names: ["${functionName}"] })\`
+
+2️⃣  If fails, categorize:
+
+**[MUST] FIXABLE** → Fix these:
+| Error | Fix Method |
+|-------|-----------|
+| Wrong imports | find_file(fileName) to get the file path + calculate_relative_path + search_replace_block |
+| Missing mocks | insert_at_position |
+| Syntax errors | search_replace_block (3-5 lines context) |
+| Mock pollution | Fix beforeEach pattern |
+| "Test suite failed to run" | get_file_preamble + fix imports/mocks |
+| "Cannot find module" | calculate_relative_path |
+
+**LEGITIMATE** → Report, don't fix:
+- Source returns wrong type
+- Missing null checks in source  
+- Logic errors in source
+
+⛔ NEVER report "Test suite failed to run" as legitimate
+
+3️⃣ Repeat until: ✅ Pass OR 📋 Legitimate failure (report_legitimate_failure)
+
+---
+
+## CRITICAL REMINDERS
+
+- Use calculate_relative_path for ALL jest.mock() paths
+- virtual:true ONLY for: db, config, models, routes, index, services, axios, newrelic, GOOGLE_CLOUD_STORAGE
+- search_replace_block preferred (handles whitespace)
+- Ensure test independence (no pollution)
+- Fix test bugs, report source bugs
+- [CRITICAL] Each test suite should be completely self-contained and not depend on or affect any other test suite's state.
+
+**START:** Call analyze_file_ast on ${sourceFile} now. This will give you the file structure and the functions in the file.`
         }
     ];
     let iterations = 0;
@@ -2392,6 +3667,7 @@ START NOW by calling the analyze_file_ast tool with the source file path.`
     let lastTestError = '';
     let sameErrorCount = 0;
     while (iterations < maxIterations) {
+        console.log('USING CLAUDE PROMPT original 16');
         iterations++;
         if (iterations === 1) {
             console.log(`\n🤖 AI is analyzing selected functions...`);
@@ -2400,6 +3676,7 @@ START NOW by calling the analyze_file_ast tool with the source file path.`
             console.log(`\n🤖 AI is still working (step ${iterations})...`);
         }
         const response = await callAI(messages, TOOLS);
+        console.log('response from AI', JSON.stringify(response, null, 2));
         if (response.content) {
             const content = response.content;
             // Only show AI message if it's making excuses (for debugging), otherwise skip
@@ -2418,7 +3695,7 @@ START NOW by calling the analyze_file_ast tool with the source file path.`
                 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.'
+                    content: 'STOP making excuses! You CAN use the tools. Use upsert_function_tests tool NOW to write the test cases for the function.'
                 });
                 continue;
             }
@@ -2439,42 +3716,35 @@ START NOW by calling the analyze_file_ast tool with the source file path.`
             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(', ')}
+                    content: `🚨 STOP TALKING! Use upsert_function_tests tool NOW for: ${functionName}
 
 Example:
-replace_function_tests({
+upsert_function_tests({
   test_file_path: "${testFilePath}",
-  function_name: "${functionNames[0]}",
-  new_test_content: "describe('${functionNames[0]}', () => { test('should...', () => { ... }) })"
+  function_name: "${functionName}",
+  new_test_content: "describe('${functionName}', () => { 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(', ')}`
+This works for both NEW and EXISTING test files!`
                 });
             }
             else {
                 messages.push({
                     role: 'user',
-                    content: testFileExists
-                        ? `STOP talking and USE TOOLS! 
+                    content: `STOP talking and USE TOOLS NOW!
 
-✅ 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
+✅ PRIMARY: Use search_replace_block (RECOMMENDED):
+   1. Include 3-5 lines of context around the code to fix
+   2. Replace with corrected version
+   3. Handles whitespace/indentation automatically!
+   4. Then run_tests to verify
    
-⚠️ 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
+📌 ALTERNATIVE: Use insert_at_position for adding imports/mocks
+   - insert_at_position({ position: 'after_imports', content: "jest.mock('../module');" })
+   
+⚠️ SECONDARY: Use upsert_function_tests for function-level rewrites
 
-Act NOW!`
+Start NOW with search_replace_block or insert_at_position!`
                 });
             }
             continue;
@@ -2504,15 +3774,14 @@ Act NOW!`
                     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.');
+                        console.log('\n🚨 Same error repeated 3+ times! ');
                         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.`
+If this is still fixable: Make focused attempt to fix it.`
                         });
                     }
                 }
@@ -2522,32 +3791,16 @@ If this is still fixable: Make ONE final attempt to fix it.`
                 }
             }
             // Track if test file was written
-            if (toolCall.name === 'write_test_file' || toolCall.name === 'replace_function_tests') {
+            if (toolCall.name === 'upsert_function_tests') {
                 if (result.success) {
                     testFileWritten = true;
                     console.log(`\n📝 Test file ${result.replaced ? 'updated' : 'written'}: ${testFilePath}`);
+                    messages.push({
+                        role: 'user',
+                        content: `Test files are written successfully. Please use run_tests tool to verify the tests. If the tests fail, please make focused attempts to fix the tests using the tools available.`
+                    });
                 }
             }
-            // 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') {
@@ -2627,6 +3880,224 @@ DO NOT use write_test_file when the file exists! Always use replace_function_tes
         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 true if tests passed, false if legitimate failure reported
+    // Get the LAST test run result (not the first) to check final status
+    const testRuns = allToolResults.filter(tr => tr.name === 'run_tests');
+    const lastTestRun = testRuns.length > 0 ? testRuns[testRuns.length - 1] : null;
+    return !legitimateFailureReported && (lastTestRun?.result?.passed || false);
+}
+/** [Not useful, introduce side-effect]
+ * Validate and fix the complete test file after all functions are processed
+ * Runs full test suite and fixes file-level issues (mock pollution, imports, etc)
+ */
+async function validateAndFixCompleteTestFile(sourceFile, testFilePath, functionNames) {
+    console.log(`\n${'='.repeat(80)}`);
+    console.log(`🔍 FINAL VALIDATION: Running complete test suite`);
+    console.log(`${'='.repeat(80)}\n`);
+    // Run tests for entire file (no function filter)
+    const testResult = runTests(testFilePath);
+    if (testResult.passed) {
+        console.log(`\n✅ Complete test suite passed! All ${functionNames.length} functions working together correctly.`);
+        return;
+    }
+    // Tests failed - give AI a chance to fix file-level issues
+    console.log(`\n⚠️  Complete test suite has failures. Analyzing for file-level issues...\n`);
+    const messages = [
+        {
+            role: 'user',
+            content: `You are a senior software engineer fixing file-level integration issues in a Jest test file.
+
+Source file: ${sourceFile}
+Test file: ${testFilePath}
+Functions tested: ${functionNames.join(', ')}
+
+CONTEXT:
+- All ${functionNames.length} functions have been tested individually and passed their own tests
+- However, when running the COMPLETE test suite together, some tests are failing
+- This suggests FILE-LEVEL issues like:
+  * Mock pollution between test suites
+  * Shared state not being cleaned up
+  * Import/mock ordering issues
+  * beforeEach/afterEach missing or incorrect
+  * Mock implementations interfering with each other
+
+TEST OUTPUT:
+${testResult.output}
+
+YOUR TASK:
+1. Use get_file_preamble to see current imports, mocks, and setup blocks
+2. Identify file-level issues (NOT individual function logic issues)
+3. Fix using search_replace_block or insert_at_position tools
+4. Run tests again with run_tests tool
+5. Repeat until tests pass OR you determine failures are legitimate source code bugs
+
+COMMON FILE-LEVEL ISSUES TO CHECK:
+- ❌ Missing jest.clearAllMocks() in beforeEach
+- ❌ Mocks not being reset between test suites  
+- ❌ Module requires inside describe blocks (should use let + beforeEach)
+- ❌ Missing virtual:true for config/database/models mocks
+- ❌ beforeEach hooks not clearing all shared state
+- ❌ Test suites depending on execution order
+
+FIXABLE ISSUES (you should fix):
+- Mock pollution between test suites
+- Missing cleanup in beforeEach/afterEach
+- Incorrect mock setup at file level
+- Import ordering issues
+- Missing jest.clearAllMocks()
+
+LEGITIMATE FAILURES (report these):
+- Source code bugs causing actual logic errors
+- Missing null checks in source code
+- Wrong return types from source functions
+- Use report_legitimate_failure tool for these
+
+CRITICAL RULES:
+1. DO NOT change individual test logic (they passed individually!)
+2. Focus ONLY on file-level integration issues
+3. Use search_replace_block to fix specific sections
+4. Preserve all existing test cases
+5. If failures are due to source code bugs, call report_legitimate_failure and STOP
+
+START by calling get_file_preamble to understand current file structure.`
+        }
+    ];
+    let iterations = 0;
+    const maxIterations = 200; // Limit iterations for file-level fixes
+    let allToolResults = [];
+    let legitimateFailureReported = false;
+    while (iterations < maxIterations) {
+        iterations++;
+        console.log(`\n🔧 Fixing attempt ${iterations}/${maxIterations}...`);
+        const response = await callAI(messages, TOOLS);
+        if (response.content) {
+            messages.push({ role: 'assistant', content: response.content });
+        }
+        if (!response.toolCalls || response.toolCalls.length === 0) {
+            // AI stopped without fixing - check if tests pass now
+            const finalTest = runTests(testFilePath);
+            if (finalTest.passed) {
+                console.log('\n✅ Complete test suite now passes!');
+                return;
+            }
+            console.log('\n⚠️  AI stopped but tests still failing. Prompting to continue...');
+            messages.push({
+                role: 'user',
+                content: 'Tests are still failing! Use tools to fix or call report_legitimate_failure if these are source code bugs.'
+            });
+            continue;
+        }
+        // Execute 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);
+            // Check if legitimate failure reported
+            if (toolCall.name === 'report_legitimate_failure' && result.success) {
+                legitimateFailureReported = true;
+                console.log('\n✅ Legitimate failures reported. Stopping fixes.');
+                break;
+            }
+            // Check if tests passed
+            if (toolCall.name === 'run_tests' && result.passed) {
+                console.log('\n🎉 Complete test suite now passes!');
+                return;
+            }
+        }
+        if (legitimateFailureReported) {
+            break;
+        }
+        // Add tool results to conversation
+        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
+            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 }
+                });
+            }
+        }
+    }
+    if (iterations >= maxIterations) {
+        console.log(`\n⚠️  Reached max iterations (${maxIterations}) for file-level fixes.`);
+        console.log('   Some test failures may remain. Check test output above.');
+    }
+    if (legitimateFailureReported) {
+        console.log('\n📋 Test file has legitimate failures due to source code bugs.');
+    }
+}
+/**
+ * Generate tests for multiple functions, one at a time
+ */
+async function generateTestsForFunctions(sourceFile, functionNames) {
+    console.log(`\n📝 Generating tests for ${functionNames.length} selected function(s) in: ${sourceFile}\n`);
+    const testFilePath = getTestFilePath(sourceFile);
+    let testFileExists = fsSync.existsSync(testFilePath);
+    // Process each function one at a time
+    for (let i = 0; i < functionNames.length; i++) {
+        const functionName = functionNames[i];
+        console.log(`\n${'='.repeat(80)}`);
+        console.log(`Processing function ${i + 1}/${functionNames.length}: ${functionName}`);
+        console.log(`${'='.repeat(80)}\n`);
+        const passed = await generateTestForSingleFunction(sourceFile, functionName, testFilePath, testFileExists);
+        // After first function completes, test file will exist for subsequent functions
+        testFileExists = true;
+        if (passed) {
+            console.log(`\n✅ Function '${functionName}' tests completed successfully!`);
+        }
+        else {
+            console.log(`\n⚠️  Function '${functionName}' completed with issues. Continuing to next function...`);
+        }
+        await new Promise(resolve => setTimeout(resolve, 5000));
+    }
+    console.log(`\n${'='.repeat(80)}`);
+    console.log(`✅ All ${functionNames.length} function(s) processed!`);
+    console.log(`${'='.repeat(80)}\n`);
+    // FINAL VALIDATION: Run complete test suite and fix file-level issues
+    // await validateAndFixCompleteTestFile(sourceFile, testFilePath, functionNames);
     return testFilePath;
 }
 async function generateTestsForFunction() {
@@ -2676,8 +4147,236 @@ async function generateTestsForFunction() {
     await generateTestsForFunctions(selectedFile, selectedFunctions);
     console.log('\n✨ Done!');
 }
+/**
+ * Get git diff output for both staged and unstaged changes
+ * Returns the combined diff content and list of changed source files
+ */
+async function getGitDiff() {
+    try {
+        // Check if we're in a git repository
+        try {
+            (0, child_process_1.execSync)('git rev-parse --git-dir', { stdio: 'pipe' });
+        }
+        catch {
+            throw new Error('Not a git repository');
+        }
+        // Get both staged and unstaged changes with context
+        const stagedDiff = (0, child_process_1.execSync)('git diff --staged', { encoding: 'utf-8', stdio: 'pipe' }).toString();
+        // const unstagedDiff = execSync('git diff', { encoding: 'utf-8', stdio: 'pipe' }).toString();
+        // Combine both diffs
+        const fullDiff = stagedDiff;
+        console.log('Full diff is', fullDiff);
+        if (!fullDiff.trim()) {
+            return { fullDiff: '', files: [] };
+        }
+        // Parse diff to extract per-file diffs
+        const files = [];
+        const diffSections = fullDiff.split(/^diff --git /m).filter(Boolean);
+        for (const section of diffSections) {
+            const lines = section.split('\n');
+            const firstLine = 'diff --git ' + lines[0];
+            // Extract file path from diff header
+            const match = firstLine.match(/b\/(.+)$/);
+            if (match) {
+                const filePath = match[1];
+                const ext = path.extname(filePath);
+                const basename = path.basename(filePath);
+                // Skip test files and non-source files
+                const isTestFile = basename.includes('.test.') ||
+                    basename.includes('.spec.') ||
+                    basename.includes('test.') ||
+                    basename.includes('spec.') ||
+                    filePath.includes('/__tests__/') ||
+                    filePath.includes('/tests/') ||
+                    filePath.includes(CONFIG.testDir);
+                // Only include supported source files (not test files)
+                if (CONFIG.extensions.includes(ext) && !isTestFile) {
+                    files.push({
+                        filePath,
+                        diff: 'diff --git ' + section
+                    });
+                }
+            }
+        }
+        return { fullDiff, files };
+    }
+    catch (error) {
+        if (error.message === 'Not a git repository') {
+            throw error;
+        }
+        console.error('⚠️  Error reading git diff:', error.message);
+        return { fullDiff: '', files: [] };
+    }
+}
+/**
+ * Use AI to extract changed function names from git diff
+ */
+async function getChangedFunctionsFromDiff(filePath, diff) {
+    try {
+        // First, check if file exists
+        if (!fsSync.existsSync(filePath)) {
+            console.log(`   ⚠️  File not found: ${filePath}`);
+            return [];
+        }
+        // First, get all exported functions from the file
+        console.log(`   📁 Analyzing file: ${filePath}`);
+        const result = analyzeFileAST(filePath);
+        console.log(`   📊 AST Analysis result:`, JSON.stringify({
+            success: result.success,
+            totalFunctions: result.analysis?.functions?.length || 0,
+            error: result.error || 'none'
+        }, null, 2));
+        if (!result.success || !result.analysis || !result.analysis.functions) {
+            console.log(`   ⚠️  Failed to analyze file: ${result.error || 'unknown error'}`);
+            return [];
+        }
+        // Filter to only exported functions
+        const exportedFunctions = result.analysis.functions.filter((f) => f.exported);
+        console.log(`   📦 Found ${exportedFunctions.length} exported function(s):`, exportedFunctions.map((f) => f.name).join(', '));
+        if (exportedFunctions.length === 0) {
+            console.log(`   ⚠️  No exported functions found in file`);
+            console.log(`   💡 Tip: Make sure the file has exported functions (export const/function/async)`);
+            return [];
+        }
+        const exportedFunctionNames = exportedFunctions.map((f) => f.name);
+        console.log(`   📦 Exported functions in file: ${exportedFunctionNames.join(', ')}`);
+        // Ask AI to identify which functions appear in the diff
+        const prompt = `You are analyzing a git diff to identify which exported functions have been changed or added.
+
+Here is the git diff for file: ${filePath}
+
+\`\`\`diff
+${diff}
+\`\`\`
+
+The file has the following exported functions: ${exportedFunctionNames.join(', ')}
+
+Your task: Look at the git diff and identify which of these exported functions have changes inside them.
+- Look at the @@ line numbers and context to see which function the changes are in
+- A function is changed if any line within that function's body is modified (marked with + or -)
+- Return ONLY a JSON array of function names, like: ["functionName1", "functionName2"]
+- If no exported functions are in the diff, return an empty array: []
+
+Return ONLY the JSON array, nothing else.`;
+        const messages = [
+            {
+                role: 'user',
+                content: prompt
+            }
+        ];
+        console.log(`   🤖 Calling AI to analyze diff...`);
+        // Call AI without tools - just need text response
+        const response = await callAI(messages, [], CONFIG.aiProvider);
+        if (!response.content) {
+            console.error('   ⚠️  AI returned no content');
+            return [];
+        }
+        // Parse AI response to extract function names
+        const content = response.content.trim();
+        console.log(`   🤖 AI response: ${content}`);
+        // Try to extract JSON array from response
+        const jsonMatch = content.match(/\[.*\]/s);
+        if (jsonMatch) {
+            try {
+                const functionNames = JSON.parse(jsonMatch[0]);
+                if (Array.isArray(functionNames)) {
+                    // Filter to only include functions that actually exist in the file
+                    const filtered = functionNames.filter(name => exportedFunctionNames.includes(name));
+                    console.log(`   ✅ Extracted ${filtered.length} function(s) from AI response: ${filtered.join(', ')}`);
+                    return filtered;
+                }
+            }
+            catch (parseError) {
+                console.error('   ⚠️  Failed to parse AI response as JSON:', content);
+            }
+        }
+        else {
+            console.log('   ⚠️  No JSON array found in AI response');
+        }
+        return [];
+    }
+    catch (error) {
+        console.error(`   ⚠️  Error getting changed functions from AI:`, error.message);
+        return [];
+    }
+}
+/**
+ * Auto-generate tests for changed functions detected via git diff
+ */
+async function autoGenerateTests() {
+    console.log('🔍 Scanning git changes...\n');
+    try {
+        // Get all changes from git diff
+        console.log('Getting git diff...');
+        const { fullDiff, files } = await getGitDiff();
+        console.log('Full diff is', fullDiff);
+        console.log('Files are', files);
+        if (files.length === 0) {
+            console.log('✅ No changes detected in source files.');
+            console.log('   (Only staged and unstaged changes are checked)');
+            return;
+        }
+        console.log(`📝 Found changes in ${files.length} file(s)\n`);
+        let totalFunctions = 0;
+        let processedFiles = 0;
+        let errorFiles = 0;
+        // Process each changed file
+        for (const fileInfo of files) {
+            const { filePath, diff } = fileInfo;
+            // Check if file exists
+            if (!fsSync.existsSync(filePath)) {
+                console.log(`⏭️  Skipping ${filePath} (file not found)`);
+                continue;
+            }
+            console.log(`\n🔄 Processing: ${filePath}`);
+            console.log(`   Analyzing diff with AI...`);
+            // Use AI to extract changed function names from diff
+            const changedFunctions = await getChangedFunctionsFromDiff(filePath, diff);
+            console.log('Changed functions are', changedFunctions);
+            if (changedFunctions.length === 0) {
+                console.log(`   ⏭️  No exported functions changed`);
+                continue;
+            }
+            console.log(`   📦 Changed functions: ${changedFunctions.join(', ')}`);
+            try {
+                // Use existing generateTestsForFunctions
+                await generateTestsForFunctions(filePath, changedFunctions);
+                processedFiles++;
+                totalFunctions += changedFunctions.length;
+                console.log(`   ✅ Tests generated successfully`);
+            }
+            catch (error) {
+                errorFiles++;
+                console.error(`   ❌ Error generating tests: ${error.message}`);
+                // Continue with next file
+            }
+        }
+        // Summary
+        console.log('\n' + '='.repeat(60));
+        console.log('📊 Auto-Generation Summary');
+        console.log('='.repeat(60));
+        console.log(`✅ Successfully processed: ${processedFiles} file(s)`);
+        console.log(`📝 Functions tested: ${totalFunctions}`);
+        if (errorFiles > 0) {
+            console.log(`⚠️  Failed: ${errorFiles} file(s)`);
+        }
+        console.log('='.repeat(60));
+        console.log('\n✨ Done!');
+    }
+    catch (error) {
+        if (error.message === 'Not a git repository') {
+            console.error('❌ Error: Not a git repository');
+            console.error('   Auto mode requires git to detect changes.');
+            process.exit(1);
+        }
+        throw error;
+    }
+}
 async function main() {
     console.log('🧪 AI-Powered Unit Test Generator with AST Analysis\n');
+    // Check for auto mode from CLI arguments EARLY (before any prompts)
+    const args = process.argv.slice(2);
+    const isAutoMode = args.includes('auto');
     // Load configuration from codeguard.json
     try {
         CONFIG = (0, config_1.loadConfig)();
@@ -2700,6 +4399,22 @@ async function main() {
         console.error('npm install @babel/parser @babel/traverse ts-node\n');
         process.exit(1);
     }
+    // If auto mode, skip indexing setup and proceed directly
+    if (isAutoMode) {
+        console.log('🤖 Auto Mode: Detecting changes via git diff\n');
+        console.log(`✅ Using ${CONFIG.aiProvider.toUpperCase()} (${CONFIG.models[CONFIG.aiProvider]}) with AST-powered analysis\n`);
+        // Initialize indexer if it exists, but don't prompt
+        globalIndexer = new codebaseIndexer_1.CodebaseIndexer();
+        const hasExistingIndex = globalIndexer.hasIndex();
+        if (hasExistingIndex) {
+            await globalIndexer.loadIndex();
+        }
+        else {
+            globalIndexer = null;
+        }
+        await autoGenerateTests();
+        return;
+    }
     // Optional: Codebase Indexing
     globalIndexer = new codebaseIndexer_1.CodebaseIndexer();
     const hasExistingIndex = globalIndexer.hasIndex();