@grafema/core 0.1.0-alpha.5 → 0.1.1-alpha

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 } 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);
         }
     }
@@ -136,18 +143,18 @@ export class ExpressRouteAnalyzer extends Plugin {
                                     // Все предыдущие - 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),
                                         routerName: objectName,
                                         handlerLine: mainHandler.loc
-                                            ? mainHandler.loc.start.line
-                                            : node.loc.start.line
+                                            ? getLine(mainHandler)
+                                            : getLine(node)
                                     });
                                     // Обрабатываем middleware
                                     middlewareHandlers.forEach((mw, index) => {
@@ -164,16 +171,16 @@ 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),
                                                 endpointId: endpointId,
                                                 order: index // Порядок в цепочке
                                             });
@@ -204,13 +211,13 @@ 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),
                                             mountPath: mountPath,
                                             isGlobal: mountPath === '/' // Global middleware если нет path
                                         });
@@ -297,7 +304,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,6 +11,7 @@
 import { Plugin } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 export declare class FetchAnalyzer extends Plugin {
+    private networkNodeCreated;
     get metadata(): PluginMetadata;
     execute(context: PluginContext): Promise<PluginResult>;
     private analyzeModule;

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;AA8BhF,qBAAa,aAAc,SAAQ,MAAM;IACvC,OAAO,CAAC,kBAAkB,CAAS;IAEnC,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;YAyD9C,aAAa;IAyP3B;;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"}

package/dist/plugins/analysis/FetchAnalyzer.js

@@ -12,9 +12,12 @@ 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 } from './ast/utils/location.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = traverseModule.default || traverseModule;
 export class FetchAnalyzer extends Plugin {
+    networkNodeCreated = false;
     get metadata() {
         return {
             name: 'FetchAnalyzer',
@@ -28,41 +31,52 @@ export class FetchAnalyzer extends Plugin {
         };
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { graph } = context;
+            // Create net:request singleton (GraphBackend handles deduplication)
+            const networkNode = NetworkRequestNode.create();
+            await graph.addNode(networkNode);
+            this.networkNodeCreated = true;
             // Получаем все модули
             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();
             for (let i = 0; i < modules.length; i++) {
                 const module = modules[i];
-                const result = await this.analyzeModule(module, graph);
+                const result = await this.analyzeModule(module, graph, networkNode.id);
                 requestsCount += result.requests;
                 apisCount += result.apis;
                 // Progress every 20 modules
                 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);
         }
     }
-    async analyzeModule(module, graph) {
+    async analyzeModule(module, graph, networkId) {
         try {
             const code = readFileSync(module.file, 'utf-8');
             const ast = parse(code, {
@@ -90,7 +104,7 @@ 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',
@@ -115,7 +129,7 @@ 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',
@@ -148,7 +162,7 @@ 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',
@@ -174,7 +188,7 @@ 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',
@@ -202,6 +216,12 @@ export class FetchAnalyzer extends Plugin {
                     src: module.id,
                     dst: request.id
                 });
+                // http:request --CALLS--> net:request singleton
+                await graph.addEdge({
+                    type: 'CALLS',
+                    src: request.id,
+                    dst: networkId
+                });
                 // Ищем FUNCTION node которая делает запрос
                 const functions = [];
                 for await (const fn of graph.queryNodes({ type: 'FUNCTION' })) {
@@ -254,7 +274,7 @@ export class FetchAnalyzer extends Plugin {
             };
         }
         catch (error) {
-            console.error(`[FetchAnalyzer] Error analyzing ${module.file}:`, error.message);
+            // Silent - per-module errors shouldn't spam logs
             return { requests: 0, apis: 0 };
         }
     }

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

@@ -26,11 +26,11 @@ export declare class IncrementalAnalysisPlugin extends Plugin {
     initialize(context: PluginContext): Promise<void>;
     execute(context: PluginContext): Promise<PluginResult>;
     /**
-     * Обработать один изменённый файл
+     * Process a single changed file
      */
     private processChangedFile;
     /**
-     * Fine-grained merge - ключевая функция инкрементального анализа
+     * Fine-grained merge - key function for incremental analysis
      */
     private finegrainedMerge;
     /**
@@ -42,7 +42,7 @@ export declare class IncrementalAnalysisPlugin extends Plugin {
      */
     private isExported;
     /**
-     * Переанализировать ноды для создания CALLS/USES edges
+     * Reanalyze nodes to create CALLS/USES edges
      */
     private reanalyzeNodes;
     /**
@@ -55,6 +55,9 @@ export declare class IncrementalAnalysisPlugin extends Plugin {
     private traverseFunctionBody;
     /**
      * Найти callee и создать CALLS edge
+     * TODO: Implement using existing graph.queryNodes() method
+     * This method was disabled as part of stableId removal (REG-140).
+     * The getNodesByStableId method never existed on GraphBackend.
      */
     private findCalleeAndCreateEdge;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"IncrementalAnalysisPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/IncrementalAnalysisPlugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAmDhF,qBAAa,yBAA0B,SAAQ,MAAM;IACnD,OAAO,CAAC,SAAS,CAA0B;IAE3C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAcjD,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAyF5D;;OAEG;YACW,kBAAkB;IA8BhC;;OAEG;YACW,gBAAgB;IAmF9B;;OAEG;YACW,oBAAoB;IAiIlC;;OAEG;IACH,OAAO,CAAC,UAAU;IAmClB;;OAEG;YACW,cAAc;IAsC5B;;OAEG;YACW,oBAAoB;IA0ClC;;OAEG;YACW,oBAAoB;IA6DlC;;OAEG;YACW,uBAAuB;IAsCrC;;OAEG;YAEW,mBAAmB;CASlC"}
+{"version":3,"file":"IncrementalAnalysisPlugin.d.ts","sourceRoot":"","sources":["../../../src/plugins/analysis/IncrementalAnalysisPlugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAkDhF,qBAAa,yBAA0B,SAAQ,MAAM;IACnD,OAAO,CAAC,SAAS,CAA0B;IAE3C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,UAAU,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAejD,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAuF5D;;OAEG;YACW,kBAAkB;IAkChC;;OAEG;YACW,gBAAgB;IAuF9B;;OAEG;YACW,oBAAoB;IAiIlC;;OAEG;IACH,OAAO,CAAC,UAAU;IAmClB;;OAEG;YACW,cAAc;IAuC5B;;OAEG;YACW,oBAAoB;IA0ClC;;OAEG;YACW,oBAAoB;IA6DlC;;;;;OAKG;YAEW,uBAAuB;IAUrC;;OAEG;YAEW,mBAAmB;CASlC"}

package/dist/plugins/analysis/IncrementalAnalysisPlugin.js

@@ -41,125 +41,140 @@ export class IncrementalAnalysisPlugin extends Plugin {
         };
     }
     async initialize(context) {
-        // Инициализируем VCS плагин
+        const logger = this.log(context);
+        // Initialize VCS plugin
         const manifest = context.manifest;
         this.vcsPlugin = await VCSPluginFactory.detect({
             rootPath: manifest?.projectPath
-        });
+        }, logger);
         if (!this.vcsPlugin) {
-            console.log('[IncrementalAnalysis] No VCS detected, skipping incremental analysis');
+            logger.warn('No VCS detected, skipping incremental analysis');
         }
         else {
-            console.log(`[IncrementalAnalysis] Using VCS: ${this.vcsPlugin.metadata.name}`);
+            logger.info('VCS detected', { vcs: this.vcsPlugin.metadata.name });
         }
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { graph } = context;
             const manifest = context.manifest;
             const projectPath = manifest?.projectPath ?? '';
-            // Если нет VCS - пропускаем инкрементальный анализ
+            // Skip if no VCS detected
             if (!this.vcsPlugin) {
                 return createSuccessResult({ nodes: 0, edges: 0 }, {
                     skipped: true,
                     reason: 'No VCS detected'
                 });
             }
-            // Проверяем наличие uncommitted изменений
+            // Check for uncommitted changes
             const hasChanges = await this.vcsPlugin.hasUncommittedChanges();
             if (!hasChanges) {
-                console.log('[IncrementalAnalysis] No uncommitted changes detected');
+                logger.info('No uncommitted changes detected');
                 return createSuccessResult({ nodes: 0, edges: 0 }, {
                     skipped: true,
                     reason: 'No uncommitted changes'
                 });
             }
-            // Получаем список изменённых файлов
+            // Get list of changed files
             const changedFiles = (await this.vcsPlugin.getChangedFiles());
-            console.log(`[IncrementalAnalysis] All changed files:`, changedFiles.map(f => f.path));
+            logger.debug('Changed files detected', { count: changedFiles.length, files: changedFiles.map(f => f.path) });
             const jsFiles = changedFiles.filter(file => file.path.endsWith('.js') || file.path.endsWith('.mjs') || file.path.endsWith('.cjs'));
             if (jsFiles.length === 0) {
-                console.log('[IncrementalAnalysis] No JavaScript files changed');
+                logger.info('No JavaScript files changed');
                 return createSuccessResult({ nodes: 0, edges: 0 }, {
                     skipped: true,
                     reason: 'No JS files changed'
                 });
             }
-            console.log(`[IncrementalAnalysis] Found ${jsFiles.length} changed JS files:`, jsFiles.map(f => f.path));
+            logger.info('Processing changed JS files', { count: jsFiles.length });
+            for (const f of jsFiles) {
+                logger.debug('Changed file', { path: f.path, status: f.status });
+            }
             let totalNodesCreated = 0;
             let totalEdgesCreated = 0;
-            // Обрабатываем каждый изменённый файл
+            // Process each changed file
             for (const fileInfo of jsFiles) {
-                const result = await this.processChangedFile(fileInfo, projectPath, graph);
+                const result = await this.processChangedFile(fileInfo, projectPath, graph, logger);
                 totalNodesCreated += result.nodesCreated;
                 totalEdgesCreated += result.edgesCreated;
             }
-            console.log(`[IncrementalAnalysis] Created ${totalNodesCreated} __local nodes, ${totalEdgesCreated} edges`);
+            logger.info('Incremental analysis complete', { nodesCreated: totalNodesCreated, edgesCreated: totalEdgesCreated });
             return createSuccessResult({ nodes: totalNodesCreated, edges: totalEdgesCreated }, {
                 filesProcessed: jsFiles.length,
                 changedFiles: jsFiles.map(f => ({ path: f.path, status: f.status }))
             });
         }
         catch (error) {
-            console.error('[IncrementalAnalysis] Error:', error);
+            logger.error('Incremental analysis failed', { error: error instanceof Error ? error.message : String(error) });
             return createErrorResult(error);
         }
     }
     /**
-     * Обработать один изменённый файл
+     * Process a single changed file
      */
-    async processChangedFile(fileInfo, projectPath, graph) {
+    async processChangedFile(fileInfo, projectPath, graph, logger) {
         const { path: relativePath, status } = fileInfo;
-        // relativePath может начинаться с / или быть относительным
+        // relativePath can start with / or be relative
         const fullPath = relativePath.startsWith('/') ? relativePath : `${projectPath}/${relativePath}`;
-        console.log(`[IncrementalAnalysis] Processing ${relativePath} (${status})`);
-        // Если файл удалён - ничего не делаем (main версия остаётся, __local не создаём)
+        logger.debug('Processing file', { path: relativePath, status });
+        // If file is deleted - do nothing (main version remains, no __local)
         if (status === 'deleted') {
-            console.log(`  → File deleted, keeping main version only`);
+            logger.debug('File deleted, keeping main version only');
             return { nodesCreated: 0, edgesCreated: 0 };
         }
-        // Выполняем fine-grained merge
-        const result = await this.finegrainedMerge(fullPath, graph);
-        console.log(`  → Added: ${result.added}, Modified: ${result.modified}, Unchanged: ${result.unchanged}, Deleted: ${result.deleted}`);
+        // Execute fine-grained merge
+        const result = await this.finegrainedMerge(fullPath, graph, logger);
+        logger.debug('Merge result', {
+            added: result.added,
+            modified: result.modified,
+            unchanged: result.unchanged,
+            deleted: result.deleted
+        });
         return {
             nodesCreated: result.added + result.modified,
             edgesCreated: result.edgesCreated || 0
         };
     }
     /**
-     * Fine-grained merge - ключевая функция инкрементального анализа
+     * Fine-grained merge - key function for incremental analysis
      */
-    async finegrainedMerge(filePath, graph) {
-        // 1. Парсим новое содержимое файла
+    async finegrainedMerge(filePath, graph, logger) {
+        // 1. Parse new file content
         const newContent = await readFile(filePath, 'utf-8');
         const newNodes = await this.extractTopLevelNodes(newContent, filePath);
-        console.log(`  → Parsed ${newNodes.length} nodes from new content`);
-        // 2. Получаем существующие main ноды для этого файла
+        logger.debug('Parsed new content', { nodesCount: newNodes.length });
+        // 2. Get existing main nodes for this file
         const mainNodes = await graph.getNodesByVersion('main', {
             file: filePath
         });
         const mainTopLevel = mainNodes.filter(node => ['FUNCTION', 'CLASS', 'VARIABLE_DECLARATION', 'MODULE'].includes(node.type));
-        console.log(`  → Found ${mainTopLevel.length} existing main nodes`);
-        // 3. Классифицируем изменения
+        logger.debug('Existing main nodes', { count: mainTopLevel.length });
+        // 3. Classify changes
         const changes = versionManager.classifyChanges(mainTopLevel, newNodes);
-        console.log(`  → Classification: +${changes.added.length} ~${changes.modified.length} =${changes.unchanged.length} -${changes.deleted.length}`);
-        // 4. Создаём __local версии для added/modified нод
+        logger.debug('Change classification', {
+            added: changes.added.length,
+            modified: changes.modified.length,
+            unchanged: changes.unchanged.length,
+            deleted: changes.deleted.length
+        });
+        // 4. Create __local versions for added/modified nodes
         let edgesCreated = 0;
-        // 4a. ADDED nodes - просто создаём с версией __local
+        // 4a. ADDED nodes - create with __local version
         for (const node of changes.added) {
             const enrichedNode = versionManager.enrichNodeWithVersion(node, '__local');
             await graph.addNode(enrichedNode);
         }
-        // 4b. MODIFIED nodes - создаём __local версию + REPLACES ребро
+        // 4b. MODIFIED nodes - create __local version + REPLACES edge
         for (const { old: oldNode, new: newNode } of changes.modified) {
             const mainNodeId = versionManager.generateVersionedId(oldNode, 'main');
             const enrichedNode = versionManager.enrichNodeWithVersion(newNode, '__local', {
                 replacesId: mainNodeId
             });
             await graph.addNode(enrichedNode);
-            // Создаём REPLACES ребро
+            // Create REPLACES edge
             const replacesEdge = versionManager.createReplacesEdge(enrichedNode.id, mainNodeId);
-            console.log(`    [REPLACES] ${newNode.name}: ${enrichedNode.id} → ${mainNodeId}`);
+            logger.debug('Node replacement', { name: newNode.name, from: enrichedNode.id, to: mainNodeId });
             await graph.addEdge({
                 type: replacesEdge.type,
                 src: replacesEdge.fromId,
@@ -167,12 +182,12 @@ export class IncrementalAnalysisPlugin extends Plugin {
             });
             edgesCreated++;
         }
-        // 4c. UNCHANGED nodes - не создаём __local версию (используется main)
-        // 4d. DELETED nodes - не создаём __local версию (main остаётся, показывая что было удалено)
-        // 5. Переанализируем изменённые ноды для создания связей (CALLS, USES)
+        // 4c. UNCHANGED nodes - no __local version (main is used)
+        // 4d. DELETED nodes - no __local version (main remains, showing what was deleted)
+        // 5. Reanalyze changed nodes to create relationships (CALLS, USES)
         const nodesToReanalyze = [...changes.added, ...changes.modified.map(m => m.new)];
         if (nodesToReanalyze.length > 0) {
-            const reanalyzeResult = await this.reanalyzeNodes(nodesToReanalyze, filePath, '__local', graph);
+            const reanalyzeResult = await this.reanalyzeNodes(nodesToReanalyze, filePath, '__local', graph, logger);
             edgesCreated += reanalyzeResult.edgesCreated;
         }
         return {
@@ -276,8 +291,8 @@ export class IncrementalAnalysisPlugin extends Plugin {
                 }
             });
         }
-        catch (error) {
-            console.error(`  ✗ Failed to parse ${filePath}:`, error.message);
+        catch {
+            // Parse error - return empty nodes array
         }
         return nodes;
     }
@@ -315,19 +330,19 @@ export class IncrementalAnalysisPlugin extends Plugin {
         return false;
     }
     /**
-     * Переанализировать ноды для создания CALLS/USES edges
+     * Reanalyze nodes to create CALLS/USES edges
      */
-    async reanalyzeNodes(nodes, filePath, version, graph) {
+    async reanalyzeNodes(nodes, filePath, version, graph, logger) {
         let edgesCreated = 0;
         try {
-            // Читаем файл заново
+            // Read file again
             const content = await readFile(filePath, 'utf-8');
-            // Парсим AST
+            // Parse AST
             const ast = parse(content, {
                 sourceType: 'module',
                 plugins: ['jsx', 'typescript', 'decorators-legacy']
             });
-            // Для каждой ноды ищем её в AST и анализируем
+            // For each node, find it in AST and analyze
             for (const node of nodes) {
                 if (node.type === 'FUNCTION') {
                     const functionEdges = await this.analyzeFunctionCalls(node, ast, version, graph);
@@ -338,11 +353,11 @@ export class IncrementalAnalysisPlugin extends Plugin {
                     edgesCreated += classEdges;
                 }
             }
-            console.log(`  → Reanalyzed ${nodes.length} nodes, created ${edgesCreated} edges`);
+            logger.debug('Reanalyzed nodes', { nodesCount: nodes.length, edgesCreated });
             return { edgesCreated };
         }
-        catch (error) {
-            console.error(`[IncrementalAnalysis] Error reanalyzing nodes:`, error);
+        catch {
+            // Error reanalyzing nodes - silently return empty result
             return { edgesCreated: 0 };
         }
     }
@@ -419,47 +434,28 @@ export class IncrementalAnalysisPlugin extends Plugin {
             // Пытаемся найти callee в графе (сначала __local, потом main)
             const calleeName = callSite.callee.split('.')[0]; // Для method calls берём объект
             const calleeStableId = `FUNCTION:${calleeName}:${functionNode.file}`;
-            // Ищем callee в базе
+            // Find callee and create edge
             try {
                 const created = await this.findCalleeAndCreateEdge(callerId, calleeStableId, version, graph);
                 if (created)
                     edgesCreated++;
             }
-            catch (err) {
-                console.error(`[IncrementalAnalysis] Error creating CALLS edge:`, err);
+            catch {
+                // Error creating CALLS edge - skip silently
             }
         }
         return edgesCreated;
     }
     /**
      * Найти callee и создать CALLS edge
+     * TODO: Implement using existing graph.queryNodes() method
+     * This method was disabled as part of stableId removal (REG-140).
+     * The getNodesByStableId method never existed on GraphBackend.
      */
-    async findCalleeAndCreateEdge(callerId, calleeStableId, version, graph) {
-        try {
-            // Ищем callee сначала в __local, потом в main
-            const calleeVersions = await graph.getNodesByStableId(calleeStableId);
-            if (calleeVersions.length === 0) {
-                // Callee не найден - возможно это external функция
-                return false;
-            }
-            // Предпочитаем __local версию, если есть
-            const calleeNode = calleeVersions.find(n => n.version === '__local') ||
-                calleeVersions.find(n => n.version === 'main');
-            if (!calleeNode) {
-                return false;
-            }
-            // Создаём CALLS edge
-            await graph.addEdge({
-                type: 'CALLS',
-                src: callerId,
-                dst: calleeNode.id
-            });
-            return true;
-        }
-        catch (error) {
-            console.error(`[IncrementalAnalysis] Error finding callee:`, error);
-            return false;
-        }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async findCalleeAndCreateEdge(_callerId, _calleeStableId, _version, _graph) {
+        // Disabled - needs implementation using graph.queryNodes()
+        return false;
     }
     /**
      * Анализировать методы класса