@grafema/core 0.1.1-alpha → 0.2.1-beta

package/dist/plugins/enrichment/AliasTracker.js

@@ -13,6 +13,7 @@
  * - CALL -> ALIAS_OF -> EXPRESSION (для трассировки)
  */
 import { Plugin, createSuccessResult } from '../Plugin.js';
+import { StrictModeError } from '../../errors/GrafemaError.js';
 export class AliasTracker extends Plugin {
     static MAX_DEPTH = 10;
     depthExceeded = [];
@@ -35,6 +36,7 @@ export class AliasTracker extends Plugin {
         let aliasesFound = 0;
         let edgesCreated = 0;
         let resolvedToMethod = 0;
+        const errors = [];
         // Трекинг превышений глубины
         this.depthExceeded = [];
         // 1. Найти все CALL без object (call sites) которые ещё не резолвлены
@@ -118,9 +120,22 @@ export class AliasTracker extends Plugin {
                     chain: info.chain.join(' → ')
                 }))
             });
+            // In strict mode, report as errors
+            if (context.strictMode) {
+                for (const info of this.depthExceeded) {
+                    const error = new StrictModeError(`Alias chain exceeded max depth (${info.depth}): ${info.name}`, 'STRICT_ALIAS_DEPTH_EXCEEDED', {
+                        filePath: info.file,
+                        phase: 'ENRICHMENT',
+                        plugin: 'AliasTracker',
+                        aliasName: info.name,
+                        chainLength: info.depth,
+                    }, `Possible circular alias reference. Chain: ${info.chain.slice(0, 3).join(' -> ')}...`);
+                    errors.push(error);
+                }
+            }
         }
         logger.info('Summary', summary);
