@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/dist/plugins/analysis/ExpressRouteAnalyzer.js

@@ -11,6 +11,7 @@ import { readFileSync } from 'fs';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+import { getLine, getColumn } from './ast/utils/location.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = traverseModule.default || traverseModule;
 const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'options', 'head'];
@@ -28,11 +29,12 @@ export class ExpressRouteAnalyzer extends Plugin {
         };
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { graph } = context;
             // Получаем все MODULE ноды
             const modules = await this.getModules(graph);
-            console.log(`[ExpressRouteAnalyzer] Processing ${modules.length} modules...`);
+            logger.info('Processing modules', { count: modules.length });
             let endpointsCreated = 0;
             let middlewareCreated = 0;
             let edgesCreated = 0;
@@ -48,17 +50,22 @@ export class ExpressRouteAnalyzer extends Plugin {
                 if ((i + 1) % 20 === 0 || i === modules.length - 1) {
                     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
                     const avgTime = ((Date.now() - startTime) / (i + 1)).toFixed(0);
-                    console.log(`[ExpressRouteAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`);
+                    logger.debug('Progress', {
+                        current: i + 1,
+                        total: modules.length,
+                        elapsed: `${elapsed}s`,
+                        avgTime: `${avgTime}ms/module`
+                    });
                 }
             }
-            console.log(`[ExpressRouteAnalyzer] Found ${endpointsCreated} endpoints, ${middlewareCreated} middleware`);
+            logger.info('Analysis complete', { endpointsCreated, middlewareCreated });
             return createSuccessResult({
                 nodes: endpointsCreated + middlewareCreated,
                 edges: edgesCreated
             }, { modulesAnalyzed: modules.length });
         }
         catch (error) {
-            console.error(`[ExpressRouteAnalyzer] Error:`, error);
+            logger.error('Analysis failed', { error });
             return createErrorResult(error);
         }
     }
