codeguard-testgen 1.0.9 → 1.0.11

package/dist/index.js

@@ -33,11 +33,13 @@ exports.insertAtPosition = insertAtPosition;
 exports.deleteLines = deleteLines;
 exports.insertLines = insertLines;
 exports.replaceLines = replaceLines;
+exports.writeReview = writeReview;
 const fs = require("fs/promises");
 const fsSync = require("fs");
 const path = require("path");
 const child_process_1 = require("child_process");
 const readline = require("readline");
+const ora = require('ora');
 // AST parsers
 const babelParser = require("@babel/parser");
 const traverse = require('@babel/traverse').default;
@@ -52,6 +54,9 @@ const fuzzyMatcher_1 = require("./fuzzyMatcher");
 let CONFIG;
 // Global indexer instance (optional - only initialized if user chooses to index)
 let globalIndexer = null;
+let globalSpinner = null; // Shared spinner for all operations
+// Global variable to track expected test file path (to prevent AI from creating per-function files)
+let EXPECTED_TEST_FILE_PATH = null;
 // AI Provider configurations - models will be set from CONFIG
 function getAIProviders() {
     return {
@@ -121,13 +126,17 @@ const TOOLS = [
     },
     {
         name: 'analyze_file_ast',
-        description: 'Parse file using AST and extract detailed information about all functions, classes, types, and exports',
+        description: 'Parse file using AST and extract detailed information about functions, classes, types, and exports. Optionally filter to specific function for token efficiency in function-wise test generation.',
         input_schema: {
             type: 'object',
             properties: {
                 file_path: {
                     type: 'string',
                     description: 'The relative path to the source file.'
+                },
+                function_name: {
+                    type: 'string',
+                    description: 'Optional: Filter results to only this function. Use in function-wise test generation to reduce tokens (returns metadata for 1 function instead of all). Omit to get all functions (file-wise mode).'
                 }
             },
             required: ['file_path']
@@ -181,7 +190,7 @@ const TOOLS = [
     },
     {
         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.',
+        description: 'Extract top-level code (imports, vi.mock calls, 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: {
@@ -253,7 +262,7 @@ const TOOLS = [
     },
     {
         name: 'run_tests',
-        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.',
+        description: 'Run Vitest 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: {
@@ -264,7 +273,7 @@ const TOOLS = [
                 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.'
+                    description: 'Optional: Array of function names to test. When provided, only runs tests matching these function names using Vitest -t flag. Use this in function-wise mode to isolate specific function tests.'
                 }
             },
             required: ['test_file_path']
@@ -300,7 +309,7 @@ const TOOLS = [
     },
     {
         name: 'calculate_relative_path',
-        description: 'Calculate the correct relative import path from one file to another',
+        description: 'Calculate the correct relative import path from one file to one or more target files. Accepts multiple to_file paths for efficiency - get all relative paths in a single call!',
         input_schema: {
             type: 'object',
             properties: {
@@ -310,39 +319,12 @@ const TOOLS = [
                 },
                 to_file: {
                     type: 'string',
-                    description: 'The file being imported (e.g., "src/models/serviceDesk.models.ts")'
+                    description: 'One or more files to import. Can be a single file path or multiple comma-separated paths (e.g., "src/services/aws.ts, src/models/doctors.ts")'
                 }
             },
             required: ['from_file', 'to_file']
         }
     },
-    {
-        name: 'report_legitimate_failure',
-        description: 'Report that test failures are legitimate due to bugs in the source code, not issues with the test itself. Use this when tests are correctly written but fail because the source code has bugs.',
-        input_schema: {
-            type: 'object',
-            properties: {
-                test_file_path: {
-                    type: 'string',
-                    description: 'The path to the test file'
-                },
-                failing_tests: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'List of test names that are legitimately failing'
-                },
-                reason: {
-                    type: 'string',
-                    description: 'Explanation of why the failures are legitimate (e.g., "Function returns undefined instead of expected object", "Missing null check causes TypeError")'
-                },
-                source_code_issue: {
-                    type: 'string',
-                    description: 'Description of the bug in the source code that causes the failure'
-                }
-            },
-            required: ['test_file_path', 'failing_tests', 'reason', 'source_code_issue']
-        }
-    },
     {
         name: '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.',
@@ -397,8 +379,60 @@ const TOOLS = [
             required: ['file_path', 'content']
         }
     },
+    {
+        name: 'write_review',
+        description: 'Write code review findings to a markdown file in the reviews/ directory. Use this to output your comprehensive code review.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path to the review file (e.g., "reviews/index.review.md"). Should be in reviews/ directory with .review.md extension.'
+                },
+                review_content: {
+                    type: 'string',
+                    description: 'The complete markdown content of the code review including summary, findings by category (Code Quality, Bugs, Performance, Security), severity levels, and recommendations.'
+                }
+            },
+            required: ['file_path', 'review_content']
+        }
+    },
+    {
+        name: 'search_codebase',
+        description: 'Search the entire codebase for a pattern using grep. Useful for finding where a function is used, where routes are registered, or finding usage examples. Returns matching lines with file paths and line numbers. IMPORTANT: Use focused searches to avoid token limits - be specific with patterns and use file_extension filter.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                pattern: {
+                    type: 'string',
+                    description: 'The search pattern (can be a string or regex). Examples: "getUsers", "router.get.*getUsers" (be specific!)'
+                },
+                file_extension: {
+                    type: 'string',
+                    description: 'RECOMMENDED: Filter by file extension (e.g., ".ts", ".js") to reduce results'
+                },
+                max_results: {
+                    type: 'number',
+                    description: 'Maximum number of matching lines to return (default: 20, max: 50). Use low values to avoid token limits.'
+                },
+                files_only: {
+                    type: 'boolean',
+                    description: 'If true, return only file paths without content. Use this first to see how many files match, then search specific files.'
+                }
+            },
+            required: ['pattern']
+        }
+    },
 ];
 exports.TOOLS = TOOLS;
+// Filtered tools for test generation (excludes write_review)
+const TOOLS_FOR_TEST_GENERATION = TOOLS.filter(tool => tool.name !== 'write_review');
+const TOOLS_FOR_CODE_REVIEW = TOOLS.filter((tool) => tool.name !== "run_tests" &&
+    tool.name !== "upsert_function_tests" &&
+    tool.name !== "insert_at_position" &&
+    tool.name !== "search_replace_block" &&
+    tool.name !== "calculate_relative_path" &&
+    tool.name !== "resolve_import_path");
 // AST Parsing utilities
 function parseFileToAST(filePath, content) {
     const ext = path.extname(filePath);
@@ -423,7 +457,7 @@ function parseFileToAST(filePath, content) {
         throw new Error(`Failed to parse ${filePath}: ${error.message}`);
     }
 }