-        return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary);
+        return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary, errors);
     }
     /**
      * Строит индекс алиасов: file:variableName -> EXPRESSION info

package/dist/plugins/enrichment/ArgumentParameterLinker.d.ts

@@ -0,0 +1,32 @@
+/**
+ * ArgumentParameterLinker - creates RECEIVES_ARGUMENT edges connecting
+ * function parameters to call arguments.
+ *
+ * RECEIVES_ARGUMENT edges connect:
+ *   PARAMETER node -> RECEIVES_ARGUMENT -> argument source (VARIABLE, LITERAL, CALL, etc.)
+ *
+ * This is the inverse of PASSES_ARGUMENT:
+ *   - PASSES_ARGUMENT: CALL -> argument (call site perspective)
+ *   - RECEIVES_ARGUMENT: PARAMETER -> argument (function perspective)
+ *
+ * Edge attributes:
+ *   - argIndex: position of the argument (0-based)
+ *   - callId: ID of the CALL node that passed this argument
+ *
+ * Algorithm:
+ * For each CALL node with PASSES_ARGUMENT edges:
+ *   1. Get outgoing CALLS edge to find target function
+ *   2. If no CALLS edge -> skip (unresolved call)
+ *   3. Get target function's PARAMETER nodes via HAS_PARAMETER edges
+ *   4. For each PASSES_ARGUMENT edge:
+ *      a. Get argIndex from edge metadata
+ *      b. Find PARAMETER with matching index
+ *      c. Create RECEIVES_ARGUMENT edge: PARAMETER -> argument_source
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class ArgumentParameterLinker extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+}
+//# sourceMappingURL=ArgumentParameterLinker.d.ts.map

package/dist/plugins/enrichment/ArgumentParameterLinker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArgumentParameterLinker.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/ArgumentParameterLinker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAiChF,qBAAa,uBAAwB,SAAQ,MAAM;IACjD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAqK7D"}

package/dist/plugins/enrichment/ArgumentParameterLinker.js

@@ -0,0 +1,175 @@
+/**
+ * ArgumentParameterLinker - creates RECEIVES_ARGUMENT edges connecting
+ * function parameters to call arguments.
+ *
+ * RECEIVES_ARGUMENT edges connect:
+ *   PARAMETER node -> RECEIVES_ARGUMENT -> argument source (VARIABLE, LITERAL, CALL, etc.)
+ *
+ * This is the inverse of PASSES_ARGUMENT:
+ *   - PASSES_ARGUMENT: CALL -> argument (call site perspective)
+ *   - RECEIVES_ARGUMENT: PARAMETER -> argument (function perspective)
+ *
+ * Edge attributes:
+ *   - argIndex: position of the argument (0-based)
+ *   - callId: ID of the CALL node that passed this argument
+ *
+ * Algorithm:
+ * For each CALL node with PASSES_ARGUMENT edges:
+ *   1. Get outgoing CALLS edge to find target function
+ *   2. If no CALLS edge -> skip (unresolved call)
+ *   3. Get target function's PARAMETER nodes via HAS_PARAMETER edges
+ *   4. For each PASSES_ARGUMENT edge:
+ *      a. Get argIndex from edge metadata
+ *      b. Find PARAMETER with matching index
+ *      c. Create RECEIVES_ARGUMENT edge: PARAMETER -> argument_source
+ */
+import { Plugin, createSuccessResult } from '../Plugin.js';
+import { StrictModeError } from '../../errors/GrafemaError.js';
+export class ArgumentParameterLinker extends Plugin {
+    get metadata() {
+        return {
+            name: 'ArgumentParameterLinker',
+            phase: 'ENRICHMENT',
+            priority: 45, // Runs AFTER MethodCallResolver (50) which creates required CALLS edges
+            creates: {
+                nodes: [],
+                edges: ['RECEIVES_ARGUMENT']
+            },
+            dependencies: ['JSASTAnalyzer', 'MethodCallResolver'] // Requires CALLS edges
+        };
+    }
+    async execute(context) {
+        const { graph, onProgress } = context;
+        const logger = this.log(context);
+        logger.info('Starting argument-parameter linking');
+        const startTime = Date.now();
+        let callsProcessed = 0;
+        let edgesCreated = 0;
+        let unresolvedCalls = 0;
+        let noParams = 0;
+        const errors = [];
+        // Collect all CALL nodes (both CALL and METHOD_CALL via CALL type check)
+        const callNodes = [];
+        for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+            callNodes.push(node);
+        }
+        logger.info('Found calls to process', { count: callNodes.length });
+        // Build a Set of existing RECEIVES_ARGUMENT edges to avoid duplicates
+        // Key: `${paramId}:${dstId}:${callId}`
+        const existingEdges = new Set();
+        for await (const node of graph.queryNodes({ nodeType: 'PARAMETER' })) {
+            const edges = await graph.getOutgoingEdges(node.id, ['RECEIVES_ARGUMENT']);
+            for (const edge of edges) {
+                const callId = edge.callId ?? edge.metadata?.callId ?? '';
+                existingEdges.add(`${node.id}:${edge.dst}:${callId}`);
+            }
+        }
+        logger.debug('Found existing RECEIVES_ARGUMENT edges', { count: existingEdges.size });
+        for (const callNode of callNodes) {
+            callsProcessed++;
+            // Report progress every 100 calls
+            if (onProgress && callsProcessed % 100 === 0) {
+                const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+                onProgress({
+                    phase: 'enrichment',
+                    currentPlugin: 'ArgumentParameterLinker',
+                    message: `Linking arguments ${callsProcessed}/${callNodes.length} (${elapsed}s)`,
+                    totalFiles: callNodes.length,
+                    processedFiles: callsProcessed
+                });
+            }
+            // 1. Get PASSES_ARGUMENT edges from this call
+            const passesArgumentEdges = await graph.getOutgoingEdges(callNode.id, ['PASSES_ARGUMENT']);
+            if (passesArgumentEdges.length === 0) {
+                continue; // No arguments passed, skip
+            }
+            // 2. Get CALLS edge to find target function
+            const callsEdges = await graph.getOutgoingEdges(callNode.id, ['CALLS']);
+            if (callsEdges.length === 0) {
+                unresolvedCalls++;
+                // In strict mode, report unresolved calls that have arguments
+                if (context.strictMode) {
+                    const error = new StrictModeError(`Call with arguments has no resolved target: ${callNode.name || callNode.id}`, 'STRICT_UNRESOLVED_ARGUMENT', {
+                        filePath: callNode.file,
+                        lineNumber: callNode.line,
+                        phase: 'ENRICHMENT',
+                        plugin: 'ArgumentParameterLinker',
+                        callId: callNode.id,
+                    }, `Ensure the called function is imported or defined`);
+                    errors.push(error);
+                }
+                continue; // Unresolved call, skip
+            }
+            // Get target function node
+            const targetFunctionId = callsEdges[0].dst;
+            const targetFunction = await graph.getNode(targetFunctionId);
+            if (!targetFunction) {
+                unresolvedCalls++;
+                continue;
+            }
+            // 3. Get target function's PARAMETER nodes via HAS_PARAMETER edges
+            const hasParameterEdges = await graph.getOutgoingEdges(targetFunctionId, ['HAS_PARAMETER']);
+            if (hasParameterEdges.length === 0) {
+                noParams++;
+                continue; // Function has no parameters
+            }
+            // Build parameter index map: argIndex -> paramNode
+            const paramsByIndex = new Map();
+            for (const paramEdge of hasParameterEdges) {
+                const paramNode = await graph.getNode(paramEdge.dst);
+                if (paramNode && typeof paramNode.index === 'number') {
+                    paramsByIndex.set(paramNode.index, paramNode);
+                }
+            }
+            if (paramsByIndex.size === 0) {
+                noParams++;
+                continue;
+            }
+            // 4. For each PASSES_ARGUMENT edge, create RECEIVES_ARGUMENT edge
+            for (const passesEdge of passesArgumentEdges) {
+                // Get argIndex from edge (can be top-level or in metadata)
+                const argIndex = passesEdge.argIndex ?? passesEdge.metadata?.argIndex;
+                if (argIndex === undefined) {
+                    continue; // No argIndex, skip
+                }
+                // Find matching parameter
+                const paramNode = paramsByIndex.get(argIndex);
+                if (!paramNode) {
+                    continue; // No parameter for this argument index (extra arg)
+                }
+                // Check for duplicate
+                const edgeKey = `${paramNode.id}:${passesEdge.dst}:${callNode.id}`;
+                if (existingEdges.has(edgeKey)) {
+                    continue; // Already exists
+                }
+                // Create RECEIVES_ARGUMENT edge: PARAMETER -> argument_source
+                await graph.addEdge({
+                    type: 'RECEIVES_ARGUMENT',
+                    src: paramNode.id,
+                    dst: passesEdge.dst,
+                    metadata: {
+                        argIndex,
+                        callId: callNode.id
+                    }
+                });
+                existingEdges.add(edgeKey);
+                edgesCreated++;
+            }
+        }
+        const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+        logger.info('Complete', {
+            callsProcessed,
+            edgesCreated,
+            unresolvedCalls,
+            noParams,
+            time: `${totalTime}s`
+        });
+        return createSuccessResult({ nodes: 0, edges: edgesCreated }, {
+            callsProcessed,
+            edgesCreated,
+            unresolvedCalls,
+            noParams,
+            timeMs: Date.now() - startTime
+        }, errors);
+    }
+}

