api-tests-coverage 1.0.12 → 1.0.14

package/dist/src/pipeline/stages/ast/abstractLayerTraversal.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Abstract layer traversal — resolves inherited assertions, imported helpers,
+ * fixture injections, and page objects across the inheritance chain.
+ *
+ * Implements the spec's abstract layer resolution with a configurable depth cap
+ * (default 5, RULE-05). When the cap is reached, resolution is marked as 'partial'.
+ * Cycles are detected and broken (RULE-15).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseInheritanceChain = traverseInheritanceChain;
+exports.resolveImportedHelper = resolveImportedHelper;
+exports.resolveFixtureInjection = resolveFixtureInjection;
+/**
+ * Traverse the inheritance chain starting from a test class to resolve
+ * assertions, HTTP calls, and helper references from base classes.
+ *
+ * @param className - The test class/suite to start from
+ * @param table - The cross-file symbol table
+ * @param depthCap - Maximum traversal depth (RULE-05: default 5)
+ */
+function traverseInheritanceChain(className, table, depthCap = 5) {
+    const visited = new Set();
+    const resolvedAssertions = [];
+    const resolvedHttpCalls = [];
+    const unresolvedChain = [];
+    let maxDepth = 0;
+    let cycleDetected = false;
+    function traverse(name, depth) {
+        var _a;
+        if (depth > depthCap) {
+            unresolvedChain.push(`${name} (depth cap ${depthCap} reached)`);
+            return;
+        }
+        if (visited.has(name)) {
+            cycleDetected = true;
+            unresolvedChain.push(`${name} (cycle detected)`);
+            return;
+        }
+        visited.add(name);
+        maxDepth = Math.max(maxDepth, depth);
+        // Find the class declaration
+        const classDecl = table.classes.get(name);
+        if (!classDecl) {
+            if (depth > 0) {
+                unresolvedChain.push(`${name} (class not found)`);
+            }
+            return;
+        }
+        // Get the semantic model for this class's file
+        const model = table.models.get(classDecl.filePath);
+        if (!model) {
+            unresolvedChain.push(`${name} (model not found for ${classDecl.filePath})`);
+            return;
+        }
+        // Collect assertions from this class's model
+        for (const assertion of model.assertions) {
+            resolvedAssertions.push(assertion);
+        }
+        // Collect HTTP calls from this class's functions
+        for (const methodName of classDecl.methods) {
+            const func = (_a = model.functions.get(methodName)) !== null && _a !== void 0 ? _a : model.functions.get(`${name}.${methodName}`);
+            if (func) {
+                resolvedHttpCalls.push(...func.bodyHttpCalls);
+            }
+        }
+        // Recurse into base class
+        if (classDecl.extendsClass) {
+            traverse(classDecl.extendsClass, depth + 1);
+        }
+    }
+    traverse(className, 0);
+    const resolution = unresolvedChain.length > 0 ? 'partial' : 'full';
+    const assertionSource = maxDepth === 0
+        ? 'direct'
+        : resolvedAssertions.length > 0
+            ? 'inherited'
+            : 'unresolved';
+    return {
+        resolvedAssertions,
+        resolvedHttpCalls,
+        assertionSource,
+        traversalDepth: maxDepth,
+        resolution,
+        unresolvedChain: unresolvedChain.length > 0 ? unresolvedChain : undefined,
+        cycleDetected,
+    };
+}
+/**
+ * Resolve an imported helper function by following the import chain.
+ *
+ * @param functionName - The helper function to resolve
+ * @param fromFile - The file importing the helper
+ * @param table - The cross-file symbol table
+ * @param depthCap - Maximum traversal depth
+ */
+function resolveImportedHelper(functionName, fromFile, table, depthCap = 5) {
+    const visited = new Set();
+    const resolvedAssertions = [];
+    const resolvedHttpCalls = [];
+    const unresolvedChain = [];
+    let maxDepth = 0;
+    let cycleDetected = false;
+    function resolve(funcName, file, depth) {
+        var _a;
+        if (depth > depthCap) {
+            unresolvedChain.push(`${funcName} in ${file} (depth cap reached)`);
+            return;
+        }
+        const key = `${file}::${funcName}`;
+        if (visited.has(key)) {
+            cycleDetected = true;
+            unresolvedChain.push(`${funcName} in ${file} (cycle detected)`);
+            return;
+        }
+        visited.add(key);
+        maxDepth = Math.max(maxDepth, depth);
+        const model = table.models.get(file);
+        if (!model) {
+            unresolvedChain.push(`${funcName} (model not found for ${file})`);
+            return;
+        }
+        // Find the function in the model
+        const func = model.functions.get(funcName);
+        if (!func) {
+            // Try imported files
+            const importedFiles = (_a = table.importGraph.get(file)) !== null && _a !== void 0 ? _a : [];
+            for (const importedFile of importedFiles) {
+                const importedModel = table.models.get(importedFile);
+                if (importedModel === null || importedModel === void 0 ? void 0 : importedModel.functions.has(funcName)) {
+                    resolve(funcName, importedFile, depth + 1);
+                    return;
+                }
+            }
+            unresolvedChain.push(`${funcName} (function not found in ${file})`);
+            return;
+        }
+        // Collect HTTP calls from this function
+        resolvedHttpCalls.push(...func.bodyHttpCalls);
+        // Collect any assertions from the model that relate to this function
+        for (const assertion of model.assertions) {
+            resolvedAssertions.push(assertion);
+        }
+        // Follow called functions recursively
+        for (const calledFunc of func.calledFunctions) {
+            resolve(calledFunc, file, depth + 1);
+        }
+    }
+    resolve(functionName, fromFile, 0);
+    const resolution = unresolvedChain.length > 0 ? 'partial' : 'full';
+    const assertionSource = resolvedAssertions.length > 0 ? 'helper' : 'unresolved';
+    return {
+        resolvedAssertions,
+        resolvedHttpCalls,
+        assertionSource,
+        traversalDepth: maxDepth,
+        resolution,
+        unresolvedChain: unresolvedChain.length > 0 ? unresolvedChain : undefined,
+        cycleDetected,
+    };
+}
+/**
+ * Resolve fixture-injected assertions and HTTP calls.
+ * Traces @BeforeEach/beforeEach/pytest fixtures/@Autowired patterns.
+ *
+ * @param fixtureName - The fixture function name
+ * @param table - The cross-file symbol table
+ * @param depthCap - Maximum traversal depth
+ */
+function resolveFixtureInjection(fixtureName, table, depthCap = 5) {
+    const resolvedAssertions = [];
+    const resolvedHttpCalls = [];
+    const unresolvedChain = [];
+    let maxDepth = 0;
+    let found = false;
+    // Search all models for the fixture function
+    for (const [filePath, model] of table.models) {
+        const func = model.functions.get(fixtureName);
+        if (!func)
+            continue;
+        found = true;
+        maxDepth = 1;
+        // Collect HTTP calls from the fixture
+        resolvedHttpCalls.push(...func.bodyHttpCalls);
+        // Check if fixture has assertions
+        for (const assertion of model.assertions) {
+            resolvedAssertions.push(assertion);
+        }
+        break; // Use first match
+    }
+    if (!found) {
+        unresolvedChain.push(`${fixtureName} (fixture not found)`);
+    }
+    return {
+        resolvedAssertions,
+        resolvedHttpCalls,
+        assertionSource: found ? 'fixture' : 'unresolved',
+        traversalDepth: maxDepth,
+        resolution: found ? 'full' : 'partial',
+        unresolvedChain: unresolvedChain.length > 0 ? unresolvedChain : undefined,
+        cycleDetected: false,
+    };
+}

