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

package/src/plugins/enrichment/ImportExportLinker.ts

@@ -42,7 +42,7 @@ export class ImportExportLinker extends Plugin {
       priority: 90, // Run early in enrichment, after analysis
       creates: {
         nodes: [],
-        edges: ['IMPORTS_FROM']
+        edges: ['IMPORTS', 'IMPORTS_FROM']
       },
       dependencies: ['JSASTAnalyzer'] // Requires IMPORT and EXPORT nodes
     };
@@ -50,26 +50,27 @@ export class ImportExportLinker extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph, onProgress } = context;
+    const logger = this.log(context);
 
-    console.log('[ImportExportLinker] Starting import-export linking...');
+    logger.info('Starting import-export linking');
 
     const startTime = Date.now();
 
     // Step 1: Build EXPORT index - Map<file, Map<exportKey, exportNode>>
     const exportIndex = await this.buildExportIndex(graph);
     const indexTime = Date.now() - startTime;
-    console.log(`[ImportExportLinker] Indexed exports from ${exportIndex.size} files in ${indexTime}ms`);
+    logger.debug('Indexed exports', { files: exportIndex.size, time: `${indexTime}ms` });
 
     // Step 2: Build MODULE lookup - Map<file, moduleNode>
     const modulesByFile = await this.buildModuleLookup(graph);
-    console.log(`[ImportExportLinker] Indexed ${modulesByFile.size} modules`);
+    logger.debug('Indexed modules', { count: modulesByFile.size });
 
     // Step 3: Process all IMPORT nodes
     const imports: ImportNode[] = [];
     for await (const node of graph.queryNodes({ nodeType: 'IMPORT' })) {
       imports.push(node as ImportNode);
     }
-    console.log(`[ImportExportLinker] Found ${imports.length} imports to link`);
+    logger.info('Found imports to link', { count: imports.length });
 
     let edgesCreated = 0;
     let skipped = 0;
@@ -125,6 +126,18 @@ export class ImportExportLinker extends Plugin {
         continue;
       }
 
+      // Create MODULE -> IMPORTS -> MODULE edge for relative imports
+      const sourceModule = modulesByFile.get(imp.file!);
+      const targetModule = modulesByFile.get(targetFile);
+      if (sourceModule && targetModule) {
+        await graph.addEdge({
+          type: 'IMPORTS',
+          src: sourceModule.id,
+          dst: targetModule.id
+        });
+        edgesCreated++;
+      }
+
       // Find matching export based on import type
       const importType = imp.importType; // 'default', 'named', or 'namespace'
       let targetExport: ExportNode | undefined;
@@ -155,7 +168,12 @@ export class ImportExportLinker extends Plugin {
     }
 
     const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