-function analyzeFileAST(filePath) {
+function analyzeFileAST(filePath, functionName) {
     try {
         const content = fsSync.readFileSync(filePath, 'utf-8');
         const ast = parseFileToAST(filePath, content);
@@ -436,7 +470,8 @@ function analyzeFileAST(filePath) {
             exports: [],
             imports: [],
             types: [],
-            constants: []
+            constants: [],
+            routeRegistrations: []
         };
         traverse(ast, {
             // Function declarations
@@ -547,6 +582,49 @@ function analyzeFileAST(filePath) {
                 });
             }
         });
+        // Detect route registrations
+        analysis.routeRegistrations = detectRouteRegistrations(content, analysis.imports);
+        // Filter to specific function if requested (token optimization)
+        if (functionName) {
+            const targetFunction = analysis.functions.find(f => f.name === functionName);
+            if (!targetFunction) {
+                // Provide helpful error with available functions
+                const available = analysis.functions.map(f => f.name).slice(0, 10).join(', ');
+                const more = analysis.functions.length > 10 ? ` (and ${analysis.functions.length - 10} more)` : '';
+                return {
+                    success: false,
+                    error: `Function '${functionName}' not found in ${filePath}. Available functions: ${available}${more}`
+                };
+            }
+            // Find related class if function is a method
+            let relatedClass = null;
+            for (const cls of analysis.classes) {
+                if (cls.methods?.some((m) => m.name === functionName)) {
+                    relatedClass = cls;
+                    break;
+                }
+            }
+            return {
+                success: true,
+                analysis: {
+                    functions: [targetFunction],
+                    classes: relatedClass ? [relatedClass] : [],
+                    exports: analysis.exports.filter(e => e.name === functionName || e.local === functionName),
+                    imports: analysis.imports, // Keep all imports for dependency context
+                    types: [], // Types filtered out for token efficiency
+                    constants: [], // Constants filtered out for token efficiency
+                    routeRegistrations: analysis.routeRegistrations.filter(r => r.handler === functionName)
+                },
+                summary: {
+                    functionCount: 1,
+                    classCount: relatedClass ? 1 : 0,
+                    exportCount: analysis.exports.filter(e => e.name === functionName || e.local === functionName).length,
+                    typeCount: 0,
+                    filtered: true,
+                    targetFunction: functionName
+                }
+            };
+        }
         return {
             success: true,
             analysis,
@@ -562,6 +640,60 @@ function analyzeFileAST(filePath) {
         return { success: false, error: error.message };
     }
 }
+// Fast route detection using regex patterns
+function detectRouteRegistrations(code, imports) {
+    const registrations = [];
+    // Express: router.get('/users', getUsers) or app.post('/users', createUser)
+    const expressPattern = /\b(app|router)\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(\w+)/g;
+    for (const match of code.matchAll(expressPattern)) {
+        registrations.push({
+            framework: 'express',
+            method: match[2].toUpperCase(),
+            path: match[3],
+            handler: match[4],
+            handlerImportedFrom: findImportSource(match[4], imports),
+            line: getLineNumber(code, match.index || 0)
+        });
+    }
+    // Fastify: fastify.get('/users', getUsers)
+    const fastifyPattern = /\bfastify\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(\w+)/g;
+    for (const match of code.matchAll(fastifyPattern)) {
+        registrations.push({
+            framework: 'fastify',
+            method: match[1].toUpperCase(),
+            path: match[2],
+            handler: match[3],
+            handlerImportedFrom: findImportSource(match[3], imports),
+            line: getLineNumber(code, match.index || 0)
+        });
+    }
+    // Koa: router.get('/users', getUsers)
+    const koaPattern = /\brouter\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(\w+)/g;
+    for (const match of code.matchAll(koaPattern)) {
+        registrations.push({
+            framework: 'koa',
+            method: match[1].toUpperCase(),
+            path: match[2],
+            handler: match[3],
+            handlerImportedFrom: findImportSource(match[3], imports),
+            line: getLineNumber(code, match.index || 0)
+        });
+    }
+    return registrations;
+}
+function findImportSource(functionName, imports) {
+    for (const imp of imports) {
+        if (imp.imported && Array.isArray(imp.imported)) {
+            if (imp.imported.some((i) => i.local === functionName || i.imported === functionName)) {
+                return imp.source;
+            }
+        }
+    }
+    return undefined;
+}
+function getLineNumber(code, index) {
+    return code.substring(0, index).split('\n').length;
+}
 function extractParamInfo(param) {
     if (param.type === 'Identifier') {
         return {
@@ -669,7 +801,7 @@ function getFunctionAST(filePath, functionName) {
     }
     // Fallback: If we have an indexer, search for the function in the index
     if (globalIndexer) {
-        console.log(`   🔍 Function not found in ${filePath}, searching index...`);
+        // console.log(`   🔍 Function not found in ${filePath}, searching index...`);
         // Search through all indexed files
         const indexData = globalIndexer.index;
         if (indexData && indexData.files) {
@@ -679,7 +811,7 @@ function getFunctionAST(filePath, functionName) {
                 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}`);
+                    // console.log(`   ✅ Found ${functionName} in ${indexedFilePath}`);
                     const result = searchInFile(indexedFilePath);
                     if (result) {
                         return result;
@@ -820,7 +952,7 @@ function getImportsAST(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...`);
+            // 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);
@@ -930,7 +1062,7 @@ function getTypeDefinitions(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...`);
+            // 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);
@@ -1015,13 +1147,13 @@ function getFilePreamble(filePath) {
                             });
                         });
                     }
-                    // Expression statements (could be jest.mock or setup blocks)
+                    // Expression statements (could be vi.mock/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()
+                        // Check for vi.mock() or jest.mock()
                         if (callee.type === 'MemberExpression' &&
-                            callee.object?.name === 'jest' &&
+                            (callee.object?.name === 'vi' || callee.object?.name === 'jest') &&
                             callee.property?.name === 'mock') {
                             const moduleName = callExpr.arguments[0]?.value || 'unknown';
                             let isVirtual = false;
@@ -1075,7 +1207,7 @@ function getFilePreamble(filePath) {
                 ...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(`   ✅ Found file at ${targetPath}`);
             // console.log(`   fullCode: ${fullCode}`);
             // console.log(`   summary: ${JSON.stringify({
             //   importCount: imports.length,
@@ -1097,7 +1229,6 @@ function getFilePreamble(filePath) {
                     setupBlocks,
                     topLevelVariables
                 },
-                fullCode,
                 summary: {
                     importCount: imports.length,
                     mockCount: mocks.length,
@@ -1118,7 +1249,7 @@ function getFilePreamble(filePath) {
     }
     // Fallback: If we have an indexer, search for file with matching path
     if (globalIndexer) {
-        console.log(`   🔍 File not found at ${filePath}, searching index...`);
+        // console.log(`   🔍 File not found at ${filePath}, searching index...`);
         const indexData = globalIndexer.index;
         if (indexData && indexData.files) {
             const searchName = path.basename(filePath);
@@ -1151,10 +1282,10 @@ function getFilePreamble(filePath) {
                     // 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}`);
+                    // console.log(`   💡 Multiple matches found, choosing best match: ${correctPath}`);
                 }
                 else {
-                    console.log(`   ✅ Found file at ${correctPath}`);
+                    // console.log(`   ✅ Found file at ${correctPath}`);
                 }
                 const retryResult = extractPreamble(correctPath);
                 if (retryResult) {
@@ -1236,7 +1367,7 @@ function getClassMethods(filePath, className) {
     }
     // Fallback: If we have an indexer, search for the class in the index
     if (globalIndexer) {
-        console.log(`   🔍 Class not found in ${filePath}, searching index...`);
+        // console.log(`   🔍 Class not found in ${filePath}, searching index...`);
         // Search through all indexed files
         const indexData = globalIndexer.index;
         if (indexData && indexData.files) {
@@ -1245,7 +1376,7 @@ function getClassMethods(filePath, className) {
                 // Check if this file contains the class
                 const hasClass = analysis.classes?.some((cls) => cls.name === className);
                 if (hasClass) {
-                    console.log(`   ✅ Found ${className} in ${indexedFilePath}`);
+                    // console.log(`   ✅ Found ${className} in ${indexedFilePath}`);
                     const result = searchInFile(indexedFilePath);
                     if (result) {
                         return result;
@@ -1266,7 +1397,7 @@ function getClassMethods(filePath, className) {
 }
 // Other tool implementations
 async function readFile(filePath) {
-    const MAX_LINES = 2000;
+    const MAX_LINES = 1000;
     // Helper to read and validate file
     const tryReadFile = async (targetPath) => {
         try {
@@ -1279,14 +1410,14 @@ async function readFile(filePath) {
                 if (globalIndexer) {
                     const cached = globalIndexer.getFileAnalysis(targetPath);
                     if (cached) {
-                        console.log(`   📦 File too large (${lines.length} lines), returning cached analysis instead`);
+                        // 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)`);
+                                // console.log(`   📋 Also extracted preamble (${preambleResult.summary.importCount} imports, ${preambleResult.summary.mockCount} mocks)`);
                             }
                         }
                         return {
@@ -1324,7 +1455,7 @@ async function readFile(filePath) {
     }
     // Fallback: If we have an indexer, search for file with matching path
     if (globalIndexer) {
-        console.log(`   🔍 File not found at ${filePath}, searching index...`);
+        // console.log(`   🔍 File not found at ${filePath}, searching index...`);
         const indexData = globalIndexer.index;
         if (indexData && indexData.files) {
             const searchName = path.basename(filePath);
@@ -1357,10 +1488,10 @@ async function readFile(filePath) {
                     // 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}`);
+                    // console.log(`   💡 Multiple matches found, choosing best match: ${correctPath}`);
                 }
                 else {
-                    console.log(`   ✅ Found file at ${correctPath}`);
+                    // console.log(`   ✅ Found file at ${correctPath}`);
                 }
                 // Try to read from correct path
                 const retryResult = await tryReadFile(correctPath);
@@ -1455,7 +1586,7 @@ async function readFileLines(filePath, startLine, endLine) {
     }
     // Fallback: If we have an indexer, search for file with matching path
     if (globalIndexer) {
-        console.log(`   🔍 File not found at ${filePath}, searching index...`);
+        // console.log(`   🔍 File not found at ${filePath}, searching index...`);
         const indexData = globalIndexer.index;
         if (indexData && indexData.files) {
             const searchName = path.basename(filePath);
@@ -1488,10 +1619,10 @@ async function readFileLines(filePath, startLine, endLine) {
                     // 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}`);
+                    // console.log(`   💡 Multiple matches found, choosing best match: ${correctPath}`);
                 }
                 else {
-                    console.log(`   ✅ Found file at ${correctPath}`);
+                    // console.log(`   ✅ Found file at ${correctPath}`);
                 }
                 // Try to read from correct path
                 const retryResult = await tryReadFileLines(correctPath);
@@ -1889,7 +2020,55 @@ async function replaceFunctionTests(testFilePath, functionName, newTestContent)
         return { success: false, error: error.message };
     }
 }
-function runTests(testFilePath, functionNames) {
+// Strip ANSI color codes from output
+function stripAnsi(str) {
+    return str.replace(/\u001b\[[0-9;]*m/g, '').replace(/\\u001b\[[0-9;]*m/g, '');
+}
+function runTestsVitest(testFilePath, functionNames) {
+    try {
+        // Build Vitest command using npm run test with dot reporter and no color for clean output
+        let command = `npm run test ${testFilePath} -- --reporter=dot --no-color`;
+        // If function names provided, use Vitest -t flag to run only those tests
+        if (functionNames && functionNames.length > 0) {
+            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',
+            timeout: 60000, // 60 seconds - Vitest needs time to start
+            maxBuffer: 10 * 1024 * 1024 // 10MB buffer
+        });
+        // console.log('RUN TESTS OUTPUT', stripAnsi(output));
+        // console.log('RUN TESTS COMMAND', command);
+        return {
+            success: true,
+            output: stripAnsi(output),
+            passed: true,
+            command
+        };
+    }
+    catch (error) {
+        // execSync error has stdout/stderr as strings when encoding is set
+        let output = '';
+        if (error.stdout)
+            output += error.stdout;
+        if (error.stderr)
+            output += error.stderr;
+        // Fallback: extract from error message if output is empty
+        if (!output && error.message) {
+            output = error.message;
+        }
+        return {
+            success: false,
+            output: stripAnsi(output) || 'Test failed with no output captured',
+            passed: false,
+            error: error.message
+        };
+    }
+}
+function runTestsJest(testFilePath, functionNames) {
     try {
         // Build Jest command with optional function name filter
         let command = `npx jest ${testFilePath} --no-coverage --verbose=false`;
@@ -1903,7 +2082,8 @@ function runTests(testFilePath, functionNames) {
         }
         const output = (0, child_process_1.execSync)(command, {
             encoding: 'utf-8',
-            stdio: 'pipe'
+            stdio: 'pipe',
+            timeout: 10000
         });
         console.log(`   Test run output: ${output}`);
         return {
@@ -1914,8 +2094,8 @@ function runTests(testFilePath, functionNames) {
         };
     }
     catch (error) {
-        console.log(`   Test run error: ${error.message}`);
-        console.log(`output sent to ai: ${error.stdout + error.stderr}`);
+        // 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,
@@ -1924,6 +2104,121 @@ function runTests(testFilePath, functionNames) {
         };
     }
 }
+/**
+ * Run specific tests in isolation to detect if failure is due to pollution or regression
+ * Used by smartValidateTestSuite to differentiate between test infrastructure issues and source code bugs
+ */
+function runTestsIsolated(testFilePath, specificTestNames) {
+    try {
+        // Build Vitest command using npm run test with dot reporter and no color for clean output
+        let command = `npm run test ${testFilePath} -- --reporter=dot --no-color`;
+        if (specificTestNames && specificTestNames.length > 0) {
+            const escapedNames = specificTestNames.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',
+            timeout: 60000, // 60 seconds
+            maxBuffer: 10 * 1024 * 1024 // 10MB buffer
+        });
+        return {
+            success: true,
+            output: stripAnsi(output),
+            passed: true,
+            command
+        };
+    }
+    catch (error) {
+        // execSync error has stdout/stderr as strings when encoding is set
+        let output = '';
+        if (error.stdout)
+            output += error.stdout;
+        if (error.stderr)
+            output += error.stderr;
+        // Fallback: extract from error message if output is empty
+        if (!output && error.message) {
+            output = error.message;
+        }
+        return {
+            success: false,
+            output: stripAnsi(output) || 'Test failed with no output captured',
+            passed: false,
+            error: error.message
+        };
+    }
+}
+/**
+ * Parse Vitest output to extract names of failing tests
+ * Returns array of test names that failed
+ */
+function parseFailingTestNamesVitest(vitestOutput) {
+    const failingTests = [];
+    // Vitest output patterns for failing tests:
+    // ● describe block › test name
+    // or: FAIL path/to/test.ts
+    //     ✕ test name (XXms)
+    const lines = vitestOutput.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Pattern 1: ● describe block › test name
+        const bulletMatch = line.match(/^\s*●\s+(.+?)\s+›\s+(.+?)$/);
+        if (bulletMatch) {
+            const testName = bulletMatch[2].trim();
+            failingTests.push(testName);
+            continue;
+        }
+        // Pattern 2: ✕ test name
+        const xMatch = line.match(/^\s*✕\s+(.+?)(?:\s+\(\d+m?s\))?$/);
+        if (xMatch) {
+            const testName = xMatch[1].trim();
+            failingTests.push(testName);
+            continue;
+        }
+        // Pattern 3: FAIL in summary
+        const failMatch = line.match(/^\s*✓?\s*(.+?)\s+\(\d+m?s\)$/);
+        if (failMatch && line.includes('✕')) {
+            const testName = failMatch[1].trim();
+            failingTests.push(testName);
+        }
+    }
+    // Remove duplicates
+    return [...new Set(failingTests)];
+}
+function parseFailingTestNamesJest(jestOutput) {
+    const failingTests = [];
+    // Jest output patterns for failing tests:
+    // ● describe block › test name
+    // or: FAIL path/to/test.ts
+    //     ✕ test name (XXms)
+    const lines = jestOutput.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Pattern 1: ● describe block › test name
+        const bulletMatch = line.match(/^\s*●\s+(.+?)\s+›\s+(.+?)$/);
+        if (bulletMatch) {
+            const testName = bulletMatch[2].trim();
+            failingTests.push(testName);
+            continue;
+        }
+        // Pattern 2: ✕ test name
+        const xMatch = line.match(/^\s*✕\s+(.+?)(?:\s+\(\d+m?s\))?$/);
+        if (xMatch) {
+            const testName = xMatch[1].trim();
+            failingTests.push(testName);
+            continue;
+        }
+        // Pattern 3: FAIL in summary
+        const failMatch = line.match(/^\s*✓?\s*(.+?)\s+\(\d+m?s\)$/);
+        if (failMatch && line.includes('✕')) {
+            const testName = failMatch[1].trim();
+            failingTests.push(testName);
+        }
+    }
+    // Remove duplicates
+    return [...new Set(failingTests)];
+}
 function listDirectory(directoryPath) {
     try {
         if (!fsSync.existsSync(directoryPath)) {
@@ -2004,25 +2299,138 @@ function findFile(filename) {
         return { success: false, error: error.message };
     }
 }
+/**
+ * Calculate relative import path from one file to one or more target files.
+ * Handles multiple paths for efficiency - AI can get all relative paths in a single call.
+ *
+ * @param fromFile - The file containing the import
+ * @param toFile - Single path or comma-separated list of paths to import
+ * @returns Object with relative paths for all target files
+ */
 function calculateRelativePath(fromFile, toFile) {
     try {
+        // Normalize and validate the from_file path
+        const normalizedFromFile = normalizePath(fromFile);
+        if (!normalizedFromFile) {
+            return { success: false, error: `Invalid from_file path: "${fromFile}"` };
+        }
+        // Parse multiple to_file paths (comma-separated)
+        const toFiles = parseMultiplePaths(toFile);
+        if (toFiles.length === 0) {
+            return { success: false, error: `No valid to_file paths provided: "${toFile}"` };
+        }
+        // Calculate relative path for each target file
+        const results = [];
+        const errors = [];
+        for (const targetFile of toFiles) {
+            const result = calculateSingleRelativePath(normalizedFromFile, targetFile);
+            if (result.success) {
+                results.push(result);
+            }
+            else {
+                errors.push({ file: targetFile, error: result.error });
+            }
+        }
+        // Return appropriate response based on number of files
+        if (toFiles.length === 1) {
+            // Single file: return flat result for backward compatibility
+            return results.length > 0 ? results[0] : errors[0];
+        }
+        else {
+            // Multiple files: return array of results
+            return {
+                success: errors.length === 0,
+                from: normalizedFromFile,
+                totalFiles: toFiles.length,
+                successCount: results.length,
+                errorCount: errors.length,
+                results,
+                errors: errors.length > 0 ? errors : undefined
+            };
+        }
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Parse comma-separated or space-separated file paths into an array.
+ * Handles various input formats and trims whitespace.
+ */
+function parseMultiplePaths(input) {
+    if (!input || typeof input !== 'string') {
+        return [];
+    }
+    // Split by comma (primary delimiter)
+    const paths = input
+        .split(',')
+        .map(p => p.trim())
+        .filter(p => p.length > 0)
+        .map(p => normalizePath(p))
+        .filter((p) => p !== null);
+    return paths;
+}
+/**
+ * Normalize a file path - handle various edge cases.
+ */
+function normalizePath(filePath) {
+    if (!filePath || typeof filePath !== 'string') {
+        return null;
+    }
+    let normalized = filePath.trim();
+    // Remove surrounding quotes if present
+    if ((normalized.startsWith('"') && normalized.endsWith('"')) ||
+        (normalized.startsWith("'") && normalized.endsWith("'"))) {
+        normalized = normalized.slice(1, -1);
+    }
+    // Convert backslashes to forward slashes
+    normalized = normalized.replace(/\\/g, '/');
+    // Remove leading ./ if present (will be added back correctly)
+    if (normalized.startsWith('./')) {
+        normalized = normalized.slice(2);
+    }
+    // Remove duplicate slashes
+    normalized = normalized.replace(/\/+/g, '/');
+    // Remove trailing slash
+    if (normalized.endsWith('/')) {
+        normalized = normalized.slice(0, -1);
+    }
+    // Validate it looks like a file path (has at least one character and doesn't start with special chars)
+    if (normalized.length === 0 || /^[\s@#$%^&*]/.test(normalized)) {
+        return null;
+    }
+    return normalized;
+}
+/**
+ * Calculate relative path from one file to a single target file.
+ * Core path calculation logic with robust handling.
+ */
+function calculateSingleRelativePath(fromFile, toFile) {
+    try {
+        // Get the directory of the source file
         const fromDir = path.dirname(fromFile);
+        // Calculate relative path
         let relativePath = path.relative(fromDir, toFile);
+        // Handle empty path (same directory)
+        if (!relativePath) {
+            const basename = path.basename(toFile);
+            relativePath = './' + basename;
+        }
         // Remove .ts, .tsx, .js, .jsx extensions for imports
         relativePath = relativePath.replace(/\.(ts|tsx|js|jsx)$/, '');
+        // Also handle /index suffix (import from './folder' instead of './folder/index')
+        relativePath = relativePath.replace(/\/index$/, '');
         // Ensure it starts with ./ or ../
-        if (!relativePath.startsWith('.')) {
+        if (!relativePath.startsWith('.') && !relativePath.startsWith('..')) {
             relativePath = './' + relativePath;
         }
         // 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}';`
-        // })})`)
+        // Handle edge case where path ends up as just '.'
+        if (relativePath === '.') {
+            const basename = path.basename(toFile).replace(/\.(ts|tsx|js|jsx)$/, '');
+            relativePath = './' + basename;
+        }
         return {
             success: true,
             from: fromFile,
@@ -2032,26 +2440,26 @@ function calculateRelativePath(fromFile, toFile) {
         };
     }
     catch (error) {
-        return { success: false, error: error.message };
+        return { success: false, file: toFile, error: error.message };
     }
 }
-function reportLegitimateFailure(testFilePath, failingTests, reason, sourceCodeIssue) {
-    console.log('\n⚠️  LEGITIMATE TEST FAILURE REPORTED');
-    console.log(`   Test file: ${testFilePath}`);
-    console.log(`   Failing tests: ${failingTests.join(', ')}`);
-    console.log(`   Reason: ${reason}`);
-    console.log(`   Source code issue: ${sourceCodeIssue}`);
-    return {
-        success: true,
-        acknowledged: true,
-        message: 'Legitimate failure reported. Tests have been written correctly but source code has bugs.',
-        testFilePath,
-        failingTests,
-        reason,
-        sourceCodeIssue,
-        recommendation: 'Fix the source code to resolve these test failures.'
-    };
-}
+// function reportLegitimateFailure(testFilePath: string, failingTests: string[], reason: string, sourceCodeIssue: string): any {
+//   console.log('\n⚠️  LEGITIMATE TEST FAILURE REPORTED');
+//   console.log(`   Test file: ${testFilePath}`);
+//   console.log(`   Failing tests: ${failingTests.join(', ')}`);
+//   console.log(`   Reason: ${reason}`);
+//   console.log(`   Source code issue: ${sourceCodeIssue}`);
+//   return {
+//     success: true,
+//     acknowledged: true,
+//     message: 'Legitimate failure reported. Tests have been written correctly but source code has bugs.',
+//     testFilePath,
+//     failingTests,
+//     reason,
+//     sourceCodeIssue,
+//     recommendation: 'Fix the source code to resolve these test failures.'
+//   };
+// }
 async function deleteLines(filePath, startLine, endLine) {
     try {
         const content = await fs.readFile(filePath, 'utf-8');
@@ -2372,6 +2780,31 @@ async function insertAtPosition(filePath, content, position, afterMarker) {
         return { success: false, error: error.message };
     }
 }
+/**
+ * Write code review findings to a markdown file in the reviews/ directory
+ */
+async function writeReview(filePath, reviewContent) {
+    try {
+        // Ensure the reviews directory exists
+        const reviewsDir = path.dirname(filePath);
+        if (!fsSync.existsSync(reviewsDir)) {
+            await fs.mkdir(reviewsDir, { recursive: true });
+        }
+        // Write the review file
+        await fs.writeFile(filePath, reviewContent, 'utf-8');
+        return {
+            success: true,
+            message: `Review written to ${filePath}`,
+            filePath: filePath
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to write review: ${error.message}`
+        };
+    }
+}
 // User-friendly messages for each tool
 const TOOL_MESSAGES = {
     'read_file': '📖 Reading source file',
@@ -2388,9 +2821,10 @@ const TOOL_MESSAGES = {
     'list_directory': '📂 Exploring directory structure',
     'find_file': '🔍 Locating file in repository',
     'calculate_relative_path': '🧭 Calculating import path',
-    'report_legitimate_failure': '⚠️  Reporting legitimate test failures',
     'search_replace_block': '🔍🔄 Searching and replacing code block',
     'insert_at_position': '➕ Inserting content at position',
+    'write_review': '📝 Writing code review',
+    'search_codebase': '🔎 Searching codebase',
 };
 // Tool execution router
 async function executeTool(toolName, args) {
@@ -2410,7 +2844,16 @@ async function executeTool(toolName, args) {
     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}...`);
+    // Use global spinner for seamless in-place updates
+    if (!globalSpinner) {
+        globalSpinner = ora(friendlyMessage).start();
+    }
+    else if (globalSpinner.isSpinning) {
+        globalSpinner.text = friendlyMessage;
+    }
+    else {
+        globalSpinner = ora(friendlyMessage).start();
+    }
     let result;
     try {
         switch (toolName) {
@@ -2421,21 +2864,21 @@ async function executeTool(toolName, args) {
                 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) {
+                // Try cache first if indexer is available (only for non-filtered requests)
+                if (globalIndexer && !args.function_name) {
                     // Check if file has been modified since caching
                     if (globalIndexer.isFileStale(args.file_path)) {
-                        console.log('   🔄 File modified, re-analyzing...');
-                        result = analyzeFileAST(args.file_path);
-                        // Update cache with new analysis
-                        if (result.success) {
+                        globalSpinner.text = '🔄 File modified, re-analyzing...';
+                        result = analyzeFileAST(args.file_path, args.function_name);
+                        // Update cache with new analysis (only if not filtered)
+                        if (result.success && !args.function_name) {
                             await globalIndexer.updateIndex([args.file_path], analyzeFileAST);
                         }
                         break;
                     }
                     const cached = globalIndexer.getFileAnalysis(args.file_path);
                     if (cached) {
-                        console.log('   📦 Using cached analysis');
+                        globalSpinner.text = '📦 Using cached analysis';
                         result = {
                             success: true,
                             analysis: cached,
@@ -2443,14 +2886,14 @@ async function executeTool(toolName, args) {
                                 functionCount: cached.functions.length,
                                 classCount: cached.classes.length,
                                 exportCount: cached.exports.length,
-                                typeCount: cached.types.length
+                                typeCount: cached.types.length,
                             }
                         };
                         break;
                     }
                 }
-                // Fall back to actual analysis
-                result = analyzeFileAST(args.file_path);
+                // Fall back to actual analysis (with optional filtering)
+                result = analyzeFileAST(args.file_path, args.function_name);
                 break;
             case 'get_function_ast':
                 result = getFunctionAST(args.file_path, args.function_name);
@@ -2471,10 +2914,29 @@ async function executeTool(toolName, args) {
                 result = resolveImportPath(args.from_file, args.import_path);
                 break;
             case 'upsert_function_tests':
+                // CRITICAL VALIDATION: Prevent AI from creating per-function test files
+                if (EXPECTED_TEST_FILE_PATH && args.test_file_path !== EXPECTED_TEST_FILE_PATH) {
+                    // Normalize paths for comparison (handle different path separators)
+                    const normalizedExpected = path.normalize(EXPECTED_TEST_FILE_PATH).replace(/\\/g, '/');
+                    const normalizedProvided = path.normalize(args.test_file_path).replace(/\\/g, '/');
+                    if (normalizedExpected !== normalizedProvided) {
+                        if (globalSpinner)
+                            globalSpinner.stop();
+                        console.log(`\n⚠️  BLOCKED: AI attempted separate test file, enforcing single file policy`);
+                        globalSpinner = ora(friendlyMessage).start();
+                        // Override the test file path to the expected one
+                        args.test_file_path = EXPECTED_TEST_FILE_PATH;
+                    }
+                }
                 result = await replaceFunctionTests(args.test_file_path, args.function_name, args.new_test_content);
                 break;
             case 'run_tests':
-                result = runTests(args.test_file_path, args.function_names);
+                if (CONFIG.testEnv == 'vitest') {
+                    result = runTestsVitest(args.test_file_path, args.function_names);
+                }
+                else {
+                    result = runTestsJest(args.test_file_path, args.function_names);
+                }
                 break;
             case 'list_directory':
                 result = listDirectory(args.directory_path);
@@ -2485,15 +2947,18 @@ async function executeTool(toolName, args) {
             case 'calculate_relative_path':
                 result = calculateRelativePath(args.from_file, args.to_file);
                 break;
-            case 'report_legitimate_failure':
-                result = reportLegitimateFailure(args.test_file_path, args.failing_tests, args.reason, args.source_code_issue);
-                break;
             case 'search_replace_block':
                 result = await searchReplaceBlock(args.file_path, args.search, args.replace, args.match_mode);
                 break;
             case 'insert_at_position':
                 result = await insertAtPosition(args.file_path, args.content, args.position, args.after_marker);
                 break;
+            case 'write_review':
+                result = await writeReview(args.file_path, args.review_content);
+                break;
+            case 'search_codebase':
+                result = searchCodebase(args.pattern, args.file_extension, args.max_results, args.files_only);
+                break;
             default:
                 result = { success: false, error: `Unknown tool: ${toolName}` };
         }
@@ -2501,16 +2966,139 @@ async function executeTool(toolName, args) {
     catch (error) {
         result = { success: false, error: error.message, stack: error.stack };
     }
-    // Show result with friendly message
+    // Just keep spinner running - next tool will update the text
+    // No checkmarks for intermediate steps - smoother like Claude CLI
     if (result.success) {
-        // console.log('result', JSON.stringify(result, null, 2));
-        console.log(`   ✅ Done`);
+        // Small delay so users see the operation briefly
+        await new Promise(resolve => setTimeout(resolve, 150));
     }
     else if (result.error) {
-        console.log(`   ❌ ${result.error.substring(0, 100)}${result.error.length > 100 ? '...' : ''}`);
+        // Show persistent error and reset
+        const errorMsg = result.error.substring(0, 100) + (result.error.length > 100 ? '...' : '');
+        if (globalSpinner) {
+            globalSpinner.fail(errorMsg);
+            globalSpinner = null;
+        }
+        await new Promise(resolve => setTimeout(resolve, 300));
     }
     return result;
 }
+// Search codebase utility
+function searchCodebase(pattern, fileExtension, maxResults = 20, filesOnly = false) {
+    try {
+        const { execSync } = require('child_process');
+        // Cap maxResults to prevent token explosion
+        const limit = Math.min(maxResults || 20, 50);
+        // Build grep command
+        let cmd = `grep -rn`;
+        // If files_only, just list files
+        if (filesOnly) {
+            cmd = `grep -rl`; // -l for files with matches only
+        }
+        else {
+            cmd += ` -C 1`; // Only 1 line of context to save tokens
+        }
+        // Add file extension filter if provided
+        if (fileExtension) {
+            const ext = fileExtension.startsWith('.') ? fileExtension : `.${fileExtension}`;
+            cmd += ` --include="*${ext}"`;
+        }
+        // Exclude common directories
+        const excludeDirs = ['node_modules', 'dist', 'build', '.git', 'coverage', '.codeguard-cache', '.jest-cache', '.testgen-cache', '.vitest', 'reviews'];
+        for (const dir of excludeDirs) {
+            cmd += ` --exclude-dir=${dir}`;
+        }
+        // Add pattern and search path
+        cmd += ` "${pattern}" .`;
+        // Limit output lines to prevent token overflow
+        cmd += ` | head -n ${limit * 3}`; // 3 lines per match (context + match)
+        // Execute grep
+        const output = execSync(cmd, {
+            encoding: 'utf-8',
+            cwd: process.cwd(),
+            maxBuffer: 5 * 1024 * 1024, // 1MB max (reduced from 10MB)
+            stdio: ['pipe', 'pipe', 'ignore'] // Ignore stderr
+        });
+        if (filesOnly) {
+            // Return just file list
+            const files = output.trim().split('\n').filter(f => f.length > 0).slice(0, limit);
+            return {
+                success: true,
+                pattern,
+                filesOnly: true,
+                totalFiles: files.length,
+                files: files.map(f => ({ file: f })),
+                message: `Found ${files.length} file(s) matching pattern`,
+                hint: 'Use search_codebase with files_only=false on specific files to see content'
+            };
+        }
+        // Parse results with token awareness
+        const lines = output.trim().split('\n').slice(0, limit);
+        const results = [];
+        const fileSet = new Set();
+        let currentFile = '';
+        let currentMatches = [];
+        for (const line of lines) {
+            if (line.includes(':')) {
+                const match = line.match(/^([^:]+):(\d+):(.*)/);
+                if (match) {
+                    const [, file, lineNum, content] = match;
+                    fileSet.add(file);
+                    if (file !== currentFile) {
+                        if (currentFile && currentMatches.length > 0) {
+                            results.push({
+                                file: currentFile,
+                                matchCount: currentMatches.length,
+                                matches: currentMatches.slice(0, 5) // Max 5 matches per file
+                            });
+                        }
+                        currentFile = file;
+                        currentMatches = [];
+                    }
+                    // Truncate long lines to save tokens
+                    const truncatedContent = content.length > 150 ? content.substring(0, 150) + '...' : content;
+                    currentMatches.push(`Line ${lineNum}: ${truncatedContent}`);
+                }
+            }
+        }
+        // Add last file
+        if (currentFile && currentMatches.length > 0) {
+            results.push({
+                file: currentFile,
+                matchCount: currentMatches.length,
+                matches: currentMatches.slice(0, 5)
+            });
+        }
+        const totalMatches = results.reduce((sum, r) => sum + r.matchCount, 0);
+        return {
+            success: true,
+            pattern,
+            totalFiles: fileSet.size,
+            totalMatches,
+            files: results.slice(0, 10), // Max 10 files in response
+            truncated: results.length > 10 || lines.length >= limit,
+            message: `Found ${fileSet.size} file(s) with ${totalMatches} match(es)${results.length > 10 ? ' (showing first 10 files)' : ''}`,
+            hint: results.length > 10 ? 'Too many results. Try adding file_extension filter or more specific pattern.' : undefined
+        };
+    }
+    catch (error) {
+        // Grep returns exit code 1 when no matches found
+        if (error.status === 1 || error.message?.includes('No such file')) {
+            return {
+                success: true,
+                pattern,
+                totalFiles: 0,
+                totalMatches: 0,
+                files: [],
+                message: 'No matches found'
+            };
+        }
+        return {
+            success: false,
+            error: `Search failed: ${error.message}`
+        };
+    }
+}
 // File system utilities
 async function listFilesRecursive(dir, fileList = []) {
     const files = await fs.readdir(dir);
@@ -2573,7 +3161,7 @@ function getTestFilePath(sourceFile) {
         // No subdirectory: testDir/filename.test.ts
         testPath = path.join(CONFIG.testDir, testFileName);
     }
-    console.log(`  📁 Test file path: ${testPath}`);
+    // console.log(`  📁 Test file path: ${testPath}`);
     return testPath;
 }
 // AI Provider implementations
@@ -2749,603 +3337,34 @@ async function callAI(messages, tools, provider = CONFIG.aiProvider) {
 }
 // Main conversation loop
 async function generateTests(sourceFile) {
-    console.log(`\n📝 Generating tests for: ${sourceFile}\n`);
-    // 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}`);
-                }
-            }
-        }
+    // console.log(`\n📝 Generating tests for: ${sourceFile}\n`);
+    // Analyze file to get all functions (with retry)
+    let result = analyzeFileAST(sourceFile);
+    // Retry once if failed
+    if (!result.success) {
+        // console.log('⚠️  AST analysis failed, retrying once...');
+        result = analyzeFileAST(sourceFile);
     }
-    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
+    // If still failed, throw error
+    if (!result.success || !result.analysis || !result.analysis.functions) {
+        throw new Error(`File analysis failed. Unable to extract functions from file. Error: ${result.error || 'unknown'}`);
     }
-    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 [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
-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: 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 (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
-    
-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
-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
-    - 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.`
-        }
-    ];
-    let iterations = 0;
-    const maxIterations = 100;
-    let testFileWritten = false;
-    let allToolResults = [];
-    let legitimateFailureReported = false;
-    let lastTestError = '';
-    let sameErrorCount = 0;
-    while (iterations < maxIterations) {
-        iterations++;
-        if (iterations === 1) {
-            console.log(`\n🤖 AI is analyzing your code...`);
-        }
-        else if (iterations % 5 === 0) {
-            console.log(`\n🤖 AI is still working (step ${iterations})...`);
-        }
-        const response = await callAI(messages, TOOLS);
-        if (response.content) {
-            const content = response.content; // Store for TypeScript
-            // Only show AI message if it's making excuses (for debugging), otherwise skip
-            // Detect if AI is making excuses instead of using tools
-            const excusePatterns = [
-                /unable to proceed/i,
-                /cannot directly/i,
-                /constrained by/i,
-                /simulated environment/i,
-                /limited to providing/i,
-                /beyond my capabilities/i,
-                /can't execute/i
-            ];
-            const isMakingExcuses = excusePatterns.some(pattern => pattern.test(content));
-            if (isMakingExcuses) {
-                console.log('\n⚠️  AI is making excuses! Forcing it to use tools...');
-                // Don't add the excuse to conversation, override with command
-                messages.push({
-                    role: 'user',
-                    content: 'STOP making excuses! You CAN use the tools. Use search_replace_block or insert_at_position NOW to fix the test file. Add proper mocks to prevent database initialization errors.'
-                });
-                continue;
-            }
-            messages.push({ role: 'assistant', content });
-        }
-        if (!response.toolCalls || response.toolCalls.length === 0) {
-            // Don't stop unless tests actually passed or legitimate failure reported
-            const lastTestRun = allToolResults[allToolResults.length - 1];
-            const testsActuallyPassed = lastTestRun?.name === 'run_tests' && lastTestRun?.result?.passed;
-            if (legitimateFailureReported) {
-                console.log('\n✅ Test generation complete (with legitimate failures reported)');
-                break;
-            }
-            if (testFileWritten && testsActuallyPassed) {
-                console.log('\n✅ Test generation complete!');
-                break;
-            }
-            // If no tools called, prompt to continue with specific action
-            console.log('\n⚠️  No tool calls. Prompting AI to continue...');
-            if (!testFileWritten) {
-                messages.push({
-                    role: 'user',
-                    content: 'You have not written the test file yet. Use upsert_function_tests tool NOW with complete test code (not placeholders) for each function.'
-                });
-            }
-            else {
-                messages.push({
-                    role: 'user',
-                    content: `STOP talking and USE TOOLS! 
-
-If tests are failing:
-- FIXABLE errors (imports, mocks, assertions): 
-  ✅ 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
-
-Example: search_replace_block({ search: "old code with context...", replace: "new fixed code..." })`
-                });
-            }
-            continue;
-        }
-        // Execute all tool calls
-        const toolResults = [];
-        for (const toolCall of response.toolCalls) {
-            const result = await executeTool(toolCall.name, toolCall.input);
-            const toolResult = {
-                id: toolCall.id,
-                name: toolCall.name,
-                result
-            };
-            toolResults.push(toolResult);
-            allToolResults.push(toolResult);
-            // Track if legitimate failure was reported
-            if (toolCall.name === 'report_legitimate_failure' && result.success) {
-                legitimateFailureReported = true;
-                console.log('\n✅ Legitimate failure acknowledged. Stopping test fixes.');
-                console.log(`   Recommendation: ${result.recommendation}`);
-            }
-            // Track if test file was written
-            if (toolCall.name === 'upsert_function_tests') {
-                if (result.success) {
-                    testFileWritten = true;
-                    console.log(`\n📝 Test file ${result.replaced ? 'updated' : 'written'}: ${testFilePath}`);
-                }
-            }
-            // 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: `🚨 SYNTAX ERROR DETECTED at line ${result.location.line}:${result.location.column}
-
-${result.error}
-
-💡 ${result.suggestion}
-
-Your last modification created invalid syntax and was ROLLED BACK automatically.
-
-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
-
-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 NOW by reading the file around line ${result.location.line}!`
-                });
-            }
-            // Detect repeated errors (suggests legitimate failure)
-            if (toolCall.name === 'run_tests' && !result.success) {
-                const errorOutput = result.output || result.error || '';
-                const currentError = errorOutput.substring(0, 300); // First 300 chars as signature
-                if (currentError === lastTestError) {
-                    sameErrorCount++;
-                    console.log(`\n⚠️  Same error repeated ${sameErrorCount} times`);
-                    if (sameErrorCount >= 3) {
-                        console.log('\n🚨 Same error repeated 3+ times! ');
-                        messages.push({
-                            role: 'user',
-                            content: `The same test error has occurred ${sameErrorCount} times in a row!
-
-
-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.
-If FIXABLE: Make one more attempt to fix it.`
-                        });
-                    }
-                }
-                else {
-                    lastTestError = currentError;
-                    sameErrorCount = 1;
-                }
-            }
-            // Detect import path errors
-            if (toolCall.name === 'run_tests' && !result.success) {
-                const errorOutput = result.output || result.error || '';
-                // Check for module not found errors
-                const moduleNotFoundMatch = errorOutput.match(/Cannot find module ['"]([^'"]+)['"]/);
-                const tsModuleErrorMatch = errorOutput.match(/TS2307.*Cannot find module ['"]([^'"]+)['"]/);
-                if (moduleNotFoundMatch || tsModuleErrorMatch) {
-                    const missingModule = moduleNotFoundMatch?.[1] || tsModuleErrorMatch?.[1];
-                    console.log(`\n🔍 Import error detected: Cannot find module "${missingModule}"`);
-                    // Extract filename from the path
-                    const filename = missingModule?.split('/').pop();
-                    messages.push({
-                        role: 'user',
-                        content: `Import path error detected! Module not found: "${missingModule}"
-
-✅ FIX WITH 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 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. 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!`
-                    });
-                }
-                // Check for database initialization errors
-                const isDatabaseError = /Cannot read properties of undefined.*reading|database|config|SSL|CA|HOST/i.test(errorOutput);
-                if (isDatabaseError) {
-                    console.log('\n🔍 Database initialization error detected! Need to add mocks...');
-                    messages.push({
-                        role: 'user',
-                        content: `The test is failing because the source file imports modules that initialize database connections.
-
-✅ FIX WITH SEARCH-REPLACE:
-
-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"
-   })
-
-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 insert_at_position!`
-                    });
-                }
-            }
-        }
-        // Add tool results to conversation based on provider
-        if (CONFIG.aiProvider === 'claude') {
-            messages.push({
-                role: 'assistant',
-                content: response.toolCalls.map(tc => ({
-                    type: 'tool_use',
-                    id: tc.id,
-                    name: tc.name,
-                    input: tc.input
-                }))
-            });
-            messages.push({
-                role: 'user',
-                content: toolResults.map(tr => ({
-                    type: 'tool_result',
-                    tool_use_id: tr.id,
-                    content: JSON.stringify(tr.result)
-                }))
-            });
-        }
-        else if (CONFIG.aiProvider === 'openai') {
-            messages.push({
-                role: 'assistant',
-                tool_calls: response.toolCalls.map(tc => ({
-                    id: tc.id,
-                    type: 'function',
-                    function: {
-                        name: tc.name,
-                        arguments: JSON.stringify(tc.input)
-                    }
-                }))
-            });
-            for (const tr of toolResults) {
-                messages.push({
-                    role: 'tool',
-                    tool_call_id: tr.id,
-                    content: JSON.stringify(tr.result)
-                });
-            }
-        }
-        else {
-            // Gemini - use proper function call format
-            for (const toolCall of response.toolCalls) {
-                // Add model's function call
-                messages.push({
-                    role: 'model',
-                    functionCall: {
-                        name: toolCall.name,
-                        args: toolCall.input
-                    }
-                });
-                // Add user's function response
-                const result = toolResults.find(tr => tr.name === toolCall.name);
-                messages.push({
-                    role: 'user',
-                    functionResponse: {
-                        name: toolCall.name,
-                        response: result?.result
-                    }
-                });
-            }
-        }
-        // Check if legitimate failure was reported
-        if (legitimateFailureReported) {
-            console.log('\n✅ Stopping iteration: Legitimate failure reported.');
-            break;
-        }
-        // Check if tests were run and passed
-        const testRun = toolResults.find(tr => tr.name === 'run_tests');
-        if (testRun?.result.passed) {
-            console.log('\n🎉 All tests passed!');
-            break;
-        }
-    }
-    if (iterations >= maxIterations) {
-        console.log('\n⚠️  Reached maximum iterations. Tests may not be complete.');
-    }
-    if (!testFileWritten) {
-        console.log('\n❌ WARNING: Test file was never written! The AI may not have used the tools correctly.');
-        console.log('   Try running again or check your API key and connectivity.');
+    // Filter to only EXPORTED functions
+    const exportedFunctions = result.analysis.functions.filter((f) => f.exported);
+    const functionNames = exportedFunctions.map((f) => f.name).filter((name) => name);
+    // Error if no exported functions
+    if (functionNames.length === 0) {
+        throw new Error('No exported functions found in file. Cannot generate tests.');
     }
-    else if (legitimateFailureReported) {
-        console.log('\n📋 Test file created with legitimate failures documented.');
-        console.log('   These failures indicate bugs in the source code that need to be fixed.');
+    // Log what we found
+    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)`);
     }
-    return testFilePath;
+    // Always use function-by-function generation
+    return await generateTestsForFunctions(sourceFile, functionNames);
 }
 // Interactive CLI
 async function promptUser(question) {
@@ -3428,14 +3447,233 @@ async function generateTestsForFolder() {
  * @returns true if tests passed, false if legitimate failure reported
  */
 async function generateTestForSingleFunction(sourceFile, functionName, testFilePath, testFileExists) {
-    const messages = [
-        {
-            role: 'user',
-            content: `You are an expert software test engineer. Generate comprehensive Jest unit tests for: ${functionName} in ${sourceFile}. 
+    // Set the expected test file path globally to prevent AI from creating per-function files
+    EXPECTED_TEST_FILE_PATH = testFilePath;
+    const testEnv = CONFIG.testEnv;
+    let messages;
+    if (testEnv == "vitest") {
+        messages = [
+            {
+                role: "user",
+                content: `You are a senior developer generating production-ready Vitest unit tests for TypeScript.
+
+## TARGET
+Function: ${functionName} | Source: ${sourceFile}
+Test File: ${testFilePath} (Exists: ${testFileExists})
+
+## WORKFLOW
+
+### 1. ANALYSIS (Execute in order)
+1. analyze_file_ast(${sourceFile}, "${functionName}") → target function metadata
+2. get_function_ast(${sourceFile}, "${functionName}") → implementation
+3. get_imports_ast(${sourceFile}) → trace ALL dependencies
+4. get_file_preamble(${testFilePath}) → existing mocks/imports (if exists)
+5. For each dependency: find_file() → get_function_ast() → understand behavior
+6. calculate_relative_path(from: ${testFilePath}, to: import_path) → all imports
+
+**Dependency Tracing (CRITICAL):**
+- Map EVERY function call to its import source (verify with get_imports_ast)
+- Create vi.mock() for EVERY imported module (even conditional usage)
+- Export ALL used functions from each vi.mock block
+- Set return values in beforeEach for ALL mocked functions
+- Auto-detect required named exports from AST to prevent "X is not defined"
+
+### 2. FILE STRUCTURE (STRICT ORDER)
+
+
+// 1. MOCKS (before ANY imports)
+vi.mock('module-path');
+vi.mock('database/index', () => ({ db: { query: vi.fn() } }));
+vi.mock('env', () => ({ _ENV: { KEY: 'test' } }));
+
+// 2. IMPORTS
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { TypeOnly } from './types';
+import { ${functionName} } from 'calculated-path';
+import { dependency } from 'dependency-path';
+
+// 3. TYPED MOCKS
+const mockDep = vi.mocked(dependency);
+
+// 4. TESTS
+describe('${functionName}', () => {
+  beforeEach(() => {
+    // clearMocks: true in config handles cleanup
+    mockDep.mockResolvedValue(defaultValue);
+  });
+
+  it('should_behavior_when_condition', async () => {
+    // ARRANGE
+    const input = { id: 1 };
+    mockDep.mockResolvedValueOnce(specificValue);
+    
+    // ACT
+    const result = await ${functionName}(input);
+    
+    // ASSERT
+    expect(result).toEqual(expected);
+    expect(mockDep).toHaveBeenCalledWith(input);
+    expect(mockDep).toHaveBeenCalledTimes(1);
+  });
+});
+
+
+### 3. COVERAGE (Minimum 5 tests)
+
+1. **Happy Path** (1-2): Valid inputs → expected outputs
+2. **Edge Cases** (2-3): Empty/null/undefined/0/boundaries/special chars
+3. **Error Handling** (1-2): Invalid inputs, dependency failures
+   - Sync: expect(() => fn()).toThrow(ErrorClass)
+   - Async: await expect(fn()).rejects.toThrow(ErrorClass)
+4. **Branch Coverage**: Each conditional path tested
+5. **Async Behavior**: Promise resolution/rejection (if applicable)
+
+### 4. MOCK STRATEGY
+
+**ALWAYS Mock:**
+- External modules (fs, http, database)
+- Modules with side effects (logging, analytics)
+- database/index, env, WinstonLogger
+
+**Consider NOT Mocking:**
+- Pure utility functions from same codebase (test integration)
+- Type imports: import type { X } (NEVER mock)
+
+**Mock Pattern:**
+- Module-level: vi.mock('path') → const mockFn = vi.mocked(importedFn)
+- NEVER: vi.spyOn(exports, 'fn') or global wrappers
+- Hoist mock functions for use in both factory and tests
+
+### 5. ASSERTIONS
+
+**Priority Order:**
+1. **Exact**: toEqual(), toBe() for primitives
+2. **Partial**: toMatchObject() for subset matching
+3. **Structural**: expect.objectContaining(), expect.any(Type)
+4. **Specific Checks**: toBeDefined(), toBeNull(), toHaveLength(n)
+5. **Mock Verification**: toHaveBeenCalledWith(), toHaveBeenCalledTimes()
+
+**NEVER:**
+- toBeTruthy() for object existence (use toBeDefined())
+- Snapshots for dates, random values, or as primary assertions
+
+### 6. CRITICAL RULES
+
+**MUST:**
+- ✅ ALL vi.mock() before imports
+- ✅ Use calculate_relative_path for ALL imports
+- ✅ Test file exists: ${testFileExists} - if the test file exist, alway check the mock and imports already present in the test file, using get_file_preamble tool. Make sure you do not duplicate mocks and mocks and imports are added at correct position.
+- ✅ When editing existing file: UPDATE existing vi.mock, NEVER duplicate
+- ✅ Test names: should_behavior_when_condition
+- ✅ AAA pattern with comments
+- ✅ Each test = one behavior
+- ✅ Import types separately: import type { Config }
+- ✅ Use vi.mocked<typeof module>() for full type inference
+- ✅ Mock internal non-exported functions
+- ✅ Use vi.useFakeTimers() for time-dependent tests
+- ✅ Test cases expectations must match source code
+
+
+**NEVER:**
+- ❌ Mock after imports
+- ❌ Shared state between tests
+- ❌ Multiple behaviors in one test
+- ❌ Generic test names ("test1", "works")
+- ❌ Manual cleanup (vi.clearAllMocks in tests - config handles it)
+- ❌ Environment dependencies without mocks
+- ❌ Use require() (ES imports only)
+- ❌ Reference function from wrong module (verify with get_imports_ast)
+- ❌ Change existing mocks in ways that break other tests\
+
+
+### 7. EXECUTION
+
+upsert_function_tests({
+  test_file_path: "${testFilePath}",
+  function_name: "${functionName}",
+  new_test_content: "..." // complete test code
+});
+
+run_tests({
+  test_file_path: "${testFilePath}",
+  function_names: ["${functionName}"]
+});
+
+
+### 8. FAILURE DEBUGGING
+
+**Import Errors:**
+- Recalculate paths with calculate_relative_path
+- Check barrel exports (index.ts redirects)
+- Verify source file exports function
+
+**Mock Errors:**
+- Add missing vi.mock() at top
+- Ensure all used functions exported from mock
+- Verify mock setup in beforeEach
+
+**Type Errors:**
+- Import types with import type
+- Check mock return types match signatures
+- Use proper generic constraints
+
+**Assertion Failures:**
+- Log mock calls: console.log(mockFn.mock.calls)
+- Check execution path (add temp logs in source)
+- Verify input data types
+- Check async/await usage
+- Validate prerequisite mocks return expected values
+
+** 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 |
+
+**Process:**
+1. Read FULL error message
+2. Identify error type (import/mock/assertion/type)
+3. Make focused fix using available tools
+4. Iterate until ALL PASS
+
+### 9. QUALITY CHECKLIST
+- [ ] Independent tests (no execution order dependency)
+- [ ] Fast (<100ms per test, no real I/O)
+- [ ] Readable (AAA, descriptive names)
+- [ ] Focused (one behavior per test)
+- [ ] Deterministic (same input = same output)
+- [ ] Type-safe (no any, proper generics)
+- [ ] Complete coverage (all paths tested)
+- [ ] No duplicate declarations
+- [ ] Existing tests still pass
+
+## START
+\`analyze_file_ast\` → gather context → **write tests immediately** → verify → run → fix → complete.
+
+**[CRITICAL]** NEVER change existing mocks such that other tests fail. Use test-specific overrides with mockReturnValueOnce. 
+You must be efficient and fast in your approach, do not overthink the problem.`,
+            },
+        ];
+    }
+    else {
+        messages = [
+            {
+                role: "user",
+                content: `You are an expert software test engineer. Generate comprehensive Jest unit tests for: ${functionName} in ${sourceFile}. 
+      [Critical] Be prompt and efficient in your response. Make sure the test case file is typed and complete. Be as fast as possible in your repsonse.
+      [Critical] You cannot remove or modify the existing mocks and imports in the test file since other test may be using it. You can only add new mocks and imports for the new test cases.
 
 ## CONTEXT
 Test file: ${testFilePath} | Exists: ${testFileExists}
 
+⚠️  CRITICAL: You MUST use this EXACT test file path: ${testFilePath}
+
 ---
 
 ## EXECUTION PLAN
@@ -3448,8 +3686,9 @@ Test file: ${testFilePath} | Exists: ${testFileExists}
    - 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
+5. calculate_relative_path(from: ${testFilePath}, to: import_path) → all imports, accpets multiple comma separated 'to' paths. Use exact path returned by this tool for all imports.
 6. get_file_preamble → imports and mocks already declared in the file
+7. search_codebase → look for relevant context in codebase.
 \\\`\\\`\\\`
 
 **Phase 1.1: Execution Path Tracing (CRITICAL FOR SUCCESS)**
@@ -3461,7 +3700,7 @@ Test file: ${testFilePath} | Exists: ${testFileExists}
 
 **Phase 2: Test Generation**
 
-Mock Pattern (CRITICAL - Top of file, before imports):
+Mock Pattern (CRITICAL - Top of file):
 \\\`\\\`\\\`typescript
 // ===== MOCKS (BEFORE IMPORTS) =====
 jest.mock('config', () => ({
@@ -3469,14 +3708,19 @@ jest.mock('config', () => ({
     AUTH: { JWT_KEY: 'test', COOKIE_DATA_ONE_YEAR: 31536000000 },
     USER_DEL_SECRET: 'secret'
   })
-}), { virtual: true });
+}), { virtual: true }); 
+
+ // virtual:true ONLY for config, db, models, routes, services, axios, newrelic, GOOGLE_CLOUD_STORAGE, winston, logger, etc.
 
-jest.mock('../path/from/calculate_relative_path');
-// Never virtual:true for actual source helpers!
-// ⚠️ CRITICAL: Mock ALL dependencies at top level, even if unused
+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>;
+
 \\\`\\\`\\\`
 
 Requirements (5+ tests minimum):
@@ -3486,121 +3730,93 @@ Requirements (5+ tests minimum):
 - ⏱️ 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';
+/**
+ * Phase 3: Anti-Pollution Pattern (MUST FOLLOW EXACTLY THIS PATTERN, NO VARIATIONS)
+ */
 
-// ===== TYPED MOCKS =====
-const mockDependencyMethod = dependencyMethod as jest.MockedFunction<typeof dependencyMethod>;
+\\\`\\\`\\\`typescript
+// ===== GLOBAL CLEANUP (Near top, outside describe blocks) =====
+afterEach(() => {
+  jest.restoreAllMocks(); // Automatically restores ALL spies
+});
 
-### Step 2: Test Structure
+// ===== TESTS =====
 describe('functionName', () => {
   beforeEach(() => {
-    // ALWAYS first line
-    jest.clearAllMocks();
+    jest.resetAllMocks(); // Resets ALL mocks (call history + implementations)
     
-    // Set defaults for THIS describe block only
-    mockDependencyMethod.mockResolvedValue({ status: 'success' });
+    // Set fresh defaults for THIS describe block only
+    mockDep1.mockResolvedValue({ status: 'success' });
+    mockDep2.mockReturnValue(true);
   });
 
   test('happy path', async () => {
-    // Override default for this test only
-    mockDependencyMethod.mockResolvedValueOnce({ id: 123 });
+    mockDep1.mockResolvedValueOnce({ id: 123 }); // Override for this test only
     
     const result = await functionName();
     
     expect(result).toEqual({ id: 123 });
-    expect(mockDependencyMethod).toHaveBeenCalledWith(expect.objectContaining({
-      param: 'value'
-    }));
+    expect(mockDep1).toHaveBeenCalledWith(expect.objectContaining({ param: 'value' }));
   });
 
   test('error case', async () => {
-    mockDependencyMethod.mockRejectedValueOnce(new Error('fail'));
-    
-    const result = await functionName();
-    
-    expect(result).toEqual({});
+    mockDep1.mockRejectedValueOnce(new Error('fail'));
+    await expect(functionName()).rejects.toThrow('fail');
   });
 });
 
-describe('anotherFunction', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    
-    // Different defaults for different function
-    mockDependencyMethod.mockResolvedValue({ status: 'pending' });
-  });
-  
-  // ... tests
-});
-
-
-### Step 3: Internal Function Mocking (When Needed)
-
+// ===== INTERNAL SPIES (When testing same-file function calls) =====
 describe('functionWithInternalCalls', () => {
   let internalFnSpy: jest.SpyInstance;
 
   beforeEach(() => {
-    jest.clearAllMocks();
+    jest.resetAllMocks();
     
+    // ✅ EXCEPTION: require() needed here for spying on same module
     const controller = require('../controller');
-    internalFnSpy = jest.spyOn(controller, 'internalFunction')
-      .mockResolvedValue(undefined);
-  });
-
-  afterEach(() => {
-    internalFnSpy.mockRestore();
+    internalFnSpy = jest.spyOn(controller, 'internalFunction').mockResolvedValue(undefined);
   });
+  
+  // No manual restore needed - global afterEach handles it
 
   test('calls internal function', async () => {
     await functionWithInternalCalls();
     expect(internalFnSpy).toHaveBeenCalled();
   });
 });
+\\\`\\\`\\\`
 
-### CRITICAL RULES:
+### CRITICAL RULES (Prevent Mock Pollution):
 **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
+1. \`jest.resetAllMocks()\` as FIRST line in every \`beforeEach()\` (not clearAllMocks)
+2. Global \`afterEach(() => jest.restoreAllMocks())\` near top of test file
+3. Set mock defaults in each \`describe\` block's \`beforeEach()\` independently
+4. Override with \`mockResolvedValueOnce/mockReturnValueOnce\` in individual tests
+5. Type all mocks: \`const mockFn = fn as jest.MockedFunction<typeof fn>\`
+6. All \`jest.mock()\` at top before imports (use calculate_relative_path for paths)
+7. Check for existing mocks with \`get_file_preamble\` tool before adding duplicates
 
 **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
+1. Use \`jest.clearAllMocks()\` (only clears history, not implementations) → Use \`resetAllMocks()\`
+2. Manually \`.mockReset()\` individual mocks → \`resetAllMocks()\` handles all
+3. Share mock state between \`describe\` blocks → Each block sets its own defaults
+4. Use \`require()\` except when creating spies on same module being tested
+5. Use \`virtual:true\` for regular files → Only for: config, db, models, services (modules not in filesystem)
+6. Forget global \`afterEach(() => jest.restoreAllMocks())\` → Causes spy pollution
+
+
 
 **Phase 4: Write Tests**
+⚠️  CRITICAL REQUIREMENT: Use EXACTLY this test file path: "${testFilePath}"
+    DO NOT modify the path. DO NOT create ${functionName}.test.ts or any other variation.
+
 → upsert_function_tests({ 
-  test_file_path: "${testFilePath}",
+  test_file_path: "${testFilePath}",  // ⚠️  USE THIS EXACT PATH - DO NOT CHANGE!
   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.
+All functions from the same source file MUST share the same test file.
 
 
 
@@ -3636,14 +3852,8 @@ This will automatically replace the existing test cases for the function with th
 | "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)
+3️⃣ Repeat until: ✅ All test cases pass
 
 ---
 
@@ -3655,10 +3865,14 @@ This will automatically replace the existing test cases for the function with th
 - 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.
+- Test file exists: ${testFileExists} - if the test file exist, always check the mock and imports already present in the test file, using get_file_preamble tool. Make sure you do not duplicate mocks and mocks and imports are added at correct position.
+- Mocking of winston logger or any other external dependeny is critical and mandatory.
+- Use search_codebase tool to look for relevant context in codebase quickly.
 
-**START:** Call analyze_file_ast on ${sourceFile} now. This will give you the file structure and the functions in the file.`
-        }
-    ];
+**START:** Call analyze_file_ast on ${sourceFile} now. This will give you the file structure and the functions in the file. Analyze deeply and write test cases only when you are sure about the function and the dependencies. Make sure the written test cases run and pass on first attempt.`,
+            },
+        ];
+    }
     let iterations = 0;
     const maxIterations = 100;
     let testFileWritten = false;
@@ -3667,16 +3881,25 @@ This will automatically replace the existing test cases for the function with th
     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...`);
+            if (!globalSpinner || !globalSpinner.isSpinning) {
+                globalSpinner = ora('🤖 AI is analyzing selected functions...').start();
+            }
+            else {
+                globalSpinner.text = '🤖 AI is analyzing selected functions...';
+            }
         }
         else if (iterations % 5 === 0) {
-            console.log(`\n🤖 AI is still working (step ${iterations})...`);
+            if (globalSpinner) {
+                globalSpinner.text = `🤖 AI is still working (step ${iterations})...`;
+            }
         }
-        const response = await callAI(messages, TOOLS);
+        // console.log('messages', messages);
+        // console.log('TOOLS_FOR_TEST_GENERATION', TOOLS_FOR_TEST_GENERATION);
+        const response = await callAI(messages, TOOLS_FOR_TEST_GENERATION);
         // console.log('response from AI', JSON.stringify(response, null, 2));
+        // console.log('TEst file path', testFilePath);
         if (response.content) {
             const content = response.content;
             // Only show AI message if it's making excuses (for debugging), otherwise skip
@@ -3690,7 +3913,7 @@ This will automatically replace the existing test cases for the function with th
                 /beyond my capabilities/i,
                 /can't execute/i
             ];
-            const isMakingExcuses = excusePatterns.some(pattern => pattern.test(content));
+            const isMakingExcuses = excusePatterns.some(pattern => typeof content === 'string' && pattern.test(content));
             if (isMakingExcuses) {
                 console.log('\n⚠️  AI is making excuses! Forcing it to use tools...');
                 messages.push({
@@ -3740,7 +3963,7 @@ This works for both NEW and EXISTING test files!`
    4. Then run_tests to verify
    
 📌 ALTERNATIVE: Use insert_at_position for adding imports/mocks
-   - insert_at_position({ position: 'after_imports', content: "jest.mock('../module');" })
+   - insert_at_position({ position: 'after_imports', content: "vi.mock('../module');" })
    
 ⚠️ SECONDARY: Use upsert_function_tests for function-level rewrites
 
@@ -3772,16 +3995,13 @@ Start NOW with search_replace_block or insert_at_position!`
                 const currentError = errorOutput.substring(0, 300);
                 if (currentError === lastTestError) {
                     sameErrorCount++;
-                    console.log(`\n⚠️  Same error repeated ${sameErrorCount} times`);
+                    // console.log(`\n⚠️  Same error repeated ${sameErrorCount} times`);
                     if (sameErrorCount >= 3) {
-                        console.log('\n🚨 Same error repeated 3+ times! ');
+                        // console.log('\n🚨 Same error repeated 3+ times! ');
                         messages.push({
                             role: 'user',
                             content: `The same test error has occurred ${sameErrorCount} times in a row!
-
-
-If this is a source code bug: Call report_legitimate_failure tool NOW.
-If this is still fixable: Make focused attempt to fix it.`
+              Make focused attempt to fix the tests using the tools available.`
                         });
                     }
                 }
@@ -3794,7 +4014,7 @@ If this is still fixable: Make focused attempt to fix it.`
             if (toolCall.name === 'upsert_function_tests') {
                 if (result.success) {
                     testFileWritten = true;
-                    console.log(`\n📝 Test file ${result.replaced ? 'updated' : 'written'}: ${testFilePath}`);
+                    // 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.`
@@ -3880,12 +4100,194 @@ If this is still fixable: Make focused attempt to fix it.`
         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.');
     }
+    // Clear the expected test file path (cleanup)
+    EXPECTED_TEST_FILE_PATH = null;
     // 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);
 }
+/**
+ * Smart validation that fixes failing tests
+ * - Runs full test suite
+ * - For failures, attempts to fix all failing tests using AI
+ */
+async function smartValidateTestSuite(sourceFile, testFilePath, functionNames) {
+    console.log(`\n${'='.repeat(80)}`);
+    console.log(`🔍 VALIDATION: Running full test suite (${functionNames.length} function(s))`);
+    console.log(`${'='.repeat(80)}\n`);
+    // Run tests for entire file (no function filter)
+    let fullSuiteResult;
+    if (CONFIG.testEnv == 'vitest') {
+        fullSuiteResult = runTestsVitest(testFilePath);
+    }
+    else {
+        fullSuiteResult = runTestsJest(testFilePath);
+    }
+    if (fullSuiteResult.passed) {
+        console.log(`\n✅ Full test suite passed! All ${functionNames.length} function(s) working together correctly.`);
+        return;
+    }
+    console.log(`\n⚠️  Full test suite has failures. Attempting to fix failing tests...\n`);
+    // Parse failing test names from Vitest output
+    let failingTests;
+    if (CONFIG.testEnv == 'vitest') {
+        failingTests = parseFailingTestNamesVitest(fullSuiteResult.output);
+    }
+    else {
+        failingTests = parseFailingTestNamesJest(fullSuiteResult.output);
+    }
+    console.log(`\n📊 Debug: Found ${failingTests.length} failing test(s) from output`);
+    if (failingTests.length === 0) {
+        console.log('⚠️  Could not parse specific failing test names from output.');
+        console.log('    Attempting general fix based on full error output...\n');
+        // Fallback: Still attempt to fix using the full output even without parsed test names
+        await fixFailingTests(sourceFile, testFilePath, functionNames, [], fullSuiteResult.output);
+        return;
+    }
+    console.log(`Found ${failingTests.length} failing test(s): ${failingTests.join(', ')}\n`);
+    // Attempt to fix all failing tests
+    await fixFailingTests(sourceFile, testFilePath, functionNames, failingTests, fullSuiteResult.output);
+}
+/**
+ * Fix failing tests using AI
+ * Attempts to fix all test issues including pollution, imports, mocks, etc.
+ */
+async function fixFailingTests(sourceFile, testFilePath, functionNames, failingTests, fullSuiteOutput) {
+    const messages = [
+        {
+            role: 'user',
+            content: `You are fixing FAILING TESTS in the Vitest test suite.
+
+Source file: ${sourceFile}
+Test file: ${testFilePath}
+Functions tested: ${functionNames.join(', ')}
+
+FAILING TESTS:
+${failingTests.map(t => `- ${t}`).join('\n')}
+
+Full suite output:
+${fullSuiteOutput}
+
+YOUR TASK - Fix all failing tests:
+
+COMMON ISSUES TO FIX:
+- Mock state bleeding between describe blocks
+- Missing vitest imports (describe, it, expect, beforeEach, vi)
+- Incorrect mock typing (use MockedFunction from vitest)
+- beforeEach not setting up mocks properly
+- Missing or incorrect imports
+- Mock implementation issues
+- Incorrect test assertions
+- Test logic errors
+
+NOTE: vitest.config.ts should have clearMocks/restoreMocks enabled.
+
+TOOLS TO USE:
+1. get_file_preamble - See current setup
+2. search_replace_block - Fix specific sections (preferred)
+3. insert_at_position - Add missing imports/mocks
+4. run_tests - Verify fixes
+
+START by calling get_file_preamble to see the current test structure.`
+        }
+    ];
+    let iterations = 0;
+    const maxIterations = 100; // Limit iterations for test fixes
+    while (iterations < maxIterations) {
+        iterations++;
+        console.log(`\n🔧 Test fix attempt ${iterations}/${maxIterations}...`);
+        const response = await callAI(messages, TOOLS_FOR_TEST_GENERATION);
+        if (response.content) {
+            messages.push({ role: 'assistant', content: response.content });
+        }
+        if (!response.toolCalls || response.toolCalls.length === 0) {
+            // AI stopped - check if tests pass now
+            let finalTest;
+            if (CONFIG.testEnv == 'vitest') {
+                finalTest = runTestsVitest(testFilePath);
+            }
+            else {
+                finalTest = runTestsJest(testFilePath);
+            }
+            if (finalTest.passed) {
+                console.log('\n✅ Tests fixed! Full test suite now passes.');
+                return;
+            }
+            console.log('\n⚠️  AI stopped but tests still failing.');
+            break;
+        }
+        // Execute tool calls
+        const toolResults = [];
+        for (const toolCall of response.toolCalls) {
+            const result = await executeTool(toolCall.name, toolCall.input);
+            toolResults.push({ id: toolCall.id, name: toolCall.name, result });
+            // Check if tests passed
+            if (toolCall.name === 'run_tests' && result.passed) {
+                console.log('\n✅ Tests fixed! Full test suite now passes.');
+                return;
+            }
+        }
+        // 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 {
+            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
+                    }
+                });
+            }
+        }
+    }
+    console.log('\n⚠️  Could not automatically fix all failing tests. Manual review may be needed.');
+}
 /** [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)
@@ -3895,7 +4297,13 @@ async function validateAndFixCompleteTestFile(sourceFile, testFilePath, function
     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);
+    let testResult;
+    if (CONFIG.testEnv == 'vitest') {
+        testResult = runTestsVitest(testFilePath);
+    }
+    else {
+        testResult = runTestsJest(testFilePath);
+    }
     if (testResult.passed) {
         console.log(`\n✅ Complete test suite passed! All ${functionNames.length} functions working together correctly.`);
         return;
@@ -3905,7 +4313,7 @@ async function validateAndFixCompleteTestFile(sourceFile, testFilePath, function
     const messages = [
         {
             role: 'user',
-            content: `You are a senior software engineer fixing file-level integration issues in a Jest test file.
+            content: `You are a senior software engineer fixing file-level integration issues in a Vitest test file.
 
 Source file: ${sourceFile}
 Test file: ${testFilePath}
@@ -3918,7 +4326,7 @@ CONTEXT:
   * Mock pollution between test suites
   * Shared state not being cleaned up
   * Import/mock ordering issues
-  * beforeEach/afterEach missing or incorrect
+  * beforeEach setup issues
   * Mock implementations interfering with each other
 
 TEST OUTPUT:
@@ -3929,35 +4337,27 @@ YOUR TASK:
 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
+5. Repeat until all test cases pass
 
 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
+- ❌ Missing vitest imports (describe, it, expect, beforeEach, vi)
+- ❌ Module imports inside describe blocks (use await import() in beforeEach)
+- ❌ beforeEach hooks not setting up mocks properly
 - ❌ Test suites depending on execution order
 
+NOTE: vitest.config.ts should have clearMocks/restoreMocks enabled for auto-cleanup.
+
 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
+- Missing vitest imports
 
 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.`
         }
@@ -3969,13 +4369,19 @@ START by calling get_file_preamble to understand current file structure.`
     while (iterations < maxIterations) {
         iterations++;
         console.log(`\n🔧 Fixing attempt ${iterations}/${maxIterations}...`);
-        const response = await callAI(messages, TOOLS);
+        const response = await callAI(messages, TOOLS_FOR_TEST_GENERATION);
         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);
+            let finalTest;
+            if (CONFIG.testEnv == 'vitest') {
+                finalTest = runTestsVitest(testFilePath);
+            }
+            else {
+                finalTest = runTestsJest(testFilePath);
+            }
             if (finalTest.passed) {
                 console.log('\n✅ Complete test suite now passes!');
                 return;
@@ -3983,7 +4389,7 @@ START by calling get_file_preamble to understand current file structure.`
             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.'
+                content: 'Tests are still failing! Use tools to fix.'
             });
             continue;
         }
@@ -4073,43 +4479,74 @@ START by calling get_file_preamble to understand current file structure.`
  * 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`);
+    // console.log(`\n📝 Generating tests for ${functionNames.length} selected function(s) in: ${sourceFile}\n`);
     const testFilePath = getTestFilePath(sourceFile);
     let testFileExists = fsSync.existsSync(testFilePath);
+    // Read validation interval from config
+    const validationInterval = CONFIG.validationInterval;
     // Process each function one at a time
     for (let i = 0; i < functionNames.length; i++) {
         const functionName = functionNames[i];
+        // Clear spinner before showing section header
+        if (globalSpinner && globalSpinner.isSpinning) {
+            globalSpinner.stop();
+            globalSpinner = null;
+        }
         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;
+        // Clear spinner before showing completion
+        if (globalSpinner && globalSpinner.isSpinning) {
+            globalSpinner.stop();
+            globalSpinner = null;
+        }
         if (passed) {
             console.log(`\n✅ Function '${functionName}' tests completed successfully!`);
         }
         else {
             console.log(`\n⚠️  Function '${functionName}' completed with issues. Continuing to next function...`);
         }
+        // Periodic validation checkpoint (only if validation is enabled in config)
+        if (validationInterval !== undefined && validationInterval !== null) {
+            const isPeriodicCheckpoint = validationInterval > 0 && (i + 1) % validationInterval === 0;
+            const isFinalFunction = i === functionNames.length - 1;
+            if (isPeriodicCheckpoint || isFinalFunction) {
+                console.log(`\n${'─'.repeat(80)}`);
+                console.log(`📊 CHECKPOINT ${i + 1}/${functionNames.length}: Running full suite validation...`);
+                console.log(`${'─'.repeat(80)}`);
+                await smartValidateTestSuite(sourceFile, testFilePath, functionNames.slice(0, i + 1));
+            }
+        }
         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() {
     console.log('\n🎯 Function-wise Test Generation\n');
     // List all files
-    console.log('📂 Scanning repository...\n');
+    if (!globalSpinner || !globalSpinner.isSpinning) {
+        globalSpinner = ora('📂 Scanning repository...').start();
+    }
+    else {
+        globalSpinner.text = '📂 Scanning repository...';
+    }
     const files = await listFilesRecursive('.');
     if (files.length === 0) {
-        console.log('No source files found!');
+        globalSpinner.fail('No source files found!');
+        globalSpinner = null;
         return;
     }
-    console.log('Select a file:\n');
+    globalSpinner.text = `Found ${files.length} source file(s)`;
+    await new Promise(resolve => setTimeout(resolve, 200));
+    globalSpinner.stop();
+    globalSpinner = null;
+    console.log('\nSelect a file:\n');
     files.forEach((file, index) => {
         console.log(`${index + 1}. ${file}`);
     });
@@ -4145,6 +4582,11 @@ async function generateTestsForFunction() {
     }
     console.log(`\n✅ Selected functions: ${selectedFunctions.join(', ')}\n`);
     await generateTestsForFunctions(selectedFile, selectedFunctions);
+    // Clear spinner before final message
+    if (globalSpinner && globalSpinner.isSpinning) {
+        globalSpinner.stop();
+        globalSpinner = null;
+    }
     console.log('\n✨ Done!');
 }
 /**
@@ -4272,7 +4714,7 @@ Return ONLY the JSON array, nothing else.`;
             return [];
         }
         // Parse AI response to extract function names
-        const content = response.content.trim();
+        const content = typeof response.content === 'string' ? response.content.trim() : JSON.stringify(response.content || '');
         // console.log(`   🤖 AI response: ${content}`);
         // Try to extract JSON array from response
         const jsonMatch = content.match(/\[.*\]/s);
@@ -4304,16 +4746,25 @@ Return ONLY the JSON array, nothing else.`;
  * Auto-generate tests for changed functions detected via git diff
  */
 async function autoGenerateTests() {
-    console.log('🔍 Scanning git changes...\n');
+    if (!globalSpinner) {
+        globalSpinner = ora('🔍 Scanning git changes...').start();
+    }
+    else {
+        globalSpinner.text = '🔍 Scanning git changes...';
+        globalSpinner.start();
+    }
     try {
         // Get all changes from git diff
         const { fullDiff, files } = await getGitDiff();
         if (files.length === 0) {
+            globalSpinner.stop();
+            globalSpinner = null;
             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`);
+        globalSpinner.text = `Found changes in ${files.length} file(s)`;
+        await new Promise(resolve => setTimeout(resolve, 200));
         let totalFunctions = 0;
         let processedFiles = 0;
         let errorFiles = 0;
@@ -4322,25 +4773,41 @@ async function autoGenerateTests() {
             const { filePath, diff } = fileInfo;
             // Check if file exists
             if (!fsSync.existsSync(filePath)) {
-                console.log(`⏭️  Skipping ${filePath} (file not found)`);
+                if (!globalSpinner || !globalSpinner.isSpinning) {
+                    globalSpinner = ora(`⏭️  Skipping ${filePath} (file not found)`).start();
+                }
+                else {
+                    globalSpinner.text = `⏭️  Skipping ${filePath} (file not found)`;
+                }
+                await new Promise(resolve => setTimeout(resolve, 100));
                 continue;
             }
-            console.log(`\n🔄 Processing: ${filePath}`);
-            console.log(`  🤖 Analyzing diff with AI...`);
+            if (!globalSpinner || !globalSpinner.isSpinning) {
+                globalSpinner = ora(`🔄 Processing: ${path.basename(filePath)}`).start();
+            }
+            else {
+                globalSpinner.text = `🔄 Processing: ${path.basename(filePath)}`;
+            }
             // Use AI to extract changed function names from diff
+            globalSpinner.text = `🤖 Analyzing diff with AI: ${path.basename(filePath)}`;
             const changedFunctions = await getChangedFunctionsFromDiff(filePath, diff);
             // console.log('Changed functions are', changedFunctions);
             if (changedFunctions.length === 0) {
-                console.log(`   ⏭️  No exported functions changed`);
+                globalSpinner.text = `⏭️  No exported functions changed in ${path.basename(filePath)}`;
+                await new Promise(resolve => setTimeout(resolve, 150));
                 continue;
             }
-            console.log(`   📦 Changed functions: ${changedFunctions.join(', ')}`);
+            globalSpinner.text = `Found ${changedFunctions.length} function(s): ${changedFunctions.join(', ')}`;
+            await new Promise(resolve => setTimeout(resolve, 200));
             try {
                 // Use existing generateTestsForFunctions
                 await generateTestsForFunctions(filePath, changedFunctions);
                 processedFiles++;
                 totalFunctions += changedFunctions.length;
-                console.log(`   ✅ Tests generated successfully`);
+                if (globalSpinner) {
+                    globalSpinner.text = `Tests generated for ${path.basename(filePath)}`;
+                    await new Promise(resolve => setTimeout(resolve, 200));
+                }
             }
             catch (error) {
                 errorFiles++;
@@ -4351,6 +4818,11 @@ async function autoGenerateTests() {
         // Summary
         console.log('\n' + '='.repeat(60));
         console.log('📊 Auto-Generation Summary');
+        // Clear spinner before final summary
+        if (globalSpinner && globalSpinner.isSpinning) {
+            globalSpinner.stop();
+            globalSpinner = null;
+        }
         console.log('='.repeat(60));
         console.log(`✅ Successfully processed: ${processedFiles} file(s)`);
         console.log(`📝 Functions tested: ${totalFunctions}`);
@@ -4369,11 +4841,526 @@ async function autoGenerateTests() {
         throw error;
     }
 }
+/**
+ * Review code changes for quality, bugs, performance, and security issues
+ */
+async function reviewChangedFiles() {
+    if (!globalSpinner) {
+        globalSpinner = ora('🔍 Scanning git changes for review...').start();
+    }
+    else {
+        globalSpinner.text = '🔍 Scanning git changes for review...';
+        globalSpinner.start();
+    }
+    try {
+        // Get all changes from git diff
+        const { fullDiff, files } = await getGitDiff();
+        if (files.length === 0) {
+            globalSpinner.stop();
+            globalSpinner = null;
+            console.log('✅ No changes detected in source files.');
+            console.log('   (Only staged and unstaged changes are checked)');
+            return;
+        }
+        globalSpinner.text = `Found changes in ${files.length} file(s) to review`;
+        await new Promise(resolve => setTimeout(resolve, 200));
+        // Collect all changed files and their functions
+        const filesToReview = [];
+        for (const fileInfo of files) {
+            const { filePath, diff } = fileInfo;
+            // Check if file exists
+            if (!fsSync.existsSync(filePath)) {
+                if (!globalSpinner || !globalSpinner.isSpinning) {
+                    globalSpinner = ora(`⏭️  Skipping ${filePath} (file not found)`).start();
+                }
+                else {
+                    globalSpinner.text = `⏭️  Skipping ${filePath} (file not found)`;
+                }
+                await new Promise(resolve => setTimeout(resolve, 100));
+                continue;
+            }
+            if (!globalSpinner || !globalSpinner.isSpinning) {
+                globalSpinner = ora(`🔄 Analyzing: ${filePath}`).start();
+            }
+            else {
+                globalSpinner.text = `🔄 Analyzing: ${filePath}`;
+            }
+            // Use AI to extract changed function names from diff
+            const changedFunctions = await getChangedFunctionsFromDiff(filePath, diff);
+            if (changedFunctions.length === 0) {
+                globalSpinner.text = `⏭️  No exported functions changed in ${path.basename(filePath)}`;
+                await new Promise(resolve => setTimeout(resolve, 150));
+                continue;
+            }
+            globalSpinner.text = `Found ${changedFunctions.length} changed function(s) in ${path.basename(filePath)}`;
+            await new Promise(resolve => setTimeout(resolve, 200));
+            filesToReview.push({ filePath, diff, functions: changedFunctions });
+        }
+        if (filesToReview.length === 0) {
+            console.log('\n✅ No functions to review.');
+            return;
+        }
+        // Generate unified review for all changes
+        try {
+            await generateUnifiedCodeReview(filesToReview);
+            // Ensure spinner is cleared before final message
+            if (globalSpinner && globalSpinner.isSpinning) {
+                globalSpinner.stop();
+                globalSpinner = null;
+            }
+            console.log('\n✅ Code review completed!');
+        }
+        catch (error) {
+            console.error(`\n❌ Error during review: ${error.message}`);
+        }
+        // Summary
+        console.log('\n' + '='.repeat(60));
+        console.log('📊 Code Review Summary');
+        console.log('='.repeat(60));
+        console.log(`✅ Files reviewed: ${filesToReview.length}`);
+        console.log(`📝 Total functions: ${filesToReview.reduce((sum, f) => sum + f.functions.length, 0)}`);
+        console.log(`📁 Review saved to: reviews/code_review.md`);
+        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('   Review mode requires git to detect changes.');
+            process.exit(1);
+        }
+        throw error;
+    }
+}
+/**
+ * Build AI prompt for a specific review step based on its ruleset
+ */
+async function buildStepPrompt(step, filesToReview, stepOutputPath) {
+    const filesContext = filesToReview.map(f => `- ${f.filePath}: ${f.functions.join(', ')}`).join('\n');
+    const totalFunctions = filesToReview.reduce((sum, f) => sum + f.functions.length, 0);
+    // Read ruleset from markdown file
+    const rulesetPath = path.join(process.cwd(), 'codeguard-ruleset', step.ruleset);
+    let rulesetContent;
+    try {
+        rulesetContent = await fs.readFile(rulesetPath, 'utf-8');
+        if (globalSpinner && globalSpinner.isSpinning) {
+            globalSpinner.text = `📖 Loaded ruleset: ${step.ruleset}`;
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+    catch (error) {
+        if (globalSpinner && globalSpinner.isSpinning) {
+            globalSpinner.stop();
+            globalSpinner = null;
+        }
+        console.warn(`⚠️  Could not read ruleset file: ${rulesetPath}`);
+        console.warn(`   Using default ruleset message. Error: ${error.message}`);
+        rulesetContent = `Please review the code for ${step.name} following industry best practices.`;
+    }
+    return `You are a senior software engineer conducting a focused code review for: **${step.name}**
+
+## CONTEXT
+Review Focus: ${step.name}
+Category: ${step.category}
+Total files changed: ${filesToReview.length}
+Total functions changed: ${totalFunctions}
+
+Changed files and functions:
+${filesContext}
+
+## GIT DIFFS
+
+${filesToReview.map(f => `### ${f.filePath}
+\`\`\`diff
+${f.diff}
+\`\`\`
+`).join('\n')}
+
+## YOUR TASK
+Conduct a focused code review ONLY for ${step.name}. Use the available tools to analyze the code thoroughly.
+Must complete and write the review within 1 minutes. Your review should be brief and to the point. 
+
+## ANALYSIS STEPS
+
+**Phase 1: Code Analysis (MANDATORY)**
+For each changed file:
+1. analyze_file_ast(filePath) → Get file structure and all functions
+   - OR use analyze_file_ast(filePath, functionName) for specific function reviews (token-efficient)
+2. For each changed function:
+   - get_function_ast(filePath, functionName) → Get implementation details
+3. get_imports_ast(filePath) → Understand dependencies
+4. get_type_definitions(filePath) → Review type safety
+5. Use search_codebase() if needed to understand usage patterns
+6. Use tools to analyze the code thoroughly. -> Where the functions is used and what all dependencies are there that call this function? What can be potential issues with the code?
+
+  **Phase 2: Review Analysis for ${step.name}**
+  
+  Review the code against the following ruleset:
+  
+  ${rulesetContent}
+  
+  Also give attention to any industry specific points that are not covered by the ruleset for ${step.name}.
+
+**Phase 3: Write Review**
+
+Use the write_review tool to save findings to: ${stepOutputPath}
+
+## OUTPUT FORMAT
+
+Your review MUST be in markdown format with the following structure:
+
+\`\`\`markdown
+# ${step.name}
+
+
+## Findings
+
+### 🔴 Critical Issues
+
+#### [Issue Title]
+**File**: \`filePath\`
+**Function**: \`functionName\`
+**Severity**: Critical
+
+**Issue**:
+[Description]
+
+**Current Code**:
+\`\`\`typescript
+// problematic code
+\`\`\`
+
+**Recommended Code**:
+\`\`\`typescript
+// improved code
+\`\`\`
+
+**Rationale**:
+[Why this is important]
+
+---
+
+### 🟠 High Priority Issues
+[Same format as above]
+
+---
+
+### 🟡 Medium Priority Issues
+[Same format as above]
+
+---
+
+## Positive Aspects
+[What was done well in this area]
+
+## Recommendations
+[Specific recommendations for ${step.name}]
+\`\`\`
+
+## CRITICAL REMINDERS
+
+- ALWAYS use tools to analyze code before reviewing
+- Focus ONLY on ${step.name} - do not review other aspects
+- Be specific and actionable
+- Include code examples
+- Use write_review tool to save to: ${stepOutputPath}
+- Must complete within 30 seconds
+- Use avaiable tools extensively to analyze the code.
+- The review should be based on the ruleset, it should be to the point without too much text.
+- Before writing the review, make sure to analyze the code thoroughly using the tools available, how similar code is used in the codebase.
+- Keep the review short and to the point, do not write too much text.
+
+**START**: Begin by calling analyze_file_ast on each changed file.`;
+}
+/**
+ * Execute a single review step with AI
+ */
+async function executeReviewStep(step, filesToReview, stepOutputPath) {
+    // console.log(`\n🔍 Running ${step.name} review step...`);
+    try {
+        const prompt = await buildStepPrompt(step, filesToReview, stepOutputPath);
+        const messages = [
+            {
+                role: 'user',
+                content: prompt
+            }
+        ];
+        let iterations = 0;
+        const maxIterations = 30;
+        let reviewWritten = false;
+        while (iterations < maxIterations) {
+            iterations++;
+            const response = await callAI(messages, TOOLS_FOR_CODE_REVIEW, CONFIG.aiProvider);
+            if (response.content) {
+                const content = typeof response.content === 'string' ? response.content : JSON.stringify(response.content);
+                messages.push({ role: 'assistant', content });
+                // Check if review is complete
+                if (typeof content === 'string' && (content.toLowerCase().includes('review complete') ||
+                    content.toLowerCase().includes('review has been written'))) {
+                    if (reviewWritten) {
+                        break;
+                    }
+                }
+            }
+            if (!response.toolCalls || response.toolCalls.length === 0) {
+                if (reviewWritten) {
+                    break;
+                }
+                // Prompt AI to continue
+                messages.push({
+                    role: 'user',
+                    content: `Please use the write_review tool NOW to save your ${step.name} review to ${stepOutputPath}. Include all findings with severity levels and code examples.`
+                });
+                continue;
+            }
+            // Execute tool calls
+            const toolResults = [];
+            for (const toolCall of response.toolCalls) {
+                const toolResult = await executeTool(toolCall.name, toolCall.input);
+                toolResults.push({ id: toolCall.id, name: toolCall.name, result: toolResult });
+                // Track if review was written
+                if (toolCall.name === 'write_review' && toolResult.success) {
+                    reviewWritten = true;
+                }
+            }
+            // Add tool calls and results to messages (format differs by provider)
+            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 if (CONFIG.aiProvider === '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 }
+                    });
+                }
+            }
+            else {
+                // 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)
+                    }))
+                });
+            }
+        }
+        if (!reviewWritten) {
+            throw new Error(`Could not complete ${step.name} review within iteration limit`);
+        }
+        console.log(`   ✅ ${step.name} review completed`);
+        return { success: true, stepId: step.id, stepName: step.name };
+    }
+    catch (error) {
+        console.error(`   ❌ ${step.name} review failed: ${error.message}`);
+        return { success: false, error: error.message, stepId: step.id, stepName: step.name };
+    }
+}
+/**
+ * Merge review results from multiple steps into a single unified review
+ */
+async function mergeReviewResults(stepResults, filesToReview, finalOutputPath) {
+    const timestamp = new Date().toISOString().split('T')[0];
+    const totalFunctions = filesToReview.reduce((sum, f) => sum + f.functions.length, 0);
+    // Start building the merged review
+    let mergedReview = `# Code Review
+
+**Date**: ${timestamp}
+**Reviewer**: AI Code Review System
+**Files Changed**: ${filesToReview.length}
+**Functions Changed**: ${totalFunctions}
+
+---
+
+## Summary
+
+This review covers ${filesToReview.length} file(s) with ${totalFunctions} changed function(s). The review was conducted across multiple aspects: ${stepResults.map(r => r.stepName).join(', ')}.
+
+---
+
+## Files Changed
+
+${filesToReview.map(f => `- **${f.filePath}**
+  - Functions: ${f.functions.join(', ')}`).join('\n')}
+
+---
+
+`;
+    // Add each step's findings
+    for (const result of stepResults) {
+        const stepFilePath = path.join('reviews', '.tmp', `step-${result.stepId}.md`);
+        if (result.success) {
+            try {
+                // Read the step review file
+                if (fsSync.existsSync(stepFilePath)) {
+                    const stepContent = await fs.readFile(stepFilePath, 'utf-8');
+                    // Extract content after the first heading (skip the step title)
+                    const lines = stepContent.split('\n');
+                    let contentStart = 0;
+                    for (let i = 0; i < lines.length; i++) {
+                        if (lines[i].startsWith('# ')) {
+                            contentStart = i + 1;
+                            break;
+                        }
+                    }
+                    const content = lines.slice(contentStart).join('\n').trim();
+                    // Add as a section in the merged review
+                    mergedReview += `## ${result.stepName}\n\n${content}\n\n---\n\n`;
+                }
+                else {
+                    mergedReview += `## ${result.stepName}\n\n⚠️ Review file not found.\n\n---\n\n`;
+                }
+            }
+            catch (error) {
+                mergedReview += `## ${result.stepName}\n\n⚠️ Error reading review: ${error.message}\n\n---\n\n`;
+            }
+        }
+        else {
+            mergedReview += `## ${result.stepName}\n\n❌ **Review step failed**: ${result.error}\n\n---\n\n`;
+        }
+    }
+    // Add conclusion
+    mergedReview += `## Conclusion
+
+This comprehensive review analyzed the code changes from multiple perspectives. Please address the findings based on their severity levels, starting with critical issues.
+
+The review was conducted using AI-powered analysis with access to the full codebase context.
+`;
+    // Ensure reviews directory exists
+    const reviewsDir = path.dirname(finalOutputPath);
+    if (!fsSync.existsSync(reviewsDir)) {
+        await fs.mkdir(reviewsDir, { recursive: true });
+    }
+    // Write the merged review
+    await fs.writeFile(finalOutputPath, mergedReview, 'utf-8');
+    console.log(`\n✅ Merged review written to: ${finalOutputPath}`);
+    // Clean up temporary files
+    try {
+        const tmpDir = path.join('reviews', '.tmp');
+        if (fsSync.existsSync(tmpDir)) {
+            const tmpFiles = await fs.readdir(tmpDir);
+            for (const file of tmpFiles) {
+                await fs.unlink(path.join(tmpDir, file));
+            }
+            await fs.rmdir(tmpDir);
+        }
+    }
+    catch (error) {
+        // Ignore cleanup errors
+    }
+}
+/**
+ * Generate unified code review for all changed files
+ */
+async function generateUnifiedCodeReview(filesToReview) {
+    const reviewFilePath = path.join('reviews', 'code_review.md');
+    // Get enabled review steps from config
+    const enabledSteps = CONFIG.reviewSteps.filter(step => step.enabled);
+    if (enabledSteps.length === 0) {
+        console.log('\n⚠️  No review steps enabled. Please enable at least one step in codeguard.json');
+        return;
+    }
+    console.log(`\n📋 Running ${enabledSteps.length} review step(s): ${enabledSteps.map(s => s.name).join(', ')}`);
+    // Ensure temporary directory exists
+    const tmpDir = path.join('reviews', '.tmp');
+    if (!fsSync.existsSync(tmpDir)) {
+        await fs.mkdir(tmpDir, { recursive: true });
+    }
+    // Execute review steps
+    let stepResults;
+    if (CONFIG.reviewExecutionMode === 'parallel') {
+        if (!globalSpinner || !globalSpinner.isSpinning) {
+            globalSpinner = ora('🔄 Executing review steps in parallel...').start();
+        }
+        else {
+            globalSpinner.text = '🔄 Executing review steps in parallel...';
+        }
+        // Run all steps in parallel
+        const stepPromises = enabledSteps.map(step => {
+            const stepOutputPath = path.join('reviews', '.tmp', `step-${step.id}.md`);
+            return executeReviewStep(step, filesToReview, stepOutputPath);
+        });
+        stepResults = await Promise.all(stepPromises);
+    }
+    else {
+        if (!globalSpinner || !globalSpinner.isSpinning) {
+            globalSpinner = ora('🔄 Executing review steps sequentially...').start();
+        }
+        else {
+            globalSpinner.text = '🔄 Executing review steps sequentially...';
+        }
+        // Run steps sequentially
+        stepResults = [];
+        for (const step of enabledSteps) {
+            if (globalSpinner) {
+                globalSpinner.text = `🔍 Running ${step.name} review step...`;
+            }
+            const stepOutputPath = path.join('reviews', '.tmp', `step-${step.id}.md`);
+            const result = await executeReviewStep(step, filesToReview, stepOutputPath);
+            stepResults.push(result);
+            if (globalSpinner && result.success) {
+                globalSpinner.text = `${step.name} review completed`;
+                await new Promise(resolve => setTimeout(resolve, 200));
+            }
+        }
+    }
+    // Merge results into final review
+    await mergeReviewResults(stepResults, filesToReview, reviewFilePath);
+    // Clear global spinner before final summary
+    if (globalSpinner && globalSpinner.isSpinning) {
+        globalSpinner.stop();
+        globalSpinner = null;
+    }
+    // Summary
+    const successCount = stepResults.filter(r => r.success).length;
+    const failCount = stepResults.filter(r => !r.success).length;
+    console.log(`\n✅ Review complete: ${successCount} step(s) succeeded${failCount > 0 ? `, ${failCount} failed` : ''}`);
+}
 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)
+    // Parse command from CLI arguments EARLY (before any prompts)
     const args = process.argv.slice(2);
-    const isAutoMode = args.includes('auto');
+    const command = args[0]; // First argument is the command: 'auto', 'test', 'review', or undefined
+    // Validate command if provided
+    if (command && !['auto', 'test', 'review', 'doc'].includes(command)) {
+        console.error('❌ Invalid command. Usage:\n');
+        console.error('  testgen auto    - Review changes and generate tests');
+        console.error('  testgen test    - Generate tests only');
+        console.error('  testgen review  - Review changes only');
+        console.error('  testgen doc     - Generate API documentation');
+        console.error('  testgen         - Interactive mode\n');
+        process.exit(1);
+    }
     // Load configuration from codeguard.json
     try {
         CONFIG = (0, config_1.loadConfig)();
@@ -4396,20 +5383,52 @@ 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');
+    // If command mode (auto, test, review, doc), prepare index (build/update) and proceed directly
+    if (command === 'auto' || command === 'test' || command === 'review' || command === 'doc') {
+        const modeLabel = command === 'auto' ? 'Auto Mode (Review + Test)' :
+            command === 'test' ? 'Test Generation Mode' :
+                command === 'review' ? 'Code Review Mode' :
+                    CONFIG.repoDoc ? 'Documentation Generation Mode (Full Repository)' : 'Documentation Generation Mode (Changes Only)';
+        console.log(`🤖 ${modeLabel}: 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
+        // Initialize and prepare codebase indexer (build or update) without prompts
         globalIndexer = new codebaseIndexer_1.CodebaseIndexer();
         const hasExistingIndex = globalIndexer.hasIndex();
         if (hasExistingIndex) {
-            await globalIndexer.loadIndex();
+            const loaded = await globalIndexer.loadIndex();
+            if (loaded) {
+                const staleFiles = globalIndexer.getStaleFiles();
+                if (staleFiles.length > 0) {
+                    console.log(`🔄 Updating ${staleFiles.length} modified file(s) in index...`);
+                    await globalIndexer.updateIndex(staleFiles, analyzeFileAST);
+                }
+            }
         }
         else {
-            globalIndexer = null;
+            // Build index once for the whole repo to speed up AST queries
+            console.log('📦 Building codebase index for faster analysis...');
+            await globalIndexer.buildIndex('.', analyzeFileAST);
+        }
+        // Execute based on command
+        if (command === 'auto') {
+            // Run review first, then tests
+            await reviewChangedFiles();
+            console.log('\n' + '='.repeat(60) + '\n');
+            await autoGenerateTests();
+        }
+        else if (command === 'test') {
+            // Only generate tests
+            await autoGenerateTests();
+        }
+        else if (command === 'review') {
+            // Only review changes
+            await reviewChangedFiles();
+        }
+        else if (command === 'doc') {
+            // Only generate documentation
+            console.log('Currently in development. Please try again later.');
+            // await generateDocumentationMode();
         }
-        await autoGenerateTests();
         return;
     }
     // Optional: Codebase Indexing
@@ -4425,16 +5444,18 @@ async function main() {
             // Check for stale files (modified since last index)
             const staleFiles = globalIndexer.getStaleFiles();
             if (staleFiles.length > 0) {
-                console.log(`🔄 Updating ${staleFiles.length} modified file(s)...`);
-                // Show which files are being updated (if not too many)
-                if (staleFiles.length <= 5) {
-                    staleFiles.forEach(f => console.log(`   📝 ${path.basename(f)}`));
+                if (!globalSpinner || !globalSpinner.isSpinning) {
+                    globalSpinner = ora(`🔄 Updating ${staleFiles.length} modified file(s)...`).start();
                 }
                 else {
-                    console.log(`   📝 Updating ${staleFiles.length} files...`);
+                    globalSpinner.text = `🔄 Updating ${staleFiles.length} modified file(s)...`;
                 }
                 await globalIndexer.updateIndex(staleFiles, analyzeFileAST);
-                console.log(`✅ Index updated!\n`);
+                globalSpinner.text = `Index updated - ${staleFiles.length} file(s) refreshed`;
+                await new Promise(resolve => setTimeout(resolve, 200));
+                globalSpinner.stop();
+                globalSpinner = null;
+                console.log(); // Empty line for spacing
             }
             else {
                 console.log('✅ All files up to date!\n');
@@ -4497,13 +5518,23 @@ async function main() {
         case '1':
         default:
             // File-wise mode (original functionality)
-            console.log('\n📂 Scanning repository...\n');
+            if (!globalSpinner || !globalSpinner.isSpinning) {
+                globalSpinner = ora('📂 Scanning repository...').start();
+            }
+            else {
+                globalSpinner.text = '📂 Scanning repository...';
+            }
             const files = await listFilesRecursive('.');
             if (files.length === 0) {
-                console.log('No source files found!');
+                globalSpinner.fail('No source files found!');
+                globalSpinner = null;
                 return;
             }
-            console.log('Select a file to generate tests:\n');
+            globalSpinner.text = `Found ${files.length} source file(s)`;
+            await new Promise(resolve => setTimeout(resolve, 200));
+            globalSpinner.stop();
+            globalSpinner = null;
+            console.log('\nSelect a file to generate tests:\n');
             files.forEach((file, index) => {
                 console.log(`${index + 1}. ${file}`);
             });
@@ -4514,6 +5545,11 @@ async function main() {
                 return;
             }
             await generateTests(selectedFile);
+            // Clear spinner before final message
+            if (globalSpinner && globalSpinner.isSpinning) {
+                globalSpinner.stop();
+                globalSpinner = null;
+            }
             console.log('\n✨ Done!');
             break;
     }