package/dist/src/pipeline/stages/ast/astStage.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AST Stage — Stage 2 of the coverage pipeline.
+ *
+ * Wraps the existing AST analysis orchestrator and extends it with:
+ * - Multi-file analysis: parses all discovered files and builds a cross-file symbol table
+ * - Abstract layer traversal: resolves inherited assertions, helpers, fixtures
+ * - Graph building: converts analysis results into GraphNode[] and GraphEdge[]
+ *
+ * The AST stage reads the SCA output (from context.stageOutputs) to determine
+ * which languages and frameworks are present, enabling targeted analysis heuristics.
+ */
+import type { PipelineStage, PipelineContext } from '../../stageInterface';
+import type { AstStageOutput } from './types';
+export declare class AstStage implements PipelineStage<AstStageOutput> {
+    readonly name: "ast";
+    readonly optional = false;
+    execute(context: PipelineContext): Promise<AstStageOutput>;
+}
+//# sourceMappingURL=astStage.d.ts.map

package/dist/src/pipeline/stages/ast/astStage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"astStage.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/ast/astStage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE3E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAkB9C,qBAAa,QAAS,YAAW,aAAa,CAAC,cAAc,CAAC;IAC5D,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAC/B,QAAQ,CAAC,QAAQ,SAAS;IAEpB,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,cAAc,CAAC;CAyKjE"}

