@grafema/core 0.1.1-alpha → 0.2.0-beta

package/dist/plugins/enrichment/HTTPConnectionEnricher.js

@@ -17,9 +17,9 @@ export class HTTPConnectionEnricher extends Plugin {
             priority: 50, // После основных enrichers
             creates: {
                 nodes: [],
-                edges: ['INTERACTS_WITH']
+                edges: ['INTERACTS_WITH', 'HTTP_RECEIVES']
             },
-            dependencies: ['ExpressRouteAnalyzer', 'FetchAnalyzer']
+            dependencies: ['ExpressRouteAnalyzer', 'FetchAnalyzer', 'ExpressResponseAnalyzer']
         };
     }
     async execute(context) {
@@ -60,22 +60,42 @@ export class HTTPConnectionEnricher extends Plugin {
                 // Ищем matching route
                 for (const route of uniqueRoutes) {
                     const routeMethod = (route.method || 'GET').toUpperCase();
-                    const routePath = route.path;
+                    // Use fullPath (from MountPointResolver) if available, fallback to local path
+                    const routePath = route.fullPath || route.path;
                     if (routePath && method === routeMethod && this.pathsMatch(url, routePath)) {
-                        // Создаём edge
+                        // 1. Create INTERACTS_WITH edge (existing)
                         await graph.addEdge({
                             type: 'INTERACTS_WITH',
                             src: request.id,
                             dst: route.id,
                             matchType: this.hasParams(routePath) ? 'parametric' : 'exact'
                         });
+                        edgesCreated++;
+                        // 2. Create HTTP_RECEIVES edges if both sides have data nodes
+                        const responseDataNode = request.responseDataNode;
+                        if (responseDataNode) {
+                            const respondsWithEdges = await graph.getOutgoingEdges(route.id, ['RESPONDS_WITH']);
+                            for (const respEdge of respondsWithEdges) {
+                                await graph.addEdge({
+                                    type: 'HTTP_RECEIVES',
+                                    src: responseDataNode,
+                                    dst: respEdge.dst,
+                                    metadata: {
+                                        method: request.method,
+                                        path: request.url,
+                                        viaRequest: request.id,
+                                        viaRoute: route.id
+                                    }
+                                });
+                                edgesCreated++;
+                            }
+                        }
                         connections.push({
                             request: `${method} ${url}`,
                             route: `${routeMethod} ${routePath}`,
                             requestFile: request.file,
                             routeFile: route.file
                         });
-                        edgesCreated++;
                         break; // Один request → один route
                     }
                 }
@@ -99,31 +119,55 @@ export class HTTPConnectionEnricher extends Plugin {
         }
     }
     /**
-     * Проверяет совпадают ли пути
-     * Поддерживает параметризованные пути: /api/users/:id матчится с /api/users/123
+     * Normalize URL to canonical form for comparison.
+     * Converts both Express params (:id) and template literals (${...}) to {param}.
+     */
+    normalizeUrl(url) {
+        return url
+            .replace(/:[^/]+/g, '{param}') // :id -> {param}
+            .replace(/\$\{[^}]*\}/g, '{param}'); // ${...} -> {param}, ${userId} -> {param}
+    }
+    /**
+     * Check if URL has any parameter placeholders (after normalization)
+     */
+    hasParamsNormalized(normalizedUrl) {
+        return normalizedUrl.includes('{param}');
+    }
+    /**
+     * Check if request URL matches route path.
+     * Supports:
+     * - Exact match
+     * - Express params (:id)
+     * - Template literals (${...})
+     * - Concrete values matching params (/users/123 matches /users/:id)
      */
     pathsMatch(requestUrl, routePath) {
-        // Точное совпадение
-        if (requestUrl === routePath) {
+        // Normalize both to canonical form
+        const normRequest = this.normalizeUrl(requestUrl);
+        const normRoute = this.normalizeUrl(routePath);
+        // If both normalize to same string, they match
+        if (normRequest === normRoute) {
             return true;
         }
-        // Если route не имеет параметров, требуем точное совпадение
-        if (!this.hasParams(routePath)) {
+        // If route has no params after normalization, require exact match
+        if (!this.hasParamsNormalized(normRoute)) {
             return false;
         }
-        // Преобразуем route path в regex
-        // /api/users/:id → /api/users/[^/]+
-        const regexPattern = routePath
-            .replace(/:[^/]+/g, '[^/]+') // :param → [^/]+
-            .replace(/\//g, '\\/'); // / → \/
-        const regex = new RegExp(`^${regexPattern}$`);
-        return regex.test(requestUrl);
+        // Handle case where request has concrete value (e.g., '/users/123')
+        // and route has param (e.g., '/users/{param}')
+        const routeRegex = normRoute
+            .replace(/\{param\}/g, '[^/]+') // {param} -> [^/]+
+            .replace(/\//g, '\\/'); // / -> \/
+        return new RegExp(`^${routeRegex}$`).test(normRequest);
     }
     /**
-     * Проверяет есть ли параметры в пути
+     * Check if path has parameters (for edge matchType metadata)
      */
     hasParams(path) {
-        return Boolean(path && path.includes(':'));
+        if (!path)
+            return false;
+        // Check for Express params or template literals
+        return path.includes(':') || path.includes('${');
     }
     /**
      * Убирает дубликаты по ID

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

@@ -1 +1 @@
-{"version":3,"file":"MethodCallResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/MethodCallResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAmBhF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,OAAO,CAAC,qBAAqB,CAAC,CAAqC;IAEnE,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAoG5D;;OAEG;YACW,qBAAqB;IA0CnC;;OAEG;YACW,sBAAsB;IAkBpC;;OAEG;YACW,iBAAiB;IA0D/B;;OAEG;YACW,mBAAmB;YAqBnB,4BAA4B;IAyB1C;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAWzB"}
+{"version":3,"file":"MethodCallResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/MethodCallResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAoBhF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,OAAO,CAAC,qBAAqB,CAAC,CAAqC;IAEnE,IAAI,QAAQ,IAAI,cAAc,CAU7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAuH5D;;OAEG;YACW,qBAAqB;IA0CnC;;OAEG;YACW,sBAAsB;IAkBpC;;OAEG;YACW,iBAAiB;IA0D/B;;OAEG;YACW,mBAAmB;YAqBnB,4BAA4B;IAyB1C;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAWzB"}

package/dist/plugins/enrichment/MethodCallResolver.js

@@ -11,6 +11,7 @@
  * - METHOD_CALL -> CALLS -> FUNCTION (для методов объектов)
  */
 import { Plugin, createSuccessResult } from '../Plugin.js';
+import { StrictModeError } from '../../errors/GrafemaError.js';
 export class MethodCallResolver extends Plugin {
     _containingClassCache;
     get metadata() {
@@ -31,6 +32,7 @@ export class MethodCallResolver extends Plugin {
         let methodCallsProcessed = 0;
         let edgesCreated = 0;
         let unresolved = 0;
+        const errors = [];
         // Собираем все METHOD_CALL ноды (CALL с object атрибутом)
         const methodCalls = [];
         for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
@@ -91,6 +93,18 @@ export class MethodCallResolver extends Plugin {
             }
             else {
                 unresolved++;
+                // In strict mode, collect error for later reporting
+                if (context.strictMode) {
+                    const error = new StrictModeError(`Cannot resolve method call: ${methodCall.object}.${methodCall.method}`, 'STRICT_UNRESOLVED_METHOD', {
+                        filePath: methodCall.file,
+                        lineNumber: methodCall.line,
+                        phase: 'ENRICHMENT',
+                        plugin: 'MethodCallResolver',
+                        object: methodCall.object,
+                        method: methodCall.method,
+                    }, `Check if class "${methodCall.object}" is imported and has method "${methodCall.method}"`);
+                    errors.push(error);
+                }
             }
         }
         const summary = {
@@ -100,7 +114,7 @@ export class MethodCallResolver extends Plugin {
             classesIndexed: classMethodIndex.size
         };
         logger.info('Summary', summary);
-        return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary);
+        return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary, errors);
     }
     /**
      * Строит индекс классов и их методов

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

@@ -1,26 +1,28 @@
 /**
  * MountPointResolver - ENRICHMENT plugin for resolving mount points
  *
- * Updates ENDPOINT nodes by adding fullPath based on MOUNT_POINT prefixes.
+ * REG-248 Fix: Now works with ExpressRouteAnalyzer's node types:
+ * - express:middleware (with mountPath) instead of MOUNT_POINT
+ * - http:route instead of ENDPOINT
  *
- * Graph traversal:
- * MOUNT_POINT --MOUNTS--> MODULE --EXPOSES--> ENDPOINT
+ * REG-318 Fix: Uses IMPORT nodes to determine which file a router variable
+ * comes from, then applies mount prefix ONLY to routes in that specific file.
  *
- * Updates:
- * endpoint.fullPath = mountPoint.prefix + endpoint.localPath
+ * Algorithm:
+ * 1. Find express:middleware nodes with mountPath
+ * 2. Build import map: for each mount file, map local variable names to resolved file paths
+ * 3. For each mount, find the specific imported file matching mount.name
+ * 4. Apply mount prefix only to routes in that specific file
  */
 import { Plugin } from '../Plugin.js';
 import type { PluginMetadata, PluginContext, PluginResult } from '@grafema/types';
 export declare class MountPointResolver extends Plugin {
     get metadata(): PluginMetadata;
-    execute(context: PluginContext): Promise<PluginResult>;
-    /**
-     * Recursively resolve mount point and all nested mount points
-     */
-    private resolveMountPoint;
     /**
-     * Helper method for finding edges by criteria
+     * Resolve relative import source to absolute file path.
+     * Replicates JSModuleIndexer.resolveModulePath() logic.
      */
-    private findEdges;
+    private resolveImportSource;
+    execute(context: PluginContext): Promise<PluginResult>;
 }
 //# sourceMappingURL=MountPointResolver.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"MountPointResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/MountPointResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAgB,MAAM,gBAAgB,CAAC;AAuBhG,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAkG5D;;OAEG;YACW,iBAAiB;IAsF/B;;OAEG;YACW,SAAS;CA2BxB"}
+{"version":3,"file":"MountPointResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/MountPointResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AA6BlF,qBAAa,kBAAmB,SAAQ,MAAM;IAC5C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAED;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IA0BrB,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAwL7D"}

package/dist/plugins/enrichment/MountPointResolver.js

@@ -1,16 +1,23 @@
 /**
  * MountPointResolver - ENRICHMENT plugin for resolving mount points
  *
- * Updates ENDPOINT nodes by adding fullPath based on MOUNT_POINT prefixes.
+ * REG-248 Fix: Now works with ExpressRouteAnalyzer's node types:
+ * - express:middleware (with mountPath) instead of MOUNT_POINT
+ * - http:route instead of ENDPOINT
  *
- * Graph traversal:
- * MOUNT_POINT --MOUNTS--> MODULE --EXPOSES--> ENDPOINT
+ * REG-318 Fix: Uses IMPORT nodes to determine which file a router variable
+ * comes from, then applies mount prefix ONLY to routes in that specific file.
  *
- * Updates:
- * endpoint.fullPath = mountPoint.prefix + endpoint.localPath
+ * Algorithm:
+ * 1. Find express:middleware nodes with mountPath
+ * 2. Build import map: for each mount file, map local variable names to resolved file paths
+ * 3. For each mount, find the specific imported file matching mount.name
+ * 4. Apply mount prefix only to routes in that specific file
  */
 import { Plugin } from '../Plugin.js';
 import { createSuccessResult, createErrorResult } from '@grafema/types';
+import { dirname, resolve, join } from 'path';
+import { existsSync } from 'fs';
 export class MountPointResolver extends Plugin {
     get metadata() {
         return {
@@ -18,177 +25,191 @@ export class MountPointResolver extends Plugin {
             phase: 'ENRICHMENT',
             priority: 90, // High priority - one of first enrichment plugins
             creates: {
-                nodes: [], // Doesn't create new nodes
-                edges: [] // Doesn't create new edges
+                nodes: [], // Updates existing nodes
+                edges: [] // Doesn't create edges
             },
-            dependencies: ['JSModuleIndexer', 'JSASTAnalyzer']
+            dependencies: ['JSModuleIndexer', 'JSASTAnalyzer', 'ExpressRouteAnalyzer']
         };
     }
+    /**
+     * Resolve relative import source to absolute file path.
+     * Replicates JSModuleIndexer.resolveModulePath() logic.
+     */
+    resolveImportSource(importSource, containingFile) {
+        // Only handle relative imports
+        if (!importSource.startsWith('./') && !importSource.startsWith('../')) {
+            return null; // External package
+        }
+        const dir = dirname(containingFile);
+        const basePath = resolve(dir, importSource);
+        // Try direct path
+        if (existsSync(basePath))
+            return basePath;
+        // Try extensions
+        for (const ext of ['.js', '.mjs', '.jsx', '.ts', '.tsx']) {
+            if (existsSync(basePath + ext))
+                return basePath + ext;
+        }
+        // Try index files
+        for (const indexFile of ['index.js', 'index.ts', 'index.mjs', 'index.tsx']) {
+            const indexPath = join(basePath, indexFile);
+            if (existsSync(indexPath))
+                return indexPath;
+        }
+        return null;
+    }
     async execute(context) {
         try {
             const { graph } = context;
             const logger = this.log(context);
-            let endpointsUpdated = 0;
+            let routesUpdated = 0;
             let mountPointsProcessed = 0;
-            // Find all MOUNT_POINT nodes
-            const allNodes = await graph.getAllNodes();
-            const mountPoints = allNodes.filter(node => node.type === 'MOUNT_POINT');
-            logger.info('Found mount points', { count: mountPoints.length });
-            // For each top-level mount point (from app.use in index.js)
-            // apply recursive resolver
-            const processedMountPoints = new Set();
-            for (const mountPoint of mountPoints) {
-                if (!processedMountPoints.has(mountPoint.id)) {
-                    const updated = await this.resolveMountPoint(graph, mountPoint, '', processedMountPoints);
-                    endpointsUpdated += updated;
-                    mountPointsProcessed++;
+            // Step 1: Find all mount points (express:middleware with mountPath)
+            const mountNodes = [];
+            for await (const node of graph.queryNodes({ type: 'express:middleware' })) {
+                const mount = node;
+                // Only include mounts with a meaningful path (not global middleware)
+                if (mount.mountPath && mount.mountPath !== '/' && mount.name) {
+                    mountNodes.push(mount);
                 }
             }
-            // Fallback: process mount points without recursion (old logic for compatibility)
-            for (const mountPoint of mountPoints) {
-                if (processedMountPoints.has(mountPoint.id))
-                    continue;
-                // Find MOUNT_POINT --MOUNTS--> MODULE edge
-                const mountsEdges = await this.findEdges(graph, {
-                    type: 'MOUNTS',
-                    src: mountPoint.id
+            // Also check for express:mount (from ExpressAnalyzer, if enabled)
+            for await (const node of graph.queryNodes({ type: 'express:mount' })) {
+                const mount = node;
+                if (mount.mountPath || mount.prefix) {
+                    // express:mount uses 'prefix' field
+                    const prefix = mount.mountPath || mount.prefix;
+                    if (prefix && prefix !== '/') {
+                        mountNodes.push({
+                            ...mount,
+                            mountPath: prefix
+                        });
+                    }
+                }
+            }
+            logger.info('Found mount points', { count: mountNodes.length });
+            // Debug: log mount point details
+            for (const mount of mountNodes) {
+                logger.debug('Mount point details', {
+                    id: mount.id,
+                    mountPath: mount.mountPath,
+                    name: mount.name,
+                    file: mount.file
                 });
-                for (const mountsEdge of mountsEdges) {
-                    const targetModuleId = mountsEdge.dst;
-                    // Find MODULE --EXPOSES--> ENDPOINT edges
-                    const exposesEdges = await this.findEdges(graph, {
-                        type: 'EXPOSES',
-                        src: targetModuleId
-                    });
-                    for (const exposesEdge of exposesEdges) {
-                        const endpointId = exposesEdge.dst;
-                        const endpoint = await graph.getNode(endpointId);
-                        if (endpoint && endpoint.type === 'ENDPOINT') {
-                            // Support multiple mount points for one endpoint
-                            // Store all prefixes and fullPaths in arrays
-                            const mountPrefixes = endpoint.mountPrefixes || [];
-                            const fullPaths = endpoint.fullPaths || [];
-                            const prefix = mountPoint.prefix;
-                            const fullPath = prefix + (endpoint.localPath || endpoint.path || '');
-                            // Only add if not already added (avoid duplicates)
-                            if (!mountPrefixes.includes(prefix)) {
-                                mountPrefixes.push(prefix);
-                                fullPaths.push(fullPath);
-                            }
-                            // Update endpoint node
-                            const updatedEndpoint = {
-                                ...endpoint,
-                                mountPrefixes,
-                                fullPaths,
-                                mountPrefix: endpoint.mountPrefix || prefix,
-                                fullPath: endpoint.fullPath || fullPath
-                            };
-                            await graph.addNode(updatedEndpoint);
-                            endpointsUpdated++;
-                        }
+            }
+            if (mountNodes.length === 0) {
+                return createSuccessResult({ nodes: 0, edges: 0 }, { routesUpdated: 0, mountPointsProcessed: 0 });
+            }
+            // Step 2: Build import map for files that contain mount points
+            // Map<file, Map<localName, resolvedFile>>
+            const importMaps = new Map();
+            const mountFiles = new Set(mountNodes.map(m => m.file).filter((f) => Boolean(f)));
+            for (const mountFile of mountFiles) {
+                const importMap = new Map();
+                // Query IMPORT nodes in this file
+                for await (const node of graph.queryNodes({ type: 'IMPORT' })) {
+                    const importNode = node;
+                    if (importNode.file !== mountFile)
+                        continue;
+                    if (!importNode.local || !importNode.source)
+                        continue;
+                    // Resolve source to absolute path
+                    const resolvedPath = this.resolveImportSource(importNode.source, mountFile);
+                    if (resolvedPath) {
+                        importMap.set(importNode.local, resolvedPath);
+                        logger.debug('Import mapped', {
+                            local: importNode.local,
+                            source: importNode.source,
+                            resolved: resolvedPath
+                        });
                     }
                 }
-                mountPointsProcessed++;
+                importMaps.set(mountFile, importMap);
             }
-            logger.info('Updated endpoints', {
-                endpoints: endpointsUpdated,
-                mountPoints: mountPointsProcessed
+            logger.debug('Import maps built', {
+                files: importMaps.size,
+                totalMappings: [...importMaps.values()].reduce((sum, m) => sum + m.size, 0)
             });
-            return createSuccessResult({ nodes: 0, edges: 0 }, { endpointsUpdated, mountPointsProcessed });
-        }
-        catch (error) {
-            const logger = this.log(context);
-            logger.error('Error in MountPointResolver', { error });
-            return createErrorResult(error);
-        }
-    }
-    /**
-     * Recursively resolve mount point and all nested mount points
-     */
-    async resolveMountPoint(graph, mountPoint, parentPrefix, processedMountPoints) {
-        let endpointsUpdated = 0;
-        // Mark as processed
-        processedMountPoints.add(mountPoint.id);
-        // Calculate full prefix (parent + current)
-        const fullPrefix = parentPrefix + mountPoint.prefix;
-        // Find MOUNT_POINT --MOUNTS--> MODULE edge
-        const mountsEdges = await this.findEdges(graph, {
-            type: 'MOUNTS',
-            src: mountPoint.id
-        });
-        for (const mountsEdge of mountsEdges) {
-            const targetModuleId = mountsEdge.dst;
-            // 1. Process ENDPOINT in this module
-            const exposesEdges = await this.findEdges(graph, {
-                type: 'EXPOSES',
-                src: targetModuleId
-            });
-            for (const exposesEdge of exposesEdges) {
-                const endpointId = exposesEdge.dst;
-                const endpoint = await graph.getNode(endpointId);
-                if (endpoint && endpoint.type === 'ENDPOINT') {
+            // Step 3: Collect all routes by file
+            const routesByFile = new Map();
+            for await (const node of graph.queryNodes({ type: 'http:route' })) {
+                const route = node;
+                if (route.file) {
+                    if (!routesByFile.has(route.file)) {
+                        routesByFile.set(route.file, []);
+                    }
+                    routesByFile.get(route.file).push(route);
+                }
+            }
+            // Step 4: For each mount point, find and update routes
+            for (const mount of mountNodes) {
+                if (!mount.file || !mount.mountPath || !mount.name)
+                    continue;
+                // Get import map for this file
+                const importMap = importMaps.get(mount.file);
+                if (!importMap) {
+                    logger.debug('No import map for mount file', { file: mount.file });
+                    continue;
+                }
+                // Find the specific imported file for this mount variable
+                const importedFile = importMap.get(mount.name);
+                if (!importedFile) {
+                    logger.debug('No import found for mount name', {
+                        file: mount.file,
+                        mountName: mount.name,
+                        availableImports: [...importMap.keys()]
+                    });
+                    continue;
+                }
+                // Get routes in that specific file
+                const routes = routesByFile.get(importedFile);
+                if (!routes || routes.length === 0) {
+                    logger.debug('No routes in imported file', {
+                        importedFile,
+                        mountName: mount.name
+                    });
+                    continue;
+                }
+                logger.debug('Applying mount prefix', {
+                    mountPath: mount.mountPath,
+                    mountName: mount.name,
+                    importedFile,
+                    routeCount: routes.length
+                });
+                // Update routes with fullPath
+                for (const route of routes) {
+                    const localPath = route.localPath || route.path || '';
+                    const fullPath = mount.mountPath + localPath;
                     // Support multiple mount points
-                    const mountPrefixes = endpoint.mountPrefixes || [];
-                    const fullPaths = endpoint.fullPaths || [];
-                    const fullPath = fullPrefix + (endpoint.localPath || endpoint.path || '');
-                    // Only add if not already added
-                    if (!mountPrefixes.includes(fullPrefix)) {
-                        mountPrefixes.push(fullPrefix);
+                    const mountPrefixes = route.mountPrefixes || [];
+                    const fullPaths = route.fullPaths || [];
+                    if (!mountPrefixes.includes(mount.mountPath)) {
+                        mountPrefixes.push(mount.mountPath);
                         fullPaths.push(fullPath);
                     }
-                    // Update endpoint node with new data
-                    const updatedEndpoint = {
-                        ...endpoint,
+                    // Update route node
+                    const updatedRoute = {
+                        ...route,
                         mountPrefixes,
                         fullPaths,
-                        mountPrefix: endpoint.mountPrefix || fullPrefix,
-                        fullPath: endpoint.fullPath || fullPath
+                        mountPrefix: route.mountPrefix || mount.mountPath,
+                        fullPath: route.fullPath || fullPath
                     };
-                    await graph.addNode(updatedEndpoint);
-                    endpointsUpdated++;
+                    await graph.addNode(updatedRoute);
+                    routesUpdated++;
                 }
+                mountPointsProcessed++;
             }
-            // 2. Recursively process nested MOUNT_POINT in this module
-            const definesEdges = await this.findEdges(graph, {
-                type: 'DEFINES',
-                src: targetModuleId
+            logger.info('Updated routes with mount prefixes', {
+                routes: routesUpdated,
+                mountPoints: mountPointsProcessed
             });
-            for (const definesEdge of definesEdges) {
-                const nestedMountPointId = definesEdge.dst;
-                const nestedMountPoint = await graph.getNode(nestedMountPointId);
-                if (nestedMountPoint && nestedMountPoint.type === 'MOUNT_POINT' &&
-                    !processedMountPoints.has(nestedMountPointId)) {
-                    // Recursively process nested mount point
-                    endpointsUpdated += await this.resolveMountPoint(graph, nestedMountPoint, fullPrefix, // Pass accumulated prefix
-                    processedMountPoints);
-                }
-            }
+            return createSuccessResult({ nodes: 0, edges: 0 }, { routesUpdated, mountPointsProcessed });
         }
-        return endpointsUpdated;
-    }
-    /**
-     * Helper method for finding edges by criteria
-     */
-    async findEdges(graph, criteria) {
-        const result = [];
-        // Get all edges using RFDBServerBackend API
-        if (!graph.getAllEdges) {
-            return result;
-        }
-        const allEdges = await graph.getAllEdges();
-        for (const edge of allEdges) {
-            let matches = true;
-            for (const [key, value] of Object.entries(criteria)) {
-                const edgeRecord = edge;
-                if (edgeRecord[key] !== value) {
-                    matches = false;
-                    break;
-                }
-            }
-            if (matches) {
-                result.push(edge);
-            }
+        catch (error) {
+            const logger = this.log(context);
+            logger.error('Error in MountPointResolver', { error });
+            return createErrorResult(error);
         }
-        return result;
     }
 }

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

@@ -0,0 +1,44 @@
+/**
+ * NodejsBuiltinsResolver - Creates EXTERNAL_FUNCTION nodes for Node.js builtin calls (REG-218)
+ *
+ * This ENRICHMENT plugin:
+ * 1. Queries all CALL nodes
+ * 2. For each call that targets a builtin function:
+ *    - Checks if call's `object` matches a builtin module (fs, path, etc.)
+ *    - Or traces via IMPORT node to find the module source
+ * 3. Creates EXTERNAL_FUNCTION node lazily (if not exists)
+ * 4. Creates CALLS edge from CALL to EXTERNAL_FUNCTION
+ *
+ * Architecture:
+ * - Nodes are created lazily - only when a call is detected
+ * - ID format: EXTERNAL_FUNCTION:fs.readFile
+ * - Metadata includes: isBuiltin:true, security?, pure?
+ *
+ * Also creates:
+ * - EXTERNAL_MODULE nodes for imported builtin modules
+ * - IMPORTS_FROM edges from IMPORT to EXTERNAL_MODULE
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class NodejsBuiltinsResolver extends Plugin {
+    private registry;
+    constructor(config?: Record<string, unknown>);
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Build index of imports for tracking module sources.
+     *
+     * Maps: file:localName -> {source, imported, importNodeId, importType}
+     */
+    private buildImportIndex;
+    /**
+     * Resolve a CALL node to its builtin module and function.
+     *
+     * Handles:
+     * 1. Method calls: fs.readFile() -> {module: 'fs', function: 'readFile'}
+     * 2. Direct calls from imports: readFile() -> trace to import source
+     * 3. Aliased imports: rf() where rf = readFile from 'fs'
+     */
+    private resolveBuiltinCall;
+}
+//# sourceMappingURL=NodejsBuiltinsResolver.d.ts.map