@@ -133,21 +140,51 @@ export class ExpressRouteAnalyzer extends Plugin {
                                     const handlers = args.slice(1);
                                     // Последний handler - это route handler
                                     const mainHandler = handlers[handlers.length - 1];
+                                    // Unwrap wrapper functions (asyncHandler, catchAsync, etc.)
+                                    // Pattern: wrapper(async (req, res) => {...}) -> extract inner function
+                                    // Also handles nested wrappers: outer(inner(handler))
+                                    let actualHandler = mainHandler;
+                                    while (actualHandler.type === 'CallExpression') {
+                                        const callExpr = actualHandler;
+                                        const firstArg = callExpr.arguments[0];
+                                        if (!firstArg) {
+                                            // No arguments - not a wrapper pattern
+                                            break;
+                                        }
+                                        if (firstArg.type === 'ArrowFunctionExpression' ||
+                                            firstArg.type === 'FunctionExpression') {
+                                            // Found the actual handler function
+                                            actualHandler = firstArg;
+                                            break;
+                                        }
+                                        else if (firstArg.type === 'CallExpression') {
+                                            // Nested wrapper: outer(inner(...)) - continue unwrapping
+                                            actualHandler = firstArg;
+                                        }
+                                        else {
+                                            // First arg is not a function or CallExpression - not a wrapper pattern
+                                            break;
+                                        }
+                                    }
                                     // Все предыдущие - middleware
                                     const middlewareHandlers = handlers.slice(0, -1);
                                     // Создаём http:route
-                                    const endpointId = `http:route#${method.toUpperCase()}:${routePath}#${module.file}#${node.loc.start.line}`;
+                                    const endpointId = `http:route#${method.toUpperCase()}:${routePath}#${module.file}#${getLine(node)}`;
                                     endpoints.push({
                                         id: endpointId,
                                         type: 'http:route',
                                         method: method.toUpperCase(),
                                         path: routePath,
                                         file: module.file,
-                                        line: node.loc.start.line,
+                                        line: getLine(node),
+                                        column: getColumn(node),
                                         routerName: objectName,
-                                        handlerLine: mainHandler.loc
-                                            ? mainHandler.loc.start.line
-                                            : node.loc.start.line
+                                        handlerLine: actualHandler.loc
+                                            ? getLine(actualHandler)
+                                            : getLine(node),
+                                        handlerColumn: actualHandler.loc
+                                            ? getColumn(actualHandler)
+                                            : getColumn(node)
                                     });
                                     // Обрабатываем middleware
                                     middlewareHandlers.forEach((mw, index) => {
@@ -164,16 +201,17 @@ export class ExpressRouteAnalyzer extends Plugin {
                                         }
                                         else if (mwNode.type === 'ArrowFunctionExpression' ||
                                             mwNode.type === 'FunctionExpression') {
-                                            middlewareName = `inline:${mwNode.loc.start.line}`;
+                                            middlewareName = `inline:${getLine(mwNode)}`;
                                         }
                                         if (middlewareName) {
-                                            const middlewareId = `express:middleware#${middlewareName}#${module.file}#${mwNode.loc.start.line}`;
+                                            const middlewareId = `express:middleware#${middlewareName}#${module.file}#${getLine(mwNode)}`;
                                             middlewares.push({
                                                 id: middlewareId,
                                                 type: 'express:middleware',
                                                 name: middlewareName,
                                                 file: module.file,
-                                                line: mwNode.loc ? mwNode.loc.start.line : node.loc.start.line,
+                                                line: mwNode.loc ? getLine(mwNode) : getLine(node),
+                                                column: mwNode.loc ? getColumn(mwNode) : getColumn(node),
                                                 endpointId: endpointId,
                                                 order: index // Порядок в цепочке
                                             });
@@ -204,13 +242,14 @@ export class ExpressRouteAnalyzer extends Plugin {
                                         middlewareName = middlewareArg.callee.name;
                                     }
                                     if (middlewareName) {
-                                        const middlewareId = `express:middleware#${middlewareName}#${module.file}#${node.loc.start.line}`;
+                                        const middlewareId = `express:middleware#${middlewareName}#${module.file}#${getLine(node)}`;
                                         middlewares.push({
                                             id: middlewareId,
                                             type: 'express:middleware',
                                             name: middlewareName,
                                             file: module.file,
-                                            line: node.loc.start.line,
+                                            line: getLine(node),
+                                            column: getColumn(node),
                                             mountPath: mountPath,
                                             isGlobal: mountPath === '/' // Global middleware если нет path
                                         });
@@ -223,10 +262,11 @@ export class ExpressRouteAnalyzer extends Plugin {
             });
             // Создаём ENDPOINT ноды
             for (const endpoint of endpoints) {
-                // Сохраняем handlerLine ПЕРЕД destructuring
+                // Сохраняем handler location ПЕРЕД destructuring
                 const handlerLine = endpoint.handlerLine;
+                const handlerColumn = endpoint.handlerColumn;
                 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                const { handlerLine: _, routerName, ...endpointData } = endpoint;
+                const { handlerLine: _hl, handlerColumn: _hc, routerName, ...endpointData } = endpoint;
                 await graph.addNode(endpointData);
                 endpointsCreated++;
                 // MODULE -> CONTAINS -> ENDPOINT
@@ -236,22 +276,24 @@ export class ExpressRouteAnalyzer extends Plugin {
                     dst: endpoint.id
                 });
                 edgesCreated++;
-                // Ищем FUNCTION ноду для handler (arrow function на той же строке)
+                // Ищем FUNCTION ноду для handler по line+column
+                // NOTE: queryNodes не поддерживает line/column фильтрацию, поэтому фильтруем вручную
                 if (handlerLine) {
-                    // Используем queryNodes вместо прямого доступа к graph.nodes
                     for await (const fn of graph.queryNodes({
                         type: 'FUNCTION',
-                        file: module.file,
-                        line: handlerLine
+                        file: module.file
                     })) {
-                        // ENDPOINT -> HANDLED_BY -> FUNCTION
-                        await graph.addEdge({
-                            type: 'HANDLED_BY',
-                            src: endpoint.id,
-                            dst: fn.id
-                        });
-                        edgesCreated++;
-                        break; // Берём только первую найденную функцию
+                        // Проверяем точное совпадение line и column
+                        if (fn.line === handlerLine && fn.column === handlerColumn) {
+                            // ENDPOINT -> HANDLED_BY -> FUNCTION
+                            await graph.addEdge({
+                                type: 'HANDLED_BY',
+                                src: endpoint.id,
+                                dst: fn.id
+                            });
+                            edgesCreated++;
+                            break;
+                        }
                     }
                 }
             }
@@ -297,7 +339,7 @@ export class ExpressRouteAnalyzer extends Plugin {
             }
         }
         catch (error) {
-            console.error(`[ExpressRouteAnalyzer] Error analyzing ${module.file}:`, error.message);
+            // Silent - per-module errors shouldn't spam logs
         }
         return {
             endpoints: endpointsCreated,

package/dist/plugins/analysis/FetchAnalyzer.d.ts

@@ -11,8 +11,15 @@
 import { Plugin } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 export declare class FetchAnalyzer extends Plugin {
+    private networkNodeCreated;
+    private networkNodeId;
     get metadata(): PluginMetadata;
     execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Ensures net:request singleton exists, creating it if necessary.
+     * Called lazily when first HTTP request is detected.
+     */
+    private ensureNetworkNode;
     private analyzeModule;
     /**
      * Извлекает URL из аргумента
@@ -26,6 +33,15 @@ export declare class FetchAnalyzer extends Plugin {
      * Извлекает строковое значение
      */
     private extractString;
+    /**
+     * Returns expected CALL node names based on library and HTTP method.
+     * Used to match http:request with corresponding CALL node.
+     *
+     * @param library - Library name (fetch, axios, or custom wrapper name)
+     * @param method - HTTP method (GET, POST, etc.)
+     * @returns Array of possible call names
+     */
+    private getExpectedCallNames;
     /**
      * Проверяет является ли URL внешним API
      */
@@ -34,5 +50,30 @@ export declare class FetchAnalyzer extends Plugin {
      * Извлекает домен из URL
      */
     private extractDomain;
+    /**
+     * Extracts the variable name that holds the fetch response.
+     * Handles patterns like:
+     * - const response = await fetch(url)
+     * - let res = await fetch(url)
+     * - response = await fetch(url)
+     *
+     * @param path - NodePath of the CallExpression
+     * @returns Variable name or null if not found
+     */
+    private getResponseVariableName;
+    /**
+     * Finds the response consumption CALL node (response.json(), response.text(), etc.)
+     * by querying the graph for CALL nodes in the same file with matching object name.
+     *
+     * Important: Filters to find the response.json() call AFTER the fetch line and
+     * closest to it, ensuring we match the correct call in the same function scope.
+     *
+     * @param graph - Graph backend
+     * @param file - File path where fetch call is located
+     * @param responseVarName - Variable name holding the response
+     * @param fetchLine - Line number of the fetch call (response.json must be after this)
+     * @returns CALL node ID or null if not found
+     */
+    private findResponseJsonCall;
 }
 //# sourceMappingURL=FetchAnalyzer.d.ts.map

package/dist/plugins/analysis/FetchAnalyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FetchAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/FetchAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA4BhF,qBAAa,aAAc,SAAQ,MAAM;IACvC,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YA8C9C,aAAa;IAiP3B;;OAEG;IACH,OAAO,CAAC,UAAU;IA8BlB;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAUrB;;OAEG;IACH,OAAO,CAAC,aAAa;IASrB;;OAEG;IACH,OAAO,CAAC,aAAa;CAUtB"}
+{"version":3,"file":"FetchAnalyzer.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/FetchAnalyzer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA8ChF,qBAAa,aAAc,SAAQ,MAAM;IACvC,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,aAAa,CAAuB;IAE5C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAsD5D;;;OAGG;YACW,iBAAiB;YAUjB,aAAa;IA4S3B;;OAEG;IACH,OAAO,CAAC,UAAU;IA8BlB;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAUrB;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAc5B;;OAEG;IACH,OAAO,CAAC,aAAa;IASrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAWrB;;;;;;;;;OASG;IACH,OAAO,CAAC,uBAAuB;IA8B/B;;;;;;;;;;;;OAYG;YACW,oBAAoB;CAiCnC"}

package/dist/plugins/analysis/FetchAnalyzer.js

@@ -12,9 +12,17 @@ import { readFileSync } from 'fs';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
+import { NetworkRequestNode } from '../../core/nodes/NetworkRequestNode.js';
+import { getLine, getColumn } from './ast/utils/location.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = traverseModule.default || traverseModule;
+/**
+ * Response consumption methods for fetch API
+ */
+const RESPONSE_CONSUMPTION_METHODS = ['json', 'text', 'blob', 'arrayBuffer', 'formData'];
 export class FetchAnalyzer extends Plugin {
+    networkNodeCreated = false;
+    networkNodeId = null;
     get metadata() {
         return {
             name: 'FetchAnalyzer',
@@ -28,11 +36,13 @@ export class FetchAnalyzer extends Plugin {
         };
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { graph } = context;
+            // net:request singleton created lazily in analyzeModule when first request found
             // Получаем все модули
             const modules = await this.getModules(graph);
-            console.log(`[FetchAnalyzer] Processing ${modules.length} modules...`);
+            logger.info('Processing modules', { count: modules.length });
             let requestsCount = 0;
             let apisCount = 0;
             const startTime = Date.now();
@@ -45,23 +55,42 @@ export class FetchAnalyzer extends Plugin {
                 if ((i + 1) % 20 === 0 || i === modules.length - 1) {
                     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
                     const avgTime = ((Date.now() - startTime) / (i + 1)).toFixed(0);
-                    console.log(`[FetchAnalyzer] Progress: ${i + 1}/${modules.length} (${elapsed}s, avg ${avgTime}ms/module)`);
+                    logger.debug('Progress', {
+                        current: i + 1,
+                        total: modules.length,
+                        elapsed: `${elapsed}s`,
+                        avgTime: `${avgTime}ms/module`
+                    });
                 }
             }
-            console.log(`[FetchAnalyzer] Found ${requestsCount} HTTP requests, ${apisCount} external APIs`);
+            logger.info('Analysis complete', { requestsCount, apisCount });
             return createSuccessResult({
-                nodes: requestsCount + apisCount,
-                edges: 0
+                nodes: requestsCount + apisCount + (this.networkNodeCreated ? 1 : 0),
+                edges: requestsCount // CALLS edges from http:request to net:request
             }, {
                 requestsCount,
-                apisCount
+                apisCount,
+                networkSingletonCreated: this.networkNodeCreated
             });
         }
         catch (error) {
-            console.error('[FetchAnalyzer] Error:', error);
+            logger.error('Analysis failed', { error });
             return createErrorResult(error);
         }
     }
+    /**
+     * Ensures net:request singleton exists, creating it if necessary.
+     * Called lazily when first HTTP request is detected.
+     */
+    async ensureNetworkNode(graph) {
+        if (!this.networkNodeId) {
+            const networkNode = NetworkRequestNode.create();
+            await graph.addNode(networkNode);
+            this.networkNodeCreated = true;
+            this.networkNodeId = networkNode.id;
+        }
+        return this.networkNodeId;
+    }
     async analyzeModule(module, graph) {
         try {
             const code = readFileSync(module.file, 'utf-8');
@@ -78,7 +107,7 @@ export class FetchAnalyzer extends Plugin {
                     'nullishCoalescingOperator'
                 ]
             });
-            const httpRequests = [];
+            const fetchCalls = [];
             const externalAPIs = new Set();
             // Детект HTTP request паттернов
             traverse(ast, {
@@ -90,18 +119,22 @@ export class FetchAnalyzer extends Plugin {
                         const urlArg = node.arguments[0];
                         const url = this.extractURL(urlArg);
                         const method = this.extractMethod(node.arguments[1]) || 'GET';
-                        const line = node.loc.start.line;
+                        const line = getLine(node);
                         const request = {
                             id: `http:request#${method}:${url}#${module.file}#${line}`,
                             type: 'http:request',
+                            name: `${method} ${url}`,
                             method: method,
                             url: url,
                             library: 'fetch',
                             file: module.file,
                             line: line,
+                            column: getColumn(node),
                             staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
                         };
-                        httpRequests.push(request);
+                        // Extract response variable name for responseDataNode tracking
+                        const responseVarName = this.getResponseVariableName(path);
+                        fetchCalls.push({ request, responseVarName });
                         // Определяем внешний ли это API
                         if (this.isExternalAPI(url)) {
                             externalAPIs.add(this.extractDomain(url));
@@ -115,18 +148,21 @@ export class FetchAnalyzer extends Plugin {
                         const method = callee.property.name.toUpperCase();
                         const urlArg = node.arguments[0];
                         const url = this.extractURL(urlArg);
-                        const line = node.loc.start.line;
+                        const line = getLine(node);
                         const request = {
                             id: `http:request#${method}:${url}#${module.file}#${line}`,
                             type: 'http:request',
+                            name: `${method} ${url}`,
                             method: method,
                             url: url,
                             library: 'axios',
                             file: module.file,
                             line: line,
+                            column: getColumn(node),
                             staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
                         };
-                        httpRequests.push(request);
+                        // Axios uses response.data, not response.json() - out of scope for v1.0
+                        fetchCalls.push({ request, responseVarName: null });
                         if (this.isExternalAPI(url)) {
                             externalAPIs.add(this.extractDomain(url));
                         }
@@ -148,18 +184,21 @@ export class FetchAnalyzer extends Plugin {
                             const method = methodProp
                                 ? this.extractString(methodProp.value) || 'GET'
                                 : 'GET';
-                            const line = node.loc.start.line;
+                            const line = getLine(node);
                             const request = {
                                 id: `http:request#${method.toUpperCase()}:${url}#${module.file}#${line}`,
                                 type: 'http:request',
+                                name: `${method.toUpperCase()} ${url}`,
                                 method: method.toUpperCase(),
                                 url: url,
                                 library: 'axios',
                                 file: module.file,
                                 line: line,
+                                column: getColumn(node),
                                 staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
                             };
-                            httpRequests.push(request);
+                            // Axios uses response.data, not response.json() - out of scope for v1.0
+                            fetchCalls.push({ request, responseVarName: null });
                             if (this.isExternalAPI(url)) {
                                 externalAPIs.add(this.extractDomain(url));
                             }
@@ -174,18 +213,22 @@ export class FetchAnalyzer extends Plugin {
                             const urlArg = node.arguments[0];
                             const url = this.extractURL(urlArg);
                             const method = this.extractMethod(node.arguments[1]) || 'GET';
-                            const line = node.loc.start.line;
+                            const line = getLine(node);
                             const request = {
                                 id: `http:request#${method}:${url}#${module.file}#${line}`,
                                 type: 'http:request',
+                                name: `${method} ${url}`,
                                 method: method,
                                 url: url,
                                 library: calleeName,
                                 file: module.file,
                                 line: line,
+                                column: getColumn(node),
                                 staticUrl: url !== 'dynamic' && url !== 'unknown' ? 'yes' : 'no'
                             };
-                            httpRequests.push(request);
+                            // Custom wrappers may use fetch-like response.json() pattern
+                            const responseVarName = this.getResponseVariableName(path);
+                            fetchCalls.push({ request, responseVarName });
                             if (this.isExternalAPI(url)) {
                                 externalAPIs.add(this.extractDomain(url));
                             }
@@ -193,8 +236,18 @@ export class FetchAnalyzer extends Plugin {
                     }
                 }
             });
+            // Extract httpRequests for external API handling
+            const httpRequests = fetchCalls.map(fc => fc.request);
             // Создаём HTTP_REQUEST ноды
-            for (const request of httpRequests) {
+            for (const fetchCall of fetchCalls) {
+                const request = fetchCall.request;
+                // Find responseDataNode if we have a response variable name
+                if (fetchCall.responseVarName) {
+                    const responseDataNodeId = await this.findResponseJsonCall(graph, request.file, fetchCall.responseVarName, request.line);
+                    if (responseDataNodeId) {
+                        request.responseDataNode = responseDataNodeId;
+                    }
+                }
                 await graph.addNode(request);
                 // Создаём ребро от модуля к request
                 await graph.addEdge({
@@ -202,6 +255,13 @@ export class FetchAnalyzer extends Plugin {
                     src: module.id,
                     dst: request.id
                 });
+                // http:request --CALLS--> net:request singleton (created lazily)
+                const networkId = await this.ensureNetworkNode(graph);
+                await graph.addEdge({
+                    type: 'CALLS',
+                    src: request.id,
+                    dst: networkId
+                });
                 // Ищем FUNCTION node которая делает запрос
                 const functions = [];
                 for await (const fn of graph.queryNodes({ type: 'FUNCTION' })) {
@@ -224,6 +284,21 @@ export class FetchAnalyzer extends Plugin {
                         dst: request.id
                     });
                 }
+                // Find CALL node that makes this request (same file, same line)
+                // Determine expected call name based on library
+                const expectedCallNames = this.getExpectedCallNames(request.library, request.method);
+                for await (const callNode of graph.queryNodes({ type: 'CALL' })) {
+                    if (callNode.file === request.file &&
+                        callNode.line === request.line &&
+                        expectedCallNames.includes(callNode.name)) {
+                        await graph.addEdge({
+                            type: 'MAKES_REQUEST',
+                            src: callNode.id,
+                            dst: request.id
+                        });
+                        break; // Only link to first matching CALL node
+                    }
+                }
             }
             // Создаём EXTERNAL ноды для внешних API
             for (const apiDomain of externalAPIs) {
@@ -249,12 +324,12 @@ export class FetchAnalyzer extends Plugin {
                 }
             }
             return {
-                requests: httpRequests.length,
+                requests: fetchCalls.length,
                 apis: externalAPIs.size
             };
         }
         catch (error) {
-            console.error(`[FetchAnalyzer] Error analyzing ${module.file}:`, error.message);
+            // Silent - per-module errors shouldn't spam logs
             return { requests: 0, apis: 0 };
         }
     }
@@ -317,6 +392,25 @@ export class FetchAnalyzer extends Plugin {
         }
         return null;
     }
+    /**
+     * Returns expected CALL node names based on library and HTTP method.
+     * Used to match http:request with corresponding CALL node.
+     *
+     * @param library - Library name (fetch, axios, or custom wrapper name)
+     * @param method - HTTP method (GET, POST, etc.)
+     * @returns Array of possible call names
+     */
+    getExpectedCallNames(library, method) {
+        if (library === 'fetch') {
+            return ['fetch'];
+        }
+        if (library === 'axios') {
+            // axios.get(), axios.post(), etc. or axios() config call
+            return [`axios.${method.toLowerCase()}`, 'axios'];
+        }
+        // Custom wrapper (authFetch, apiFetch, etc.)
+        return [library];
+    }
     /**
      * Проверяет является ли URL внешним API
      */
@@ -341,4 +435,78 @@ export class FetchAnalyzer extends Plugin {
             return match ? match[1] : url;
         }
     }
+    /**
+     * Extracts the variable name that holds the fetch response.
+     * Handles patterns like:
+     * - const response = await fetch(url)
+     * - let res = await fetch(url)
+     * - response = await fetch(url)
+     *
+     * @param path - NodePath of the CallExpression
+     * @returns Variable name or null if not found
+     */
+    getResponseVariableName(path) {
+        // Walk up the AST to find the variable assignment
+        let current = path.parentPath;
+        // Pattern: await fetch()
+        if (current && current.node.type === 'AwaitExpression') {
+            current = current.parentPath;
+        }
+        if (!current)
+            return null;
+        // Pattern: const response = await fetch() / let response = await fetch()
+        if (current.node.type === 'VariableDeclarator') {
+            const declarator = current.node;
+            if (declarator.id.type === 'Identifier') {
+                return declarator.id.name;
+            }
+        }
+        // Pattern: response = await fetch() (reassignment)
+        if (current.node.type === 'AssignmentExpression') {
+            const assignment = current.node;
+            if (assignment.left.type === 'Identifier') {
+                return assignment.left.name;
+            }
+        }
+        return null;
+    }
+    /**
+     * Finds the response consumption CALL node (response.json(), response.text(), etc.)
+     * by querying the graph for CALL nodes in the same file with matching object name.
+     *
+     * Important: Filters to find the response.json() call AFTER the fetch line and
+     * closest to it, ensuring we match the correct call in the same function scope.
+     *
+     * @param graph - Graph backend
+     * @param file - File path where fetch call is located
+     * @param responseVarName - Variable name holding the response
+     * @param fetchLine - Line number of the fetch call (response.json must be after this)
+     * @returns CALL node ID or null if not found
+     */
+    async findResponseJsonCall(graph, file, responseVarName, fetchLine) {
+        // Collect all matching CALL nodes
+        const candidates = [];
+        for await (const node of graph.queryNodes({ type: 'CALL' })) {
+            // Check if it's in the same file
+            if (node.file !== file)
+                continue;
+            // Check if object matches response variable name
+            const callNode = node;
+            if (callNode.object !== responseVarName)
+                continue;
+            // Check if method is a response consumption method
+            if (callNode.method && RESPONSE_CONSUMPTION_METHODS.includes(callNode.method)) {
+                const nodeLine = node.line ?? 0;
+                // Only consider calls AFTER the fetch line (response.json comes after fetch)
+                if (nodeLine > fetchLine) {
+                    candidates.push({ id: node.id, line: nodeLine });
+                }
+            }
+        }
+        if (candidates.length === 0)
+            return null;
+        // Return the closest match (smallest line number after fetch)
+        candidates.sort((a, b) => a.line - b.line);
+        return candidates[0].id;
+    }
 }