package/dist/src/pipeline/stages/ast/astStage.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * AST Stage — Stage 2 of the coverage pipeline.
+ *
+ * Wraps the existing AST analysis orchestrator and extends it with:
+ * - Multi-file analysis: parses all discovered files and builds a cross-file symbol table
+ * - Abstract layer traversal: resolves inherited assertions, helpers, fixtures
+ * - Graph building: converts analysis results into GraphNode[] and GraphEdge[]
+ *
+ * The AST stage reads the SCA output (from context.stageOutputs) to determine
+ * which languages and frameworks are present, enabling targeted analysis heuristics.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AstStage = void 0;
+const astAnalysisOrchestrator_1 = require("../../../ast/astAnalysisOrchestrator");
+const crossFileResolver_1 = require("./crossFileResolver");
+const abstractLayerTraversal_1 = require("./abstractLayerTraversal");
+const graphBuilder_1 = require("./graphBuilder");
+const fileClassifier_1 = require("../../../discovery/fileClassifier");
+const projectDiscovery_1 = require("../../../discovery/projectDiscovery");
+const parserRegistry_1 = require("../../../ast/parserRegistry");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class AstStage {
+    constructor() {
+        this.name = 'ast';
+        this.optional = false;
+    }
+    async execute(context) {
+        var _a;
+        const startTime = Date.now();
+        const filesScanned = [];
+        const filesSkipped = [];
+        // Ensure all language analyzers are registered
+        (0, astAnalysisOrchestrator_1.registerAllAnalyzers)();
+        // Get SCA output for language/framework context
+        const scaOutput = context.stageOutputs.get('sca');
+        // Build analysis context
+        const analysisContext = (0, astAnalysisOrchestrator_1.buildAnalysisContext)(context.config.astConfig);
+        // Discover all files
+        const artifacts = (0, projectDiscovery_1.discoverProject)({ rootDir: context.projectRoot });
+        const allSourceFiles = [
+            ...artifacts.testFiles,
+            ...artifacts.serviceFiles,
+        ];
+        // Phase 1: Parse all files and build semantic models
+        const models = new Map();
+        const interactionsMap = new Map();
+        for (const filePath of allSourceFiles) {
+            // Enforce per-file timeout (RULE-16)
+            const fileStart = Date.now();
+            let content;
+            try {
+                content = fs.readFileSync(filePath, 'utf-8');
+            }
+            catch (err) {
+                filesSkipped.push({ file: filePath, reason: 'read-error' });
+                continue;
+            }
+            // Detect language from file extension
+            const language = detectLanguage(filePath, scaOutput);
+            if (!language) {
+                filesSkipped.push({ file: filePath, reason: 'unsupported-language' });
+                continue;
+            }
+            // Check timeout
+            if (Date.now() - fileStart > context.config.fileTimeoutMs) {
+                filesSkipped.push({ file: filePath, reason: 'timeout' });
+                continue;
+            }
+            try {
+                // Use existing AST analysis
+                const result = (0, astAnalysisOrchestrator_1.analyzeFileDetailed)(content, filePath, language, analysisContext);
+                interactionsMap.set(filePath, result.interactions);
+                // Build semantic model if we have an analyzer
+                const analyzer = (0, parserRegistry_1.getAnalyzer)(language, analysisContext.astConfig);
+                if (analyzer) {
+                    const parsed = analyzer.parse(filePath, content);
+                    if (!parsed.parseError) {
+                        const model = analyzer.buildSemanticModel(parsed, analysisContext);
+                        models.set(filePath, model);
+                    }
+                    else {
+                        // RULE-02: File not skipped on parse error — we already have fallback interactions
+                        filesSkipped.push({ file: filePath, reason: 'parse-error' });
+                    }
+                }
+                filesScanned.push(filePath);
+            }
+            catch (err) {
+                // RULE-02: Never skip a file entirely on error
+                filesSkipped.push({
+                    file: filePath,
+                    reason: `analysis-error: ${err instanceof Error ? err.message : String(err)}`,
+                });
+            }
+        }
+        // Phase 2: Build cross-file symbol table
+        const crossFileTable = (0, crossFileResolver_1.buildCrossFileSymbolTable)(models, context.projectRoot);
+        // Phase 3: Run abstract layer traversal for test files
+        const traversalResults = new Map();
+        const depthCap = context.config.traversalDepthCap;
+        for (const [filePath] of models) {
+            const basename = path.basename(filePath);
+            if (!(0, fileClassifier_1.isTestFile)(basename))
+                continue;
+            // Try inheritance chain traversal for classes in this test file
+            for (const [className, classDecl] of crossFileTable.classes) {
+                if (classDecl.filePath === filePath && classDecl.extendsClass) {
+                    const result = (0, abstractLayerTraversal_1.traverseInheritanceChain)(className, crossFileTable, depthCap);
+                    traversalResults.set(filePath, result);
+                    break; // One traversal result per test file
+                }
+            }
+            // If no inheritance found, try resolving imported helpers
+            if (!traversalResults.has(filePath)) {
+                const model = models.get(filePath);
+                if (model) {
+                    for (const [funcName, func] of model.functions) {
+                        for (const calledFunc of func.calledFunctions) {
+                            // Check if this is an imported function
+                            const importedFiles = (_a = crossFileTable.importGraph.get(filePath)) !== null && _a !== void 0 ? _a : [];
+                            for (const importedFile of importedFiles) {
+                                const importedModel = models.get(importedFile);
+                                if (importedModel === null || importedModel === void 0 ? void 0 : importedModel.functions.has(calledFunc)) {
+                                    const result = (0, abstractLayerTraversal_1.resolveImportedHelper)(calledFunc, importedFile, crossFileTable, depthCap);
+                                    if (result.resolvedAssertions.length > 0 || result.resolvedHttpCalls.length > 0) {
+                                        traversalResults.set(filePath, result);
+                                    }
+                                    break;
+                                }
+                            }
+                            if (traversalResults.has(filePath))
+                                break;
+                        }
+                        if (traversalResults.has(filePath))
+                            break;
+                    }
+                }
+            }
+        }
+        // Phase 4: Build graph nodes and edges
+        const { nodes, edges } = (0, graphBuilder_1.buildAstGraph)(models, crossFileTable, traversalResults, interactionsMap);
+        // Add nodes and edges to the context graph
+        for (const node of nodes) {
+            if (!context.graph.hasNode(node.id)) {
+                context.graph.addNode(node);
+            }
+        }
+        for (const edge of edges) {
+            if (!context.graph.hasEdge(edge.id)) {
+                context.graph.addEdge(edge);
+            }
+        }
+        // Record diagnostics (RULE-12)
+        const diagnostics = {
+            stageName: 'ast',
+            filesScanned,
+            filesSkipped,
+            durationMs: Date.now() - startTime,
+            metadata: {
+                totalModels: models.size,
+                totalInteractions: Array.from(interactionsMap.values()).reduce((sum, arr) => sum + arr.length, 0),
+                totalClasses: crossFileTable.classes.size,
+                totalExportedSymbols: crossFileTable.exportedSymbols.size,
+                traversalResultCount: traversalResults.size,
+                graphNodesAdded: nodes.length,
+                graphEdgesAdded: edges.length,
+            },
+        };
+        context.diagnostics.set('ast', diagnostics);
+        // Build output
+        const output = {
+            models,
+            crossFileTable,
+            traversalResults,
+            analyzedFiles: filesScanned,
+            skippedFiles: filesSkipped,
+        };
+        context.stageOutputs.set('ast', output);
+        return output;
+    }
+}
+exports.AstStage = AstStage;
+/**
+ * Detect the language of a file from its extension.
+ */
+function detectLanguage(filePath, scaOutput) {
+    const ext = path.extname(filePath).toLowerCase();
+    const extensionMap = {
+        '.ts': 'typescript',
+        '.tsx': 'typescript',
+        '.js': 'javascript',
+        '.jsx': 'javascript',
+        '.mjs': 'javascript',
+        '.cjs': 'javascript',
+        '.java': 'java',
+        '.kt': 'kotlin',
+        '.kts': 'kotlin',
+        '.py': 'python',
+        '.rb': 'ruby',
+        '.feature': 'cucumber',
+    };
+    return extensionMap[ext];
+}

