codeguard-testgen 1.0.14 → 1.0.16

package/dist/testGenerator.js

@@ -0,0 +1,1107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFilesRecursive = listFilesRecursive;
+exports.getTestFilePath = getTestFilePath;
+exports.generateTests = generateTests;
+exports.promptUser = promptUser;
+exports.generateTestsForFolder = generateTestsForFolder;
+exports.generateTestForSingleFunction = generateTestForSingleFunction;
+exports.smartValidateTestSuite = smartValidateTestSuite;
+exports.fixFailingTests = fixFailingTests;
+exports.generateTestsForFunctions = generateTestsForFunctions;
+exports.generateTestsForFunction = generateTestsForFunction;
+const fs = require("fs/promises");
+const fsSync = require("fs");
+const path = require("path");
+const readline = require("readline");
+const globals_1 = require("./globals");
+const ast_1 = require("./ast");
+const ai_1 = require("./ai");
+const toolHandlers_1 = require("./toolHandlers");
+const toolDefinitions_1 = require("./toolDefinitions");
+// ---------------------------------------------------------------------------
+// File system utilities (only used internally by test generator)
+// ---------------------------------------------------------------------------
+async function listFilesRecursive(dir, fileList = []) {
+    const files = await fs.readdir(dir);
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stat = await fs.stat(filePath);
+        if (stat.isDirectory()) {
+            const shouldExclude = globals_1.g.CONFIG.excludeDirs.includes(file) ||
+                file.startsWith('.') ||
+                file === 'tests' ||
+                file === '__tests__' ||
+                file === 'test';
+            if (!shouldExclude) {
+                await listFilesRecursive(filePath, fileList);
+            }
+        }
+        else {
+            const ext = path.extname(file);
+            const isTestFile = file.endsWith('.test.ts') ||
+                file.endsWith('.test.tsx') ||
+                file.endsWith('.test.js') ||
+                file.endsWith('.test.jsx') ||
+                file.endsWith('.spec.ts') ||
+                file.endsWith('.spec.tsx') ||
+                file.endsWith('.spec.js') ||
+                file.endsWith('.spec.jsx');
+            if (globals_1.g.CONFIG.extensions.includes(ext) && !isTestFile && !file.startsWith('.')) {
+                fileList.push(filePath);
+            }
+        }
+    }
+    return fileList;
+}
+// Generate test file path preserving directory structure
+function getTestFilePath(sourceFile) {
+    const testFileName = path.basename(sourceFile).replace(/\.(ts|js)x?$/, '.test.ts');
+    const normalizedSource = sourceFile.replace(/\\/g, '/');
+    let relativeDir = path.dirname(normalizedSource);
+    if (relativeDir.startsWith('./')) {
+        relativeDir = relativeDir.substring(2);
+    }
+    const sourceRoot = globals_1.g.CONFIG.sourceRoot || 'src';
+    const sourceRootPattern = `${sourceRoot}/`;
+    if (normalizedSource.includes(sourceRootPattern)) {
+        const srcIndex = normalizedSource.indexOf(sourceRootPattern);
+        const pathAfterSrc = normalizedSource.substring(srcIndex + sourceRootPattern.length);
+        relativeDir = path.dirname(pathAfterSrc);
+    }
+    let testPath;
+    if (relativeDir && relativeDir !== '.') {
+        testPath = path.join(globals_1.g.CONFIG.testDir, relativeDir, testFileName);
+    }
+    else {
+        testPath = path.join(globals_1.g.CONFIG.testDir, testFileName);
+    }
+    return testPath;
+}
+// ---------------------------------------------------------------------------
+// Main conversation loop
+// ---------------------------------------------------------------------------
+async function generateTests(sourceFile) {
+    let result = (0, ast_1.analyzeFileAST)(sourceFile);
+    console.log('HELLO123');
+    if (!result.success) {
+        result = (0, ast_1.analyzeFileAST)(sourceFile);
+    }
+    if (!result.success || !result.analysis || !result.analysis.functions) {
+        throw new Error(`File analysis failed. Unable to extract functions from file. Error: ${result.error || 'unknown'}`);
+    }
+    const exportedFunctions = result.analysis.functions.filter((f) => f.exported);
+    const functionNames = exportedFunctions.map((f) => f.name).filter((name) => name);
+    if (functionNames.length === 0) {
+        throw new Error('No exported functions found in file. Cannot generate tests.');
+    }
+    return await generateTestsForFunctions(sourceFile, functionNames);
+}
+// ---------------------------------------------------------------------------
+// Interactive CLI helpers
+// ---------------------------------------------------------------------------
+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() && !globals_1.g.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');
+    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;
+    }
+    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`);
+    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}`);
+        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 (core loop)
+// ---------------------------------------------------------------------------
+/**
+ * Generate tests for a single function
+ * @returns true if tests passed, false if legitimate failure reported
+ */
+async function generateTestForSingleFunction(sourceFile, functionName, testFilePath, testFileExists) {
+    globals_1.g.EXPECTED_TEST_FILE_PATH = testFilePath;
+    const functionAST = (0, ast_1.getFunctionAST)(sourceFile, functionName);
+    const testEnv = globals_1.g.CONFIG.testEnv;
+    let messages;
+    if (testEnv == "vitest") {
+        messages = [
+            {
+                role: "user",
+                content: `You are a senior developer generating production-ready Vitest unit tests for TypeScript.
+
+## TARGET
+Function: ${functionName} | Source: ${sourceFile}
+Test File: ${testFilePath} (Exists: ${testFileExists})
+
+## WORKFLOW
+
+### 1. ANALYSIS (Execute in order)
+1. get_function_ast(${sourceFile}, "${functionName}") → implementation
+3. get_imports_ast(${sourceFile}) → trace ALL dependencies
+4. get_file_preamble(${testFilePath}) → existing mocks/imports (if exists)
+5. For each dependency: find_file() → get_function_ast() → understand behavior
+6. calculate_relative_path(from: ${testFilePath}, to: import_path) → all imports
+
+**Dependency Tracing (CRITICAL):**
+- Map EVERY function call to its import source (verify with get_imports_ast)
+- Export ALL used functions from each vi.mock block
+- Set return values in beforeEach for ALL mocked functions
+- Auto-detect required named exports from AST to prevent "X is not defined"
+- For each dependency: get_function_ast() → note its **returnType** → use that type for mock return values
+- If returnType is a custom type/interface: get_type_definitions() → build mock matching the exact shape
+
+### 2. FILE STRUCTURE (STRICT ORDER)
+
+
+// 1. MOCKS (before ANY imports)
+vi.mock('module-path');
+vi.mock('database/index', () => ({ db: { query: vi.fn() } }));
+vi.mock('env', () => ({ _ENV: { KEY: 'test' } }));
+
+// 2. IMPORTS
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import type { TypeOnly } from './types';
+import { ${functionName} } from 'calculated-path';
+import { dependency } from 'dependency-path';
+
+// 3. TYPED MOCKS
+const mockDep = vi.mocked(dependency);
+
+// 4. TESTS
+describe('${functionName}', () => {
+  beforeEach(() => {
+    // clearMocks: true in config handles cleanup
+    mockDep.mockResolvedValue(defaultValue);
+  });
+
+  it('should_behavior_when_condition', async () => {
+    // ARRANGE
+    const input = { id: 1 };
+    mockDep.mockResolvedValueOnce(specificValue);
+    
+    // ACT
+    const result = await ${functionName}(input);
+    
+    // ASSERT
+    expect(result).toEqual(expected);
+    expect(mockDep).toHaveBeenCalledWith(input);
+    expect(mockDep).toHaveBeenCalledTimes(1);
+  });
+});
+
+
+### 3. COVERAGE (Minimum 5 tests)
+
+1. **Happy Path** (1-2): Valid inputs → expected outputs
+2. **Edge Cases** (2-3): Empty/null/undefined/0/boundaries/special chars
+3. **Error Handling** (1-2): Invalid inputs, dependency failures
+   - Sync: expect(() => fn()).toThrow(ErrorClass)
+   - Async: await expect(fn()).rejects.toThrow(ErrorClass)
+4. **Branch Coverage**: Each conditional path tested
+5. **Async Behavior**: Promise resolution/rejection (if applicable)
+
+### 4. MOCK STRATEGY
+
+**ALWAYS Mock:**
+- External modules (fs, http, database)
+- Modules with side effects (logging, analytics)
+- database/index, env, WinstonLogger
+
+**NOT Mocking:**
+- Pure utility functions from same codebase (test integration)
+- Type imports: import type { X } (NEVER mock)
+
+**Mock Pattern:**
+- Module-level: vi.mock('path') → const mockFn = vi.mocked(importedFn)
+- NEVER: vi.spyOn(exports, 'fn') or global wrappers
+- Hoist mock functions for use in both factory and tests
+
+### 4.1 MOCK RETURN TYPE SAFETY (CRITICAL)
+
+When setting up mock return values, you MUST match the dependency's declared return type:
+
+**Step**: For EVERY mocked function, check its return type via get_function_ast before setting mockResolvedValue/mockReturnValue.
+
+**Type → Mock Value Rules:**
+| Return Type | Correct Mock | WRONG Mock |
+|-------------|-------------|------------|
+| \`boolean\` | \`true\` or \`false\` | \`{ success: true }\` |
+| \`Promise<boolean>\` | \`mockResolvedValue(true)\` | \`mockResolvedValue({ ok: true })\` |
+| \`string\` | \`'some-string'\` | \`{ value: 'str' }\` |
+| \`number\` | \`42\` | \`{ count: 42 }\` |
+| \`void\` / \`undefined\` | \`mockResolvedValue(undefined)\` | \`mockResolvedValue({ done: true })\` |
+| \`Promise<SomeType>\` | \`mockResolvedValue(objectMatchingSomeType)\` | Primitive or wrong shape |
+| \`SomeType\` (interface/type) | Use \`get_type_definitions\` to build a matching object | Guessed object shape |
+
+**Process for each mock:**
+1. Identify the dependency function being mocked
+2. Use \`get_function_ast\` on the dependency to get its \`returnType\`
+3. If return type is a custom type/interface, use \`get_type_definitions\` to get the full shape
+4. Set mock value that EXACTLY matches the return type
+5. For \`Promise<T>\`, use \`mockResolvedValue(valueOfTypeT)\`; for plain \`T\`, use \`mockReturnValue(valueOfTypeT)\`
+
+**NEVER guess mock return values. ALWAYS verify against the dependency's declared return type.**
+
+### 5. ASSERTIONS
+
+**Priority Order:**
+1. **Exact**: toEqual(), toBe() for primitives
+2. **Partial**: toMatchObject() for subset matching
+3. **Structural**: expect.objectContaining(), expect.any(Type)
+4. **Specific Checks**: toBeDefined(), toBeNull(), toHaveLength(n)
+5. **Mock Verification**: toHaveBeenCalledWith(), toHaveBeenCalledTimes()
+
+**NEVER:**
+- toBeTruthy() for object existence (use toBeDefined())
+- Snapshots for dates, random values, or as primary assertions
+
+### 6. CRITICAL RULES
+
+**MUST:**
+- ✅ ALL vi.mock() before imports
+- ✅ Use calculate_relative_path for ALL imports
+- ✅ Test file exists: ${testFileExists} - if the test file exist, alway check the mock and imports already present in the test file, using get_file_preamble tool. Make sure you do not duplicate mocks and mocks and imports are added at correct position.
+- ✅ When editing existing file: UPDATE existing vi.mock, NEVER duplicate
+- ✅ Test names: should_behavior_when_condition
+- ✅ AAA pattern with comments
+- ✅ Each test = one behavior
+- ✅ Import types separately: import type { Config }
+- ✅ Use vi.mocked<typeof module>() for full type inference
+- ✅ Mock internal non-exported functions
+- ✅ Use vi.useFakeTimers() for time-dependent tests
+- ✅ Test cases expectations must match source code
+- ✅ When making new test cases for a function make sure that other test function are not affected by the new test cases.
+- ✅ You are allowed to read vitest or jest config file to understand the configuration and the rules, and generate tests accordingly. 
+- ✅ When adding new test cases for a function, make sure you add the imports and mocks at the correct position. Proper order as mentioned above should always be maintained. 
+- ✅ Generated test cases must be meaningful for production usage and easily understandable by developers.
+
+
+**NEVER:**
+- ❌ Mock after imports
+- ❌ Shared state between tests
+- ❌ Multiple behaviors in one test
+- ❌ Generic test names ("test1", "works")
+- ❌ Manual cleanup (vi.clearAllMocks in tests - config handles it)
+- ❌ Environment dependencies without mocks
+- ❌ Use require() (ES imports only)
+- ❌ Reference function from wrong module (verify with get_imports_ast)
+- ❌ Change existing mocks in ways that break other tests
+- ❌ Modify source file or any other file in the codebase.
+
+
+### 6.5. PLAN BEFORE WRITING (MANDATORY)
+Before writing any test code, insert a planning comment at the top of the describe block:
+
+\`\`\`typescript
+describe('${functionName}', () => {
+  // This function: [one-sentence summary of what it does].
+  // It calls: [list every direct dependency/function call].
+  // I will only mock: [list exactly which deps to mock and why].
+  // Edge cases to cover: [list specific edge cases from the code].
+  ...
+});
+\`\`\`
+
+This forces you to reason about the function before writing tests.
+After all tests pass, use search_replace_block to DELETE the planning comment from the final test file. [MANDATORY]
+
+
+### 7. EXECUTION
+
+**Step 1: Add imports/mocks (if test file already exists)**
+Use insert_at_position to add any NEW imports or mocks that don't already exist:
+- insert_at_position({ position: 'before_imports', content: "vi.mock('new-module');" })
+- insert_at_position({ position: 'after_imports', content: "import { dep } from './dep';" })
+
+**Step 2: Write the describe block**
+upsert_function_tests({
+  test_file_path: "${testFilePath}",
+  function_name: "${functionName}",
+  new_test_content: "describe('${functionName}', () => { ... })"
+});
+
+⚠️  CRITICAL: new_test_content must contain ONLY the describe block for this function.
+Do NOT include imports, vi.mock() calls, or other functions' describe blocks in new_test_content.
+If you need to add imports or mocks, use insert_at_position BEFORE calling upsert_function_tests.
+
+**Step 3: Run tests**
+run_tests({
+  test_file_path: "${testFilePath}",
+  function_names: ["${functionName}"]
+});
+
+
+### 8. FAILURE DEBUGGING
+
+**Import Errors:**
+- Recalculate paths with calculate_relative_path
+- Check barrel exports (index.ts redirects)
+- Verify source file exports function
+
+**Mock Errors:**
+- Add missing vi.mock() at top
+- Ensure all used functions exported from mock
+- Verify mock setup in beforeEach
+
+**Type Errors:**
+- Import types with import type
+- Check mock return types match signatures
+- Use proper generic constraints
+- Mock return type mismatch: Re-check dependency's returnType via get_function_ast, fix mockResolvedValue/mockReturnValue to match the declared return type exactly
+
+**Assertion Failures:**
+- Log mock calls: console.log(mockFn.mock.calls)
+- Check execution path (add temp logs in source)
+- Verify input data types
+- Check async/await usage
+- Validate prerequisite mocks return expected values
+
+** If fails, categorize:
+
+**[MUST] FIXABLE** → Fix these:
+| Error | Fix Method |
+|-------|-----------|
+| Wrong imports | find_file(fileName) to get the file path + calculate_relative_path + search_replace_block |
+| Missing mocks | insert_at_position |
+| Syntax errors | search_replace_block (3-5 lines context) |
+| Mock pollution | Fix beforeEach pattern |
+| "Test suite failed to run" | get_file_preamble + fix imports/mocks |
+| "Cannot find module" | calculate_relative_path |
+
+**Process:**
+1. Read FULL error message
+2. Identify error type (import/mock/assertion/type)
+3. Make focused fix using available tools
+4. Iterate until ALL PASS
+
+### 9. QUALITY CHECKLIST
+- [ ] Independent tests (no execution order dependency)
+- [ ] Fast (<100ms per test, no real I/O)
+- [ ] Readable (AAA, descriptive names)
+- [ ] Focused (one behavior per test)
+- [ ] Deterministic (same input = same output)
+- [ ] Type-safe (no any, proper generics)
+- [ ] Complete coverage (all paths tested)
+- [ ] No duplicate declarations
+- [ ] Existing tests still pass
+- [ ] Planning comment is removed from the top of the describe block, after all tests pass.
+
+## START
+gather context → **write tests immediately** → verify → run → fix → complete.
+
+**[CRITICAL]** NEVER change existing mocks such that other tests fail. Use test-specific overrides with mockReturnValueOnce. 
+You must be efficient and fast in your approach, do not overthink the problem.
+
+**PRE COMPUTED FUNCTION AST **
+${JSON.stringify(functionAST)}
+`
+            },
+        ];
+    }
+    else {
+        messages = [
+            {
+                role: "user",
+                content: `You are an expert software test engineer. Generate comprehensive Jest unit tests for: ${functionName} in ${sourceFile}. 
+      [Critical] Be prompt and efficient in your response. Make sure the test case file is typed and complete. Be as fast as possible in your repsonse.
+      [Critical] You cannot remove or modify the existing mocks and imports in the test file since other test may be using it. You can only add new mocks and imports for the new test cases.
+
+## CONTEXT
+Test file: ${testFilePath} | Exists: ${testFileExists}
+
+⚠️  CRITICAL: You MUST use this EXACT test file path: ${testFilePath}
+
+---
+
+## EXECUTION PLAN
+
+**Phase 1: Deep Analysis**
+\`\`\`
+1. For each dependency:
+   - Same file: get_function_ast(${sourceFile},{functionName}) ->  implementation + dependencies
+   - Other file [Can take reference from the imports of the ${sourceFile} file for the file name that has the required function]: find_file(filename) to get file path -> get_function_ast({file_path},{functionName}) + check for external calls
+2. get_imports_ast → all dependencies
+3. calculate_relative_path(from: ${testFilePath}, to: import_path) → all imports, accpets multiple comma separated 'to' paths. Use exact path returned by this tool for all imports.
+4. get_file_preamble → imports and mocks already declared in the file
+5. search_codebase → look for relevant context in codebase.
+\`\`\`
+
+**Phase 1.1: Execution Path Tracing (CRITICAL FOR SUCCESS)**
+*Before writing tests, map the logic requirements for external calls.*
+1. Identify every external call (e.g., \`analyticsHelper.postEvent\`).
+2. Trace backwards: What \`if\`, \`switch\`, or \`try/catch\` block guards this call?
+3. Identify the dependency that controls that guard.
+4. Plan the Mock Return: Determine exactly what value the dependency must return to enter that block.
+5. For each dependency: get_function_ast() → note its **returnType** → use that type for mock return values.
+6. If returnType is a custom type/interface: get_type_definitions() → build mock matching the exact shape.
+
+**Phase 2: Test Generation**
+
+Mock Pattern (CRITICAL - Top of file):
+\`\`\`typescript
+// ===== MOCKS (BEFORE IMPORTS) =====
+jest.mock('config', () => ({
+  get: (key: string) => ({
+    AUTH: { JWT_KEY: 'test', COOKIE_DATA_ONE_YEAR: 31536000000 },
+    USER_DEL_SECRET: 'secret'
+  })
+}), { virtual: true }); 
+
+ // virtual:true ONLY for config, db, models, routes, services, axios, newrelic, GOOGLE_CLOUD_STORAGE, winston, logger, etc.
+
+jest.mock('../helpers/dependency'); // NO virtual:true for regular modules
+
+// ===== IMPORTS =====
+import { functionName } from '../controller';
+import { dependencyMethod } from '../helpers/dependency';
+
+// ===== TYPED MOCKS =====
+const mockDependencyMethod = dependencyMethod as jest.MockedFunction<typeof dependencyMethod>;
+
+\`\`\`
+
+Requirements (5+ tests minimum):
+- ✅ Happy path
+- 🔸 Edge cases (null, undefined, empty)
+- ❌ Error conditions  
+- ⏱️ Async behavior
+- 🔍 API null/undefined handling
+
+/**
+ * Phase 3: Anti-Pollution Pattern (MUST FOLLOW EXACTLY THIS PATTERN, NO VARIATIONS)
+ */
+
+\`\`\`typescript
+// ===== GLOBAL CLEANUP (Near top, outside describe blocks) =====
+afterEach(() => {
+  jest.restoreAllMocks(); // Automatically restores ALL spies
+});
+
+// ===== 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);
+  });
+
+  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' }));
+  });
+
+  test('error case', async () => {
+    mockDep1.mockRejectedValueOnce(new Error('fail'));
+    await expect(functionName()).rejects.toThrow('fail');
+  });
+});
+
+// ===== INTERNAL SPIES (When testing same-file function calls) =====
+describe('functionWithInternalCalls', () => {
+  let internalFnSpy: jest.SpyInstance;
+
+  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 (Prevent Mock Pollution):
+**DO ✅**
+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. Use \`jest.clearAllMocks()\` (only clears history, not implementations) → Use \`resetAllMocks()\`
+2. Manually \`.mockReset()\` individual mocks → \`resetAllMocks()\` handles all
+3. Share mock state between \`describe\` blocks → Each block sets its own defaults
+4. Use \`require()\` except when creating spies on same module being tested
+5. Use \`virtual:true\` for regular files → Only for: config, db, models, services (modules not in filesystem)
+6. Forget global \`afterEach(() => jest.restoreAllMocks())\` → Causes spy pollution
+
+### Phase 3.5: Plan Before Writing (MANDATORY)
+Before writing any test code, insert a planning comment at the top of the describe block:
+
+\`\`\`typescript
+describe('${functionName}', () => {
+  // This function: [one-sentence summary of what it does].
+  // It calls: [list every direct dependency/function call].
+  // I will only mock: [list exactly which deps to mock and why].
+  // Edge cases to cover: [list specific edge cases from the code].
+  ...
+});
+\`\`\`
+
+This forces you to reason about the function before writing tests.
+After all tests pass, use search_replace_block to DELETE the planning comment from the final test file.
+
+### Phase 4: Write Tests
+
+**Step 1: Add imports/mocks (if test file already exists)**
+Use insert_at_position to add any NEW imports or mocks that don't already exist:
+- insert_at_position({ position: 'before_imports', content: "jest.mock('new-module');" })
+- insert_at_position({ position: 'after_imports', content: "import { dep } from './dep';" })
+
+**Step 2: Write the describe block**
+upsert_function_tests({
+  test_file_path: "${testFilePath}",
+  function_name: "${functionName}",
+  new_test_content: "describe('${functionName}', () => { ... })"
+});
+
+⚠️  CRITICAL: new_test_content must contain ONLY the describe block for this function.
+Do NOT include imports, jest.mock() calls, or other functions' describe blocks in new_test_content.
+If you need to add imports or mocks, use insert_at_position BEFORE calling upsert_function_tests.
+
+**Step 3: Run tests**
+run_tests({ test_file_path: "${testFilePath}", function_names: ["${functionName}"] });
+
+
+### MOCK RETURN TYPE SAFETY (CRITICAL)
+
+When setting up mock return values, you MUST match the dependency's declared return type:
+
+**Step**: For EVERY mocked function, check its return type via get_function_ast before setting mockResolvedValue/mockReturnValue.
+
+**Type → Mock Value Rules:**
+| Return Type | Correct Mock | WRONG Mock |
+|-------------|-------------|------------|
+| \`boolean\` | \`true\` or \`false\` | \`{ success: true }\` |
+| \`Promise<boolean>\` | \`mockResolvedValue(true)\` | \`mockResolvedValue({ ok: true })\` |
+| \`string\` | \`'some-string'\` | \`{ value: 'str' }\` |
+| \`number\` | \`42\` | \`{ count: 42 }\` |
+| \`void\` / \`undefined\` | \`mockResolvedValue(undefined)\` | \`mockResolvedValue({ done: true })\` |
+| \`Promise<SomeType>\` | \`mockResolvedValue(objectMatchingSomeType)\` | Primitive or wrong shape |
+| \`SomeType\` (interface/type) | Use \`get_type_definitions\` to build a matching object | Guessed object shape |
+
+**Process for each mock:**
+1. Identify the dependency function being mocked
+2. Use \`get_function_ast\` on the dependency to get its \`returnType\`
+3. If return type is a custom type/interface, use \`get_type_definitions\` to get the full shape
+4. Set mock value that EXACTLY matches the return type
+5. For \`Promise<T>\`, use \`mockResolvedValue(valueOfTypeT)\`; for plain \`T\`, use \`mockReturnValue(valueOfTypeT)\`
+
+**NEVER guess mock return values. ALWAYS verify against the dependency's declared return type.**
+
+**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.
+
+If the test file already exists, first add any NEW imports/mocks using insert_at_position:
+- insert_at_position({ position: 'before_imports', content: "vi.mock('new-module');" })
+- insert_at_position({ position: 'after_imports', content: "import { dep } from './dep';" })
+
+Then write ONLY the describe block:
+→ upsert_function_tests({
+  test_file_path: "${testFilePath}",  // ⚠️  USE THIS EXACT PATH - DO NOT CHANGE!
+  function_name: "${functionName}",
+  new_test_content: "describe('${functionName}', () => {...})"  // ⚠️  ONLY the describe block!
+})
+
+⚠️  new_test_content must contain ONLY the describe('${functionName}', ...) block.
+Do NOT include imports, vi.mock() calls, or other functions' tests in new_test_content.
+This will automatically replace existing tests for the function or append if not found.
+All functions from the same source file MUST share the same test file.
+
+
+
+## PHASE 5: SELF-REVIEW (Before Running Tests)
+
+**Review Checklist:**
+1. ✅ All jest.mock() calls at top of file (before imports)?
+2. ✅ Used calculate_relative_path for all mock paths?
+3. ✅ Functions imported directly (not loaded via require)?
+4. ✅ Mocks typed with \`as jest.MockedFunction<typeof fn>\`?
+5. ✅ beforeEach() has jest.clearAllMocks() as FIRST line?
+6. ✅ Each describe block sets its own default mock values in beforeEach()?
+7. ✅ Used mockResolvedValueOnce/mockReturnValueOnce for test overrides?
+8. ✅ At least 5 test cases (happy/error/edge/async/null)?
+9. ✅ All async functions use async/await in tests?
+10. ✅ Spies on internal functions restored in afterEach()?
+11. ✅ No re-requiring modules or checking if mocks exist?
+12. ✅ No TypeScript type errors in test code?
+13. ✅ Generated test cases are meaningful for production usage and easily understandable by developers.
+14. ✅ Phase 3.5: Plan Before Writing (MANDATORY) is followed.
+15. ✅ Planning comment is present at the top of the describe block.
+
+
+**Phase 6: Tests - Run & Fix - Loop**
+
+1️⃣ Run: \`run_tests({ test_file_path: "${testFilePath}", function_names: ["${functionName}"] })\`
+
+2️⃣  If fails, categorize:
+
+**[MUST] FIXABLE** → Fix these:
+| Error | Fix Method |
+|-------|-----------|
+| Wrong imports | find_file(fileName) to get the file path + calculate_relative_path + search_replace_block |
+| Missing mocks | insert_at_position |
+| Syntax errors | search_replace_block (3-5 lines context) |
+| Mock pollution | Fix beforeEach pattern |
+| "Test suite failed to run" | get_file_preamble + fix imports/mocks |
+| "Cannot find module" | calculate_relative_path |
+| Mock return type mismatch | Re-check dependency's returnType via get_function_ast, fix mockResolvedValue/mockReturnValue to match the declared return type exactly |
+
+
+3️⃣ Repeat until: ✅ All test cases pass
+
+---
+
+## CRITICAL REMINDERS
+
+- Use calculate_relative_path for ALL jest.mock() paths
+- virtual:true ONLY for: db, config, models, routes, index, services, axios, newrelic, GOOGLE_CLOUD_STORAGE
+- search_replace_block preferred (handles whitespace)
+- Ensure test independence (no pollution)
+- Fix test bugs, report source bugs
+- [CRITICAL] Each test suite should be completely self-contained and not depend on or affect any other test suite's state.
+- Test file exists: ${testFileExists} - if the test file exist, always check the mock and imports already present in the test file, using get_file_preamble tool. Make sure you do not duplicate mocks and mocks and imports are added at correct position.
+- Mocking of winston logger or any other external dependeny is critical and mandatory.
+- Use search_codebase tool to look for relevant context in codebase quickly.
+
+**START:** Analyze deeply and write test cases only when you are sure about the function and the dependencies. Make sure the written test cases run and pass on first attempt.
+
+**PRE COMPUTED FUNCTION AST **
+${JSON.stringify(functionAST)}
+`,
+            },
+        ];
+    }
+    let iterations = 0;
+    const maxIterations = 100;
+    let testFileWritten = false;
+    let allToolResults = [];
+    let legitimateFailureReported = false;
+    let lastTestError = '';
+    let sameErrorCount = 0;
+    while (iterations < maxIterations) {
+        iterations++;
+        if (iterations === 1) {
+            (0, globals_1.updateSpinner)('🤖 AI is analyzing selected functions...');
+        }
+        else if (iterations % 5 === 0) {
+            if (globals_1.g.globalSpinner) {
+                globals_1.g.globalSpinner.text = `🤖 AI is still working (step ${iterations})...`;
+            }
+        }
+        const response = await (0, ai_1.callAI)(messages, toolDefinitions_1.TOOLS_FOR_TEST_GENERATION);
+        if (response.content) {
+            const content = response.content;
+            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 => typeof content === 'string' && pattern.test(content));
+            if (isMakingExcuses) {
+                console.log('\n⚠️  AI is making excuses! Forcing it to use tools...');
+                messages.push({
+                    role: 'user',
+                    content: 'STOP making excuses! You CAN use the tools. Use upsert_function_tests tool NOW to write the test cases for the function.'
+                });
+                continue;
+            }
+            messages.push({ role: 'assistant', content });
+        }
+        if (!response.toolCalls || response.toolCalls.length === 0) {
+            const lastTestRun = allToolResults[allToolResults.length - 1];
+            const testsActuallyPassed = lastTestRun?.name === 'run_tests' && lastTestRun?.result?.passed;
+            if (legitimateFailureReported) {
+                console.log('\n✅ Test generation complete (with legitimate failures reported)');
+                break;
+            }
+            if (testFileWritten && testsActuallyPassed) {
+                console.log('\n✅ Test generation complete!');
+                break;
+            }
+            console.log('\n⚠️  No tool calls. Prompting AI to continue...');
+            if (!testFileWritten) {
+                messages.push({
+                    role: 'user',
+                    content: `🚨 STOP TALKING! Use upsert_function_tests tool NOW for: ${functionName}
+
+Example:
+upsert_function_tests({
+  test_file_path: "${testFilePath}",
+  function_name: "${functionName}",
+  new_test_content: "describe('${functionName}', () => { test('should...', () => { ... }) })"
+})
+
+⚠️ new_test_content must ONLY contain the describe block - NO imports or mocks!
+Use insert_at_position separately for imports/mocks if needed.
+This works for both NEW and EXISTING test files!`
+                });
+            }
+            else {
+                messages.push({
+                    role: 'user',
+                    content: `STOP talking and USE TOOLS NOW!
+
+✅ PRIMARY: Use search_replace_block (RECOMMENDED):
+   1. Include 3-5 lines of context around the code to fix
+   2. Replace with corrected version
+   3. Handles whitespace/indentation automatically!
+   4. Then run_tests to verify
+   
+📌 ALTERNATIVE: Use insert_at_position for adding imports/mocks
+   - insert_at_position({ position: 'after_imports', content: "vi.mock('../module');" })
+   
+⚠️ SECONDARY: Use upsert_function_tests for function-level rewrites
+
+Start NOW with search_replace_block or insert_at_position!`
+                });
+            }
+            continue;
+        }
+        const toolResults = [];
+        for (const toolCall of response.toolCalls) {
+            // console.log('toolCall', toolCall);
+            const result = await (0, toolHandlers_1.executeTool)(toolCall.name, toolCall.input);
+            // console.log('result', result);
+            const toolResult = {
+                id: toolCall.id,
+                name: toolCall.name,
+                result
+            };
+            toolResults.push(toolResult);
+            allToolResults.push(toolResult);
+            if (toolCall.name === 'report_legitimate_failure' && result.success) {
+                legitimateFailureReported = true;
+                console.log('\n✅ Legitimate failure acknowledged. Stopping test fixes.');
+                console.log(`   Recommendation: ${result.recommendation}`);
+            }
+            if (toolCall.name === 'run_tests' && !result.success) {
+                const errorOutput = result.output || result.error || '';
+                const currentError = errorOutput.substring(0, 300);
+                if (currentError === lastTestError) {
+                    sameErrorCount++;
+                    if (sameErrorCount >= 3) {
+                        messages.push({
+                            role: 'user',
+                            content: `The same test error has occurred ${sameErrorCount} times in a row!
+              Make focused attempt to fix the tests using the tools available.`
+                        });
+                    }
+                }
+                else {
+                    lastTestError = currentError;
+                    sameErrorCount = 1;
+                }
+            }
+            if (toolCall.name === 'upsert_function_tests') {
+                if (result.success) {
+                    testFileWritten = true;
+                    messages.push({
+                        role: 'user',
+                        content: `Test files are written successfully. Please use run_tests tool to verify the tests. If the tests fail, please make focused attempts to fix the tests using the tools available.`
+                    });
+                }
+            }
+        }
+        // Add tool results to conversation based on provider
+        (0, ai_1.addToolResultsToMessages)(globals_1.g.CONFIG.aiProvider, messages, response.toolCalls, toolResults);
+        if (legitimateFailureReported) {
+            console.log('\n✅ Stopping iteration: Legitimate failure reported.');
+            break;
+        }
+        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.');
+    }
+    globals_1.g.EXPECTED_TEST_FILE_PATH = null;
+    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
+ */
+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`);
+    let fullSuiteResult;
+    if (globals_1.g.CONFIG.testEnv == 'vitest') {
+        fullSuiteResult = (0, toolHandlers_1.runTestsVitest)(testFilePath);
+    }
+    else {
+        fullSuiteResult = (0, toolHandlers_1.runTestsJest)(testFilePath);
+    }
+    if (fullSuiteResult.passed) {
+        console.log(`\n✅ Full test suite passed! All ${functionNames.length} function(s) working together correctly.`);
+        return;
+    }
+    console.log(`\n⚠️  Full test suite has failures. Attempting to fix failing tests...\n`);
+    const failingTests = (0, toolHandlers_1.parseFailingTestNames)(fullSuiteResult.output);
+    console.log(`\n📊 Debug: Found ${failingTests.length} failing test(s) from output`);
+    if (failingTests.length === 0) {
+        console.log('⚠️  Could not parse specific failing test names from output.');
+        console.log('    Attempting general fix based on full error output...\n');
+        await fixFailingTests(sourceFile, testFilePath, functionNames, [], fullSuiteResult.output);
+        return;
+    }
+    console.log(`Found ${failingTests.length} failing test(s): ${failingTests.join(', ')}\n`);
+    await fixFailingTests(sourceFile, testFilePath, functionNames, failingTests, fullSuiteResult.output);
+}
+/**
+ * Fix failing tests using AI
+ */
+async function fixFailingTests(sourceFile, testFilePath, functionNames, failingTests, fullSuiteOutput) {
+    const messages = [
+        {
+            role: 'user',
+            content: `You are fixing FAILING TESTS in the ${globals_1.g.CONFIG.testEnv === 'vitest' ? 'Vitest' : 'Jest'} test suite.
+
+Source file: ${sourceFile}
+Test file: ${testFilePath}
+Functions tested: ${functionNames.join(', ')}
+
+FAILING TESTS:
+${failingTests.map(t => `- ${t}`).join('\n')}
+
+Full suite output:
+${fullSuiteOutput}
+
+YOUR TASK - Fix all failing tests:
+
+COMMON ISSUES TO FIX:
+- Mock state bleeding between describe blocks
+- Missing ${globals_1.g.CONFIG.testEnv === 'vitest' ? 'vitest' : 'jest'} imports (describe, it, expect, beforeEach, ${globals_1.g.CONFIG.testEnv === 'vitest' ? 'vi' : 'jest'})
+- Incorrect mock typing (use MockedFunction from ${globals_1.g.CONFIG.testEnv})
+- beforeEach not setting up mocks properly
+- Missing or incorrect imports
+- Mock implementation issues
+- Incorrect test assertions
+- Test logic errors
+
+NOTE: ${globals_1.g.CONFIG.testEnv === 'vitest' ? 'vitest.config.ts' : 'jest.config.ts'} should have clearMocks/restoreMocks enabled.
+
+TOOLS TO USE:
+1. get_file_preamble - See current setup
+2. search_replace_block - Fix specific sections (preferred)
+3. insert_at_position - Add missing imports/mocks
+4. run_tests - Verify fixes
+
+START by calling get_file_preamble to see the current test structure.`
+        }
+    ];
+    let iterations = 0;
+    const maxIterations = 500;
+    while (iterations < maxIterations) {
+        iterations++;
+        console.log(`\n🔧 Test fix attempt ${iterations}/${maxIterations}...`);
+        const response = await (0, ai_1.callAI)(messages, toolDefinitions_1.TOOLS_FOR_TEST_GENERATION);
+        if (response.content) {
+            messages.push({ role: 'assistant', content: response.content });
+        }
+        if (!response.toolCalls || response.toolCalls.length === 0) {
+            let finalTest;
+            if (globals_1.g.CONFIG.testEnv == 'vitest') {
+                finalTest = (0, toolHandlers_1.runTestsVitest)(testFilePath);
+            }
+            else {
+                finalTest = (0, toolHandlers_1.runTestsJest)(testFilePath);
+            }
+            if (finalTest.passed) {
+                console.log('\n✅ Tests fixed! Full test suite now passes.');
+                return;
+            }
+            console.log('\n⚠️  AI stopped but tests still failing.');
+            break;
+        }
+        const toolResults = [];
+        for (const toolCall of response.toolCalls) {
+            const result = await (0, toolHandlers_1.executeTool)(toolCall.name, toolCall.input);
+            toolResults.push({ id: toolCall.id, name: toolCall.name, result });
+            if (toolCall.name === 'run_tests' && result.passed) {
+                console.log('\n✅ Tests fixed! Full test suite now passes.');
+                return;
+            }
+        }
+        (0, ai_1.addToolResultsToMessages)(globals_1.g.CONFIG.aiProvider, messages, response.toolCalls, toolResults);
+    }
+    console.log('\n⚠️  Could not automatically fix all failing tests. Manual review may be needed.');
+}
+/**
+ * Generate tests for multiple functions, one at a time
+ */
+async function generateTestsForFunctions(sourceFile, functionNames) {
+    const testFilePath = getTestFilePath(sourceFile);
+    let testFileExists = fsSync.existsSync(testFilePath);
+    const validationInterval = globals_1.g.CONFIG.validationInterval;
+    for (let i = 0; i < functionNames.length; i++) {
+        const functionName = functionNames[i];
+        (0, globals_1.stopSpinner)();
+        console.log(`\n${'='.repeat(80)}`);
+        console.log(`Processing function ${i + 1}/${functionNames.length}: ${functionName}`);
+        console.log(`${'='.repeat(80)}\n`);
+        const passed = await generateTestForSingleFunction(sourceFile, functionName, testFilePath, testFileExists);
+        testFileExists = true;
+        (0, globals_1.stopSpinner)();
+        if (passed) {
+            console.log(`\n✅ Function '${functionName}' tests completed successfully!`);
+        }
+        else {
+            console.log(`\n⚠️  Function '${functionName}' completed with issues. Continuing to next function...`);
+        }
+        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`);
+    return testFilePath;
+}
+async function generateTestsForFunction() {
+    console.log('\n🎯 Function-wise Test Generation\n');
+    (0, globals_1.updateSpinner)('📂 Scanning repository...');
+    const files = await listFilesRecursive('.');
+    if (files.length === 0) {
+        globals_1.g.globalSpinner.fail('No source files found!');
+        globals_1.g.globalSpinner = null;
+        return;
+    }
+    (0, globals_1.updateSpinner)(`Found ${files.length} source file(s)`);
+    await new Promise(resolve => setTimeout(resolve, 200));
+    (0, globals_1.stopSpinner)();
+    console.log('\nSelect a file:\n');
+    files.forEach((file, index) => {
+        console.log(`${index + 1}. ${file}`);
+    });
+    const fileChoice = await promptUser('\nEnter file number: ');
+    const selectedFile = files[parseInt(fileChoice) - 1];
+    if (!selectedFile) {
+        console.log('Invalid selection!');
+        return;
+    }
+    const analysis = (0, ast_1.analyzeFileAST)(selectedFile);
+    if (!analysis.success) {
+        console.error(`Failed to analyze file: ${analysis.error}`);
+        return;
+    }
+    const functions = analysis.analysis.functions.filter((f) => f.exported);
+    if (functions.length === 0) {
+        console.log('No exported functions found in the file!');
+        return;
+    }
+    functions.forEach((func, index) => {
+        console.log(`${index + 1}. ${func.name} (${func.type}, ${func.async ? 'async' : 'sync'})`);
+    });
+    const functionsChoice = await promptUser('\nEnter function numbers (comma-separated, e.g., 1,3,4): ');
+    const selectedIndices = functionsChoice.split(',').map(s => parseInt(s.trim()) - 1);
+    const selectedFunctions = selectedIndices
+        .filter(i => i >= 0 && i < functions.length)
+        .map(i => functions[i].name);
+    if (selectedFunctions.length === 0) {
+        console.log('No valid functions selected!');
+        return;
+    }
+    console.log(`\n✅ Selected functions: ${selectedFunctions.join(', ')}\n`);
+    await generateTestsForFunctions(selectedFile, selectedFunctions);
+    (0, globals_1.stopSpinner)();
+    console.log('\n✨ Done!');
+}
+//# sourceMappingURL=testGenerator.js.map