package/dist/plugins/enrichment/ClosureCaptureEnricher.d.ts

@@ -0,0 +1,51 @@
+/**
+ * ClosureCaptureEnricher - tracks transitive closure captures
+ *
+ * Problem: CAPTURES edges only exist for immediate parent scope (depth=1).
+ * Multi-level captures (grandparent, great-grandparent) are not tracked.
+ *
+ * Solution: Walk scope chains upward to find ALL captured variables,
+ * creating CAPTURES edges with depth metadata.
+ *
+ * USES:
+ * - SCOPE nodes with scopeType='closure'
+ * - SCOPE.parentScopeId for scope chain navigation
+ * - VARIABLE nodes with parentScopeId
+ * - CONSTANT nodes with parentScopeId
+ * - PARAMETER nodes with parentFunctionId (resolved via HAS_SCOPE)
+ *
+ * CREATES:
+ * - SCOPE -> CAPTURES -> VARIABLE/CONSTANT/PARAMETER (with metadata: { depth: N })
+ *
+ * NOTE: Depth=1 edges are created by JSASTAnalyzer without depth metadata.
+ * This enricher only creates edges for depth > 1.
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class ClosureCaptureEnricher extends Plugin {
+    static MAX_DEPTH: number;
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Build index: scopeId -> ScopeNode
+     */
+    private buildScopeIndex;
+    /**
+     * Build index: scopeId -> VariableNode[]
+     * Includes VARIABLE, CONSTANT, and PARAMETER nodes
+     */
+    private buildVariablesByScopeIndex;
+    /**
+     * Build set of existing CAPTURES edges: "srcId:dstId"
+     */
+    private buildExistingCapturesSet;
+    /**
+     * Walk scope chain upward from startScopeId
+     * Returns ancestor scopes with depth (1 = immediate parent, 2 = grandparent, etc.)
+     *
+     * Walks ALL scopes in the chain (including if/for/while blocks),
+     * not just closures.
+     */
+    private walkScopeChain;
+}
+//# sourceMappingURL=ClosureCaptureEnricher.d.ts.map

