codeguard-testgen 1.0.14 → 1.0.16

package/dist/toolHandlers.js

@@ -0,0 +1,1430 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFile = readFile;
+exports.readFileLines = readFileLines;
+exports.resolveImportPath = resolveImportPath;
+exports.validateTestFileSyntax = validateTestFileSyntax;
+exports.writeTestFile = writeTestFile;
+exports.editTestFile = editTestFile;
+exports.replaceFunctionTests = replaceFunctionTests;
+exports.stripAnsi = stripAnsi;
+exports.runTestsVitest = runTestsVitest;
+exports.runTestsJest = runTestsJest;
+exports.runTestsIsolated = runTestsIsolated;
+exports.parseFailingTestNames = parseFailingTestNames;
+exports.listDirectory = listDirectory;
+exports.findFile = findFile;
+exports.calculateRelativePath = calculateRelativePath;
+exports.parseMultiplePaths = parseMultiplePaths;
+exports.normalizePath = normalizePath;
+exports.calculateSingleRelativePath = calculateSingleRelativePath;
+exports.deleteLines = deleteLines;
+exports.insertLines = insertLines;
+exports.replaceLines = replaceLines;
+exports.searchReplaceBlock = searchReplaceBlock;
+exports.insertAtPosition = insertAtPosition;
+exports.writeReview = writeReview;
+exports.searchCodebase = searchCodebase;
+exports.executeTool = executeTool;
+const fs = require("fs/promises");
+const fsSync = require("fs");
+const path = require("path");
+const child_process_1 = require("child_process");
+const babelParser = require("@babel/parser");
+const globals_1 = require("./globals");
+const pathResolver_1 = require("./pathResolver");
+const ast_1 = require("./ast");
+const fuzzyMatcher_1 = require("./fuzzyMatcher");
+const toolDefinitions_1 = require("./toolDefinitions");
+// ---------------------------------------------------------------------------
+// File reading
+// ---------------------------------------------------------------------------
+async function readFile(filePath) {
+    const MAX_LINES = 1000;
+    const tryReadFile = async (targetPath) => {
+        try {
+            const content = await fs.readFile(targetPath, 'utf-8');
+            const lines = content.split('\n');
+            if (lines.length > MAX_LINES) {
+                const isTestFile = /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(targetPath);
+                if (globals_1.g.globalIndexer) {
+                    const cached = globals_1.g.globalIndexer.getFileAnalysis(targetPath);
+                    if (cached) {
+                        let preamble = undefined;
+                        if (isTestFile) {
+                            const preambleResult = (0, ast_1.getFilePreamble)(targetPath);
+                            if (preambleResult.success) {
+                                preamble = preambleResult;
+                            }
+                        }
+                        return {
+                            success: true,
+                            usedCache: true,
+                            fileSize: lines.length,
+                            filePath: targetPath,
+                            analysis: cached,
+                            preamble: preamble,
+                            message: isTestFile
+                                ? `Test file has ${lines.length} lines (max ${MAX_LINES}). Returned cached analysis + preamble (imports/mocks/setup). Use get_function_ast with proper file path for specific test functions.`
+                                : `File has ${lines.length} lines (max ${MAX_LINES}). Returned cached analysis + preamble (imports/setup). Use read_file_lines to read specific section of file or get_function_ast with proper file path for specific functions.`
+                        };
+                    }
+                }
+                return {
+                    success: false,
+                    error: `File too large (${lines.length} lines, max ${MAX_LINES}). Use get_file_preamble for imports/mocks, analyze_file_ast for structure, or get_function_ast for specific functions or read_file_lines to read specific section of file.`,
+                    fileSize: lines.length,
+                    filePath: targetPath,
+                    suggestion: 'For large files: 1) get_file_preamble for imports/mocks/setup, 2) analyze_file_ast for all functions, 3) get_function_ast for specific functions'
+                };
+            }
+            return { success: true, content, filePath: targetPath, fileSize: lines.length };
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    const result = await tryReadFile(filePath);
+    if (result) {
+        return result;
+    }
+    if (globals_1.g.globalIndexer) {
+        const indexData = globals_1.g.globalIndexer.index;
+        if (indexData && indexData.files) {
+            const match = (0, pathResolver_1.findBestMatchInIndex)(filePath, indexData.files);
+            if (match) {
+                const retryResult = await tryReadFile(match.suggestion);
+                if (retryResult) {
+                    return retryResult;
+                }
+                return {
+                    success: false,
+                    error: `Found file at ${match.suggestion} but failed to read it`,
+                    suggestion: match.suggestion,
+                    allMatches: match.allMatches.length > 1 ? match.allMatches : undefined
+                };
+            }
+        }
+        return {
+            success: false,
+            error: `File not found: ${filePath}. No matching files found in index.`
+        };
+    }
+    return {
+        success: false,
+        error: `File not found: ${filePath}. Tip: Enable indexing for better file lookup.`
+    };
+}
+/**
+ * Read specific lines from a file
+ * Useful for examining syntax errors, bracket mismatches, or specific sections
+ */
+async function readFileLines(filePath, startLine, endLine) {
+    if (startLine < 1) {
+        return {
+            success: false,
+            error: 'Start line must be >= 1'
+        };
+    }
+    if (endLine < startLine) {
+        return {
+            success: false,
+            error: 'End line must be >= start line'
+        };
+    }
+    if (endLine - startLine > 2000) {
+        return {
+            success: false,
+            error: 'You are not allowed to read more than 2000 lines at once. End line - start line must be less than 2000'
+        };
+    }
+    const tryReadFileLines = async (targetPath) => {
+        try {
+            const content = await fs.readFile(targetPath, 'utf-8');
+            const allLines = content.split('\n');
+            if (startLine > allLines.length) {
+                return {
+                    success: false,
+                    error: `Start line ${startLine} exceeds file length (${allLines.length} lines)`,
+                    fileLength: allLines.length,
+                    filePath: targetPath
+                };
+            }
+            const actualEndLine = Math.min(endLine, allLines.length);
+            const requestedLines = allLines.slice(startLine - 1, actualEndLine);
+            const formattedLines = requestedLines.map((line, index) => {
+                const lineNumber = startLine + index;
+                return `${lineNumber.toString().padStart(6, ' ')}|${line}`;
+            }).join('\n');
+            return {
+                success: true,
+                filePath: targetPath,
+                startLine,
+                endLine: actualEndLine,
+                lineCount: requestedLines.length,
+                content: formattedLines,
+                rawLines: requestedLines
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    const result = await tryReadFileLines(filePath);
+    if (result) {
+        return result;
+    }
+    if (globals_1.g.globalIndexer) {
+        const indexData = globals_1.g.globalIndexer.index;
+        if (indexData && indexData.files) {
+            const match = (0, pathResolver_1.findBestMatchInIndex)(filePath, indexData.files);
+            if (match) {
+                const retryResult = await tryReadFileLines(match.suggestion);
+                if (retryResult) {
+                    return retryResult;
+                }
+                return {
+                    success: false,
+                    error: `Found file at ${match.suggestion} but failed to read it`,
+                    suggestion: match.suggestion,
+                    allMatches: match.allMatches.length > 1 ? match.allMatches : undefined
+                };
+            }
+        }
+        return {
+            success: false,
+            error: `File not found: ${filePath}. No matching files found in index.`
+        };
+    }
+    return {
+        success: false,
+        error: `File not found: ${filePath}. Tip: Enable indexing for better file lookup.`
+    };
+}
+function resolveImportPath(fromFile, importPath) {
+    try {
+        if (importPath.startsWith('.')) {
+            const dir = path.dirname(fromFile);
+            const resolved = path.resolve(dir, importPath);
+            const extensions = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.js'];
+            for (const ext of extensions) {
+                const withExt = resolved + ext;
+                if (fsSync.existsSync(withExt)) {
+                    return { success: true, resolvedPath: withExt };
+                }
+            }
+            if (fsSync.existsSync(resolved)) {
+                return { success: true, resolvedPath: resolved };
+            }
+        }
+        return {
+            success: true,
+            resolvedPath: importPath,
+            isExternal: true
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Validate test file syntax using AST parsing
+ * Provides detailed error information for AI to retry
+ */
+async function validateTestFileSyntax(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        babelParser.parse(content, {
+            sourceType: 'module',
+            plugins: [
+                'typescript',
+                'jsx',
+                'decorators-legacy'
+            ]
+        });
+        return { valid: true };
+    }
+    catch (error) {
+        const line = error.loc?.line || error.lineNumber || 0;
+        const column = error.loc?.column || error.column || 0;
+        let errorMessage = error.message || 'Unknown syntax error';
+        errorMessage = errorMessage.replace(/^.*?: /, '');
+        let suggestion = '';
+        if (errorMessage.includes('Unexpected token') || errorMessage.includes('unexpected')) {
+            suggestion = 'Check for missing/extra brackets, parentheses, or commas near this location.';
+        }
+        else if (errorMessage.includes('Unterminated')) {
+            suggestion = 'You have an unclosed string, comment, or template literal.';
+        }
+        else if (errorMessage.includes('Expected')) {
+            suggestion = 'Missing required syntax element. Check if you closed all blocks properly.';
+        }
+        else if (errorMessage.includes('duplicate') || errorMessage.includes('already')) {
+            suggestion = 'Duplicate declaration detected. Check for repeated variable/function names.';
+        }
+        else {
+            suggestion = 'Review the code structure around this line for syntax issues.';
+        }
+        return {
+            valid: false,
+            error: errorMessage,
+            location: { line, column },
+            suggestion
+        };
+    }
+}
+async function writeTestFile(filePath, content, sourceFilePath, functionMode = false) {
+    try {
+        const invalidPatterns = [
+            /\/\/\s*(Mock setup|Assertions|Call function|Add test|Further test|Additional test)/i,
+            /\/\/\s*(Add more|write more|Similarly|write tests for)/i,
+            /\/\/\s*TODO/i,
+            /\/\/\s*\.\.\./,
+            /\/\/.*etc\./i,
+            /expect\(\).*\/\//,
+        ];
+        const hasPlaceholders = invalidPatterns.some(pattern => pattern.test(content));
+        if (hasPlaceholders) {
+            const foundPlaceholder = content.match(invalidPatterns.find(p => p.test(content)) || /\/\/.*/);
+            return {
+                success: false,
+                error: `REJECTED: Test file contains placeholder comment: "${foundPlaceholder?.[0]}"\n\nYou must write COMPLETE tests with actual code for ALL functions, not comments like "// Add more tests", "// Similarly", "// Further tests". Write the FULL implementation for EVERY function!`
+            };
+        }
+        const expectCount = (content.match(/expect\(/g) || []).length;
+        const testCount = (content.match(/test\(|it\(/g) || []).length;
+        const describeCount = (content.match(/describe\(/g) || []).length;
+        if (testCount > 0 && expectCount === 0) {
+            return {
+                success: false,
+                error: 'REJECTED: Test file has test cases but NO expect() assertions! Every test MUST have at least one expect() statement. Write actual assertions!'
+            };
+        }
+        let expectedFunctionCount = 3;
+        if (!functionMode) {
+            if (sourceFilePath && fsSync.existsSync(sourceFilePath)) {
+                const analysis = (0, ast_1.analyzeFileAST)(sourceFilePath);
+                if (analysis.success) {
+                    const exportedFunctions = analysis.analysis.functions.filter((f) => f.exported);
+                    expectedFunctionCount = exportedFunctions.length;
+                    if (describeCount < expectedFunctionCount) {
+                        return {
+                            success: false,
+                            error: `REJECTED: Source file has ${expectedFunctionCount} exported functions but test file only has ${describeCount} describe blocks!\n\nMissing tests for: ${exportedFunctions.slice(describeCount).map((f) => f.name).join(', ')}\n\nWrite a describe block with tests for EVERY function!`
+                        };
+                    }
+                }
+            }
+        }
+        const dir = path.dirname(filePath);
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(filePath, content, 'utf-8');
+        return {
+            success: true,
+            path: filePath,
+            stats: {
+                tests: testCount,
+                expectations: expectCount
+            }
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+async function editTestFile(filePath, oldContent, newContent) {
+    try {
+        const dir = path.dirname(filePath);
+        await fs.mkdir(dir, { recursive: true });
+        let content = await fs.readFile(filePath, 'utf-8');
+        const normalizeWhitespace = (str) => str.replace(/\s+/g, ' ').trim();
+        const normalizedContent = normalizeWhitespace(content);
+        const normalizedOld = normalizeWhitespace(oldContent);
+        if (content.includes(oldContent)) {
+            content = content.replace(oldContent, newContent);
+            await fs.writeFile(filePath, content, 'utf-8');
+            return { success: true, message: 'File edited successfully (exact match)' };
+        }
+        if (normalizedContent.includes(normalizedOld)) {
+            const lines = content.split('\n');
+            const oldLines = oldContent.split('\n');
+            for (let i = 0; i <= lines.length - oldLines.length; i++) {
+                const section = lines.slice(i, i + oldLines.length).join('\n');
+                if (normalizeWhitespace(section) === normalizedOld) {
+                    lines.splice(i, oldLines.length, newContent);
+                    content = lines.join('\n');
+                    await fs.writeFile(filePath, content, 'utf-8');
+                    return { success: true, message: 'File edited successfully (normalized match)' };
+                }
+            }
+        }
+        if (!oldContent || oldContent.trim().length < 10) {
+            await fs.writeFile(filePath, newContent, 'utf-8');
+            return { success: true, message: 'File overwritten (old content was empty/short)' };
+        }
+        const preview = content.substring(0, 500);
+        return {
+            success: false,
+            error: `Old content not found. Current file preview:\n${preview}\n...\n\nHint: Use search_replace_block with more context to find the correct location.`,
+            currentContent: preview
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+async function replaceFunctionTests(testFilePath, functionName, newTestContent) {
+    try {
+        const dir = path.dirname(testFilePath);
+        await fs.mkdir(dir, { recursive: true });
+        if (!fsSync.existsSync(testFilePath)) {
+            return await writeTestFile(testFilePath, newTestContent);
+        }
+        const content = await fs.readFile(testFilePath, 'utf-8');
+        const lines = content.split('\n');
+        let describeStartLine = -1;
+        let describeEndLine = -1;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const describeMatch = line.match(/describe\s*\(\s*['"]([^'"]+)['"]\s*,/);
+            if (describeMatch) {
+                const describeName = describeMatch[1];
+                if (describeName === functionName ||
+                    describeName.endsWith(` - ${functionName}`) ||
+                    describeName.endsWith(`-${functionName}`) ||
+                    describeName.startsWith(`${functionName} -`) ||
+                    describeName.startsWith(`${functionName}-`)) {
+                    describeStartLine = i;
+                    let bracketDepth = 0;
+                    let foundOpening = false;
+                    for (let j = i; j < lines.length; j++) {
+                        const currentLine = lines[j];
+                        // Strip string literals and comments before counting braces
+                        const stripped = currentLine
+                            .replace(/\/\/.*$/, '') // remove line comments
+                            .replace(/\/\*.*?\*\//g, '') // remove inline block comments
+                            .replace(/'(?:[^'\\]|\\.)*'/g, '') // remove single-quoted strings
+                            .replace(/"(?:[^"\\]|\\.)*"/g, '') // remove double-quoted strings
+                            .replace(/`(?:[^`\\]|\\.)*`/g, ''); // remove template literals (single-line)
+                        for (const char of stripped) {
+                            if (char === '{') {
+                                bracketDepth++;
+                                foundOpening = true;
+                            }
+                            else if (char === '}') {
+                                bracketDepth--;
+                                if (foundOpening && bracketDepth === 0) {
+                                    const afterBrace = currentLine.substring(currentLine.lastIndexOf('}') + 1).trim();
+                                    if (afterBrace === ');' || afterBrace === ')' || afterBrace === '') {
+                                        describeEndLine = j;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        if (describeEndLine !== -1)
+                            break;
+                    }
+                    break;
+                }
+            }
+        }
+        if (describeStartLine !== -1 && describeEndLine !== -1) {
+            const beforeBlock = lines.slice(0, describeStartLine);
+            const afterBlock = lines.slice(describeEndLine + 1);
+            const updatedLines = [...beforeBlock];
+            if (beforeBlock.length > 0 && beforeBlock[beforeBlock.length - 1].trim() !== '') {
+                updatedLines.push('');
+            }
+            updatedLines.push(newTestContent);
+            if (afterBlock.length > 0 && afterBlock[0].trim() !== '') {
+                updatedLines.push('');
+            }
+            updatedLines.push(...afterBlock);
+            const updatedContent = updatedLines.join('\n');
+            await fs.writeFile(testFilePath, updatedContent, 'utf-8');
+            const validation = await validateTestFileSyntax(testFilePath);
+            if (!validation.valid) {
+                await fs.writeFile(testFilePath, content, 'utf-8');
+                return {
+                    success: false,
+                    error: `Syntax error after modification at line ${validation.location?.line}:${validation.location?.column}\n${validation.error}`,
+                    syntaxError: true,
+                    location: validation.location,
+                    suggestion: validation.suggestion
+                };
+            }
+            return {
+                success: true,
+                message: `Replaced existing tests for function '${functionName}' (lines ${describeStartLine + 1}-${describeEndLine + 1})`,
+                replaced: true,
+                replacedLines: { start: describeStartLine + 1, end: describeEndLine + 1 }
+            };
+        }
+        else {
+            // Strip any leading imports/mocks from new_test_content so only the describe block is appended
+            const contentLines = newTestContent.split('\n');
+            let describeLineIdx = contentLines.findIndex(l => /^\s*describe\s*\(/.test(l));
+            if (describeLineIdx > 0) {
+                // Extract non-describe preamble (imports/mocks) and add them at the top of the file
+                const preambleLines = contentLines.slice(0, describeLineIdx).filter(l => l.trim() !== '');
+                const describeContent = contentLines.slice(describeLineIdx).join('\n');
+                if (preambleLines.length > 0) {
+                    // Find where imports end in the existing file to insert new imports/mocks there
+                    let lastImportLine = -1;
+                    for (let i = 0; i < lines.length; i++) {
+                        const trimmed = lines[i].trim();
+                        if (trimmed.startsWith('import ') || trimmed.startsWith('vi.mock(') ||
+                            trimmed.startsWith('jest.mock(') || trimmed.startsWith('const mock') ||
+                            trimmed.startsWith('vi.mocked(')) {
+                            lastImportLine = i;
+                        }
+                    }
+                    const insertPreambleAt = lastImportLine !== -1 ? lastImportLine + 1 : 0;
+                    // Only add preamble lines that don't already exist in the file
+                    const existingContent = content;
+                    const newPreamble = preambleLines.filter(l => !existingContent.includes(l.trim()));
+                    if (newPreamble.length > 0) {
+                        lines.splice(insertPreambleAt, 0, ...newPreamble);
+                    }
+                }
+                newTestContent = describeContent;
+            }
+            // Append the describe block at the end of the file
+            // Remove trailing empty lines first, then add proper spacing
+            while (lines.length > 0 && lines[lines.length - 1].trim() === '') {
+                lines.pop();
+            }
+            lines.push('', newTestContent, '');
+            const updatedContent = lines.join('\n');
+            await fs.writeFile(testFilePath, updatedContent, 'utf-8');
+            const validation = await validateTestFileSyntax(testFilePath);
+            if (!validation.valid) {
+                await fs.writeFile(testFilePath, content, 'utf-8');
+                return {
+                    success: false,
+                    error: `Syntax error after modification at line ${validation.location?.line}:${validation.location?.column}\n${validation.error}`,
+                    syntaxError: true,
+                    location: validation.location,
+                    suggestion: validation.suggestion
+                };
+            }
+            return {
+                success: true,
+                message: `Added tests for function '${functionName}' at end of file`,
+                replaced: false,
+                appended: true
+            };
+        }
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+// Strip ANSI color codes from output
+function stripAnsi(str) {
+    return str.replace(/\u001b\[[0-9;]*m/g, '').replace(/\\u001b\[[0-9;]*m/g, '');
+}
+function runTestsVitest(testFilePath, functionNames) {
+    try {
+        const packageManager = globals_1.g.CONFIG.packageManager || 'npm';
+        let command = packageManager === 'yarn'
+            ? `yarn test ${testFilePath} -- --reporter=dot --no-color`
+            : `npm run test ${testFilePath} -- --reporter=dot --no-color`;
+        if (functionNames && functionNames.length > 0) {
+            const escapedNames = functionNames.map(name => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+            const pattern = escapedNames.join('|');
+            command += ` -t "${pattern}"`;
+        }
+        const output = (0, child_process_1.execSync)(command, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            timeout: 60000,
+            maxBuffer: 10 * 1024 * 1024
+        });
+        return {
+            success: true,
+            output: stripAnsi(output),
+            passed: true,
+            command
+        };
+    }
+    catch (error) {
+        let output = '';
+        if (error.stdout)
+            output += error.stdout;
+        if (error.stderr)
+            output += error.stderr;
+        if (!output && error.message) {
+            output = error.message;
+        }
+        return {
+            success: false,
+            output: stripAnsi(output) || 'Test failed with no output captured',
+            passed: false,
+            error: error.message
+        };
+    }
+}
+function runTestsJest(testFilePath, functionNames) {
+    try {
+        let command = `npx jest ${testFilePath} --no-coverage --verbose=false`;
+        if (functionNames && functionNames.length > 0) {
+            const escapedNames = functionNames.map(name => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+            const pattern = escapedNames.join('|');
+            command += ` -t "${pattern}"`;
+        }
+        const output = (0, child_process_1.execSync)(command, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            timeout: 10000
+        });
+        return {
+            success: true,
+            output,
+            passed: true,
+            command
+        };
+    }
+    catch (error) {
+        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 {
+        const packageManager = globals_1.g.CONFIG.packageManager || 'npm';
+        let command = packageManager === 'yarn'
+            ? `yarn test ${testFilePath} -- --reporter=dot --no-color`
+            : `npm run test ${testFilePath} -- --reporter=dot --no-color`;
+        if (specificTestNames && specificTestNames.length > 0) {
+            const escapedNames = specificTestNames.map(name => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+            const pattern = escapedNames.join('|');
+            command += ` -t "${pattern}"`;
+        }
+        const output = (0, child_process_1.execSync)(command, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            timeout: 60000,
+            maxBuffer: 10 * 1024 * 1024
+        });
+        return {
+            success: true,
+            output: stripAnsi(output),
+            passed: true,
+            command
+        };
+    }
+    catch (error) {
+        let output = '';
+        if (error.stdout)
+            output += error.stdout;
+        if (error.stderr)
+            output += error.stderr;
+        if (!output && error.message) {
+            output = error.message;
+        }
+        return {
+            success: false,
+            output: stripAnsi(output) || 'Test failed with no output captured',
+            passed: false,
+            error: error.message
+        };
+    }
+}
+/**
+ * Parse test output to extract names of failing tests
+ * Works with both Vitest and Jest output formats
+ * Returns array of test names that failed
+ */
+function parseFailingTestNames(testOutput) {
+    const failingTests = [];
+    const lines = testOutput.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const bulletMatch = line.match(/^\s*●\s+(.+?)\s+›\s+(.+?)$/);
+        if (bulletMatch) {
+            const testName = bulletMatch[2].trim();
+            failingTests.push(testName);
+            continue;
+        }
+        const xMatch = line.match(/^\s*✕\s+(.+?)(?:\s+\(\d+m?s\))?$/);
+        if (xMatch) {
+            const testName = xMatch[1].trim();
+            failingTests.push(testName);
+            continue;
+        }
+        const failMatch = line.match(/^\s*✓?\s*(.+?)\s+\(\d+m?s\)$/);
+        if (failMatch && line.includes('✕')) {
+            const testName = failMatch[1].trim();
+            failingTests.push(testName);
+        }
+    }
+    return [...new Set(failingTests)];
+}
+function listDirectory(directoryPath) {
+    try {
+        if (!fsSync.existsSync(directoryPath)) {
+            return { success: false, error: `Directory not found: ${directoryPath}` };
+        }
+        const items = fsSync.readdirSync(directoryPath);
+        const details = items.map(item => {
+            const fullPath = path.join(directoryPath, item);
+            const stats = fsSync.statSync(fullPath);
+            return {
+                name: item,
+                path: fullPath,
+                type: stats.isDirectory() ? 'directory' : 'file',
+                isDirectory: stats.isDirectory()
+            };
+        });
+        return {
+            success: true,
+            path: directoryPath,
+            items: details,
+            files: details.filter(d => !d.isDirectory).map(d => d.name),
+            directories: details.filter(d => d.isDirectory).map(d => d.name)
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+function findFile(filename) {
+    try {
+        const searchDirs = ['src', 'tests', '.'];
+        const found = [];
+        function searchRecursive(dir) {
+            if (!fsSync.existsSync(dir))
+                return;
+            const items = fsSync.readdirSync(dir);
+            for (const item of items) {
+                const fullPath = path.join(dir, item);
+                const stats = fsSync.statSync(fullPath);
+                if (stats.isDirectory()) {
+                    if (!['node_modules', 'dist', 'build', '.git', 'coverage'].includes(item)) {
+                        searchRecursive(fullPath);
+                    }
+                }
+                else {
+                    const normalizedFullPath = fullPath.replace(/\\/g, '/');
+                    const normalizedSearch = filename.replace(/\\/g, '/');
+                    if (normalizedFullPath === normalizedSearch ||
+                        normalizedFullPath.includes(normalizedSearch) ||
+                        normalizedFullPath.endsWith(normalizedSearch) ||
+                        item === filename ||
+                        item.includes(filename)) {
+                        found.push(fullPath);
+                    }
+                }
+            }
+        }
+        for (const dir of searchDirs) {
+            searchRecursive(dir);
+        }
+        if (found.length === 0) {
+            return {
+                success: false,
+                error: `File "${filename}" not found in repository`
+            };
+        }
+        return {
+            success: true,
+            filename,
+            found: found,
+            count: found.length,
+            primaryMatch: found[0]
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Calculate relative import path from one file to one or more target files.
+ * Handles multiple paths for efficiency - AI can get all relative paths in a single call.
+ */
+function calculateRelativePath(fromFile, toFile) {
+    try {
+        const normalizedFromFile = normalizePath(fromFile);
+        if (!normalizedFromFile) {
+            return { success: false, error: `Invalid from_file path: "${fromFile}"` };
+        }
+        const toFiles = parseMultiplePaths(toFile);
+        if (toFiles.length === 0) {
+            return { success: false, error: `No valid to_file paths provided: "${toFile}"` };
+        }
+        const results = [];
+        const errors = [];
+        for (const targetFile of toFiles) {
+            const result = calculateSingleRelativePath(normalizedFromFile, targetFile);
+            if (result.success) {
+                results.push(result);
+            }
+            else {
+                errors.push({ file: targetFile, error: result.error });
+            }
+        }
+        if (toFiles.length === 1) {
+            return results.length > 0 ? results[0] : errors[0];
+        }
+        else {
+            return {
+                success: errors.length === 0,
+                from: normalizedFromFile,
+                totalFiles: toFiles.length,
+                successCount: results.length,
+                errorCount: errors.length,
+                results,
+                errors: errors.length > 0 ? errors : undefined
+            };
+        }
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Parse comma-separated or space-separated file paths into an array.
+ */
+function parseMultiplePaths(input) {
+    if (!input || typeof input !== 'string') {
+        return [];
+    }
+    const paths = input
+        .split(',')
+        .map(p => p.trim())
+        .filter(p => p.length > 0)
+        .map(p => normalizePath(p))
+        .filter((p) => p !== null);
+    return paths;
+}
+/**
+ * Normalize a file path - handle various edge cases.
+ */
+function normalizePath(filePath) {
+    if (!filePath || typeof filePath !== 'string') {
+        return null;
+    }
+    let normalized = filePath.trim();
+    if ((normalized.startsWith('"') && normalized.endsWith('"')) ||
+        (normalized.startsWith("'") && normalized.endsWith("'"))) {
+        normalized = normalized.slice(1, -1);
+    }
+    normalized = normalized.replace(/\\/g, '/');
+    if (normalized.startsWith('./')) {
+        normalized = normalized.slice(2);
+    }
+    normalized = normalized.replace(/\/+/g, '/');
+    if (normalized.endsWith('/')) {
+        normalized = normalized.slice(0, -1);
+    }
+    if (normalized.length === 0 || /^[\s@#$%^&*]/.test(normalized)) {
+        return null;
+    }
+    return normalized;
+}
+/**
+ * Calculate relative path from one file to a single target file.
+ */
+function calculateSingleRelativePath(fromFile, toFile) {
+    try {
+        const fromDir = path.dirname(fromFile);
+        let relativePath = path.relative(fromDir, toFile);
+        if (!relativePath) {
+            const basename = path.basename(toFile);
+            relativePath = './' + basename;
+        }
+        relativePath = relativePath.replace(/\.(ts|tsx|js|jsx)$/, '');
+        relativePath = relativePath.replace(/\/index$/, '');
+        if (!relativePath.startsWith('.') && !relativePath.startsWith('..')) {
+            relativePath = './' + relativePath;
+        }
+        relativePath = relativePath.replace(/\\/g, '/');
+        if (relativePath === '.') {
+            const basename = path.basename(toFile).replace(/\.(ts|tsx|js|jsx)$/, '');
+            relativePath = './' + basename;
+        }
+        return {
+            success: true,
+            from: fromFile,
+            to: toFile,
+            relativePath,
+            importStatement: `import { ... } from '${relativePath}';`
+        };
+    }
+    catch (error) {
+        return { success: false, file: toFile, error: error.message };
+    }
+}
+async function deleteLines(filePath, startLine, endLine) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        if (startLine < 1 || endLine < 1 || startLine > lines.length || endLine > lines.length) {
+            return {
+                success: false,
+                error: `Invalid line range: ${startLine}-${endLine}. File has ${lines.length} lines.`
+            };
+        }
+        if (startLine > endLine) {
+            return {
+                success: false,
+                error: `Start line (${startLine}) must be <= end line (${endLine})`
+            };
+        }
+        const deletedLines = lines.splice(startLine - 1, endLine - startLine + 1);
+        await fs.writeFile(filePath, lines.join('\n'), 'utf-8');
+        return {
+            success: true,
+            message: `Deleted lines ${startLine}-${endLine}`,
+            deletedCount: deletedLines.length,
+            deletedContent: deletedLines.join('\n')
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+async function insertLines(filePath, lineNumber, content) {
+    try {
+        const fileContent = await fs.readFile(filePath, 'utf-8');
+        const lines = fileContent.split('\n');
+        if (lineNumber < 1 || lineNumber > lines.length + 1) {
+            return {
+                success: false,
+                error: `Invalid line number: ${lineNumber}. File has ${lines.length} lines (use 1-${lines.length + 1}).`
+            };
+        }
+        const newLines = content.split('\n');
+        lines.splice(lineNumber - 1, 0, ...newLines);
+        await fs.writeFile(filePath, lines.join('\n'), 'utf-8');
+        return {
+            success: true,
+            message: `Inserted ${newLines.length} line(s) at line ${lineNumber}`,
+            insertedCount: newLines.length
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+async function replaceLines(filePath, startLine, endLine, newContent) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        if (startLine < 1 || endLine < 1 || startLine > lines.length || endLine > lines.length) {
+            return {
+                success: false,
+                error: `Invalid line range: ${startLine}-${endLine}. File has ${lines.length} lines.`
+            };
+        }
+        if (startLine > endLine) {
+            return {
+                success: false,
+                error: `Start line (${startLine}) must be <= end line (${endLine})`
+            };
+        }
+        const oldLines = lines.splice(startLine - 1, endLine - startLine + 1, ...newContent.split('\n'));
+        await fs.writeFile(filePath, lines.join('\n'), 'utf-8');
+        return {
+            success: true,
+            message: `Replaced lines ${startLine}-${endLine}`,
+            oldContent: oldLines.join('\n'),
+            newLineCount: newContent.split('\n').length
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Search and replace a code block using fuzzy matching
+ * Much more reliable than line-based editing!
+ */
+async function searchReplaceBlock(filePath, search, replace, matchMode = 'normalized') {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        if (matchMode !== 'exact' && content.includes(search)) {
+            const newContent = content.replace(search, replace);
+            await fs.writeFile(filePath, newContent, 'utf-8');
+            if (filePath.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/)) {
+                const validation = await validateTestFileSyntax(filePath);
+                if (!validation.valid) {
+                    await fs.writeFile(filePath, content, 'utf-8');
+                    return {
+                        success: false,
+                        error: `Syntax error after modification at line ${validation.location?.line}:${validation.location?.column}\n${validation.error}`,
+                        syntaxError: true,
+                        location: validation.location,
+                        suggestion: validation.suggestion
+                    };
+                }
+            }
+            return {
+                success: true,
+                message: 'Replaced block (exact match)',
+                matchMode: 'exact',
+                confidence: 1.0,
+                linesChanged: newContent.split('\n').length - content.split('\n').length
+            };
+        }
+        const contentSize = content.length;
+        const searchSize = search.length;
+        const isLargeOperation = contentSize > 200000 || searchSize > 2000;
+        const searchMode = isLargeOperation ? 'normalized' : matchMode;
+        const result = (0, fuzzyMatcher_1.smartSearch)(content, search, searchMode);
+        if (!result || !result.found) {
+            const suggestions = isLargeOperation ? [] : (0, fuzzyMatcher_1.findSimilarBlocks)(content, search, 3);
+            const errorMessage = isLargeOperation
+                ? 'Search block not found. File is large - try including more unique context or use exact match mode.'
+                : (0, fuzzyMatcher_1.getSearchFailureMessage)(content, search);
+            return {
+                success: false,
+                error: errorMessage,
+                searchPreview: search.substring(0, 200) + (search.length > 200 ? '...' : ''),
+                suggestions: suggestions.map(s => ({
+                    text: s.text.substring(0, 150) + (s.text.length > 150 ? '...' : ''),
+                    similarity: Math.round(s.similarity * 100) + '%',
+                    lines: `${s.startLine}-${s.endLine}`
+                })),
+                hint: suggestions.length > 0
+                    ? `Found ${suggestions.length} similar block(s). Check if your search text has typos or try including more context lines.`
+                    : 'No similar blocks found. Make sure your search text matches the file content and includes enough context (3-5 lines around the target).'
+            };
+        }
+        const newContent = content.substring(0, result.startIndex) +
+            replace +
+            content.substring(result.endIndex);
+        await fs.writeFile(filePath, newContent, 'utf-8');
+        if (filePath.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/)) {
+            const validation = await validateTestFileSyntax(filePath);
+            if (!validation.valid) {
+                await fs.writeFile(filePath, content, 'utf-8');
+                return {
+                    success: false,
+                    error: `Syntax error after modification at line ${validation.location?.line}:${validation.location?.column}\n${validation.error}`,
+                    syntaxError: true,
+                    location: validation.location,
+                    suggestion: validation.suggestion
+                };
+            }
+        }
+        const getLineNumber = (charIndex) => {
+            return content.substring(0, charIndex).split('\n').length;
+        };
+        const startLine = getLineNumber(result.startIndex);
+        const endLine = getLineNumber(result.endIndex);
+        return {
+            success: true,
+            message: `Replaced block successfully using ${result.matchType} matching`,
+            matchMode: result.matchType,
+            confidence: result.confidence,
+            linesChanged: newContent.split('\n').length - content.split('\n').length,
+            linesReplaced: `${startLine}-${endLine}`,
+            replacedText: result.originalText.substring(0, 200) + (result.originalText.length > 200 ? '...' : '')
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Insert content at a specific position in the file
+ * Simpler than search_replace_block for adding new content
+ */
+async function insertAtPosition(filePath, content, position, afterMarker) {
+    try {
+        const fileContent = await fs.readFile(filePath, 'utf-8');
+        const lines = fileContent.split('\n');
+        let insertIndex = 0;
+        let insertionPoint = '';
+        if (afterMarker) {
+            const result = (0, fuzzyMatcher_1.smartSearch)(fileContent, afterMarker, 'normalized');
+            if (!result || !result.found) {
+                return {
+                    success: false,
+                    error: `Marker not found: "${afterMarker.substring(0, 100)}..."`,
+                    hint: 'Use search_replace_block or specify a position instead'
+                };
+            }
+            let charCount = 0;
+            for (let i = 0; i < lines.length; i++) {
+                charCount += lines[i].length + 1;
+                if (charCount >= result.endIndex) {
+                    insertIndex = i + 1;
+                    insertionPoint = `after marker at line ${i + 1}`;
+                    break;
+                }
+            }
+        }
+        else {
+            switch (position) {
+                case 'beginning':
+                    insertIndex = 0;
+                    insertionPoint = 'beginning of file';
+                    break;
+                case 'end':
+                    insertIndex = lines.length;
+                    insertionPoint = 'end of file';
+                    break;
+                case 'after_imports': {
+                    let lastImportLine = -1;
+                    let insideMultiLineImport = false;
+                    for (let i = 0; i < lines.length; i++) {
+                        const trimmed = lines[i].trim();
+                        // Track multi-line import/require statements
+                        if (insideMultiLineImport) {
+                            lastImportLine = i;
+                            // Check if this line closes the multi-line import
+                            if (trimmed.includes('from ') || trimmed.endsWith(');') ||
+                                (trimmed.startsWith('}') && !trimmed.includes('{'))) {
+                                insideMultiLineImport = false;
+                            }
+                            continue;
+                        }
+                        if (trimmed.startsWith('import ') || trimmed.startsWith('require(') ||
+                            (trimmed.startsWith('const ') && trimmed.includes('require('))) {
+                            lastImportLine = i;
+                            // Detect if this is a multi-line import (has opening { but no closing } or no from)
+                            const hasOpenBrace = trimmed.includes('{');
+                            const hasCloseBrace = trimmed.includes('}');
+                            const hasFrom = trimmed.includes('from ');
+                            const endsWithSemicolon = trimmed.endsWith(';');
+                            if (hasOpenBrace && !hasCloseBrace) {
+                                insideMultiLineImport = true;
+                            }
+                            else if (trimmed.startsWith('import ') && !hasFrom && !endsWithSemicolon) {
+                                insideMultiLineImport = true;
+                            }
+                        }
+                        else if (trimmed && !trimmed.startsWith('//') && !trimmed.startsWith('/*') && !trimmed.startsWith('*') && lastImportLine >= 0) {
+                            break;
+                        }
+                    }
+                    if (lastImportLine === -1) {
+                        return {
+                            success: false,
+                            error: 'No import statements found in file',
+                            hint: 'Use position: "beginning" instead or specify after_marker'
+                        };
+                    }
+                    insertIndex = lastImportLine + 1;
+                    insertionPoint = `after imports at line ${lastImportLine + 1}`;
+                    break;
+                }
+                case 'before_first_describe': {
+                    let firstDescribe = -1;
+                    for (let i = 0; i < lines.length; i++) {
+                        if (lines[i].trim().startsWith('describe(')) {
+                            firstDescribe = i;
+                            break;
+                        }
+                    }
+                    if (firstDescribe === -1) {
+                        return {
+                            success: false,
+                            error: 'No describe blocks found in file',
+                            hint: 'Use position: "end" instead or specify after_marker'
+                        };
+                    }
+                    insertIndex = firstDescribe;
+                    insertionPoint = `before first describe at line ${firstDescribe + 1}`;
+                    break;
+                }
+                default:
+                    insertIndex = lines.length;
+                    insertionPoint = 'end of file';
+            }
+        }
+        const contentLines = content.split('\n');
+        lines.splice(insertIndex, 0, ...contentLines);
+        const newContent = lines.join('\n');
+        await fs.writeFile(filePath, newContent, 'utf-8');
+        if (filePath.match(/\.(test|spec)\.(ts|js|tsx|jsx)$/)) {
+            const validation = await validateTestFileSyntax(filePath);
+            if (!validation.valid) {
+                await fs.writeFile(filePath, fileContent, 'utf-8');
+                return {
+                    success: false,
+                    error: `Syntax error after modification at line ${validation.location?.line}:${validation.location?.column}\n${validation.error}`,
+                    syntaxError: true,
+                    location: validation.location,
+                    suggestion: validation.suggestion
+                };
+            }
+        }
+        return {
+            success: true,
+            message: `Inserted ${contentLines.length} line(s) at ${insertionPoint}`,
+            insertedAt: insertionPoint,
+            lineCount: contentLines.length
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * Write code review findings to a markdown file in the reviews/ directory
+ */
+async function writeReview(filePath, reviewContent) {
+    try {
+        const reviewsDir = path.dirname(filePath);
+        if (!fsSync.existsSync(reviewsDir)) {
+            await fs.mkdir(reviewsDir, { recursive: true });
+        }
+        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}`
+        };
+    }
+}
+// Search codebase utility
+function searchCodebase(pattern, fileExtension, maxResults = 20, filesOnly = false) {
+    try {
+        const limit = Math.min(maxResults || 20, 50);
+        let cmd = `grep -rn`;
+        if (filesOnly) {
+            cmd = `grep -rl`;
+        }
+        else {
+            cmd += ` -C 1`;
+        }
+        if (fileExtension) {
+            const ext = fileExtension.startsWith('.') ? fileExtension : `.${fileExtension}`;
+            cmd += ` --include="*${ext}"`;
+        }
+        const excludeDirs = ['node_modules', 'dist', 'build', '.git', 'coverage', '.codeguard-cache', '.jest-cache', '.testgen-cache', '.vitest', 'reviews'];
+        for (const dir of excludeDirs) {
+            cmd += ` --exclude-dir=${dir}`;
+        }
+        cmd += ` "${pattern}" .`;
+        cmd += ` | head -n ${limit * 3}`;
+        const output = (0, child_process_1.execSync)(cmd, {
+            encoding: 'utf-8',
+            cwd: process.cwd(),
+            maxBuffer: 5 * 1024 * 1024,
+            stdio: ['pipe', 'pipe', 'ignore']
+        });
+        if (filesOnly) {
+            const files = output.trim().split('\n').filter(f => f.length > 0).slice(0, limit);
+            return {
+                success: true,
+                pattern,
+                filesOnly: true,
+                totalFiles: files.length,
+                files: files.map(f => ({ file: f })),
+                message: `Found ${files.length} file(s) matching pattern`,
+                hint: 'Use search_codebase with files_only=false on specific files to see content'
+            };
+        }
+        const lines = output.trim().split('\n').slice(0, limit);
+        const results = [];
+        const fileSet = new Set();
+        let currentFile = '';
+        let currentMatches = [];
+        for (const line of lines) {
+            if (line.includes(':')) {
+                const match = line.match(/^([^:]+):(\d+):(.*)/);
+                if (match) {
+                    const [, file, lineNum, content] = match;
+                    fileSet.add(file);
+                    if (file !== currentFile) {
+                        if (currentFile && currentMatches.length > 0) {
+                            results.push({
+                                file: currentFile,
+                                matchCount: currentMatches.length,
+                                matches: currentMatches.slice(0, 5)
+                            });
+                        }
+                        currentFile = file;
+                        currentMatches = [];
+                    }
+                    const truncatedContent = content.length > 150 ? content.substring(0, 150) + '...' : content;
+                    currentMatches.push(`Line ${lineNum}: ${truncatedContent}`);
+                }
+            }
+        }
+        if (currentFile && currentMatches.length > 0) {
+            results.push({
+                file: currentFile,
+                matchCount: currentMatches.length,
+                matches: currentMatches.slice(0, 5)
+            });
+        }
+        const totalMatches = results.reduce((sum, r) => sum + r.matchCount, 0);
+        return {
+            success: true,
+            pattern,
+            totalFiles: fileSet.size,
+            totalMatches,
+            files: results.slice(0, 10),
+            truncated: results.length > 10 || lines.length >= limit,
+            message: `Found ${fileSet.size} file(s) with ${totalMatches} match(es)${results.length > 10 ? ' (showing first 10 files)' : ''}`,
+            hint: results.length > 10 ? 'Too many results. Try adding file_extension filter or more specific pattern.' : undefined
+        };
+    }
+    catch (error) {
+        if (error.status === 1 || error.message?.includes('No such file')) {
+            return {
+                success: true,
+                pattern,
+                totalFiles: 0,
+                totalMatches: 0,
+                files: [],
+                message: 'No matches found'
+            };
+        }
+        return {
+            success: false,
+            error: `Search failed: ${error.message}`
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Tool execution router
+// ---------------------------------------------------------------------------
+async function executeTool(toolName, args) {
+    let friendlyMessage = toolDefinitions_1.TOOL_MESSAGES[toolName] || `🔧 ${toolName}`;
+    if (toolName === 'upsert_function_tests' && args.function_name) {
+        friendlyMessage = `✍️  Writing/updating test cases for function: ${args.function_name}`;
+    }
+    else if (toolName === 'search_replace_block') {
+        const preview = args.search ? args.search.substring(0, 50) + (args.search.length > 50 ? '...' : '') : '';
+        friendlyMessage = `🔍🔄 Searching for: "${preview}"`;
+    }
+    else if (toolName === 'insert_at_position' && args.position) {
+        friendlyMessage = `➕ Inserting at: ${args.position}`;
+    }
+    else if (toolName === 'read_file_lines' && args.start_line && args.end_line) {
+        friendlyMessage = `📖 Reading lines ${args.start_line}-${args.end_line}`;
+    }
+    (0, globals_1.updateSpinner)(friendlyMessage);
+    let result;
+    try {
+        switch (toolName) {
+            case 'read_file':
+                result = await readFile(args.file_path);
+                break;
+            case 'read_file_lines':
+                result = await readFileLines(args.file_path, args.start_line, args.end_line);
+                break;
+            case 'analyze_file_ast':
+                if (globals_1.g.globalIndexer && !args.function_name) {
+                    if (globals_1.g.globalIndexer.isFileStale(args.file_path)) {
+                        globals_1.g.globalSpinner.text = '🔄 File modified, re-analyzing...';
+                        result = (0, ast_1.analyzeFileAST)(args.file_path, args.function_name);
+                        if (result.success && !args.function_name) {
+                            await globals_1.g.globalIndexer.updateIndex([args.file_path], ast_1.analyzeFileAST);
+                        }
+                        break;
+                    }
+                    const cached = globals_1.g.globalIndexer.getFileAnalysis(args.file_path);
+                    if (cached) {
+                        globals_1.g.globalSpinner.text = '📦 Using cached analysis';
+                        result = {
+                            success: true,
+                            analysis: cached,
+                            summary: {
+                                functionCount: cached.functions.length,
+                                classCount: cached.classes.length,
+                                exportCount: cached.exports.length,
+                                typeCount: cached.types.length,
+                            }
+                        };
+                        break;
+                    }
+                }
+                result = (0, ast_1.analyzeFileAST)(args.file_path, args.function_name);
+                break;
+            case 'get_function_ast':
+                result = (0, ast_1.getFunctionAST)(args.file_path, args.function_name);
+                break;
+            case 'get_imports_ast':
+                result = (0, ast_1.getImportsAST)(args.file_path);
+                break;
+            case 'get_type_definitions':
+                result = (0, ast_1.getTypeDefinitions)(args.file_path);
+                break;
+            case 'get_class_methods':
+                result = (0, ast_1.getClassMethods)(args.file_path, args.class_name);
+                break;
+            case 'get_file_preamble':
+                result = (0, ast_1.getFilePreamble)(args.file_path);
+                break;
+            case 'resolve_import_path':
+                result = resolveImportPath(args.from_file, args.import_path);
+                break;
+            case 'upsert_function_tests':
+                if (globals_1.g.EXPECTED_TEST_FILE_PATH && args.test_file_path !== globals_1.g.EXPECTED_TEST_FILE_PATH) {
+                    const normalizedExpected = path.normalize(globals_1.g.EXPECTED_TEST_FILE_PATH).replace(/\\/g, '/');
+                    const normalizedProvided = path.normalize(args.test_file_path).replace(/\\/g, '/');
+                    if (normalizedExpected !== normalizedProvided) {
+                        if (globals_1.g.globalSpinner)
+                            globals_1.g.globalSpinner.stop();
+                        console.log(`\n⚠️  BLOCKED: AI attempted separate test file, enforcing single file policy`);
+                        (0, globals_1.updateSpinner)(friendlyMessage);
+                        args.test_file_path = globals_1.g.EXPECTED_TEST_FILE_PATH;
+                    }
+                }
+                result = await replaceFunctionTests(args.test_file_path, args.function_name, args.new_test_content);
+                break;
+            case 'run_tests':
+                if (globals_1.g.CONFIG.testEnv == 'vitest') {
+                    result = runTestsVitest(args.test_file_path, args.function_names);
+                }
+                else {
+                    result = runTestsJest(args.test_file_path, args.function_names);
+                }
+                break;
+            case 'list_directory':
+                result = listDirectory(args.directory_path);
+                break;
+            case 'find_file':
+                result = findFile(args.filename);
+                break;
+            case 'calculate_relative_path':
+                result = calculateRelativePath(args.from_file, args.to_file);
+                break;
+            case 'search_replace_block':
+                result = await searchReplaceBlock(args.file_path, args.search, args.replace, args.match_mode);
+                break;
+            case 'insert_at_position':
+                result = await insertAtPosition(args.file_path, args.content, args.position, args.after_marker);
+                break;
+            case 'write_review':
+                result = await writeReview(args.file_path, args.review_content);
+                break;
+            case 'search_codebase':
+                result = searchCodebase(args.pattern, args.file_extension, args.max_results, args.files_only);
+                break;
+            default:
+                result = { success: false, error: `Unknown tool: ${toolName}` };
+        }
+    }
+    catch (error) {
+        result = { success: false, error: error.message, stack: error.stack };
+    }
+    if (result.success) {
+        await new Promise(resolve => setTimeout(resolve, 150));
+    }
+    return result;
+}
+//# sourceMappingURL=toolHandlers.js.map