codeguard-testgen 1.0.10 → 1.0.12

package/dist/index.js

@@ -39,6 +39,7 @@ 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;
@@ -53,6 +54,7 @@ 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
@@ -124,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']
@@ -184,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: {
@@ -256,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: {
@@ -267,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']
@@ -303,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: {
@@ -313,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.',
@@ -418,10 +397,42 @@ const TOOLS = [
             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);
@@ -446,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);
@@ -459,7 +470,8 @@ function analyzeFileAST(filePath) {
             exports: [],
             imports: [],
             types: [],
-            constants: []
+            constants: [],
+            routeRegistrations: []
         };
         traverse(ast, {
             // Function declarations
@@ -570,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,
@@ -585,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 {
@@ -692,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) {
@@ -702,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;
@@ -843,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);
@@ -953,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);
@@ -1038,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;
@@ -1098,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,
@@ -1120,7 +1229,6 @@ function getFilePreamble(filePath) {
                     setupBlocks,
                     topLevelVariables
                 },
-                fullCode,
                 summary: {
                     importCount: imports.length,
                     mockCount: mocks.length,
@@ -1141,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);
@@ -1174,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) {
@@ -1259,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) {
@@ -1268,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;
@@ -1289,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 {
@@ -1302,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 {
@@ -1347,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);
@@ -1380,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);
@@ -1478,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);
@@ -1511,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);
@@ -1912,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`;
@@ -1954,10 +2110,9 @@ function runTests(testFilePath, functionNames) {
  */
 function runTestsIsolated(testFilePath, specificTestNames) {
     try {
-        // Build Jest command with specific test name filter
-        let command = `npx jest ${testFilePath} --no-coverage --verbose=false`;
+        // 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) {
-            // Escape special regex characters in test names
             const escapedNames = specificTestNames.map(name => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
             const pattern = escapedNames.join('|');
             command += ` -t "${pattern}"`;
@@ -1965,29 +2120,73 @@ function runTestsIsolated(testFilePath, specificTestNames) {
         const output = (0, child_process_1.execSync)(command, {
             encoding: 'utf-8',
             stdio: 'pipe',
-            timeout: 10000
+            timeout: 60000, // 60 seconds
+            maxBuffer: 10 * 1024 * 1024 // 10MB buffer
         });
         return {
             success: true,
-            output,
+            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: error.stdout + error.stderr,
+            output: stripAnsi(output) || 'Test failed with no output captured',
             passed: false,
             error: error.message
         };
     }
 }
 /**
- * Parse Jest output to extract names of failing tests
+ * Parse Vitest output to extract names of failing tests
  * Returns array of test names that failed
  */
-function parseFailingTestNames(jestOutput) {
+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
@@ -2100,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,
@@ -2128,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');
@@ -2509,10 +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) {
@@ -2532,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) {
@@ -2543,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,
@@ -2565,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);
@@ -2599,10 +2920,10 @@ async function executeTool(toolName, args) {
                     const normalizedExpected = path.normalize(EXPECTED_TEST_FILE_PATH).replace(/\\/g, '/');
                     const normalizedProvided = path.normalize(args.test_file_path).replace(/\\/g, '/');
                     if (normalizedExpected !== normalizedProvided) {
-                        console.log(`\n⚠️  BLOCKED: AI attempted to create separate test file per function!`);
-                        console.log(`   Expected: ${EXPECTED_TEST_FILE_PATH}`);
-                        console.log(`   AI tried: ${args.test_file_path}`);
-                        console.log(`   🛡️  Enforcing single test file policy...\n`);
+                        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;
                     }
@@ -2610,7 +2931,12 @@ async function executeTool(toolName, args) {
                 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);
@@ -2621,9 +2947,6 @@ 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;
@@ -2633,6 +2956,9 @@ async function executeTool(toolName, args) {
             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}` };
         }
@@ -2640,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);
@@ -2712,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
@@ -2888,12 +3337,12 @@ async function callAI(messages, tools, provider = CONFIG.aiProvider) {
 }
 // Main conversation loop
 async function generateTests(sourceFile) {
-    console.log(`\n📝 Generating tests for: ${sourceFile}\n`);
+    // 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...');
+        // console.log('⚠️  AST analysis failed, retrying once...');
         result = analyzeFileAST(sourceFile);
     }
     // If still failed, throw error
