codeguard-testgen 1.0.8 → 1.0.10

package/dist/index.js

@@ -33,6 +33,7 @@ exports.insertAtPosition = insertAtPosition;
 exports.deleteLines = deleteLines;
 exports.insertLines = insertLines;
 exports.replaceLines = replaceLines;
+exports.writeReview = writeReview;
 const fs = require("fs/promises");
 const fsSync = require("fs");
 const path = require("path");
@@ -52,6 +53,8 @@ const fuzzyMatcher_1 = require("./fuzzyMatcher");
 let CONFIG;
 // Global indexer instance (optional - only initialized if user chooses to index)
 let globalIndexer = null;
+// Global variable to track expected test file path (to prevent AI from creating per-function files)
+let EXPECTED_TEST_FILE_PATH = null;
 // AI Provider configurations - models will be set from CONFIG
 function getAIProviders() {
     return {
@@ -397,8 +400,28 @@ const TOOLS = [
             required: ['file_path', 'content']
         }
     },
+    {
+        name: 'write_review',
+        description: 'Write code review findings to a markdown file in the reviews/ directory. Use this to output your comprehensive code review.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                file_path: {
+                    type: 'string',
+                    description: 'The path to the review file (e.g., "reviews/index.review.md"). Should be in reviews/ directory with .review.md extension.'
+                },
+                review_content: {
+                    type: 'string',
+                    description: 'The complete markdown content of the code review including summary, findings by category (Code Quality, Bugs, Performance, Security), severity levels, and recommendations.'
+                }
+            },
+            required: ['file_path', 'review_content']
+        }
+    },
 ];
 exports.TOOLS = TOOLS;
+// Filtered tools for test generation (excludes write_review)
+const TOOLS_FOR_TEST_GENERATION = TOOLS.filter(tool => tool.name !== 'write_review');
 // AST Parsing utilities
 function parseFileToAST(filePath, content) {
     const ext = path.extname(filePath);
@@ -1903,7 +1926,8 @@ function runTests(testFilePath, functionNames) {
         }
         const output = (0, child_process_1.execSync)(command, {
             encoding: 'utf-8',
-            stdio: 'pipe'
+            stdio: 'pipe',
+            timeout: 10000
         });
         console.log(`   Test run output: ${output}`);
         return {
@@ -1914,8 +1938,43 @@ function runTests(testFilePath, functionNames) {
         };
     }
     catch (error) {
-        console.log(`   Test run error: ${error.message}`);
-        console.log(`output sent to ai: ${error.stdout + error.stderr}`);
+        // console.log(`   Test run error: ${error.message}`);
+        // console.log(`output sent to ai: ${error.stdout + error.stderr}`);
+        return {
+            success: false,
+            output: error.stdout + error.stderr,
+            passed: false,
+            error: error.message
+        };
+    }
+}
+/**
+ * Run specific tests in isolation to detect if failure is due to pollution or regression
+ * Used by smartValidateTestSuite to differentiate between test infrastructure issues and source code bugs
+ */
+function runTestsIsolated(testFilePath, specificTestNames) {
+    try {
+        // Build Jest command with specific test name filter
+        let command = `npx jest ${testFilePath} --no-coverage --verbose=false`;
+        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}"`;
+        }
+        const output = (0, child_process_1.execSync)(command, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            timeout: 10000
+        });
+        return {
+            success: true,
+            output,
+            passed: true,
+            command
+        };
+    }
+    catch (error) {
         return {
             success: false,
             output: error.stdout + error.stderr,
@@ -1924,6 +1983,43 @@ function runTests(testFilePath, functionNames) {
         };
     }
 }
