codeguard-testgen 1.0.14 → 1.0.16

package/dist/ast.js

@@ -0,0 +1,988 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFileToAST = parseFileToAST;
+exports.analyzeFileAST = analyzeFileAST;
+exports.getFunctionAST = getFunctionAST;
+exports.getImportsAST = getImportsAST;
+exports.getTypeDefinitions = getTypeDefinitions;
+exports.getFilePreamble = getFilePreamble;
+exports.getClassMethods = getClassMethods;
+const fsSync = require("fs");
+const path = require("path");
+const babelParser = require("@babel/parser");
+const traverse = require('@babel/traverse').default;
+const globals_1 = require("./globals");
+const pathResolver_1 = require("./pathResolver");
+// AST Parsing utilities
+function parseFileToAST(filePath, content) {
+    const ext = path.extname(filePath);
+    try {
+        return babelParser.parse(content, {
+            sourceType: 'module',
+            plugins: [
+                'typescript',
+                ext === '.tsx' || ext === '.jsx' ? 'jsx' : null,
+                'decorators-legacy',
+                'classProperties',
+                'objectRestSpread',
+                'asyncGenerators',
+                'dynamicImport',
+                'optionalChaining',
+                'nullishCoalescingOperator'
+            ].filter(Boolean)
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to parse ${filePath}: ${error.message}`);
+    }
+}
+function analyzeFileAST(filePath, functionName) {
+    try {
+        const content = fsSync.readFileSync(filePath, 'utf-8');
+        const ast = parseFileToAST(filePath, content);
+        if (!ast || !ast.program) {
+            throw new Error('Failed to parse AST: no program node found');
+        }
+        const analysis = {
+            functions: [],
+            classes: [],
+            exports: [],
+            imports: [],
+            types: [],
+            constants: [],
+            routeRegistrations: []
+        };
+        traverse(ast, {
+            // Function declarations
+            FunctionDeclaration(path) {
+                const node = path.node;
+                analysis.functions.push({
+                    name: node.id?.name,
+                    type: 'function',
+                    async: node.async,
+                    generator: node.generator,
+                    params: node.params.map(p => extractParamInfo(p)),
+                    returnType: node.returnType ? getTypeAnnotation(node.returnType) : null,
+                    line: node.loc?.start.line,
+                    exported: path.parent.type === 'ExportNamedDeclaration' ||
+                        path.parent.type === 'ExportDefaultDeclaration'
+                });
+            },
+            // Arrow functions and function expressions
+            VariableDeclarator(path) {
+                const node = path.node;
+                if (node.init && (node.init.type === 'ArrowFunctionExpression' ||
+                    node.init.type === 'FunctionExpression')) {
+                    analysis.functions.push({
+                        name: node.id.name,
+                        type: node.init.type === 'ArrowFunctionExpression' ? 'arrow' : 'function',
+                        async: node.init.async,
+                        params: node.init.params.map(p => extractParamInfo(p)),
+                        returnType: node.init.returnType ? getTypeAnnotation(node.init.returnType) : null,
+                        line: node.loc?.start.line,
+                        exported: path.parentPath.parent.type === 'ExportNamedDeclaration'
+                    });
+                }
+                else if (node.init) {
+                    // Constants
+                    analysis.constants.push({
+                        name: node.id.name,
+                        type: node.id.typeAnnotation ? getTypeAnnotation(node.id.typeAnnotation) : null,
+                        line: node.loc?.start.line
+                    });
+                }
+            },
+            // Classes
+            ClassDeclaration(path) {
+                const node = path.node;
+                const methods = [];
+                if (node.body && node.body.body) {
+                    node.body.body.forEach(member => {
+                        if (member.type === 'ClassMethod' || member.type === 'MethodDefinition') {
+                            methods.push({
+                                name: member.key.name,
+                                kind: member.kind,
+                                static: member.static,
+                                async: member.async,
+                                params: member.params ? member.params.map(p => extractParamInfo(p)) : [],
+                                returnType: member.returnType ? getTypeAnnotation(member.returnType) : null
+                            });
+                        }
+                    });
+                }
+                analysis.classes.push({
+                    name: node.id?.name,
+                    methods,
+                    superClass: node.superClass?.name,
+                    line: node.loc?.start.line,
+                    exported: path.parent.type === 'ExportNamedDeclaration' ||
+                        path.parent.type === 'ExportDefaultDeclaration'
+                });
+            },
+            // Type definitions
+            TSTypeAliasDeclaration(path) {
+                analysis.types.push({
+                    name: path.node.id.name,
+                    kind: 'type',
+                    line: path.node.loc?.start.line
+                });
+            },
+            TSInterfaceDeclaration(path) {
+                analysis.types.push({
+                    name: path.node.id.name,
+                    kind: 'interface',
+                    line: path.node.loc?.start.line
+                });
+            },
+            // Exports
+            ExportNamedDeclaration(path) {
+                if (path.node.specifiers) {
+                    path.node.specifiers.forEach(spec => {
+                        analysis.exports.push({
+                            name: spec.exported.name,
+                            local: spec.local.name,
+                            type: 'named'
+                        });
+                    });
+                }
+            },
+            ExportDefaultDeclaration(path) {
+                const declaration = path.node.declaration;
+                let name = 'default';
+                if (declaration.id) {
+                    name = declaration.id.name;
+                }
+                else if (declaration.name) {
+                    name = declaration.name;
+                }
+                analysis.exports.push({
+                    name,
+                    type: 'default'
+                });
+            }
+        });
+        // Detect route registrations
+        analysis.routeRegistrations = detectRouteRegistrations(content, analysis.imports);
+        // Filter to specific function if requested (token optimization)
+        if (functionName) {
+            const targetFunction = analysis.functions.find(f => f.name === functionName);
+            if (!targetFunction) {
+                const available = analysis.functions.map(f => f.name).slice(0, 10).join(', ');
+                const more = analysis.functions.length > 10 ? ` (and ${analysis.functions.length - 10} more)` : '';
+                return {
+                    success: false,
+                    error: `Function '${functionName}' not found in ${filePath}. Available functions: ${available}${more}`
+                };
+            }
+            let relatedClass = null;
+            for (const cls of analysis.classes) {
+                if (cls.methods?.some((m) => m.name === functionName)) {
+                    relatedClass = cls;
+                    break;
+                }
+            }
+            return {
+                success: true,
+                analysis: {
+                    functions: [targetFunction],
+                    classes: relatedClass ? [relatedClass] : [],
+                    exports: analysis.exports.filter(e => e.name === functionName || e.local === functionName),
+                    imports: analysis.imports,
+                    types: [],
+                    constants: [],
+                    routeRegistrations: analysis.routeRegistrations.filter(r => r.handler === functionName)
+                },
+                summary: {
+                    functionCount: 1,
+                    classCount: relatedClass ? 1 : 0,
+                    exportCount: analysis.exports.filter(e => e.name === functionName || e.local === functionName).length,
+                    typeCount: 0,
+                    filtered: true,
+                    targetFunction: functionName
+                }
+            };
+        }
+        return {
+            success: true,
+            analysis,
+            summary: {
+                functionCount: analysis.functions.length,
+                classCount: analysis.classes.length,
+                exportCount: analysis.exports.length,
+                typeCount: analysis.types.length
+            }
+        };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}
+// Fast route detection using regex patterns
+function detectRouteRegistrations(code, imports) {
+    const registrations = [];
+    // Express: router.get('/users', getUsers) or app.post('/users', createUser)
+    const expressPattern = /\b(app|router)\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(\w+)/g;
+    for (const match of code.matchAll(expressPattern)) {
+        registrations.push({
+            framework: 'express',
+            method: match[2].toUpperCase(),
+            path: match[3],
+            handler: match[4],
+            handlerImportedFrom: findImportSource(match[4], imports),
+            line: getLineNumber(code, match.index || 0)
+        });
+    }
+    // Fastify: fastify.get('/users', getUsers)
+    const fastifyPattern = /\bfastify\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(\w+)/g;
+    for (const match of code.matchAll(fastifyPattern)) {
+        registrations.push({
+            framework: 'fastify',
+            method: match[1].toUpperCase(),
+            path: match[2],
+            handler: match[3],
+            handlerImportedFrom: findImportSource(match[3], imports),
+            line: getLineNumber(code, match.index || 0)
+        });
+    }
+    // Koa: router.get('/users', getUsers)
+    const koaPattern = /\brouter\.(get|post|put|delete|patch)\s*\(\s*['"]([^'"]+)['"]\s*,\s*(\w+)/g;
+    for (const match of code.matchAll(koaPattern)) {
+        registrations.push({
+            framework: 'koa',
+            method: match[1].toUpperCase(),
+            path: match[2],
+            handler: match[3],
+            handlerImportedFrom: findImportSource(match[3], imports),
+            line: getLineNumber(code, match.index || 0)
+        });
+    }
+    return registrations;
+}
+function findImportSource(functionName, imports) {
+    for (const imp of imports) {
+        if (imp.imported && Array.isArray(imp.imported)) {
+            if (imp.imported.some((i) => i.local === functionName || i.imported === functionName)) {
+                return imp.source;
+            }
+        }
+    }
+    return undefined;
+}
+function getLineNumber(code, index) {
+    return code.substring(0, index).split('\n').length;
+}
+function extractParamInfo(param) {
+    if (param.type === 'Identifier') {
+        return {
+            name: param.name,
+            type: param.typeAnnotation ? getTypeAnnotation(param.typeAnnotation) : null,
+            optional: param.optional
+        };
+    }
+    else if (param.type === 'RestElement') {
+        return {
+            name: param.argument.name,
+            rest: true,
+            type: param.typeAnnotation ? getTypeAnnotation(param.typeAnnotation) : null
+        };
+    }
+    else if (param.type === 'AssignmentPattern') {
+        return {
+            name: param.left.name,
+            defaultValue: true,
+            type: param.left.typeAnnotation ? getTypeAnnotation(param.left.typeAnnotation) : null
+        };
+    }
+    else if (param.type === 'ObjectPattern') {
+        // Handle destructured object params like { x, y, z: zValue }
+        const properties = param.properties.map((prop) => {
+            if (prop.type === 'RestElement') {
+                return { name: prop.argument.name, rest: true };
+            }
+            return { name: prop.value.name };
+        });
+        return {
+            name: `{ ${properties.map((p) => p.name).join(', ')} }`,
+            destructured: true,
+            destructuredProps: properties,
+            type: param.typeAnnotation ? getTypeAnnotation(param.typeAnnotation) : null
+        };
+    }
+    else if (param.type === 'ArrayPattern') {
+        // Handle destructured array params like [a, b, c]
+        const elements = param.elements
+            .filter((el) => el !== null)
+            .map((el) => {
+            if (el.type === 'RestElement') {
+                return { name: el.argument.name, rest: true };
+            }
+            return { name: el.name };
+        });
+        return {
+            name: `[ ${elements.map((e) => e.name).join(', ')} ]`,
+            destructured: true,
+            destructuredElements: elements,
+            type: param.typeAnnotation ? getTypeAnnotation(param.typeAnnotation) : null
+        };
+    }
+    return { name: 'unknown' };
+}
+function getTypeAnnotation(typeNode) {
+    if (!typeNode)
+        return null;
+    if (typeNode.typeAnnotation) {
+        typeNode = typeNode.typeAnnotation;
+    }
+    if (typeNode.type === 'TSStringKeyword')
+        return 'string';
+    if (typeNode.type === 'TSNumberKeyword')
+        return 'number';
+    if (typeNode.type === 'TSBooleanKeyword')
+        return 'boolean';
+    if (typeNode.type === 'TSAnyKeyword')
+        return 'any';
+    if (typeNode.type === 'TSVoidKeyword')
+        return 'void';
+    if (typeNode.type === 'TSUndefinedKeyword')
+        return 'undefined';
+    if (typeNode.type === 'TSNullKeyword')
+        return 'null';
+    if (typeNode.type === 'TSNeverKeyword')
+        return 'never';
+    if (typeNode.type === 'TSUnknownKeyword')
+        return 'unknown';
+    if (typeNode.type === 'TSObjectKeyword')
+        return 'object';
+    if (typeNode.type === 'TSTypeReference' && typeNode.typeName) {
+        // Resolve qualified names like Foo.Bar
+        const name = typeNode.typeName.type === 'TSQualifiedName'
+            ? `${typeNode.typeName.left?.name}.${typeNode.typeName.right?.name}`
+            : (typeNode.typeName.name || 'unknown');
+        // Preserve generics: Promise<User>, Array<string>, Record<string, any>, etc.
+        if (typeNode.typeParameters?.params?.length) {
+            const params = typeNode.typeParameters.params
+                .map((p) => getTypeAnnotation(p))
+                .join(', ');
+            return `${name}<${params}>`;
+        }
+        return name;
+    }
+    if (typeNode.type === 'TSArrayType') {
+        const elementType = getTypeAnnotation(typeNode.elementType);
+        return `${elementType}[]`;
+    }
+    if (typeNode.type === 'TSUnionType') {
+        return typeNode.types.map((t) => getTypeAnnotation(t)).join(' | ');
+    }
+    if (typeNode.type === 'TSIntersectionType') {
+        return typeNode.types.map((t) => getTypeAnnotation(t)).join(' & ');
+    }
+    if (typeNode.type === 'TSTupleType') {
+        const elements = (typeNode.elementTypes || typeNode.elements || [])
+            .map((t) => getTypeAnnotation(t))
+            .join(', ');
+        return `[${elements}]`;
+    }
+    if (typeNode.type === 'TSLiteralType') {
+        const lit = typeNode.literal;
+        if (lit?.type === 'StringLiteral')
+            return `'${lit.value}'`;
+        if (lit?.type === 'NumericLiteral')
+            return String(lit.value);
+        if (lit?.type === 'BooleanLiteral')
+            return String(lit.value);
+    }
+    if (typeNode.type === 'TSParenthesizedType') {
+        return getTypeAnnotation(typeNode.typeAnnotation);
+    }
+    if (typeNode.type === 'TSOptionalType') {
+        return `${getTypeAnnotation(typeNode.typeAnnotation)}?`;
+    }
+    return 'unknown';
+}
+function getFunctionAST(filePath, functionName) {
+    const searchInFile = (targetPath) => {
+        try {
+            const content = fsSync.readFileSync(targetPath, 'utf-8');
+            const ast = parseFileToAST(targetPath, content);
+            const lines = content.split('\n');
+            let functionInfo = null;
+            traverse(ast, {
+                FunctionDeclaration(path) {
+                    if (path.node.id?.name === functionName) {
+                        functionInfo = extractFunctionDetails(path, lines);
+                        path.stop();
+                    }
+                },
+                VariableDeclarator(path) {
+                    if (path.node.id.name === functionName &&
+                        (path.node.init?.type === 'ArrowFunctionExpression' ||
+                            path.node.init?.type === 'FunctionExpression')) {
+                        functionInfo = extractFunctionDetails(path, lines, true);
+                        path.stop();
+                    }
+                },
+                ClassMethod(path) {
+                    if (path.node.key.name === functionName) {
+                        functionInfo = extractFunctionDetails(path, lines);
+                        path.stop();
+                    }
+                }
+            });
+            if (functionInfo) {
+                return { success: true, ...functionInfo, filePath: targetPath };
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    // Try the provided file path first
+    try {
+        const result = searchInFile(filePath);
+        if (result) {
+            return result;
+        }
+    }
+    catch (error) {
+        // File not found or other error - continue to fallback
+    }
+    // Fallback: If we have an indexer, search for the function in the index
+    if (globals_1.g.globalIndexer) {
+        const indexData = globals_1.g.globalIndexer.index;
+        if (indexData && indexData.files) {
+            for (const [indexedFilePath, fileData] of Object.entries(indexData.files)) {
+                const analysis = fileData.analysis;
+                const hasFunction = analysis.functions?.some((fn) => fn.name === functionName);
+                const hasMethod = analysis.classes?.some((cls) => cls.methods?.some((method) => method.name === functionName));
+                if (hasFunction || hasMethod) {
+                    const result = searchInFile(indexedFilePath);
+                    if (result) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return {
+            success: false,
+            error: `Function ${functionName} not found in ${filePath} or any indexed files`
+        };
+    }
+    return {
+        success: false,
+        error: `Function ${functionName} not found in ${filePath}. Tip: Enable indexing for better function lookup across files.`
+    };
+}
+/**
+ * Traverse a function's body and collect which properties are accessed on each
+ * named parameter. This is the primary type-inference mechanism for parameters
+ * annotated as `any` (or unannotated), where static type info is unavailable.
+ *
+ * Example: given `function fn(dto: any) { return dto.name + dto.email }`,
+ * returns `{ dto: ['name', 'email'] }`.
+ */
+function extractParameterUsages(path, paramNames) {
+    if (paramNames.length === 0)
+        return {};
+    const usages = {};
+    try {
+        path.traverse({
+            MemberExpression(memberPath) {
+                const obj = memberPath.node.object;
+                const prop = memberPath.node.property;
+                if (obj.type === 'Identifier' && paramNames.includes(obj.name)) {
+                    if (!usages[obj.name])
+                        usages[obj.name] = [];
+                    // Only collect computed-string and identifier accesses (skip dynamic keys)
+                    if (prop.type === 'Identifier' && !usages[obj.name].includes(prop.name)) {
+                        usages[obj.name].push(prop.name);
+                    }
+                    else if (prop.type === 'StringLiteral' &&
+                        !usages[obj.name].includes(prop.value)) {
+                        usages[obj.name].push(prop.value);
+                    }
+                }
+            }
+        });
+    }
+    catch (_err) {
+        // Non-fatal: traversal can fail on unusual AST shapes; return what we have
+    }
+    // Only include params that actually had property accesses
+    return Object.fromEntries(Object.entries(usages).filter(([, props]) => props.length > 0));
+}
+/**
+ * Calculate cyclomatic complexity for a function.
+ * Counts decision points: if/else, switch, case, for, while, do-while,
+ * ternary operators, logical operators (&&, ||), catch clauses
+ */
+function calculateCyclomaticComplexity(path) {
+    let complexity = 1;
+    try {
+        path.traverse({
+            IfStatement: () => { complexity++; },
+            SwitchStatement: () => { complexity++; },
+            SwitchCase: () => { complexity++; },
+            ForStatement: () => { complexity++; },
+            ForInStatement: () => { complexity++; },
+            ForOfStatement: () => { complexity++; },
+            WhileStatement: () => { complexity++; },
+            DoWhileStatement: () => { complexity++; },
+            ConditionalExpression: () => { complexity++; },
+            LogicalExpression: () => {
+                // && and || add complexity
+                complexity++;
+            },
+            CatchClause: () => { complexity++; }
+        });
+    }
+    catch (_err) {
+        // If traversal fails, return base complexity
+    }
+    return complexity;
+}
+function extractFunctionDetails(path, lines, isVariable = false) {
+    const node = isVariable ? path.node.init : path.node;
+    const startLine = node.loc.start.line - 1;
+    const endLine = node.loc.end.line - 1;
+    // Look backwards for JSDoc/comments (up to 20 lines)
+    let commentStartLine = startLine;
+    let lookbackLimit = Math.max(0, startLine - 20);
+    while (commentStartLine > lookbackLimit) {
+        const prevLine = lines[commentStartLine - 1]?.trim() || '';
+        if (prevLine.startsWith('*') ||
+            prevLine.startsWith('//') ||
+            prevLine.startsWith('/**') ||
+            prevLine.endsWith('*/') ||
+            prevLine === '') {
+            commentStartLine--;
+        }
+        else {
+            break;
+        }
+    }
+    const code = lines.slice(commentStartLine, endLine + 1).join('\n');
+    const calledFunctions = [];
+    const calledMethods = [];
+    try {
+        path.traverse({
+            CallExpression(callPath) {
+                const callee = callPath.node.callee;
+                if (callee.type === 'Identifier') {
+                    const funcName = callee.name;
+                    if (!calledFunctions.includes(funcName)) {
+                        calledFunctions.push(funcName);
+                    }
+                }
+                if (callee.type === 'MemberExpression' && callee.property.type === 'Identifier') {
+                    const objectName = callee.object.type === 'Identifier' ? callee.object.name :
+                        callee.object.type === 'ThisExpression' ? 'this' : 'unknown';
+                    const methodCall = `${objectName}.${callee.property.name}`;
+                    if (!calledMethods.includes(methodCall)) {
+                        calledMethods.push(methodCall);
+                    }
+                }
+            }
+        });
+    }
+    catch (error) {
+        // If traversal fails, just continue without called functions
+        console.warn('Could not extract called functions:', error);
+    }
+    const params = node.params.map((p) => extractParamInfo(p));
+    // Collect param names for usage analysis; skip params we couldn't resolve
+    const paramNames = node.params
+        .map((p) => {
+        if (p.type === 'Identifier')
+            return p.name;
+        if (p.type === 'AssignmentPattern' && p.left?.type === 'Identifier')
+            return p.left.name;
+        if (p.type === 'RestElement' && p.argument?.type === 'Identifier')
+            return p.argument.name;
+        return null;
+    })
+        .filter((n) => n !== null);
+    const parameterUsages = extractParameterUsages(path, paramNames);
+    return {
+        name: isVariable ? path.node.id.name : node.id?.name,
+        code,
+        startLine: commentStartLine + 1,
+        endLine: endLine + 1,
+        params,
+        returnType: node.returnType ? getTypeAnnotation(node.returnType) : null,
+        async: node.async,
+        calledFunctions: calledFunctions.length > 0 ? calledFunctions : undefined,
+        calledMethods: calledMethods.length > 0 ? calledMethods : undefined,
+        // Only included when at least one param has observable property accesses
+        parameterUsages: Object.keys(parameterUsages).length > 0 ? parameterUsages : undefined,
+        complexity: calculateCyclomaticComplexity(path)
+    };
+}
+function getImportsAST(filePath) {
+    try {
+        const content = fsSync.readFileSync(filePath, 'utf-8');
+        const ast = parseFileToAST(filePath, content);
+        const imports = [];
+        traverse(ast, {
+            ImportDeclaration(path) {
+                const node = path.node;
+                const imported = [];
+                node.specifiers.forEach(spec => {
+                    if (spec.type === 'ImportDefaultSpecifier') {
+                        imported.push({ name: spec.local.name, type: 'default' });
+                    }
+                    else if (spec.type === 'ImportSpecifier') {
+                        imported.push({
+                            name: spec.local.name,
+                            imported: spec.imported.name,
+                            type: 'named'
+                        });
+                    }
+                    else if (spec.type === 'ImportNamespaceSpecifier') {
+                        imported.push({ name: spec.local.name, type: 'namespace' });
+                    }
+                });
+                imports.push({
+                    source: node.source.value,
+                    imported,
+                    line: node.loc.start.line
+                });
+            },
+            // Handle require statements
+            CallExpression(path) {
+                if (path.node.callee.name === 'require' &&
+                    path.node.arguments[0]?.type === 'StringLiteral') {
+                    const parent = path.parent;
+                    let variableName = null;
+                    if (parent.type === 'VariableDeclarator') {
+                        variableName = parent.id.name;
+                    }
+                    imports.push({
+                        source: path.node.arguments[0].value,
+                        imported: variableName ? [{ name: variableName, type: 'require' }] : [],
+                        type: 'require',
+                        line: path.node.loc.start.line
+                    });
+                }
+            }
+        });
+        return { success: true, imports, filePath };
+    }
+    catch (error) {
+        if (globals_1.g.globalIndexer && (error.code === 'ENOENT' || error.message.includes('no such file'))) {
+            const indexData = globals_1.g.globalIndexer.index;
+            if (indexData && indexData.files) {
+                const match = (0, pathResolver_1.findBestMatchInIndex)(filePath, indexData.files);
+                if (match) {
+                    console.log(`   💡 Did you mean: ${match.suggestion}?`);
+                    return {
+                        success: false,
+                        error: `File not found: ${filePath}`,
+                        suggestion: match.suggestion,
+                        allMatches: match.allMatches.length > 1 ? match.allMatches : undefined
+                    };
+                }
+            }
+        }
+        return { success: false, error: error.message };
+    }
+}
+function getTypeDefinitions(filePath) {
+    try {
+        const content = fsSync.readFileSync(filePath, 'utf-8');
+        const ast = parseFileToAST(filePath, content);
+        const lines = content.split('\n');
+        const types = [];
+        traverse(ast, {
+            TSTypeAliasDeclaration(path) {
+                const node = path.node;
+                const startLine = node.loc.start.line - 1;
+                const endLine = node.loc.end.line - 1;
+                types.push({
+                    name: node.id.name,
+                    kind: 'type',
+                    code: lines.slice(startLine, endLine + 1).join('\n'),
+                    line: startLine + 1,
+                    exported: path.parent.type === 'ExportNamedDeclaration'
+                });
+            },
+            TSInterfaceDeclaration(path) {
+                const node = path.node;
+                const startLine = node.loc.start.line - 1;
+                const endLine = node.loc.end.line - 1;
+                const properties = [];
+                if (node.body && node.body.body) {
+                    node.body.body.forEach(member => {
+                        if (member.type === 'TSPropertySignature') {
+                            properties.push({
+                                name: member.key.name,
+                                type: member.typeAnnotation ?
+                                    getTypeAnnotation(member.typeAnnotation) : null,
+                                optional: member.optional
+                            });
+                        }
+                    });
+                }
+                types.push({
+                    name: node.id.name,
+                    kind: 'interface',
+                    code: lines.slice(startLine, endLine + 1).join('\n'),
+                    properties,
+                    line: startLine + 1,
+                    exported: path.parent.type === 'ExportNamedDeclaration'
+                });
+            },
+            TSEnumDeclaration(path) {
+                const node = path.node;
+                const startLine = node.loc.start.line - 1;
+                const endLine = node.loc.end.line - 1;
+                types.push({
+                    name: node.id.name,
+                    kind: 'enum',
+                    code: lines.slice(startLine, endLine + 1).join('\n'),
+                    line: startLine + 1,
+                    exported: path.parent.type === 'ExportNamedDeclaration'
+                });
+            }
+        });
+        return { success: true, types, filePath };
+    }
+    catch (error) {
+        if (globals_1.g.globalIndexer && (error.code === 'ENOENT' || error.message.includes('no such file'))) {
+            const indexData = globals_1.g.globalIndexer.index;
+            if (indexData && indexData.files) {
+                const match = (0, pathResolver_1.findBestMatchInIndex)(filePath, indexData.files);
+                if (match) {
+                    console.log(`   💡 Did you mean: ${match.suggestion}?`);
+                    return {
+                        success: false,
+                        error: `File not found: ${filePath}`,
+                        suggestion: match.suggestion,
+                        allMatches: match.allMatches.length > 1 ? match.allMatches : undefined
+                    };
+                }
+            }
+        }
+        return { success: false, error: error.message };
+    }
+}
+function getFilePreamble(filePath) {
+    const extractPreamble = (targetPath) => {
+        try {
+            const content = fsSync.readFileSync(targetPath, 'utf-8');
+            const ast = parseFileToAST(targetPath, content);
+            const lines = content.split('\n');
+            const imports = [];
+            const mocks = [];
+            const setupBlocks = [];
+            const topLevelVariables = [];
+            if (ast.program && ast.program.body) {
+                for (const statement of ast.program.body) {
+                    const startLine = statement.loc?.start.line || 0;
+                    const endLine = statement.loc?.end.line || 0;
+                    const code = lines.slice(startLine - 1, endLine).join('\n');
+                    if (statement.type === 'ImportDeclaration') {
+                        imports.push({
+                            code,
+                            startLine,
+                            endLine,
+                            source: statement.source?.value || ''
+                        });
+                    }
+                    else if (statement.type === 'VariableDeclaration') {
+                        statement.declarations.forEach((decl) => {
+                            topLevelVariables.push({
+                                code,
+                                startLine,
+                                endLine,
+                                name: decl.id?.name || 'unknown',
+                                kind: statement.kind
+                            });
+                        });
+                    }
+                    else if (statement.type === 'ExpressionStatement' && statement.expression?.type === 'CallExpression') {
+                        const callExpr = statement.expression;
+                        const callee = callExpr.callee;
+                        if (callee.type === 'MemberExpression' &&
+                            (callee.object?.name === 'vi' || callee.object?.name === 'jest') &&
+                            callee.property?.name === 'mock') {
+                            const moduleName = callExpr.arguments[0]?.value || 'unknown';
+                            let isVirtual = false;
+                            if (callExpr.arguments[1]?.type === 'ObjectExpression') {
+                                const props = callExpr.arguments[1].properties || [];
+                                isVirtual = props.some((prop) => prop.key?.name === 'virtual' && prop.value?.value === true);
+                            }
+                            mocks.push({
+                                code,
+                                startLine,
+                                endLine,
+                                moduleName,
+                                isVirtual
+                            });
+                        }
+                        else if (callee.type === 'Identifier' &&
+                            ['beforeAll', 'beforeEach', 'afterAll', 'afterEach'].includes(callee.name)) {
+                            setupBlocks.push({
+                                code,
+                                startLine,
+                                endLine,
+                                type: callee.name
+                            });
+                        }
+                    }
+                    // Handle require statements
+                    else if (statement.type === 'VariableDeclaration') {
+                        statement.declarations.forEach((decl) => {
+                            if (decl.init?.type === 'CallExpression' &&
+                                decl.init.callee?.name === 'require' &&
+                                decl.init.arguments[0]?.type === 'StringLiteral') {
+                                imports.push({
+                                    code,
+                                    startLine,
+                                    endLine,
+                                    source: decl.init.arguments[0].value,
+                                    type: 'require'
+                                });
+                            }
+                        });
+                    }
+                }
+            }
+            const allItems = [
+                ...imports.map(i => ({ ...i, category: 'import' })),
+                ...mocks.map(m => ({ ...m, category: 'mock' })),
+                ...setupBlocks.map(s => ({ ...s, category: 'setup' })),
+                ...topLevelVariables.map(v => ({ ...v, category: 'variable' }))
+            ].sort((a, b) => a.startLine - b.startLine);
+            return {
+                success: true,
+                filePath: targetPath,
+                preamble: {
+                    imports,
+                    mocks,
+                    setupBlocks,
+                    topLevelVariables
+                },
+                summary: {
+                    importCount: imports.length,
+                    mockCount: mocks.length,
+                    setupBlockCount: setupBlocks.length,
+                    variableCount: topLevelVariables.length,
+                    totalLines: allItems.length > 0 ? allItems[allItems.length - 1].endLine : 0
+                }
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    const result = extractPreamble(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 = extractPreamble(match.suggestion);
+                if (retryResult) {
+                    return retryResult;
+                }
+                return {
+                    success: false,
+                    error: `File not found: ${filePath}`,
+                    suggestion: match.suggestion,
+                    allMatches: match.allMatches.length > 1 ? match.allMatches : undefined
+                };
+            }
+        }
+    }
+    return {
+        success: false,
+        error: `File not found: ${filePath}. Tip: Enable indexing for better file lookup.`
+    };
+}
+function getClassMethods(filePath, className) {
+    const searchInFile = (targetPath) => {
+        try {
+            const content = fsSync.readFileSync(targetPath, 'utf-8');
+            const ast = parseFileToAST(targetPath, content);
+            const lines = content.split('\n');
+            let classInfo = null;
+            traverse(ast, {
+                ClassDeclaration(path) {
+                    if (path.node.id?.name === className) {
+                        const methods = [];
+                        if (path.node.body && path.node.body.body) {
+                            path.node.body.body.forEach(member => {
+                                if (member.type === 'ClassMethod' || member.type === 'MethodDefinition') {
+                                    const startLine = member.loc.start.line - 1;
+                                    const endLine = member.loc.end.line - 1;
+                                    methods.push({
+                                        name: member.key.name,
+                                        kind: member.kind,
+                                        static: member.static,
+                                        async: member.async,
+                                        params: member.params ? member.params.map(p => extractParamInfo(p)) : [],
+                                        returnType: member.returnType ? getTypeAnnotation(member.returnType) : null,
+                                        code: lines.slice(startLine, endLine + 1).join('\n'),
+                                        line: startLine + 1
+                                    });
+                                }
+                            });
+                        }
+                        classInfo = {
+                            name: className,
+                            methods,
+                            superClass: path.node.superClass?.name,
+                            filePath: targetPath
+                        };
+                        path.stop();
+                    }
+                }
+            });
+            if (classInfo) {
+                return { success: true, ...classInfo };
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    try {
+        const result = searchInFile(filePath);
+        if (result) {
+            return result;
+        }
+    }
+    catch (error) {
+        // File not found or other error - continue to fallback
+    }
+    if (globals_1.g.globalIndexer) {
+        const indexData = globals_1.g.globalIndexer.index;
+        if (indexData && indexData.files) {
+            for (const [indexedFilePath, fileData] of Object.entries(indexData.files)) {
+                const analysis = fileData.analysis;
+                const hasClass = analysis.classes?.some((cls) => cls.name === className);
+                if (hasClass) {
+                    const result = searchInFile(indexedFilePath);
+                    if (result) {
+                        return result;
+                    }
+                }
+            }
+        }
+        return {
+            success: false,
+            error: `Class ${className} not found in ${filePath} or any indexed files`
+        };
+    }
+    return {
+        success: false,
+        error: `Class ${className} not found in ${filePath}. Tip: Enable indexing for better class lookup across files.`
+    };
+}
+//# sourceMappingURL=ast.js.map