package/dist/plugins/enrichment/ClosureCaptureEnricher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClosureCaptureEnricher.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/ClosureCaptureEnricher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAsBhF,qBAAa,sBAAuB,SAAQ,MAAM;IAChD,MAAM,CAAC,SAAS,SAAM;IAEtB,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAyF5D;;OAEG;YACW,eAAe;IAU7B;;;OAGG;YACW,0BAA0B;IA0CxC;;OAEG;YACW,wBAAwB;IActC;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;CAgCvB"}

package/dist/plugins/enrichment/ClosureCaptureEnricher.js

@@ -0,0 +1,205 @@
+/**
+ * ClosureCaptureEnricher - tracks transitive closure captures
+ *
+ * Problem: CAPTURES edges only exist for immediate parent scope (depth=1).
+ * Multi-level captures (grandparent, great-grandparent) are not tracked.
+ *
+ * Solution: Walk scope chains upward to find ALL captured variables,
+ * creating CAPTURES edges with depth metadata.
+ *
+ * USES:
+ * - SCOPE nodes with scopeType='closure'
+ * - SCOPE.parentScopeId for scope chain navigation
+ * - VARIABLE nodes with parentScopeId
+ * - CONSTANT nodes with parentScopeId
+ * - PARAMETER nodes with parentFunctionId (resolved via HAS_SCOPE)
+ *
+ * CREATES:
+ * - SCOPE -> CAPTURES -> VARIABLE/CONSTANT/PARAMETER (with metadata: { depth: N })
+ *
+ * NOTE: Depth=1 edges are created by JSASTAnalyzer without depth metadata.
+ * This enricher only creates edges for depth > 1.
+ */
+import { Plugin, createSuccessResult } from '../Plugin.js';
+export class ClosureCaptureEnricher extends Plugin {
+    static MAX_DEPTH = 10;
+    get metadata() {
+        return {
+            name: 'ClosureCaptureEnricher',
+            phase: 'ENRICHMENT',
+            priority: 40, // Lower number = runs later. Runs after ImportExportLinker (90)
+            creates: {
+                nodes: [],
+                edges: ['CAPTURES']
+            },
+            dependencies: ['JSASTAnalyzer'] // Requires SCOPE and VARIABLE nodes
+        };
+    }
+    async execute(context) {
+        const { graph, onProgress } = context;
+        const logger = this.log(context);
+        logger.info('Starting transitive capture resolution');
+        let closuresProcessed = 0;
+        let capturesCreated = 0;
+        let existingCapturesSkipped = 0;
+        // Step 1: Build scope index for fast lookup
+        const scopeIndex = await this.buildScopeIndex(graph);
+        logger.debug('Indexed scopes', { count: scopeIndex.size });
+        // Step 2: Build variable index (scopeId -> variables/constants/parameters)
+        const variablesByScopeIndex = await this.buildVariablesByScopeIndex(graph);
+        logger.debug('Indexed variables by scope', { scopes: variablesByScopeIndex.size });
+        // Step 3: Find all closure scopes
+        const closureScopes = [];
+        for await (const node of graph.queryNodes({ type: 'SCOPE' })) {
+            const scope = node;
+            if (scope.scopeType === 'closure') {
+                closureScopes.push(scope);
+            }
+        }
+        logger.info('Found closure scopes', { count: closureScopes.length });
+        // Step 4: Build existing CAPTURES edge set to avoid duplicates
+        const existingCaptures = await this.buildExistingCapturesSet(graph);
+        logger.debug('Existing CAPTURES edges', { count: existingCaptures.size });
+        // Step 5: Process each closure
+        for (const closure of closureScopes) {
+            closuresProcessed++;
+            // Progress reporting
+            if (onProgress && closuresProcessed % 50 === 0) {
+                onProgress({
+                    phase: 'enrichment',
+                    currentPlugin: 'ClosureCaptureEnricher',
+                    message: `Processing closures ${closuresProcessed}/${closureScopes.length}`,
+                    totalFiles: closureScopes.length,
+                    processedFiles: closuresProcessed
+                });
+            }
+            // Walk scope chain upward
+            const ancestors = this.walkScopeChain(closure.id, scopeIndex);
+            // For each ancestor scope (depth > 1), find variables and create edges
+            for (const ancestor of ancestors) {
+                if (ancestor.depth <= 1)
+                    continue; // Skip immediate parent (already handled by JSASTAnalyzer)
+                const variables = variablesByScopeIndex.get(ancestor.scopeId) || [];
+                for (const variable of variables) {
+                    const edgeKey = `${closure.id}:${variable.id}`;
+                    if (existingCaptures.has(edgeKey)) {
+                        existingCapturesSkipped++;
+                        continue;
+                    }
+                    await graph.addEdge({
+                        src: closure.id,
+                        dst: variable.id,
+                        type: 'CAPTURES',
+                        metadata: { depth: ancestor.depth }
+                    });
+                    capturesCreated++;
+                    existingCaptures.add(edgeKey); // Track to avoid duplicates
+                }
+            }
+        }
+        const summary = {
+            closuresProcessed,
+            capturesCreated,
+            existingCapturesSkipped
+        };
+        logger.info('Summary', summary);
+        return createSuccessResult({ nodes: 0, edges: capturesCreated }, summary);
+    }
+    /**
+     * Build index: scopeId -> ScopeNode
+     */
+    async buildScopeIndex(graph) {
+        const index = new Map();
+        for await (const node of graph.queryNodes({ type: 'SCOPE' })) {
+            index.set(node.id, node);
+        }
+        return index;
+    }
+    /**
+     * Build index: scopeId -> VariableNode[]
+     * Includes VARIABLE, CONSTANT, and PARAMETER nodes
+     */
+    async buildVariablesByScopeIndex(graph) {
+        const index = new Map();
+        // Index VARIABLE nodes via parentScopeId
+        for await (const node of graph.queryNodes({ type: 'VARIABLE' })) {
+            const variable = node;
+            if (!variable.parentScopeId)
+                continue;
+            const vars = index.get(variable.parentScopeId) || [];
+            vars.push(variable);
+            index.set(variable.parentScopeId, vars);
+        }
+        // Index CONSTANT nodes via parentScopeId
+        for await (const node of graph.queryNodes({ type: 'CONSTANT' })) {
+            const constant = node;
+            if (!constant.parentScopeId)
+                continue;
+            const vars = index.get(constant.parentScopeId) || [];
+            vars.push(constant);
+            index.set(constant.parentScopeId, vars);
+        }
+        // Index PARAMETER nodes via parentFunctionId -> HAS_SCOPE lookup
+        for await (const node of graph.queryNodes({ type: 'PARAMETER' })) {
+            const param = node;
+            if (!param.parentFunctionId)
+                continue;
+            // Find the function's scope via HAS_SCOPE edge
+            // FUNCTION -[HAS_SCOPE]-> SCOPE
+            const scopeEdges = await graph.getOutgoingEdges(param.parentFunctionId, ['HAS_SCOPE']);
+            if (scopeEdges.length === 0)
+                continue;
+            const scopeId = scopeEdges[0].dst;
+            const params = index.get(scopeId) || [];
+            params.push(param);
+            index.set(scopeId, params);
+        }
+        return index;
+    }
+    /**
+     * Build set of existing CAPTURES edges: "srcId:dstId"
+     */
+    async buildExistingCapturesSet(graph) {
+        const set = new Set();
+        // Query all SCOPE nodes and get their CAPTURES edges
+        for await (const node of graph.queryNodes({ type: 'SCOPE' })) {
+            const edges = await graph.getOutgoingEdges(node.id, ['CAPTURES']);
+            for (const edge of edges) {
+                set.add(`${edge.src}:${edge.dst}`);
+            }
+        }
+        return set;
+    }
+    /**
+     * Walk scope chain upward from startScopeId
+     * Returns ancestor scopes with depth (1 = immediate parent, 2 = grandparent, etc.)
+     *
+     * Walks ALL scopes in the chain (including if/for/while blocks),
+     * not just closures.
+     */
+    walkScopeChain(startScopeId, scopeIndex) {
+        const result = [];
+        const visited = new Set();
+        const currentScope = scopeIndex.get(startScopeId);
+        if (!currentScope)
+            return result;
+        // Start walking from the closure's capturesFrom (immediate parent) or parentScopeId
+        let parentId = currentScope.capturesFrom || currentScope.parentScopeId;
+        let depth = 1;
+        while (parentId && depth <= ClosureCaptureEnricher.MAX_DEPTH) {
+            // Cycle protection
+            if (visited.has(parentId))
+                break;
+            visited.add(parentId);
+            result.push({ scopeId: parentId, depth });
+            // Get parent scope
+            const parentScope = scopeIndex.get(parentId);
+            if (!parentScope)
+                break;
+            // Move up the chain via parentScopeId
+            parentId = parentScope.parentScopeId;
+            depth++;
+        }
+        return result;
+    }
+}