package/dist/src/pipeline/stages/ast/crossFileResolver.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Cross-file resolver — builds a multi-file symbol table from all parsed semantic models.
+ *
+ * Aggregates per-file symbol tables, export declarations, class declarations,
+ * and import graphs into a unified `CrossFileSymbolTable` that enables
+ * cross-file constant resolution, inheritance chain traversal, and
+ * import-based helper resolution.
+ */
+import type { SemanticModel } from '../../../ast/astTypes';
+import type { CrossFileSymbolTable } from './types';
+/**
+ * Build a cross-file symbol table from all parsed semantic models.
+ *
+ * @param models - Map of filePath → SemanticModel
+ * @param projectRoot - The project root directory
+ */
+export declare function buildCrossFileSymbolTable(models: Map<string, SemanticModel>, projectRoot: string): CrossFileSymbolTable;
+/**
+ * Resolve a symbol name using the cross-file symbol table.
+ * Tries: direct lookup, qualified lookup (filePath::name), and import-chain following.
+ */
+export declare function resolveSymbolCrossFile(symbolName: string, fromFile: string, table: CrossFileSymbolTable): string | undefined;
+//# sourceMappingURL=crossFileResolver.d.ts.map

package/dist/src/pipeline/stages/ast/crossFileResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crossFileResolver.d.ts","sourceRoot":"","sources":["../../../../../src/pipeline/stages/ast/crossFileResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAuC,MAAM,uBAAuB,CAAC;AAChG,OAAO,KAAK,EAAE,oBAAoB,EAAuC,MAAM,SAAS,CAAC;AAGzF;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EAClC,WAAW,EAAE,MAAM,GAClB,oBAAoB,CAuDtB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,oBAAoB,GAC1B,MAAM,GAAG,SAAS,CA4BpB"}