@@ -2910,9 +3359,9 @@ async function generateTests(sourceFile) {
     // 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(', ')}`);
+    // 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)`);
+        // console.log(`   (Skipping ${internalFunctions} internal/helper function(s) - only testing public API)`);
     }
     // Always use function-by-function generation
     return await generateTestsForFunctions(sourceFile, functionNames);
@@ -3000,78 +3449,295 @@ async function generateTestsForFolder() {
 async function generateTestForSingleFunction(sourceFile, functionName, testFilePath, testFileExists) {
     // Set the expected test file path globally to prevent AI from creating per-function files
     EXPECTED_TEST_FILE_PATH = testFilePath;
-    const 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.
+    const functionAST = getFunctionAST(sourceFile, functionName);
+    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.
 
-## CONTEXT
-Test file: ${testFilePath} | Exists: ${testFileExists}
+## TARGET
+Function: ${functionName} | Source: ${sourceFile}
+Test File: ${testFilePath} (Exists: ${testFileExists})
 
-⚠️  CRITICAL: You MUST use this EXACT test file path: ${testFilePath}
+## WORKFLOW
 
----
+### 1. ANALYSIS (Execute in order)
+1. 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
 
-## EXECUTION PLAN
+**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"
 
-**Phase 1: Deep Analysis**
-\\\`\\\`\\\`
-1. analyze_file_ast(${sourceFile}) → function metadata.
-2. get_function_ast(${sourceFile},{functionName}) → implementation + dependencies
-3. For each dependency:
-   - Same file: get_function_ast(${sourceFile},{functionName})
-   - Other file [Can take reference from the imports of the ${sourceFile} file for the file name that has the required function]: find_file(filename) to get file path -> get_function_ast({file_path},{functionName}) + check for external calls
-4. get_imports_ast → all dependencies
-5. calculate_relative_path for each import
-6. get_file_preamble → imports and mocks already declared in the file
-\\\`\\\`\\\`
+### 2. FILE STRUCTURE (STRICT ORDER)
 
-**Phase 1.1: Execution Path Tracing (CRITICAL FOR SUCCESS)**
-*Before writing tests, map the logic requirements for external calls.*
-1. Identify every external call (e.g., \`analyticsHelper.postEvent\`).
-2. Trace backwards: What \`if\`, \`switch\`, or \`try/catch\` block guards this call?
-3. Identify the dependency that controls that guard.
-4. Plan the Mock Return: Determine exactly what value the dependency must return to enter that block.
 
-**Phase 2: Test Generation**
+// 1. MOCKS (before ANY imports)
+vi.mock('module-path');
+vi.mock('database/index', () => ({ db: { query: vi.fn() } }));
+vi.mock('env', () => ({ _ENV: { KEY: 'test' } }));
 
-Mock Pattern (CRITICAL - Top of file):
-\\\`\\\`\\\`typescript
-// ===== MOCKS (BEFORE IMPORTS) =====
-jest.mock('config', () => ({
-  get: (key: string) => ({
-    AUTH: { JWT_KEY: 'test', COOKIE_DATA_ONE_YEAR: 31536000000 },
-    USER_DEL_SECRET: 'secret'
-  })
-}), { virtual: true }); 
+// 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';
 
- // virtual:true ONLY for config, db, models, routes, services, axios, newrelic, GOOGLE_CLOUD_STORAGE, winston, logger, etc.
+// 3. TYPED MOCKS
+const mockDep = vi.mocked(dependency);
 
-jest.mock('../helpers/dependency'); // NO virtual:true for regular modules
+// 4. TESTS
+describe('${functionName}', () => {
+  beforeEach(() => {
+    // clearMocks: true in config handles cleanup
+    mockDep.mockResolvedValue(defaultValue);
+  });
 
-// ===== IMPORTS =====
-import { functionName } from '../controller';
-import { dependencyMethod } from '../helpers/dependency';
+  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);
+  });
+});
 
-// ===== TYPED MOCKS =====
-const mockDependencyMethod = dependencyMethod as jest.MockedFunction<typeof dependencyMethod>;
 
-\\\`\\\`\\\`
+### 3. COVERAGE (Minimum 5 tests)
 
-Requirements (5+ tests minimum):
-- ✅ Happy path
-- 🔸 Edge cases (null, undefined, empty)
-- ❌ Error conditions  
-- ⏱️ Async behavior
-- 🔍 API null/undefined handling
+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)
 
-/**
- * Phase 3: Anti-Pollution Pattern (MANDATORY)
- */
+### 4. MOCK STRATEGY
 
-\\\`\\\`\\\`typescript
-// ===== GLOBAL CLEANUP (Near top, outside describe blocks) =====
+**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
+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.
+
+**PRE COMPUTED FUNCTION AST **
+${JSON.stringify(functionAST)}
+`
+            },
+        ];
+    }
+    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
+
+**Phase 1: Deep Analysis**
+\\\`\\\`\\\`
+1. For each dependency:
+   - Same file: get_function_ast(${sourceFile},{functionName}) ->  implementation + dependencies
+   - 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
+2. get_imports_ast → all dependencies
+3. 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.
+4. get_file_preamble → imports and mocks already declared in the file
+5. search_codebase → look for relevant context in codebase.
+\\\`\\\`\\\`
+
+**Phase 1.1: Execution Path Tracing (CRITICAL FOR SUCCESS)**
+*Before writing tests, map the logic requirements for external calls.*
+1. Identify every external call (e.g., \`analyticsHelper.postEvent\`).
+2. Trace backwards: What \`if\`, \`switch\`, or \`try/catch\` block guards this call?
+3. Identify the dependency that controls that guard.
+4. Plan the Mock Return: Determine exactly what value the dependency must return to enter that block.
+
+**Phase 2: Test Generation**
+
+Mock Pattern (CRITICAL - Top of file):
+\\\`\\\`\\\`typescript
+// ===== MOCKS (BEFORE IMPORTS) =====
+jest.mock('config', () => ({
+  get: (key: string) => ({
+    AUTH: { JWT_KEY: 'test', COOKIE_DATA_ONE_YEAR: 31536000000 },
+    USER_DEL_SECRET: 'secret'
+  })
+}), { virtual: true }); 
+
+ // virtual:true ONLY for config, db, models, routes, services, axios, newrelic, GOOGLE_CLOUD_STORAGE, winston, logger, etc.
+
+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):
+- ✅ Happy path
+- 🔸 Edge cases (null, undefined, empty)
+- ❌ Error conditions  
+- ⏱️ Async behavior
+- 🔍 API null/undefined handling
+
+/**
+ * Phase 3: Anti-Pollution Pattern (MUST FOLLOW EXACTLY THIS PATTERN, NO VARIATIONS)
+ */
+
+\\\`\\\`\\\`typescript
+// ===== GLOBAL CLEANUP (Near top, outside describe blocks) =====
 afterEach(() => {
   jest.restoreAllMocks(); // Automatically restores ALL spies
 });
@@ -3188,14 +3854,8 @@ All functions from the same source file MUST share the same test file.
 | "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
 
 ---
 
@@ -3207,11 +3867,18 @@ All functions from the same source file MUST share the same test file.
 - 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, 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.
+- 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:** 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.
+
+**PRE COMPUTED FUNCTION AST **
+${JSON.stringify(functionAST)}
+`,
+            },
+        ];
+    }
     let iterations = 0;
     const maxIterations = 100;
     let testFileWritten = false;
