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

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;
     }
     /**
      * Анализировать методы класса