package/dist/plugins/enrichment/ExternalCallResolver.d.ts

@@ -0,0 +1,42 @@
+/**
+ * ExternalCallResolver - creates CALLS edges for external package calls (REG-226)
+ *
+ * This enrichment plugin runs AFTER FunctionCallResolver (priority 70 vs 80) and:
+ * 1. Finds CALL nodes without CALLS edges (excluding method calls)
+ * 2. For each, looks for IMPORT with matching local name in same file
+ * 3. If import source is non-relative (external package), creates CALLS edge to EXTERNAL_MODULE
+ * 4. Recognizes JS built-in global functions (no edge needed, just counts them)
+ *
+ * CREATES NODES:
+ * - EXTERNAL_MODULE (for external packages like lodash, @tanstack/react-query)
+ *
+ * CREATES EDGES:
+ * - CALL -> CALLS -> EXTERNAL_MODULE (for imported external functions)
+ *
+ * Architecture:
+ * - Runs after FunctionCallResolver handles relative imports
+ * - Skips method calls (have 'object' attribute)
+ * - Skips already resolved calls (have CALLS edge)
+ * - Creates EXTERNAL_MODULE nodes lazily (only when needed)
+ * - Uses import index for O(1) lookups
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class ExternalCallResolver extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Extract package name from import source.
+     *
+     * Handles:
+     * - Simple packages: 'lodash' -> 'lodash'
+     * - Scoped packages: '@tanstack/react-query' -> '@tanstack/react-query'
+     * - Subpath imports: 'lodash/map' -> 'lodash'
+     * - Scoped subpath: '@scope/pkg/sub' -> '@scope/pkg'
+     *
+     * @param source - Import source string
+     * @returns Package name or null if invalid
+     */
+    private extractPackageName;
+}
+//# sourceMappingURL=ExternalCallResolver.d.ts.map

package/dist/plugins/enrichment/ExternalCallResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExternalCallResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/ExternalCallResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAoBhF,qBAAa,oBAAqB,SAAQ,MAAM;IAC9C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA0K5D;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,kBAAkB;CAqB3B"}