@@ -3220,16 +3887,25 @@ All functions from the same source file MUST share the same test file.
     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})...`;
+            }
         }
+        // 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
@@ -3243,7 +3919,7 @@ All functions from the same source file MUST share the same test file.
                 /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({
@@ -3293,7 +3969,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
 
@@ -3325,16 +4001,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.`
                         });
                     }
                 }
@@ -3347,7 +4020,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.`
@@ -3451,16 +4124,32 @@ async function smartValidateTestSuite(sourceFile, testFilePath, functionNames) {
     console.log(`🔍 VALIDATION: Running full test suite (${functionNames.length} function(s))`);
     console.log(`${'='.repeat(80)}\n`);
     // Run tests for entire file (no function filter)
-    const fullSuiteResult = runTests(testFilePath);
+    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 Jest output
-    const failingTests = parseFailingTestNames(fullSuiteResult.output);
+    // 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. Skipping detailed analysis.');
+        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`);
@@ -3475,7 +4164,7 @@ async function fixFailingTests(sourceFile, testFilePath, functionNames, failingT
     const messages = [
         {
             role: 'user',
-            content: `You are fixing FAILING TESTS in the test suite.
+            content: `You are fixing FAILING TESTS in the Vitest test suite.
 
 Source file: ${sourceFile}
 Test file: ${testFilePath}
@@ -3490,29 +4179,28 @@ ${fullSuiteOutput}
 YOUR TASK - Fix all failing tests:
 
 COMMON ISSUES TO FIX:
-- Missing jest.resetAllMocks() in beforeEach (should be first line)
-- Missing jest.restoreAllMocks() in global afterEach
 - Mock state bleeding between describe blocks
-- Module-level state issues (add jest.resetModules() if needed)
-- Shared variable contamination
-- beforeEach not resetting mocks properly
-- afterEach not cleaning up spies
+- 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 global afterEach
+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
+    const maxIterations = 500; // Limit iterations for test fixes
     while (iterations < maxIterations) {
         iterations++;
         console.log(`\n🔧 Test fix attempt ${iterations}/${maxIterations}...`);
@@ -3522,7 +4210,13 @@ START by calling get_file_preamble to see the current test structure.`
         }
         if (!response.toolCalls || response.toolCalls.length === 0) {
             // AI stopped - 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✅ Tests fixed! Full test suite now passes.');
                 return;
@@ -3609,7 +4303,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;
@@ -3619,7 +4319,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}
@@ -3632,7 +4332,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:
@@ -3643,35 +4343,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.`
         }
@@ -3689,7 +4381,13 @@ START by calling get_file_preamble to understand current file structure.`
         }
         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;
@@ -3697,7 +4395,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;
         }
@@ -3787,7 +4485,7 @@ 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
@@ -3795,12 +4493,22 @@ async function generateTestsForFunctions(sourceFile, functionNames) {
     // 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!`);
         }
@@ -3828,13 +4536,23 @@ async function generateTestsForFunctions(sourceFile, functionNames) {
 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}`);
     });
@@ -3870,6 +4588,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!');
 }
 /**
@@ -3997,7 +4720,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);
@@ -4029,16 +4752,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;
@@ -4047,25 +4779,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++;
@@ -4076,6 +4824,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}`);
@@ -4098,56 +4851,81 @@ async function autoGenerateTests() {
  * Review code changes for quality, bugs, performance, and security issues
  */
 async function reviewChangedFiles() {
-    console.log('🔍 Scanning git changes for review...\n');
+    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;
         }
-        console.log(`📝 Found changes in ${files.length} file(s) to review\n`);
-        let processedFiles = 0;
-        let errorFiles = 0;
-        // Process each changed file
+        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)) {
-                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🔄 Reviewing: ${filePath}`);
-            console.log(`  🤖 Analyzing changes with AI...`);
+            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) {
-                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(', ')}`);
-            try {
-                // Generate code review for the file
-                await generateCodeReview(filePath, diff, changedFunctions);
-                processedFiles++;
-                console.log(`   ✅ Review completed`);
-            }
-            catch (error) {
-                errorFiles++;
-                console.error(`   ❌ Error during review: ${error.message}`);
-                // Continue with next file
+            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(`✅ Successfully reviewed: ${processedFiles} file(s)`);
-        if (errorFiles > 0) {
-            console.log(`⚠️  Failed: ${errorFiles} file(s)`);
-        }
-        console.log(`📁 Reviews saved to: reviews/ directory`);
+        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!');
     }