-    console.log(`[ImportExportLinker] Complete: ${edgesCreated} edges created, ${skipped} skipped, ${notFound} not found (${totalTime}s)`);
+    logger.info('Complete', {
+      edgesCreated,
+      skipped,
+      notFound,
+      time: `${totalTime}s`
+    });
 
     return createSuccessResult(
       { nodes: 0, edges: edgesCreated },

package/src/plugins/enrichment/MethodCallResolver.ts

@@ -14,6 +14,7 @@
 import { Plugin, createSuccessResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { BaseNodeRecord } from '@grafema/types';
+import { StrictModeError } from '../../errors/GrafemaError.js';
 
 /**
  * Extended call node with method properties
@@ -48,12 +49,14 @@ export class MethodCallResolver extends Plugin {
 
   async execute(context: PluginContext): Promise<PluginResult> {
     const { graph, onProgress } = context;
+    const logger = this.log(context);
 
-    console.log('[MethodCallResolver] Starting method call resolution...');
+    logger.info('Starting method call resolution');
 
     let methodCallsProcessed = 0;
     let edgesCreated = 0;
     let unresolved = 0;
+    const errors: Error[] = [];
 
     // Собираем все METHOD_CALL ноды (CALL с object атрибутом)
     const methodCalls: MethodCallNode[] = [];
@@ -64,14 +67,14 @@ export class MethodCallResolver extends Plugin {
       }
     }
 
-    console.log(`[MethodCallResolver] Found ${methodCalls.length} method calls to resolve`);
+    logger.info('Found method calls to resolve', { count: methodCalls.length });
 
     // Собираем все классы и их методы для быстрого поиска
-    const classMethodIndex = await this.buildClassMethodIndex(graph);
-    console.log(`[MethodCallResolver] Indexed ${classMethodIndex.size} classes`);
+    const classMethodIndex = await this.buildClassMethodIndex(graph, logger);
+    logger.info('Indexed classes', { count: classMethodIndex.size });
 
     // Собираем переменные и их типы (если известны)
-    const variableTypes = await this.buildVariableTypeIndex(graph);
+    const variableTypes = await this.buildVariableTypeIndex(graph, logger);
 
     const startTime = Date.now();
 
@@ -94,7 +97,12 @@ export class MethodCallResolver extends Plugin {
       if (methodCallsProcessed % 10 === 0) {
         const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
         const avgTime = ((Date.now() - startTime) / methodCallsProcessed).toFixed(0);
-        console.log(`[MethodCallResolver] Progress: ${methodCallsProcessed}/${methodCalls.length} (${elapsed}s, avg ${avgTime}ms/call)`);
+        logger.debug('Progress', {
+          processed: methodCallsProcessed,
+          total: methodCalls.length,
+          elapsed: `${elapsed}s`,
+          avgTime: `${avgTime}ms/call`
+        });
       }
 
       // Пропускаем внешние методы (console, Array.prototype, etc.)
@@ -125,6 +133,24 @@ export class MethodCallResolver extends Plugin {
         edgesCreated++;
       } 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 as number | undefined,
+              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);
+        }
       }
     }
 
@@ -135,15 +161,15 @@ export class MethodCallResolver extends Plugin {
       classesIndexed: classMethodIndex.size
     };
 
-    console.log('[MethodCallResolver] Summary:', summary);
+    logger.info('Summary', summary);
 
-    return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary);
+    return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary, errors);
   }
 
   /**
    * Строит индекс классов и их методов
    */
-  private async buildClassMethodIndex(graph: PluginContext['graph']): Promise<Map<string, ClassEntry>> {
+  private async buildClassMethodIndex(graph: PluginContext['graph'], logger: ReturnType<typeof this.log>): Promise<Map<string, ClassEntry>> {
     const index = new Map<string, ClassEntry>();
     const startTime = Date.now();
     let classCount = 0;
@@ -151,7 +177,7 @@ export class MethodCallResolver extends Plugin {
     for await (const classNode of graph.queryNodes({ nodeType: 'CLASS' })) {
       classCount++;
       if (classCount % 50 === 0) {
-        console.log(`[MethodCallResolver] Indexing classes: ${classCount}...`);
+        logger.debug('Indexing classes', { count: classCount });
       }
 
       const className = classNode.name as string;
@@ -180,7 +206,7 @@ export class MethodCallResolver extends Plugin {
     }
 
     const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
-    console.log(`[MethodCallResolver] Indexed ${index.size} class entries in ${totalTime}s`);
+    logger.debug('Indexed class entries', { count: index.size, time: `${totalTime}s` });
 
     return index;
   }
@@ -188,7 +214,7 @@ export class MethodCallResolver extends Plugin {
   /**
    * Строит индекс переменных и их типов (из INSTANCE_OF рёбер)
    */
-  private async buildVariableTypeIndex(graph: PluginContext['graph']): Promise<Map<string, string>> {
+  private async buildVariableTypeIndex(graph: PluginContext['graph'], logger: ReturnType<typeof this.log>): Promise<Map<string, string>> {
     const startTime = Date.now();
     const index = new Map<string, string>();
 
@@ -202,7 +228,7 @@ export class MethodCallResolver extends Plugin {
     }
 
     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
-    console.log(`[MethodCallResolver] Built variable type index: ${index.size} entries in ${elapsed}s`);
+    logger.debug('Built variable type index', { entries: index.size, time: `${elapsed}s` });
     return index;
   }