+/**
+ * Parse Jest output to extract names of failing tests
+ * Returns array of test names that failed
+ */
+function parseFailingTestNames(jestOutput) {
+    const failingTests = [];
+    // Jest output patterns for failing tests:
+    // ● describe block › test name
+    // or: FAIL path/to/test.ts
+    //     ✕ test name (XXms)
+    const lines = jestOutput.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Pattern 1: ● describe block › test name
+        const bulletMatch = line.match(/^\s*●\s+(.+?)\s+›\s+(.+?)$/);
+        if (bulletMatch) {
+            const testName = bulletMatch[2].trim();
+            failingTests.push(testName);
+            continue;
+        }
+        // Pattern 2: ✕ test name
+        const xMatch = line.match(/^\s*✕\s+(.+?)(?:\s+\(\d+m?s\))?$/);
+        if (xMatch) {
+            const testName = xMatch[1].trim();
+            failingTests.push(testName);
+            continue;
+        }
+        // Pattern 3: FAIL in summary
+        const failMatch = line.match(/^\s*✓?\s*(.+?)\s+\(\d+m?s\)$/);
+        if (failMatch && line.includes('✕')) {
+            const testName = failMatch[1].trim();
+            failingTests.push(testName);
+        }
+    }
+    // Remove duplicates
+    return [...new Set(failingTests)];
+}
 function listDirectory(directoryPath) {
     try {
         if (!fsSync.existsSync(directoryPath)) {
@@ -2372,6 +2468,31 @@ async function insertAtPosition(filePath, content, position, afterMarker) {
         return { success: false, error: error.message };
     }
 }
+/**
+ * Write code review findings to a markdown file in the reviews/ directory
+ */
+async function writeReview(filePath, reviewContent) {
+    try {
+        // Ensure the reviews directory exists
+        const reviewsDir = path.dirname(filePath);
+        if (!fsSync.existsSync(reviewsDir)) {
+            await fs.mkdir(reviewsDir, { recursive: true });
+        }
+        // Write the review file
+        await fs.writeFile(filePath, reviewContent, 'utf-8');
+        return {
+            success: true,
+            message: `Review written to ${filePath}`,
+            filePath: filePath
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to write review: ${error.message}`
+        };
+    }
+}
 // User-friendly messages for each tool
 const TOOL_MESSAGES = {
     'read_file': '📖 Reading source file',
@@ -2391,6 +2512,7 @@ const TOOL_MESSAGES = {
     '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',
 };
 // Tool execution router
 async function executeTool(toolName, args) {
@@ -2471,6 +2593,20 @@ async function executeTool(toolName, args) {
                 result = resolveImportPath(args.from_file, args.import_path);
                 break;
             case 'upsert_function_tests':
+                // CRITICAL VALIDATION: Prevent AI from creating per-function test files
+                if (EXPECTED_TEST_FILE_PATH && args.test_file_path !== EXPECTED_TEST_FILE_PATH) {
+                    // Normalize paths for comparison (handle different path separators)
+                    const normalizedExpected = path.normalize(EXPECTED_TEST_FILE_PATH).replace(/\\/g, '/');
+                    const normalizedProvided = path.normalize(args.test_file_path).replace(/\\/g, '/');
+                    if (normalizedExpected !== normalizedProvided) {
+                        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`);
+                        // Override the test file path to the expected one
+                        args.test_file_path = EXPECTED_TEST_FILE_PATH;
+                    }
+                }
                 result = await replaceFunctionTests(args.test_file_path, args.function_name, args.new_test_content);
                 break;
             case 'run_tests':
@@ -2494,6 +2630,9 @@ async function executeTool(toolName, args) {
             case 'insert_at_position':
                 result = await insertAtPosition(args.file_path, args.content, args.position, args.after_marker);
                 break;
+            case 'write_review':
+                result = await writeReview(args.file_path, args.review_content);
+                break;
             default:
                 result = { success: false, error: `Unknown tool: ${toolName}` };
         }
@@ -2750,857 +2889,270 @@ async function callAI(messages, tools, provider = CONFIG.aiProvider) {
 // Main conversation loop
 async function generateTests(sourceFile) {
     console.log(`\n📝 Generating tests for: ${sourceFile}\n`);
-    // Check file size and switch to function-by-function generation if large
-    try {
-        const fileContent = fsSync.readFileSync(sourceFile, 'utf-8');
-        const lineCount = fileContent.split('\n').length;
-        console.log(`📊 Source file has ${lineCount} lines`);
-        if (lineCount > 200) {
-            console.log(`\n⚡ File has more than 200 lines! Switching to function-by-function generation...\n`);
-            // Analyze file to get all functions
-            const result = analyzeFileAST(sourceFile);
-            if (result && result.success && result.analysis && result.analysis.functions && result.analysis.functions.length > 0) {
-                // Filter to only EXPORTED functions (public API)
-                const exportedFunctions = result.analysis.functions.filter((f) => f.exported);
-                const functionNames = exportedFunctions.map((f) => f.name).filter((name) => name);
-                if (functionNames.length === 0) {
-                    console.log('⚠️  No exported functions found in file. Falling back to regular generation.');
-                    // Fall through to regular generation
-                }
-                else {
-                    const totalFunctions = result.analysis.functions.length;
-                    const internalFunctions = totalFunctions - exportedFunctions.length;
-                    console.log(`✅ Found ${functionNames.length} exported function(s): ${functionNames.join(', ')}`);
-                    if (internalFunctions > 0) {
-                        console.log(`   (Skipping ${internalFunctions} internal/helper function(s) - only testing public API)`);
-                    }
-                    // Use function-by-function generation
-                    try {
-                        return await generateTestsForFunctions(sourceFile, functionNames);
-                    }
-                    catch (funcError) {
-                        // CRITICAL: Check if test file already exists with content
-                        const testFilePath = getTestFilePath(sourceFile);
-                        if (fsSync.existsSync(testFilePath)) {
-                            const existingContent = fsSync.readFileSync(testFilePath, 'utf-8');
-                            const hasExistingTests = existingContent.includes('describe(') || existingContent.includes('test(');
-                            if (hasExistingTests) {
-                                console.error('\n❌ CRITICAL: Function-by-function generation failed, but test file already has tests!');
-                                console.error('   Cannot fall back to file-wise generation as it would OVERWRITE existing tests.');
-                                console.error(`   Error: ${funcError.message}`);
-                                console.error('\n   Options:');
-                                console.error('   1. Fix the issue manually in the test file');
-                                console.error('   2. Delete the test file and regenerate from scratch');
-                                console.error('   3. Run function-wise generation again for remaining functions');
-                                throw new Error(`Function-by-function generation failed with existing tests. Manual intervention required. Original error: ${funcError.message}`);
-                            }
-                        }
-                        // No existing tests, safe to fall back
-                        console.log('⚠️  Function-by-function generation failed, but no existing tests found. Falling back to file-wise generation.');
-                        throw funcError; // Re-throw to be caught by outer try-catch
-                    }
-                }
-            }
-            else {
-                console.log('⚠️  No functions found in file. Falling back to regular generation.');
-                if (result && !result.success) {
-                    console.log(`   Analysis error: ${result.error}`);
-                }
-            }
+    // Analyze file to get all functions (with retry)
+    let result = analyzeFileAST(sourceFile);
+    // Retry once if failed
+    if (!result.success) {
+        console.log('⚠️  AST analysis failed, retrying once...');
+        result = analyzeFileAST(sourceFile);
+    }
+    // If still failed, throw error
+    if (!result.success || !result.analysis || !result.analysis.functions) {
+        throw new Error(`File analysis failed. Unable to extract functions from file. Error: ${result.error || 'unknown'}`);
+    }
+    // Filter to only EXPORTED functions
+    const exportedFunctions = result.analysis.functions.filter((f) => f.exported);
+    const functionNames = exportedFunctions.map((f) => f.name).filter((name) => name);
+    // Error if no exported functions
+    if (functionNames.length === 0) {
+        throw new Error('No exported functions found in file. Cannot generate tests.');
+    }
+    // Log what we found
+    const totalFunctions = result.analysis.functions.length;
+    const internalFunctions = totalFunctions - exportedFunctions.length;
+    console.log(`✅ Found ${functionNames.length} exported function(s): ${functionNames.join(', ')}`);
+    if (internalFunctions > 0) {
+        console.log(`   (Skipping ${internalFunctions} internal/helper function(s) - only testing public API)`);
+    }
+    // Always use function-by-function generation
+    return await generateTestsForFunctions(sourceFile, functionNames);
+}
+// Interactive CLI
+async function promptUser(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise(resolve => {
+        rl.question(question, answer => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+// Get all directories recursively
+async function listDirectories(dir, dirList = []) {
+    const items = await fs.readdir(dir);
+    for (const item of items) {
+        const itemPath = path.join(dir, item);
+        const stat = await fs.stat(itemPath);
+        if (stat.isDirectory() && !CONFIG.excludeDirs.includes(item)) {
+            dirList.push(itemPath);
+            await listDirectories(itemPath, dirList);
         }
     }
-    catch (error) {
-        // Check if this is the "existing tests" protection error
-        if (error.message && error.message.includes('Manual intervention required')) {
-            // This is a critical error - don't proceed with generation
-            console.error(`\n❌ Aborting: ${error.message}`);
-            throw error; // Re-throw to stop execution
+    return dirList;
+}
+// Folder-wise test generation
+async function generateTestsForFolder() {
+    console.log('\n📂 Folder-wise Test Generation\n');
+    // Get all directories
+    const directories = await listDirectories('.');
+    if (directories.length === 0) {
+        console.log('No directories found!');
+        return;
+    }
+    console.log('Select a folder to generate tests for all files:\n');
+    directories.forEach((dir, index) => {
+        console.log(`${index + 1}. ${dir}`);
+    });
+    const choice = await promptUser('\nEnter folder number: ');
+    const selectedDir = directories[parseInt(choice) - 1];
+    if (!selectedDir) {
+        console.log('Invalid selection!');
+        return;
+    }
+    // Get all files in the selected directory (recursive)
+    const files = await listFilesRecursive(selectedDir);
+    if (files.length === 0) {
+        console.log(`No source files found in ${selectedDir}!`);
+        return;
+    }
+    console.log(`\n📝 Found ${files.length} files to process in ${selectedDir}\n`);
+    // Process each file
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const testFilePath = getTestFilePath(file);
+        console.log(`\n[${i + 1}/${files.length}] Processing: ${file}`);
+        // Check if test file already exists
+        if (fsSync.existsSync(testFilePath)) {
+            const answer = await promptUser(`  Test file already exists: ${testFilePath}\n  Regenerate? (y/n): `);
+            if (answer.toLowerCase() !== 'y') {
+                console.log('  Skipped.');
+                continue;
+            }
+        }
+        try {
+            await generateTests(file);
+            console.log(`  ✅ Completed: ${testFilePath}`);
+        }
+        catch (error) {
+            console.error(`  ❌ Failed: ${error.message}`);
         }
-        console.log(`⚠️  Could not check file size: ${error}. Proceeding with regular generation.`);
-        // Falls through to regular file-wise generation below
     }
-    const testFilePath = getTestFilePath(sourceFile);
+    console.log(`\n✨ Folder processing complete! Processed ${files.length} files.`);
+}
+// Function-wise test generation
+/**
+ * Generate tests for a single function
+ * @returns true if tests passed, false if legitimate failure reported
+ */
+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 a senior software engineer tasked with writing comprehensive Jest unit tests including edge cases for a TypeScript file.
+            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.
 
-Source file: ${sourceFile}
-Test file path: ${testFilePath}
+## CONTEXT
+Test file: ${testFilePath} | Exists: ${testFileExists}
 
-IMPORTANT: You MUST use the provided tools to complete this task. Do not just respond with text.
+⚠️  CRITICAL: You MUST use this EXACT test file path: ${testFilePath}
 
-Your task (you MUST complete ALL steps):
-1. FIRST: Use analyze_file_ast tool to get a complete AST analysis of the source file (functions, classes, types, exports)
-   - This provides metadata about all code structures without loading full file content
-   - CRITICAL: You have only 50 iterations to complete this task, so make sure you are using the tools efficiently.
-   - Do not over explore, use the tools to get the information you need and start generating tests.
-2. Use get_imports_ast tool to understand all dependencies
-3. For each dependency, use find_file(filePath) to locate the file and calculate_relative_path to get correct import paths for the test file
-4. For complex functions, use get_function_ast tool to get detailed information
-   - Returns complete function code WITH JSDoc comments
-   - Includes calledFunctions and calledMethods lists showing what the function calls
-   - Use this to fetch related helper functions if needed
-   - [CRITICAL]: If a function calls other functions from other files, use find_file + get_function_ast tools to locate them and check if they need to mocked, since they can be making api calls to external services.
-5. Use get_function_ast to get detailed information about the functions.
-6. For large test files (>5K lines), use get_file_preamble to see existing imports/mocks/setup blocks
-   - Automatically included when reading large test files
-   - Use before adding new test cases to avoid duplicate mocks/imports
-   - Particularly useful when updating existing test files with upsert_function_tests
-   - Captures complete multi-line mocks including complex jest.mock() statements
-7. For classes, use get_class_methods tool to extract all methods
-8. Use get_type_definitions tool to understand TypeScript types and interfaces
-9. Generate comprehensive Jest unit tests with:
-   - CRITICAL: Mock ALL imports BEFORE importing the source file to prevent initialization errors. Ensure tests fully mock the config module with all expected properties.
-   - If required: 
-    - Mock database modules like '../database' or '../database/index' with virtual:true.
-    - Mock models, and any modules that access config or the database with virtual:true.
-    - Mock config properly with virtual:true.
-    - Mock isEmpty from lodash to return the expected values with virtual:true.
-    - Axios should be mocked with virtual:true.
-    - Use jest.mock() calls at the TOP of the file before any imports
-    - [CRITICAL]: Virtual modules should only be used for db/config/models/services/index/axios/routes files. You should not use virtual:true for any other files or helpers that exist in the source code. The actual helpers should never be mocked with virtual:true.
-9. REQUIRED: Write tests using upsert_function_tests tool for EACH function with REAL test code (NOT placeholders!)
-   - Call upsert_function_tests once for EACH exported function
-   - Ensure comprehensive mocks are included in the first function's test to set up the file
-   - DO NOT use ANY placeholder comments like:
-     * "// Mock setup", "// Assertions", "// Call function"  
-     * "// Further tests...", "// Additional tests..."  
-     * "// Similarly, write tests for..."
-     * "// Add more tests...", "// TODO", "// ..."
-   - Write ACTUAL working test code with real mocks, real assertions, real function calls
-   - Every test MUST have [MANDATORY]:
-     * Real setup code (mock functions, create test data)
-     * Real execution (call the function being tested)
-     * Real expect() assertions (at least one per test)
-     * null/undefined handling tests for all API responses
-     * Happy path scenarios
-     * Edge cases (null, undefined, empty arrays, etc.)
-     * Error conditions
-     * Async behavior (if applicable)
-   - Proper TypeScript types
-   - Write tests for EVERY exported function (minimum 3-5 tests per function)
-   - If source has 4 functions, test file MUST have 4 describe blocks with actual tests
-   - Example of COMPLETE test structure:
-     * Setup: Create mocks and test data
-     * Execute: Call the function being tested  
-     * Assert: Use expect() to verify results
-10. REQUIRED: Run the tests using run_tests tool
-11. REQUIRED: If tests fail with import errors:
-    - Use find_file(filePath) tool to locate the file and calculate_relative_path to get correct import paths for the test file
-    - Use calculate_relative_path tool to get correct import path
-    - ✅ PRIMARY METHOD: Use search_replace_block to fix imports:
-      * Include 3-5 lines of context around the import to change
-      * Example: search_replace_block({
-          search: "import { oldImport } from './old-path';\nimport { other } from './other';",
-          replace: "import { oldImport, newImport } from './correct-path';\nimport { other } from './other';"
-        })
-    - 📌 ALTERNATIVE: Use insert_at_position for adding new imports:
-      * insert_at_position({ position: 'after_imports', content: "import { newImport } from './path';" })
-    - ⚠️ AVOID: Line-based tools (deprecated, fragile)
-12. REQUIRED: If tests fail with other errors, analyze if they are FIXABLE or LEGITIMATE:
-    
-    FIXABLE ERRORS (you should fix these):
-    - Wrong import paths
-    - Missing mocks
-    - Incorrect mock implementations
-    - Wrong assertions or test logic
-    - TypeScript compilation errors (syntax errors, bracket mismatches)
-    - Missing test setup/teardown
-    - Cannot read properties of undefined
-    - Test case failed to run. Use read_file_lines tool to read the specific problematic section and fix the issue.
-    
-    💡 TIP: For syntax errors or bracket mismatches:
-    - Use read_file to see the file content (it includes line numbers)
-    - Use search_replace_block to fix the problematic section
-    - Include 3-5 lines of context around the error to make search unique
-    - Example: search_replace_block({
-        search: "line before error\nproblematic code with syntax error\nline after",
-        replace: "line before error\ncorrected code\nline after"
-      })
-    
-    LEGITIMATE FAILURES (source code bugs - DO NOT try to fix):
-    - Function returns wrong type (e.g., undefined instead of object)
-    - Missing null/undefined checks in source code
-    - Logic errors in source code
-    - Unhandled promise rejections in source code
-    
-13. If errors are FIXABLE (AFTER test file is written): 
-    - ✅ PRIMARY METHOD: Use search_replace_block (RECOMMENDED):
-      * Find the problematic code section
-      * Include 3-5 lines of context before/after to make search unique
-      * Replace with corrected version
-      * Example: search_replace_block({
-          file_path: "test.ts",
-          search: "const mock = jest.fn();\ntest('old test', () => {\n  mock();",
-          replace: "const mock = jest.fn().mockResolvedValue({ data: 'test' });\ntest('fixed test', () => {\n  mock();"
-        })
-      * Handles whitespace/indentation differences automatically!
-    - 📌 ALTERNATIVE: Use insert_at_position for adding mocks/imports at top:
-      * insert_at_position({ position: 'after_imports', content: "jest.mock('../database');" })
-    - ⚠️ AVOID: Line-based tools (deprecated) - they are fragile and prone to errors
-    - Then retry running tests
-14. If errors are LEGITIMATE: Call report_legitimate_failure tool with details and STOP trying to fix
-    - Provide failing test names, reason, and source code issue description
-    - The test file will be kept as-is with legitimate failing tests
-    - You are not allowed to call this tool for error - Test suite failed to run. You must ensure that test cases get executed. Fix any syntax or linting issues in the test file.
-15. REQUIRED: Repeat steps 10-14 until tests pass OR legitimate failures are reported
-16. REQUIRED: Ensure all functions are tested in the test file.
-17. CRITICAL: config and database modules must be mocked
+---
 
-18. Some known issues when running tests with fixes:
-  Route loading issue: Importing the controller triggered route setup because axios-helper imports from index.ts, which loads all routes. Routes referenced functions that weren't available during test initialization.
-   - Solution: Mocked index.ts to export only whitelistDomainsForHeaders without executing route setup code.
-  Axios mock missing required properties: The axios mock didn't include properties needed by axios-retry (like interceptors).
-   - Solution: Created a createMockAxiosInstance function that returns a mock axios instance with interceptors, defaults, and HTTP methods.
-  axios-retry not mocked: axios-retry was trying to modify axios instances during module initialization.
-   - Solution: Added a mock for axios-retry to prevent it from executing during tests.
-  Routes file execution: The routes file was being executed when the controller was imported.
-   - Solution: Mocked the routes file to return a simple Express router without executing route definitions.
+## EXECUTION PLAN
 
-CRITICAL: Distinguish between test bugs (fix them) and source code bugs (report and stop)!
+**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
+\\\`\\\`\\\`
 
-19. [ALWAYS FOLLOW] Write Jest test cases following these MANDATORY patterns to prevent mock pollution:
+**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.
 
-SECTION 1: Top-Level Mock Setup
-Declare ALL jest.mock() calls at the top of the file, outside any describe blocks
-Mock EVERY function and module the controller/function uses
-Load the controller/module under test ONCE in beforeAll()
-[MANDATORY] Always use calculate_relative_path tool to get the correct import path for the module to be used in jest.mock() calls.
+**Phase 2: Test Generation**
 
-SECTION 2: Module References in Describe Blocks (CRITICAL)
-Declare ALL module references as let variables at the top of each describe block
-NEVER use const for module requires inside describe blocks
-Re-assign these modules inside beforeEach AFTER jest.clearAllMocks()
-This ensures each test gets fresh module references with clean mocks
+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 }); 
 
-SECTION 3: BeforeEach Pattern (MANDATORY)
-Pattern Structure:
+ // virtual:true ONLY for config, db, models, routes, services, axios, newrelic, GOOGLE_CLOUD_STORAGE, winston, logger, etc.
 
-Declare let variables for all modules at top of describe block
-Load controller once in beforeAll
-In beforeEach: clear mocks first, then re-assign all modules, then reset all mock implementations
-In afterEach: restore all mocks for extra safety
-In individual tests: only override specific mocks needed for that test
+jest.mock('../helpers/dependency'); // NO virtual:true for regular modules
 
-Example Pattern:
+// ===== IMPORTS =====
+import { functionName } from '../controller';
+import { dependencyMethod } from '../helpers/dependency';
 
-Declare: let controller, let helperModule, let responseHelper, let otherDependency
-beforeAll: controller = require path to controller
-beforeEach step 1: jest.clearAllMocks()
-beforeEach step 2: Re-assign all modules with require statements
-beforeEach step 3: Set default mock implementations for all mocked functions
-afterEach: jest.restoreAllMocks()
-In tests: Override only what changes for that specific test case
+// ===== TYPED MOCKS =====
+const mockDependencyMethod = dependencyMethod as jest.MockedFunction<typeof dependencyMethod>;
 
-SECTION 4: What to NEVER Do
+\\\`\\\`\\\`
 
-Never use const for module requires inside describe blocks
-Never rely on top-level module requires for mocking within tests
-Never share module references across multiple describe blocks
-Never skip re-assigning modules in beforeEach
-Never mutate module exports directly, always use mockImplementation instead
-Never forget to clear mocks before getting fresh references
+Requirements (5+ tests minimum):
+- ✅ Happy path
+- 🔸 Edge cases (null, undefined, empty)
+- ❌ Error conditions  
+- ⏱️ Async behavior
+- 🔍 API null/undefined handling
 
-SECTION 5: Key Principles
+/**
+ * Phase 3: Anti-Pollution Pattern (MANDATORY)
+ */
 
-Isolation: Each test has its own mock instances via fresh requires
-Cleanup: Always clear and restore mocks between tests
-Explicit: Make all dependencies explicit in beforeEach
-Fresh References: Re-require modules after clearing to get clean mocks
-Default Behaviors: Set up sensible defaults in beforeEach, override in individual tests
+\\\`\\\`\\\`typescript
+// ===== GLOBAL CLEANUP (Near top, outside describe blocks) =====
+afterEach(() => {
+  jest.restoreAllMocks(); // Automatically restores ALL spies
+});
 
-SECTION 6: Verification Steps
+// ===== TESTS =====
+describe('functionName', () => {
+  beforeEach(() => {
+    jest.resetAllMocks(); // Resets ALL mocks (call history + implementations)
+    
+    // Set fresh defaults for THIS describe block only
+    mockDep1.mockResolvedValue({ status: 'success' });
+    mockDep2.mockReturnValue(true);
+  });
 
-Run tests multiple times with runInBand flag
-Run tests in random order with randomize flag
-Tests should pass consistently regardless of execution order
-Each test should be completely independent
+  test('happy path', async () => {
+    mockDep1.mockResolvedValueOnce({ id: 123 }); // Override for this test only
+    
+    const result = await functionName();
+    
+    expect(result).toEqual({ id: 123 });
+    expect(mockDep1).toHaveBeenCalledWith(expect.objectContaining({ param: 'value' }));
+  });
 
-SECTION 7: Critical Reminders
+  test('error case', async () => {
+    mockDep1.mockRejectedValueOnce(new Error('fail'));
+    await expect(functionName()).rejects.toThrow('fail');
+  });
+});
 
-Always add missing mock initializations in relevant beforeEach blocks
-Ensure all mocked functions have default behaviors set in beforeEach
-Re-require modules after jest.clearAllMocks() to get fresh mock references
-Use let not const for all module references inside describe blocks
-Load the actual controller or module under test only once in beforeAll
+// ===== INTERNAL SPIES (When testing same-file function calls) =====
+describe('functionWithInternalCalls', () => {
+  let internalFnSpy: jest.SpyInstance;
 
-Apply these patterns to ALL test files to ensure zero mock pollution between test suites and individual test cases.
-
-START NOW by calling the analyze_file_ast tool with the source file path.`
-        }
-    ];
-    let iterations = 0;
-    const maxIterations = 100;
-    let testFileWritten = false;
-    let allToolResults = [];
-    let legitimateFailureReported = false;
-    let lastTestError = '';
-    let sameErrorCount = 0;
-    while (iterations < maxIterations) {
-        iterations++;
-        if (iterations === 1) {
-            console.log(`\n🤖 AI is analyzing your code...`);
-        }
-        else if (iterations % 5 === 0) {
-            console.log(`\n🤖 AI is still working (step ${iterations})...`);
-        }
-        const response = await callAI(messages, TOOLS);
-        if (response.content) {
-            const content = response.content; // Store for TypeScript
-            // Only show AI message if it's making excuses (for debugging), otherwise skip
-            // Detect if AI is making excuses instead of using tools
-            const excusePatterns = [
-                /unable to proceed/i,
-                /cannot directly/i,
-                /constrained by/i,
-                /simulated environment/i,
-                /limited to providing/i,
-                /beyond my capabilities/i,
-                /can't execute/i
-            ];
-            const isMakingExcuses = excusePatterns.some(pattern => pattern.test(content));
-            if (isMakingExcuses) {
-                console.log('\n⚠️  AI is making excuses! Forcing it to use tools...');
-                // Don't add the excuse to conversation, override with command
-                messages.push({
-                    role: 'user',
-                    content: 'STOP making excuses! You CAN use the tools. Use search_replace_block or insert_at_position NOW to fix the test file. Add proper mocks to prevent database initialization errors.'
-                });
-                continue;
-            }
-            messages.push({ role: 'assistant', content });
-        }
-        if (!response.toolCalls || response.toolCalls.length === 0) {
-            // Don't stop unless tests actually passed or legitimate failure reported
-            const lastTestRun = allToolResults[allToolResults.length - 1];
-            const testsActuallyPassed = lastTestRun?.name === 'run_tests' && lastTestRun?.result?.passed;
-            if (legitimateFailureReported) {
-                console.log('\n✅ Test generation complete (with legitimate failures reported)');
-                break;
-            }
-            if (testFileWritten && testsActuallyPassed) {
-                console.log('\n✅ Test generation complete!');
-                break;
-            }
-            // If no tools called, prompt to continue with specific action
-            console.log('\n⚠️  No tool calls. Prompting AI to continue...');
-            if (!testFileWritten) {
-                messages.push({
-                    role: 'user',
-                    content: 'You have not written the test file yet. Use upsert_function_tests tool NOW with complete test code (not placeholders) for each function.'
-                });
-            }
-            else {
-                messages.push({
-                    role: 'user',
-                    content: `STOP talking and USE TOOLS! 
-
-If tests are failing:
-- FIXABLE errors (imports, mocks, assertions): 
-  ✅ PRIMARY: Use search_replace_block with context (handles whitespace automatically!)
-  📌 ALTERNATIVE: Use insert_at_position for adding imports/mocks
-  ⚠️ AVOID: Line-based tools (deprecated, fragile)
-  run_tests tool to run the tests and check if the tests pass.
-- LEGITIMATE failures (source code bugs): Call report_legitimate_failure tool
-
-Example: search_replace_block({ search: "old code with context...", replace: "new fixed code..." })`
-                });
-            }
-            continue;
-        }
-        // Execute all tool calls
-        const toolResults = [];
-        for (const toolCall of response.toolCalls) {
-            const result = await executeTool(toolCall.name, toolCall.input);
-            const toolResult = {
-                id: toolCall.id,
-                name: toolCall.name,
-                result
-            };
-            toolResults.push(toolResult);
-            allToolResults.push(toolResult);
-            // Track if legitimate failure was reported
-            if (toolCall.name === 'report_legitimate_failure' && result.success) {
-                legitimateFailureReported = true;
-                console.log('\n✅ Legitimate failure acknowledged. Stopping test fixes.');
-                console.log(`   Recommendation: ${result.recommendation}`);
-            }
-            // Track if test file was written
-            if (toolCall.name === 'upsert_function_tests') {
-                if (result.success) {
-                    testFileWritten = true;
-                    console.log(`\n📝 Test file ${result.replaced ? 'updated' : 'written'}: ${testFilePath}`);
-                }
-            }
-            // Detect syntax errors from validation
-            if (result.syntaxError && result.location) {
-                console.log(`\n❌ Syntax error introduced at line ${result.location.line}!`);
-                messages.push({
-                    role: 'user',
-                    content: `🚨 SYNTAX ERROR DETECTED at line ${result.location.line}:${result.location.column}
-
-${result.error}
-
-💡 ${result.suggestion}
-
-Your last modification created invalid syntax and was ROLLED BACK automatically.
-
-To fix this:
-1. Use read_file to see the current file content (includes line numbers)
-2. Find the section you need to modify around line ${result.location.line}
-3. Use search_replace_block with correct syntax:
-   - Include 3-5 lines of context around the target
-   - Ensure your replacement has valid syntax (matching brackets, quotes, etc.)
-   - Double-check for missing semicolons, commas, or closing brackets
-
-Example:
-search_replace_block({
-  file_path: "${toolCall.input.file_path || toolCall.input.test_file_path || 'test file'}",
-  search: "valid context from file\nline with issue\nmore context",
-  replace: "valid context from file\nCORRECTED line with proper syntax\nmore context"
-})
-
-Start NOW by reading the file around line ${result.location.line}!`
-                });
-            }
-            // Detect repeated errors (suggests legitimate failure)
-            if (toolCall.name === 'run_tests' && !result.success) {
-                const errorOutput = result.output || result.error || '';
-                const currentError = errorOutput.substring(0, 300); // First 300 chars as signature
-                if (currentError === lastTestError) {
-                    sameErrorCount++;
-                    console.log(`\n⚠️  Same error repeated ${sameErrorCount} times`);
-                    if (sameErrorCount >= 3) {
-                        console.log('\n🚨 Same error repeated 3+ times! ');
-                        messages.push({
-                            role: 'user',
-                            content: `The same test error has occurred ${sameErrorCount} times in a row!
-
-
-Analyze the error and determine:
-1. Is this a FIXABLE test issue (wrong mocks, imports, assertions)?
-2. Use available tools file read_file_lines to read the current state of file.
-2. Or is this a LEGITIMATE source code bug?
-
-If LEGITIMATE: Call report_legitimate_failure tool NOW with details.
-If FIXABLE: Make one more attempt to fix it.`
-                        });
-                    }
-                }
-                else {
-                    lastTestError = currentError;
-                    sameErrorCount = 1;
-                }
-            }
-            // Detect import path errors
-            if (toolCall.name === 'run_tests' && !result.success) {
-                const errorOutput = result.output || result.error || '';
-                // Check for module not found errors
-                const moduleNotFoundMatch = errorOutput.match(/Cannot find module ['"]([^'"]+)['"]/);
-                const tsModuleErrorMatch = errorOutput.match(/TS2307.*Cannot find module ['"]([^'"]+)['"]/);
-                if (moduleNotFoundMatch || tsModuleErrorMatch) {
-                    const missingModule = moduleNotFoundMatch?.[1] || tsModuleErrorMatch?.[1];
-                    console.log(`\n🔍 Import error detected: Cannot find module "${missingModule}"`);
-                    // Extract filename from the path
-                    const filename = missingModule?.split('/').pop();
-                    messages.push({
-                        role: 'user',
-                        content: `Import path error detected! Module not found: "${missingModule}"
-
-✅ FIX WITH SEARCH-REPLACE:
-
-Step 1: find_file tool to search for "${filename}" in the repository
-Step 2: calculate_relative_path tool to get correct import path  
-Step 3: Fix using search_replace_block:
-   a) Include the broken import line + 2-3 surrounding lines for context
-   b) Replace with corrected import using the right path
-   c) The tool handles whitespace/indentation automatically!
-
-Example workflow:
-1. find_file({ filename: "${filename}.ts" })
-2. calculate_relative_path({ from_file: "${testFilePath}", to_file: (found path) })
-3. search_replace_block({
-     file_path: "${testFilePath}",
-     search: "import { something } from './other';\nimport { broken } from '${missingModule}';\nimport { another } from './path';",
-     replace: "import { something } from './other';\nimport { fixed } from './correct-path';\nimport { another } from './path';"
-   })
-
-Start NOW with find_file!`
-                    });
-                }
-                // Check for database initialization errors
-                const isDatabaseError = /Cannot read properties of undefined.*reading|database|config|SSL|CA|HOST/i.test(errorOutput);
-                if (isDatabaseError) {
-                    console.log('\n🔍 Database initialization error detected! Need to add mocks...');
-                    messages.push({
-                        role: 'user',
-                        content: `The test is failing because the source file imports modules that initialize database connections.
-
-✅ FIX WITH SEARCH-REPLACE:
-
-Option 1 (Recommended): Use insert_at_position to add mocks at beginning:
-   insert_at_position({
-     file_path: "${testFilePath}",
-     position: "beginning",
-     content: "jest.mock('../database', () => ({ default: {} }));\njest.mock('../database/index', () => ({ default: {} }));\njest.mock('../models/serviceDesk.models');\n\n"
-   })
-
-Option 2: If file already has some mocks, use search_replace_block to add more:
-   search_replace_block({
-     file_path: "${testFilePath}",
-     search: "jest.mock('./existing-mock');\n\nimport { something }",
-     replace: "jest.mock('./existing-mock');\njest.mock('../database', () => ({ default: {} }));\njest.mock('../models/serviceDesk.models');\n\nimport { something }"
-   })
-
-⚠️ Mocks MUST be at the TOP before any imports!
-
-Start NOW with insert_at_position!`
-                    });
-                }
-            }
-        }
-        // Add tool results to conversation based on provider
-        if (CONFIG.aiProvider === 'claude') {
-            messages.push({
-                role: 'assistant',
-                content: response.toolCalls.map(tc => ({
-                    type: 'tool_use',
-                    id: tc.id,
-                    name: tc.name,
-                    input: tc.input
-                }))
-            });
-            messages.push({
-                role: 'user',
-                content: toolResults.map(tr => ({
-                    type: 'tool_result',
-                    tool_use_id: tr.id,
-                    content: JSON.stringify(tr.result)
-                }))
-            });
-        }
-        else if (CONFIG.aiProvider === 'openai') {
-            messages.push({
-                role: 'assistant',
-                tool_calls: response.toolCalls.map(tc => ({
-                    id: tc.id,
-                    type: 'function',
-                    function: {
-                        name: tc.name,
-                        arguments: JSON.stringify(tc.input)
-                    }
-                }))
-            });
-            for (const tr of toolResults) {
-                messages.push({
-                    role: 'tool',
-                    tool_call_id: tr.id,
-                    content: JSON.stringify(tr.result)
-                });
-            }
-        }
-        else {
-            // Gemini - use proper function call format
-            for (const toolCall of response.toolCalls) {
-                // Add model's function call
-                messages.push({
-                    role: 'model',
-                    functionCall: {
-                        name: toolCall.name,
-                        args: toolCall.input
-                    }
-                });
-                // Add user's function response
-                const result = toolResults.find(tr => tr.name === toolCall.name);
-                messages.push({
-                    role: 'user',
-                    functionResponse: {
-                        name: toolCall.name,
-                        response: result?.result
-                    }
-                });
-            }
-        }
-        // Check if legitimate failure was reported
-        if (legitimateFailureReported) {
-            console.log('\n✅ Stopping iteration: Legitimate failure reported.');
-            break;
-        }
-        // Check if tests were run and passed
-        const testRun = toolResults.find(tr => tr.name === 'run_tests');
-        if (testRun?.result.passed) {
-            console.log('\n🎉 All tests passed!');
-            break;
-        }
-    }
-    if (iterations >= maxIterations) {
-        console.log('\n⚠️  Reached maximum iterations. Tests may not be complete.');
-    }
-    if (!testFileWritten) {
-        console.log('\n❌ WARNING: Test file was never written! The AI may not have used the tools correctly.');
-        console.log('   Try running again or check your API key and connectivity.');
-    }
-    else if (legitimateFailureReported) {
-        console.log('\n📋 Test file created with legitimate failures documented.');
-        console.log('   These failures indicate bugs in the source code that need to be fixed.');
-    }
-    return testFilePath;
-}
-// Interactive CLI
-async function promptUser(question) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    return new Promise(resolve => {
-        rl.question(question, answer => {
-            rl.close();
-            resolve(answer);
-        });
-    });
-}
-// Get all directories recursively
-async function listDirectories(dir, dirList = []) {
-    const items = await fs.readdir(dir);
-    for (const item of items) {
-        const itemPath = path.join(dir, item);
-        const stat = await fs.stat(itemPath);
-        if (stat.isDirectory() && !CONFIG.excludeDirs.includes(item)) {
-            dirList.push(itemPath);
-            await listDirectories(itemPath, dirList);
-        }
-    }
-    return dirList;
-}
-// Folder-wise test generation
-async function generateTestsForFolder() {
-    console.log('\n📂 Folder-wise Test Generation\n');
-    // Get all directories
-    const directories = await listDirectories('.');
-    if (directories.length === 0) {
-        console.log('No directories found!');
-        return;
-    }
-    console.log('Select a folder to generate tests for all files:\n');
-    directories.forEach((dir, index) => {
-        console.log(`${index + 1}. ${dir}`);
-    });
-    const choice = await promptUser('\nEnter folder number: ');
-    const selectedDir = directories[parseInt(choice) - 1];
-    if (!selectedDir) {
-        console.log('Invalid selection!');
-        return;
-    }
-    // Get all files in the selected directory (recursive)
-    const files = await listFilesRecursive(selectedDir);
-    if (files.length === 0) {
-        console.log(`No source files found in ${selectedDir}!`);
-        return;
-    }
-    console.log(`\n📝 Found ${files.length} files to process in ${selectedDir}\n`);
-    // Process each file
-    for (let i = 0; i < files.length; i++) {
-        const file = files[i];
-        const testFilePath = getTestFilePath(file);
-        console.log(`\n[${i + 1}/${files.length}] Processing: ${file}`);
-        // Check if test file already exists
-        if (fsSync.existsSync(testFilePath)) {
-            const answer = await promptUser(`  Test file already exists: ${testFilePath}\n  Regenerate? (y/n): `);
-            if (answer.toLowerCase() !== 'y') {
-                console.log('  Skipped.');
-                continue;
-            }
-        }
-        try {
-            await generateTests(file);
-            console.log(`  ✅ Completed: ${testFilePath}`);
-        }
-        catch (error) {
-            console.error(`  ❌ Failed: ${error.message}`);
-        }
-    }
-    console.log(`\n✨ Folder processing complete! Processed ${files.length} files.`);
-}
-// Function-wise test generation
-/**
- * Generate tests for a single function
- * @returns true if tests passed, false if legitimate failure reported
- */
-async function generateTestForSingleFunction(sourceFile, functionName, testFilePath, testFileExists) {
-    const messages = [
-        {
-            role: 'user',
-            content: `You are an expert software test engineer. Generate comprehensive Jest unit tests for: ${functionName} in ${sourceFile}. 
-
-## CONTEXT
-Test file: ${testFilePath} | Exists: ${testFileExists}
-
----
-
-## EXECUTION PLAN
-
-**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
-\\\`\\\`\\\`
-
-**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, before imports):
-\\\`\\\`\\\`typescript
-// ===== MOCKS (BEFORE IMPORTS) =====
-jest.mock('config', () => ({
-  get: (key: string) => ({
-    AUTH: { JWT_KEY: 'test', COOKIE_DATA_ONE_YEAR: 31536000000 },
-    USER_DEL_SECRET: 'secret'
-  })
-}), { virtual: true });
-
-jest.mock('../path/from/calculate_relative_path');
-// Never virtual:true for actual source helpers!
-// ⚠️ CRITICAL: Mock ALL dependencies at top level, even if unused
-
-// ===== IMPORTS =====
-import { functionName } from '../controller';
-\\\`\\\`\\\`
-
-Requirements (5+ tests minimum):
-- ✅ Happy path
-- 🔸 Edge cases (null, undefined, empty)
-- ❌ Error conditions  
-- ⏱️ Async behavior
-- 🔍 API null/undefined handling
-
-**Phase 3: Anti-Pollution Pattern (MANDATORY)**
-
-### Step 1: Mock Setup (Top of File)
-// ===== MOCKS (BEFORE IMPORTS) =====
-jest.mock('config', () => ({
-  get: () => ({ KEY: 'value' })
-}), { virtual: true }); // virtual:true ONLY for config, db, models
-
-jest.mock('../helpers/dependency'); // NO virtual:true for regular modules
-
-// ===== IMPORTS =====
-import { functionName } from '../controller';
-import { dependencyMethod } from '../helpers/dependency';
-
-// ===== TYPED MOCKS =====
-const mockDependencyMethod = dependencyMethod as jest.MockedFunction<typeof dependencyMethod>;
-
-### Step 2: Test Structure
-describe('functionName', () => {
-  beforeEach(() => {
-    // ALWAYS first line
-    jest.clearAllMocks();
-    
-    // Set defaults for THIS describe block only
-    mockDependencyMethod.mockResolvedValue({ status: 'success' });
-  });
-
-  test('happy path', async () => {
-    // Override default for this test only
-    mockDependencyMethod.mockResolvedValueOnce({ id: 123 });
-    
-    const result = await functionName();
-    
-    expect(result).toEqual({ id: 123 });
-    expect(mockDependencyMethod).toHaveBeenCalledWith(expect.objectContaining({
-      param: 'value'
-    }));
-  });
-
-  test('error case', async () => {
-    mockDependencyMethod.mockRejectedValueOnce(new Error('fail'));
-    
-    const result = await functionName();
-    
-    expect(result).toEqual({});
-  });
-});
-
-describe('anotherFunction', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    
-    // Different defaults for different function
-    mockDependencyMethod.mockResolvedValue({ status: 'pending' });
-  });
-  
-  // ... tests
-});
-
-
-### Step 3: Internal Function Mocking (When Needed)
-
-describe('functionWithInternalCalls', () => {
-  let internalFnSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    
-    const controller = require('../controller');
-    internalFnSpy = jest.spyOn(controller, 'internalFunction')
-      .mockResolvedValue(undefined);
-  });
-
-  afterEach(() => {
-    internalFnSpy.mockRestore();
-  });
+  beforeEach(() => {
+    jest.resetAllMocks();
+    
+    // ✅ EXCEPTION: require() needed here for spying on same module
+    const controller = require('../controller');
+    internalFnSpy = jest.spyOn(controller, 'internalFunction').mockResolvedValue(undefined);
+  });
+  
+  // No manual restore needed - global afterEach handles it
 
   test('calls internal function', async () => {
     await functionWithInternalCalls();
     expect(internalFnSpy).toHaveBeenCalled();
   });
 });
+\\\`\\\`\\\`
 
-### CRITICAL RULES:
+### CRITICAL RULES (Prevent Mock Pollution):
 **DO ✅**
-1. **Mock at file top** - All \`jest.mock()\` calls before any imports
-2. **Import directly** - Use \`import { fn } from 'module'\` (never \`require()\`)
-3. **Type all mocks** - \`const mockFn = fn as jest.MockedFunction<typeof fn>\`
-4. **Clear first always** - \`jest.clearAllMocks()\` as first line in every \`beforeEach()\`
-5. **Isolate describe defaults** - Each \`describe\` block sets its own mock defaults
-6. **Override with mockOnce** - Use \`mockResolvedValueOnce/mockReturnValueOnce\` in tests
-7. **Restore spies** - Use \`jest.spyOn()\` with \`mockRestore()\` for internal function spies
-8. **Use calculate_relative_path** - For all import and mock paths
+1. \`jest.resetAllMocks()\` as FIRST line in every \`beforeEach()\` (not clearAllMocks)
+2. Global \`afterEach(() => jest.restoreAllMocks())\` near top of test file
+3. Set mock defaults in each \`describe\` block's \`beforeEach()\` independently
+4. Override with \`mockResolvedValueOnce/mockReturnValueOnce\` in individual tests
+5. Type all mocks: \`const mockFn = fn as jest.MockedFunction<typeof fn>\`
+6. All \`jest.mock()\` at top before imports (use calculate_relative_path for paths)
+7. Check for existing mocks with \`get_file_preamble\` tool before adding duplicates
 
 **DON'T ❌**
-1. **Re-require modules** - Never use \`require()\` in \`beforeEach()\` or tests
-2. **Check mock existence** - Never \`if (!mockFn)\` - indicates broken setup
-3. **Share mock state** - Don't rely on defaults from other \`describe\` blocks
-4. **Skip jest.clearAllMocks()** - Missing this is the #1 cause of pollution
-5. **Use virtual:true everywhere** - Only for: config, db, models, routes, services
-6. **Forget to restore spies** - Always pair \`jest.spyOn()\` with \`mockRestore()\`
+1. Use \`jest.clearAllMocks()\` (only clears history, not implementations) → Use \`resetAllMocks()\`
+2. Manually \`.mockReset()\` individual mocks → \`resetAllMocks()\` handles all
+3. Share mock state between \`describe\` blocks → Each block sets its own defaults
+4. Use \`require()\` except when creating spies on same module being tested
+5. Use \`virtual:true\` for regular files → Only for: config, db, models, services (modules not in filesystem)
+6. Forget global \`afterEach(() => jest.restoreAllMocks())\` → Causes spy pollution
+
 
-### Why This Works:
-- **No pollution**: Each describe block sets its own defaults in beforeEach
-- **No conflicts**: clearAllMocks() resets all mock state
-- **Type safety**: TypeScript catches mock mismatches
-- **Predictable**: Tests run in any order with same results
 
 **Phase 4: Write Tests**
+⚠️  CRITICAL REQUIREMENT: Use EXACTLY this test file path: "${testFilePath}"
+    DO NOT modify the path. DO NOT create ${functionName}.test.ts or any other variation.
+
 → upsert_function_tests({ 
-  test_file_path: "${testFilePath}",
+  test_file_path: "${testFilePath}",  // ⚠️  USE THIS EXACT PATH - DO NOT CHANGE!
   function_name: "${functionName}", 
   new_test_content: "describe('${functionName}', () => {...})"
 })
 This will automatically replace the existing test cases for the function with the new test cases or add new test cases if the function is not found in the test file.
+All functions from the same source file MUST share the same test file.
 
 
 
@@ -3655,6 +3207,7 @@ This will automatically replace the existing test cases for the function with th
 - Ensure test independence (no pollution)
 - Fix test bugs, report source bugs
 - [CRITICAL] Each test suite should be completely self-contained and not depend on or affect any other test suite's state.
+- Test file exists: ${testFileExists} - if the test file exist, 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.
 
 **START:** Call analyze_file_ast on ${sourceFile} now. This will give you the file structure and the functions in the file.`
         }
@@ -3675,8 +3228,8 @@ This will automatically replace the existing test cases for the function with th
         else if (iterations % 5 === 0) {
             console.log(`\n🤖 AI is still working (step ${iterations})...`);
         }
-        const response = await callAI(messages, TOOLS);
-        console.log('response from AI', JSON.stringify(response, null, 2));
+        const response = await callAI(messages, TOOLS_FOR_TEST_GENERATION);
+        // console.log('response from AI', JSON.stringify(response, null, 2));
         if (response.content) {
             const content = response.content;
             // Only show AI message if it's making excuses (for debugging), otherwise skip
@@ -3802,7 +3355,193 @@ If this is still fixable: Make focused attempt to fix it.`
                 }
             }
         }
-        // Add tool results to conversation based on provider
+        // Add tool results to conversation based on provider
+        if (CONFIG.aiProvider === 'claude') {
+            messages.push({
+                role: 'assistant',
+                content: response.toolCalls.map(tc => ({
+                    type: 'tool_use',
+                    id: tc.id,
+                    name: tc.name,
+                    input: tc.input
+                }))
+            });
+            messages.push({
+                role: 'user',
+                content: toolResults.map(tr => ({
+                    type: 'tool_result',
+                    tool_use_id: tr.id,
+                    content: JSON.stringify(tr.result)
+                }))
+            });
+        }
+        else if (CONFIG.aiProvider === 'openai') {
+            messages.push({
+                role: 'assistant',
+                tool_calls: response.toolCalls.map(tc => ({
+                    id: tc.id,
+                    type: 'function',
+                    function: {
+                        name: tc.name,
+                        arguments: JSON.stringify(tc.input)
+                    }
+                }))
+            });
+            for (const tr of toolResults) {
+                messages.push({
+                    role: 'tool',
+                    tool_call_id: tr.id,
+                    content: JSON.stringify(tr.result)
+                });
+            }
+        }
+        else {
+            for (const toolCall of response.toolCalls) {
+                messages.push({
+                    role: 'model',
+                    functionCall: {
+                        name: toolCall.name,
+                        args: toolCall.input
+                    }
+                });
+                const result = toolResults.find(tr => tr.name === toolCall.name);
+                messages.push({
+                    role: 'user',
+                    functionResponse: {
+                        name: toolCall.name,
+                        response: result?.result
+                    }
+                });
+            }
+        }
+        // Check if legitimate failure was reported
+        if (legitimateFailureReported) {
+            console.log('\n✅ Stopping iteration: Legitimate failure reported.');
+            break;
+        }
+        // Check if tests passed
+        const testRun = toolResults.find(tr => tr.name === 'run_tests');
+        if (testRun?.result.passed) {
+            console.log('\n🎉 All tests passed!');
+            break;
+        }
+    }
+    if (iterations >= maxIterations) {
+        console.log('\n⚠️  Reached maximum iterations. Tests may not be complete.');
+    }
+    if (legitimateFailureReported) {
+        console.log('\n📋 Test file updated with legitimate failures documented.');
+        console.log('   These failures indicate bugs in the source code that need to be fixed.');
+    }
+    // Clear the expected test file path (cleanup)
+    EXPECTED_TEST_FILE_PATH = null;
+    // Return true if tests passed, false if legitimate failure reported
+    // Get the LAST test run result (not the first) to check final status
+    const testRuns = allToolResults.filter(tr => tr.name === 'run_tests');
+    const lastTestRun = testRuns.length > 0 ? testRuns[testRuns.length - 1] : null;
+    return !legitimateFailureReported && (lastTestRun?.result?.passed || false);
+}
+/**
+ * Smart validation that fixes failing tests
+ * - Runs full test suite
+ * - For failures, attempts to fix all failing tests using AI
+ */
+async function smartValidateTestSuite(sourceFile, testFilePath, functionNames) {
+    console.log(`\n${'='.repeat(80)}`);
+    console.log(`🔍 VALIDATION: Running full test suite (${functionNames.length} function(s))`);
+    console.log(`${'='.repeat(80)}\n`);
+    // Run tests for entire file (no function filter)
+    const fullSuiteResult = runTests(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);
+    if (failingTests.length === 0) {
+        console.log('⚠️  Could not parse specific failing test names. Skipping detailed analysis.');
+        return;
+    }
+    console.log(`Found ${failingTests.length} failing test(s): ${failingTests.join(', ')}\n`);
+    // Attempt to fix all failing tests
+    await fixFailingTests(sourceFile, testFilePath, functionNames, failingTests, fullSuiteResult.output);
+}
+/**
+ * Fix failing tests using AI
+ * Attempts to fix all test issues including pollution, imports, mocks, etc.
+ */
+async function fixFailingTests(sourceFile, testFilePath, functionNames, failingTests, fullSuiteOutput) {
+    const messages = [
+        {
+            role: 'user',
+            content: `You are fixing FAILING TESTS in the test suite.
+
+Source file: ${sourceFile}
+Test file: ${testFilePath}
+Functions tested: ${functionNames.join(', ')}
+
+FAILING TESTS:
+${failingTests.map(t => `- ${t}`).join('\n')}
+
+Full suite output:
+${fullSuiteOutput}
+
+YOUR TASK - Fix all failing tests:
+
+COMMON ISSUES TO FIX:
+- 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 or incorrect imports
+- Mock implementation issues
+- Incorrect test assertions
+- Test logic errors
+
+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
+4. run_tests - Verify fixes
+
+START by calling get_file_preamble to see the current test structure.`
+        }
+    ];
+    let iterations = 0;
+    const maxIterations = 100; // Limit iterations for test fixes
+    while (iterations < maxIterations) {
+        iterations++;
+        console.log(`\n🔧 Test fix attempt ${iterations}/${maxIterations}...`);
+        const response = await callAI(messages, TOOLS_FOR_TEST_GENERATION);
+        if (response.content) {
+            messages.push({ role: 'assistant', content: response.content });
+        }
+        if (!response.toolCalls || response.toolCalls.length === 0) {
+            // AI stopped - check if tests pass now
+            const finalTest = runTests(testFilePath);
+            if (finalTest.passed) {
+                console.log('\n✅ Tests fixed! Full test suite now passes.');
+                return;
+            }
+            console.log('\n⚠️  AI stopped but tests still failing.');
+            break;
+        }
+        // Execute tool calls
+        const toolResults = [];
+        for (const toolCall of response.toolCalls) {
+            const result = await executeTool(toolCall.name, toolCall.input);
+            toolResults.push({ id: toolCall.id, name: toolCall.name, result });
+            // Check if tests passed
+            if (toolCall.name === 'run_tests' && result.passed) {
+                console.log('\n✅ Tests fixed! Full test suite now passes.');
+                return;
+            }
+        }
+        // Add tool results to conversation
         if (CONFIG.aiProvider === 'claude') {
             messages.push({
                 role: 'assistant',
@@ -3828,10 +3567,7 @@ If this is still fixable: Make focused attempt to fix it.`
                 tool_calls: response.toolCalls.map(tc => ({
                     id: tc.id,
                     type: 'function',
-                    function: {
-                        name: tc.name,
-                        arguments: JSON.stringify(tc.input)
-                    }
+                    function: { name: tc.name, arguments: JSON.stringify(tc.input) }
                 }))
             });
             for (const tr of toolResults) {
@@ -3861,30 +3597,8 @@ If this is still fixable: Make focused attempt to fix it.`
                 });
             }
         }
-        // Check if legitimate failure was reported
-        if (legitimateFailureReported) {
-            console.log('\n✅ Stopping iteration: Legitimate failure reported.');
-            break;
-        }
-        // Check if tests passed
-        const testRun = toolResults.find(tr => tr.name === 'run_tests');
-        if (testRun?.result.passed) {
-            console.log('\n🎉 All tests passed!');
-            break;
-        }
-    }
-    if (iterations >= maxIterations) {
-        console.log('\n⚠️  Reached maximum iterations. Tests may not be complete.');
-    }
-    if (legitimateFailureReported) {
-        console.log('\n📋 Test file updated with legitimate failures documented.');
-        console.log('   These failures indicate bugs in the source code that need to be fixed.');
     }
-    // Return true if tests passed, false if legitimate failure reported
-    // Get the LAST test run result (not the first) to check final status
-    const testRuns = allToolResults.filter(tr => tr.name === 'run_tests');
-    const lastTestRun = testRuns.length > 0 ? testRuns[testRuns.length - 1] : null;
-    return !legitimateFailureReported && (lastTestRun?.result?.passed || false);
+    console.log('\n⚠️  Could not automatically fix all failing tests. Manual review may be needed.');
 }
 /** [Not useful, introduce side-effect]
  * Validate and fix the complete test file after all functions are processed
@@ -3969,7 +3683,7 @@ START by calling get_file_preamble to understand current file structure.`
     while (iterations < maxIterations) {
         iterations++;
         console.log(`\n🔧 Fixing attempt ${iterations}/${maxIterations}...`);
-        const response = await callAI(messages, TOOLS);
+        const response = await callAI(messages, TOOLS_FOR_TEST_GENERATION);
         if (response.content) {
             messages.push({ role: 'assistant', content: response.content });
         }
@@ -4076,6 +3790,8 @@ async function generateTestsForFunctions(sourceFile, functionNames) {
     console.log(`\n📝 Generating tests for ${functionNames.length} selected function(s) in: ${sourceFile}\n`);
     const testFilePath = getTestFilePath(sourceFile);
     let testFileExists = fsSync.existsSync(testFilePath);
+    // Read validation interval from config
+    const validationInterval = CONFIG.validationInterval;
     // Process each function one at a time
     for (let i = 0; i < functionNames.length; i++) {
         const functionName = functionNames[i];
@@ -4091,13 +3807,22 @@ async function generateTestsForFunctions(sourceFile, functionNames) {
         else {
             console.log(`\n⚠️  Function '${functionName}' completed with issues. Continuing to next function...`);
         }
+        // Periodic validation checkpoint (only if validation is enabled in config)
+        if (validationInterval !== undefined && validationInterval !== null) {
+            const isPeriodicCheckpoint = validationInterval > 0 && (i + 1) % validationInterval === 0;
+            const isFinalFunction = i === functionNames.length - 1;
+            if (isPeriodicCheckpoint || isFinalFunction) {
+                console.log(`\n${'─'.repeat(80)}`);
+                console.log(`📊 CHECKPOINT ${i + 1}/${functionNames.length}: Running full suite validation...`);
+                console.log(`${'─'.repeat(80)}`);
+                await smartValidateTestSuite(sourceFile, testFilePath, functionNames.slice(0, i + 1));
+            }
+        }
         await new Promise(resolve => setTimeout(resolve, 5000));
     }
     console.log(`\n${'='.repeat(80)}`);
     console.log(`✅ All ${functionNames.length} function(s) processed!`);
     console.log(`${'='.repeat(80)}\n`);
-    // FINAL VALIDATION: Run complete test suite and fix file-level issues
-    // await validateAndFixCompleteTestFile(sourceFile, testFilePath, functionNames);
     return testFilePath;
 }
 async function generateTestsForFunction() {
@@ -4130,7 +3855,7 @@ async function generateTestsForFunction() {
         console.log('No exported functions found in the file!');
         return;
     }
-    console.log(`\nFound ${functions.length} exported functions:\n`);
+    // console.log(`\nFound ${functions.length} exported functions:\n`);
     functions.forEach((func, index) => {
         console.log(`${index + 1}. ${func.name} (${func.type}, ${func.async ? 'async' : 'sync'})`);
     });
@@ -4165,7 +3890,7 @@ async function getGitDiff() {
         // const unstagedDiff = execSync('git diff', { encoding: 'utf-8', stdio: 'pipe' }).toString();
         // Combine both diffs
         const fullDiff = stagedDiff;
-        console.log('Full diff is', fullDiff);
+        // console.log('Full diff is', fullDiff);
         if (!fullDiff.trim()) {
             return { fullDiff: '', files: [] };
         }
@@ -4219,27 +3944,27 @@ async function getChangedFunctionsFromDiff(filePath, diff) {
             return [];
         }
         // First, get all exported functions from the file
-        console.log(`   📁 Analyzing file: ${filePath}`);
+        // console.log(`   📁 Analyzing file: ${filePath}`);
         const result = analyzeFileAST(filePath);
-        console.log(`   📊 AST Analysis result:`, JSON.stringify({
-            success: result.success,
-            totalFunctions: result.analysis?.functions?.length || 0,
-            error: result.error || 'none'
-        }, null, 2));
+        // console.log(`   📊 AST Analysis result:`, JSON.stringify({ 
+        //   success: result.success, 
+        //   totalFunctions: result.analysis?.functions?.length || 0,
+        //   error: result.error || 'none'
+        // }, null, 2));
         if (!result.success || !result.analysis || !result.analysis.functions) {
             console.log(`   ⚠️  Failed to analyze file: ${result.error || 'unknown error'}`);
             return [];
         }
         // Filter to only exported functions
         const exportedFunctions = result.analysis.functions.filter((f) => f.exported);
-        console.log(`   📦 Found ${exportedFunctions.length} exported function(s):`, exportedFunctions.map((f) => f.name).join(', '));
+        // console.log(`   📦 Found ${exportedFunctions.length} exported function(s):`, exportedFunctions.map((f: any) => f.name).join(', '));
         if (exportedFunctions.length === 0) {
             console.log(`   ⚠️  No exported functions found in file`);
             console.log(`   💡 Tip: Make sure the file has exported functions (export const/function/async)`);
             return [];
         }
         const exportedFunctionNames = exportedFunctions.map((f) => f.name);
-        console.log(`   📦 Exported functions in file: ${exportedFunctionNames.join(', ')}`);
+        // console.log(`   📦 Exported functions in file: ${exportedFunctionNames.join(', ')}`);
         // Ask AI to identify which functions appear in the diff
         const prompt = `You are analyzing a git diff to identify which exported functions have been changed or added.
 
@@ -4264,7 +3989,7 @@ Return ONLY the JSON array, nothing else.`;
                 content: prompt
             }
         ];
-        console.log(`   🤖 Calling AI to analyze diff...`);
+        // console.log(`   🤖 Calling AI to analyze diff...`);
         // Call AI without tools - just need text response
         const response = await callAI(messages, [], CONFIG.aiProvider);
         if (!response.content) {
@@ -4273,7 +3998,7 @@ Return ONLY the JSON array, nothing else.`;
         }
         // Parse AI response to extract function names
         const content = response.content.trim();
-        console.log(`   🤖 AI response: ${content}`);
+        // console.log(`   🤖 AI response: ${content}`);
         // Try to extract JSON array from response
         const jsonMatch = content.match(/\[.*\]/s);
         if (jsonMatch) {
@@ -4282,7 +4007,7 @@ Return ONLY the JSON array, nothing else.`;
                 if (Array.isArray(functionNames)) {
                     // Filter to only include functions that actually exist in the file
                     const filtered = functionNames.filter(name => exportedFunctionNames.includes(name));
-                    console.log(`   ✅ Extracted ${filtered.length} function(s) from AI response: ${filtered.join(', ')}`);
+                    // console.log(`   ✅ Extracted ${filtered.length} function(s) from AI response: ${filtered.join(', ')}`);
                     return filtered;
                 }
             }
@@ -4307,10 +4032,7 @@ async function autoGenerateTests() {
     console.log('🔍 Scanning git changes...\n');
     try {
         // Get all changes from git diff
-        console.log('Getting git diff...');
         const { fullDiff, files } = await getGitDiff();
-        console.log('Full diff is', fullDiff);
-        console.log('Files are', files);
         if (files.length === 0) {
             console.log('✅ No changes detected in source files.');
             console.log('   (Only staged and unstaged changes are checked)');
@@ -4329,10 +4051,10 @@ async function autoGenerateTests() {
                 continue;
             }
             console.log(`\n🔄 Processing: ${filePath}`);
-            console.log(`   Analyzing diff with AI...`);
+            console.log(`  🤖 Analyzing diff with AI...`);
             // Use AI to extract changed function names from diff
             const changedFunctions = await getChangedFunctionsFromDiff(filePath, diff);
-            console.log('Changed functions are', changedFunctions);
+            // console.log('Changed functions are', changedFunctions);
             if (changedFunctions.length === 0) {
                 console.log(`   ⏭️  No exported functions changed`);
                 continue;
@@ -4372,11 +4094,387 @@ async function autoGenerateTests() {
         throw error;
     }
 }
+/**
+ * Review code changes for quality, bugs, performance, and security issues
+ */
+async function reviewChangedFiles() {
+    console.log('🔍 Scanning git changes for review...\n');
+    try {
+        // Get all changes from git diff
+        const { fullDiff, files } = await getGitDiff();
+        if (files.length === 0) {
+            console.log('✅ No changes detected in source files.');
+            console.log('   (Only staged and unstaged changes are checked)');
+            return;
+        }
+        console.log(`📝 Found changes in ${files.length} file(s) to review\n`);
+        let processedFiles = 0;
+        let errorFiles = 0;
+        // Process each changed file
+        for (const fileInfo of files) {
+            const { filePath, diff } = fileInfo;
+            // Check if file exists
+            if (!fsSync.existsSync(filePath)) {
+                console.log(`⏭️  Skipping ${filePath} (file not found)`);
+                continue;
+            }
+            console.log(`\n🔄 Reviewing: ${filePath}`);
+            console.log(`  🤖 Analyzing changes with AI...`);
+            // 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`);
+                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
+            }
+        }
+        // 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('='.repeat(60));
+        console.log('\n✨ Done!');
+    }
+    catch (error) {
+        if (error.message === 'Not a git repository') {
+            console.error('❌ Error: Not a git repository');
+            console.error('   Review mode requires git to detect changes.');
+            process.exit(1);
+        }
+        throw error;
+    }
+}
+/**
+ * Generate comprehensive code review for a specific file
+ */
+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.
+
+## CONTEXT
+File: ${filePath}
+Changed Functions: ${changedFunctions.join(', ')}
+
+## GIT DIFF
+\`\`\`diff
+${diff}
+\`\`\`
+
+## 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
+
+**Phase 3: Generate Review**
+
+Use the write_review tool to create a comprehensive markdown review file.
+
+The review MUST include:
+
+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)
+
+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
+
+3. **Positive Aspects**: What was done well
+4. **Recommendations**: General suggestions for improvement
+
+## MARKDOWN TEMPLATE
+
+\`\`\`markdown
+# Code Review: {filename}
+
+**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**:
+[Description of the problem]
+
+**Current Code**:
+\`\`\`typescript
+// problematic code snippet
+\`\`\`
+
+**Recommended Fix**:
+\`\`\`typescript
+// improved code snippet
+\`\`\`
+
+**Rationale**:
+[Why this is important and how the fix helps]
+
+---
+
+### 🟠 High Priority Issues
+
+[Same format as above]
+
+---
+
+### 🟡 Medium Priority Issues
+
+[Same format as above]
+
+---
+
+### 🟢 Low Priority Issues
+
+[Same format as above]
+
+---
+
+## ✅ Positive Aspects
+
+- [What was done well]
+- [Good practices observed]
+
+---
+
+## 💡 General Recommendations
+
+1. [Recommendation 1]
+2. [Recommendation 2]
+
+---
+
+## Conclusion
+
+[Final thoughts and overall assessment]
+\`\`\`
+
+## 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;
+                }
+            }
+        }
+        if (!response.toolCalls || response.toolCalls.length === 0) {
+            if (reviewWritten) {
+                console.log('\n✅ Code review complete!');
+                break;
+            }
+            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;
+            }
+        }
+        // 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)
+                });
+            }
+        }
+        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 }
+                });
+            }
+        }
+        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)
+                }))
+            });
+        }
+    }
+    if (!reviewWritten) {
+        console.log('\n⚠️  Could not complete code review. Manual review may be needed.');
+    }
+}
 async function main() {
     console.log('🧪 AI-Powered Unit Test Generator with AST Analysis\n');
-    // Check for auto mode from CLI arguments EARLY (before any prompts)
+    // Parse command from CLI arguments EARLY (before any prompts)
     const args = process.argv.slice(2);
-    const isAutoMode = args.includes('auto');
+    const command = args[0]; // First argument is the command: 'auto', 'test', 'review', or undefined
+    // Validate command if provided
+    if (command && !['auto', 'test', 'review'].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         - Interactive mode\n');
+        process.exit(1);
+    }
     // Load configuration from codeguard.json
     try {
         CONFIG = (0, config_1.loadConfig)();
@@ -4399,9 +4497,12 @@ async function main() {
         console.error('npm install @babel/parser @babel/traverse ts-node\n');
         process.exit(1);
     }
-    // If auto mode, skip indexing setup and proceed directly
-    if (isAutoMode) {
-        console.log('🤖 Auto Mode: Detecting changes via git diff\n');
+    // If command mode (auto, test, review), skip indexing setup and proceed directly
+    if (command === 'auto' || command === 'test' || command === 'review') {
+        const modeLabel = command === 'auto' ? 'Auto Mode (Review + Test)' :
+            command === 'test' ? 'Test Generation Mode' :
+                'Code Review Mode';
+        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
         globalIndexer = new codebaseIndexer_1.CodebaseIndexer();
@@ -4412,7 +4513,21 @@ async function main() {
         else {
             globalIndexer = null;
         }
-        await autoGenerateTests();
+        // Execute based on command
+        if (command === 'auto') {
+            // Run review first, then tests
+            await reviewChangedFiles();
+            console.log('\n' + '='.repeat(60) + '\n');
+            await autoGenerateTests();
+        }
+        else if (command === 'test') {
+            // Only generate tests
+            await autoGenerateTests();
+        }
+        else if (command === 'review') {
+            // Only review changes
+            await reviewChangedFiles();
+        }
         return;
     }
     // Optional: Codebase Indexing