@@ -4161,305 +4939,418 @@ async function reviewChangedFiles() {
     }
 }
 /**
- * Generate comprehensive code review for a specific file
+ * Build AI prompt for a specific review step based on its ruleset
  */
-async function generateCodeReview(filePath, diff, changedFunctions) {
-    // Prepare review file path
-    const fileName = path.basename(filePath);
-    const reviewFileName = fileName.replace(/\.(ts|tsx|js|jsx)$/, '.review.md');
-    const reviewFilePath = path.join('reviews', reviewFileName);
-    // Create comprehensive review prompt
-    const reviewPrompt = `You are a senior software engineer conducting a thorough code review. Review the changed functions in ${filePath} for code quality, potential bugs, performance issues, and security vulnerabilities.
+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
-File: ${filePath}
-Changed Functions: ${changedFunctions.join(', ')}
+Review Focus: ${step.name}
+Category: ${step.category}
+Total files changed: ${filesToReview.length}
+Total functions changed: ${totalFunctions}
+
+Changed files and functions:
+${filesContext}
+
+## GIT DIFFS
 
-## GIT DIFF
+${filesToReview.map(f => `### ${f.filePath}
 \`\`\`diff
-${diff}
+${f.diff}
 \`\`\`
+`).join('\n')}
 
 ## YOUR TASK