package/dist/src/pipeline/stages/ast/crossFileResolver.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * Cross-file resolver — builds a multi-file symbol table from all parsed semantic models.
+ *
+ * Aggregates per-file symbol tables, export declarations, class declarations,
+ * and import graphs into a unified `CrossFileSymbolTable` that enables
+ * cross-file constant resolution, inheritance chain traversal, and
+ * import-based helper resolution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCrossFileSymbolTable = buildCrossFileSymbolTable;
+exports.resolveSymbolCrossFile = resolveSymbolCrossFile;
+const importResolver_1 = require("./importResolver");
+/**
+ * Build a cross-file symbol table from all parsed semantic models.
+ *
+ * @param models - Map of filePath → SemanticModel
+ * @param projectRoot - The project root directory
+ */
+function buildCrossFileSymbolTable(models, projectRoot) {
+    const exportedSymbols = new Map();
+    const classes = new Map();
+    const importGraph = new Map();
+    // Pass 1: Collect all exported symbols and class declarations
+    for (const [filePath, model] of models) {
+        // Collect constants as exported symbols
+        for (const [name, symbol] of model.constants) {
+            if (symbol.value !== undefined) {
+                exportedSymbols.set(`${filePath}::${name}`, { filePath, value: symbol.value });
+                // Also register as global name for simple lookups
+                if (!exportedSymbols.has(name)) {
+                    exportedSymbols.set(name, { filePath, value: symbol.value });
+                }
+            }
+        }
+        // Collect local variables that are const-like with string values
+        for (const [name, symbol] of model.localVariables) {
+            if (symbol.kind === 'const' && symbol.value !== undefined) {
+                exportedSymbols.set(`${filePath}::${name}`, { filePath, value: symbol.value });
+            }
+        }
+        // Collect enum members as exported symbols
+        for (const [enumName, members] of model.enums) {
+            for (const [memberName, value] of members) {
+                const qualifiedName = `${enumName}.${memberName}`;
+                exportedSymbols.set(`${filePath}::${qualifiedName}`, { filePath, value });
+                if (!exportedSymbols.has(qualifiedName)) {
+                    exportedSymbols.set(qualifiedName, { filePath, value });
+                }
+            }
+        }
+        // Extract class declarations from functions (heuristic: capitalize name + has methods)
+        extractClassDeclarations(filePath, model, classes);
+    }
+    // Pass 2: Build import graph
+    for (const [filePath, model] of models) {
+        const imports = extractImportsFromModel(filePath, model, projectRoot);
+        const resolvedPaths = [];
+        for (const imp of imports) {
+            if (imp.resolvedPath) {
+                resolvedPaths.push(imp.resolvedPath);
+            }
+        }
+        importGraph.set(filePath, resolvedPaths);
+    }
+    return { models, exportedSymbols, classes, importGraph };
+}
+/**
+ * Resolve a symbol name using the cross-file symbol table.
+ * Tries: direct lookup, qualified lookup (filePath::name), and import-chain following.
+ */
+function resolveSymbolCrossFile(symbolName, fromFile, table) {
+    var _a;
+    // Try qualified lookup for the current file
+    const qualified = table.exportedSymbols.get(`${fromFile}::${symbolName}`);
+    if (qualified)
+        return qualified.value;
+    // Try global lookup
+    const global = table.exportedSymbols.get(symbolName);
+    if (global)
+        return global.value;
+    // Try following imports from the current file
+    const importedFiles = (_a = table.importGraph.get(fromFile)) !== null && _a !== void 0 ? _a : [];
+    for (const importedFile of importedFiles) {
+        const fromImported = table.exportedSymbols.get(`${importedFile}::${symbolName}`);
+        if (fromImported)
+            return fromImported.value;
+    }
+    // Try dotted name resolution (e.g. "Config.BASE_URL")
+    const dotParts = symbolName.split('.');
+    if (dotParts.length >= 2) {
+        // Try each possible combination
+        for (const [key, entry] of table.exportedSymbols) {
+            if (key.endsWith(`::${symbolName}`) || key === symbolName) {
+                return entry.value;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Extract import declarations from a semantic model.
+ * This is a heuristic extraction — real import extraction would come from the AST.
+ */
+function extractImportsFromModel(filePath, model, projectRoot) {
+    const imports = [];
+    // Use functions' calledFunctions to infer cross-file references
+    for (const [, func] of model.functions) {
+        for (const calledName of func.calledFunctions) {
+            // If the function name contains a dot, it might be an import reference
+            const dotIndex = calledName.indexOf('.');
+            if (dotIndex > 0) {
+                const modulePart = calledName.substring(0, dotIndex);
+                const resolvedPath = (0, importResolver_1.resolveImportPath)(`./${modulePart}`, filePath, projectRoot, model.language);
+                if (resolvedPath) {
+                    imports.push({
+                        source: modulePart,
+                        resolvedPath,
+                        importedNames: [calledName.substring(dotIndex + 1)],
+                        isDefault: false,
+                    });
+                }
+            }
+        }
+    }
+    return imports;
+}
+/**
+ * Extract class declarations from a semantic model (heuristic).
+ *
+ * Looks for functions that follow class patterns:
+ * - Capitalized names
+ * - Constructor patterns
+ * - Extends/implements annotations
+ */
+function extractClassDeclarations(filePath, model, classes) {
+    const classMethods = new Map();
+    for (const [name, func] of model.functions) {
+        // Look for constructor patterns to detect class names
+        if (name === 'constructor' || name.startsWith('__init__'))
+            continue;
+        // Methods prefixed with "ClassName." or "ClassName#"
+        const dotIndex = name.indexOf('.');
+        const hashIndex = name.indexOf('#');
+        const separator = dotIndex >= 0 ? dotIndex : hashIndex;
+        if (separator > 0) {
+            const className = name.substring(0, separator);
+            const methodName = name.substring(separator + 1);
+            if (!classMethods.has(className)) {
+                classMethods.set(className, []);
+            }
+            classMethods.get(className).push(methodName);
+        }
+        // Check annotations for class membership
+        if (func.annotations) {
+            for (const ann of func.annotations) {
+                // Spring/Java annotations like @Controller, @Service, @RestController
+                if (ann.match(/^@(Controller|Service|Repository|Component|RestController|SpringBootTest)/)) {
+                    const className = extractClassNameFromAnnotation(name, func);
+                    if (className && !classMethods.has(className)) {
+                        classMethods.set(className, []);
+                    }
+                }
+            }
+        }
+    }
+    // Convert to ClassDeclaration objects
+    for (const [className, methods] of classMethods) {
+        if (!classes.has(className)) {
+            classes.set(className, {
+                name: className,
+                methods,
+                filePath,
+            });
+        }
+    }
+}
+function extractClassNameFromAnnotation(functionName, _func) {
+    const dotIndex = functionName.indexOf('.');
+    if (dotIndex > 0)
+        return functionName.substring(0, dotIndex);
+    return undefined;
+}