-Conduct a comprehensive code review using the available tools to understand the full context. You MUST use tools to analyze the code thoroughly before providing your review.
-
-## EXECUTION PLAN
-
-**Phase 1: Deep Code Analysis (MANDATORY)**
-1. analyze_file_ast(${filePath}) → Get file structure and all functions
-2. For each changed function (${changedFunctions.join(', ')}):
-   - get_function_ast(${filePath}, {functionName}) → Get implementation details
-3. get_imports_ast(${filePath}) → Understand dependencies
-4. get_type_definitions(${filePath}) → Review type safety
-5. For key dependencies, use find_file() and get_function_ast() to understand their behavior
-
-**Phase 2: Review Analysis**
-
-Analyze each changed function for:
-
-### 1. CODE QUALITY
-- Naming conventions (functions, variables, types)
-- Code complexity and readability
-- Code duplication
-- Best practices adherence
-- TypeScript/JavaScript patterns
-- Error handling completeness
-- Logging and debugging support
-
-### 2. POTENTIAL BUGS
-- Logic errors
-- Edge cases not handled (null, undefined, empty arrays, etc.)
-- Type mismatches
-- Async/await issues
-- Race conditions
-- Off-by-one errors
-- Incorrect conditionals
-
-### 3. PERFORMANCE ISSUES
-- Inefficient algorithms (O(n²) when O(n) possible)
-- Unnecessary iterations or computations
-- Memory leaks (closures, event listeners)
-- Missing caching opportunities
-- Inefficient data structures
-- Unnecessary re-renders (React)
-
-### 4. SECURITY VULNERABILITIES
-- Input validation missing
-- SQL injection risks
-- XSS vulnerabilities
-- Authentication/authorization issues
-- Sensitive data exposure
-- Insecure dependencies
-- Missing rate limiting
-
-## OUTPUT FORMAT
+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. 
 
-**Phase 3: Generate Review**
+## ANALYSIS STEPS
 
-Use the write_review tool to create a comprehensive markdown review file.
+**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?
 
-The review MUST include:
+  **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}.
 
-1. **Summary**: Brief overview of changes and overall assessment
-2. **Findings by Category**: Group findings by:
-   - 🔴 Critical (must fix immediately)
-   - 🟠 High (should fix soon)
-   - 🟡 Medium (consider fixing)
-   - 🟢 Low (nice to have)
+**Phase 3: Write Review**
 
-For each finding:
-- Category (Code Quality/Bugs/Performance/Security)
-- Severity (Critical/High/Medium/Low)
-- Location (function name, approximate line)
-- Issue description
-- Code snippet showing the problem
-- Recommended fix with code example
-- Rationale
+Use the write_review tool to save findings to: ${stepOutputPath}
 
-3. **Positive Aspects**: What was done well
-4. **Recommendations**: General suggestions for improvement
+## OUTPUT FORMAT
 
-## MARKDOWN TEMPLATE
+Your review MUST be in markdown format with the following structure:
 
 \`\`\`markdown
-# Code Review: {filename}
+# ${step.name}
 
-**Date**: {current_date}
-**Reviewer**: AI Code Review System
-**Changed Functions**: {list of functions}
-
----
-
-## Summary
-
-[Brief overview of changes and overall code quality assessment]
-
----
 
 ## Findings
 
 ### 🔴 Critical Issues
 
-#### [Category] - [Issue Title]
-**Severity**: Critical  
-**Function**: \`functionName\`  
-**Location**: Line ~XX
+#### [Issue Title]
+**File**: \`filePath\`
+**Function**: \`functionName\`
+**Severity**: Critical
 
 **Issue**:
-[Description of the problem]
+[Description]
 
 **Current Code**:
 \`\`\`typescript
-// problematic code snippet
+// problematic code
 \`\`\`
 
-**Recommended Fix**:
+**Recommended Code**:
 \`\`\`typescript
-// improved code snippet
+// improved code
 \`\`\`
 
 **Rationale**:
-[Why this is important and how the fix helps]
+[Why this is important]
 
 ---
 
 ### 🟠 High Priority Issues
-
 [Same format as above]
 
 ---
 
 ### 🟡 Medium Priority Issues
-
 [Same format as above]
 
 ---
 
-### 🟢 Low Priority Issues
+## Positive Aspects
+[What was done well in this area]
 
-[Same format as above]
+## Recommendations
+[Specific recommendations for ${step.name}]
+\`\`\`
 
----
+## CRITICAL REMINDERS
 
-## ✅ Positive Aspects
+- 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.
 
-- [What was done well]
-- [Good practices observed]
+**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}
 
 ---
 
-## 💡 General Recommendations
+## Summary
 
-1. [Recommendation 1]
-2. [Recommendation 2]
+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(', ')}.
 
 ---
 
-## Conclusion
+## Files Changed
 
-[Final thoughts and overall assessment]
-\`\`\`
+${filesToReview.map(f => `- **${f.filePath}**
+  - Functions: ${f.functions.join(', ')}`).join('\n')}
 
-## CRITICAL REMINDERS
+---
 
-- ALWAYS use tools to analyze code before reviewing
-- Be thorough but constructive
-- Provide specific, actionable feedback
-- Include code examples in your suggestions
-- Consider the context and project constraints
-- Focus on changed functions but consider their impact on the whole file
-- Use write_review tool to save your review to: ${reviewFilePath}
-
-**START**: Begin by calling analyze_file_ast(${filePath}) to understand the file structure.`;
-    const messages = [
-        {
-            role: 'user',
-            content: reviewPrompt
-        }
-    ];
-    let iterations = 0;
-    const maxIterations = 50;
-    let reviewWritten = false;
-    while (iterations < maxIterations) {
-        iterations++;
-        if (iterations === 1) {
-            console.log(`\n🤖 AI is analyzing code for review...`);
-        }
-        else if (iterations % 5 === 0) {
-            console.log(`\n🤖 AI is still working on review (step ${iterations})...`);
-        }
-        const response = await callAI(messages, TOOLS, CONFIG.aiProvider);
-        if (response.content) {
-            const content = response.content;
-            messages.push({ role: 'assistant', content });
-            // Check if review is complete
-            if (content.toLowerCase().includes('review complete') ||
-                content.toLowerCase().includes('review has been written')) {
-                if (reviewWritten) {
-                    console.log('\n✅ Code review complete!');
-                    break;
+`;
+    // 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`;
                 }
             }
-        }
-        if (!response.toolCalls || response.toolCalls.length === 0) {
-            if (reviewWritten) {
-                console.log('\n✅ Code review complete!');
-                break;
+            catch (error) {
+                mergedReview += `## ${result.stepName}\n\n⚠️ Error reading review: ${error.message}\n\n---\n\n`;
             }
-            console.log('\n⚠️  No tool calls. Prompting AI to continue...');
-            messages.push({
-                role: 'user',
-                content: `Please use the write_review tool NOW to save your code review to ${reviewFilePath}. Include all findings with severity levels, code examples, and recommendations.`
-            });
-            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;
-            }
+        else {
+            mergedReview += `## ${result.stepName}\n\n❌ **Review step failed**: ${result.error}\n\n---\n\n`;
         }
-        // Add tool calls and results to messages (format differs by provider)
-        if (CONFIG.aiProvider === 'openai') {
-            // OpenAI: First add assistant message with tool_calls, then add tool results
-            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)
-                });
+    }
+    // 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);
         }
-        else if (CONFIG.aiProvider === 'gemini') {
-            // Gemini: Add function calls and responses
-            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 }
-                });
-            }
+    }
+    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 {
-            // Claude: Add tool uses and results
-            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)
-                }))
-            });
+            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));
+            }
         }
     }
-    if (!reviewWritten) {
-        console.log('\n⚠️  Could not complete code review. Manual review may be needed.');
+    // 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');
@@ -4467,11 +5358,12 @@ async function main() {
     const args = process.argv.slice(2);
     const command = args[0]; // First argument is the command: 'auto', 'test', 'review', or undefined
     // Validate command if provided
-    if (command && !['auto', 'test', 'review'].includes(command)) {
+    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);
     }
@@ -4497,21 +5389,31 @@ async function main() {
         console.error('npm install @babel/parser @babel/traverse ts-node\n');
         process.exit(1);
     }
-    // If command mode (auto, test, review), skip indexing setup and proceed directly
-    if (command === 'auto' || command === 'test' || command === 'review') {
+    // 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' :
-                'Code Review 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') {
@@ -4528,6 +5430,11 @@ async function main() {
             // Only review changes
             await reviewChangedFiles();
         }
+        else if (command === 'doc') {
+            // Only generate documentation
+            console.log('Currently in development. Please try again later.');
+            // await generateDocumentationMode();
+        }
         return;
     }
     // Optional: Codebase Indexing
@@ -4543,16 +5450,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');
@@ -4615,13 +5524,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}`);
             });
@@ -4632,6 +5551,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;
     }