@grafema/core 0.2.3-beta → 0.2.5-beta

package/src/plugins/analysis/ast/visitors/TypeScriptVisitor.ts

@@ -14,8 +14,7 @@ import type {
   TSPropertySignature,
   TSMethodSignature,
   Identifier,
-  Expression,
-  TSExpressionWithTypeArguments
+  Expression
 } from '@babel/types';
 import type { NodePath } from '@babel/traverse';
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
@@ -26,7 +25,7 @@ import type {
   EnumDeclarationInfo,
   EnumMemberInfo
 } from '../types.js';
-import { ScopeTracker } from '../../../../core/ScopeTracker.js';
+import type { ScopeTracker } from '../../../../core/ScopeTracker.js';
 import { computeSemanticId } from '../../../../core/SemanticId.js';
 import { getLine, getColumn } from '../utils/location.js';
 

package/src/plugins/analysis/ast/visitors/VariableVisitor.ts

@@ -17,9 +17,8 @@ import type {
 import type { NodePath } from '@babel/traverse';
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers, type CounterRef } from './ASTVisitor.js';
 import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
-import { ScopeTracker } from '../../../../core/ScopeTracker.js';
+import type { ScopeTracker } from '../../../../core/ScopeTracker.js';
 import { IdGenerator } from '../IdGenerator.js';
-import { NodeFactory } from '../../../../core/NodeFactory.js';
 
 /**
  * Variable info extracted from pattern
@@ -78,31 +77,6 @@ interface ClassInstantiationInfo {
   parentScopeId: string;
 }
 
-/**
- * Literal/expression info for data flow
- */
-interface LiteralExpressionInfo {
-  id: string;
-  type: 'EXPRESSION';
-  expressionType: string;
-  path: string;
-  baseName: string;
-  propertyPath: string[] | null;
-  arrayIndex?: number;
-  file: string;
-  line: number;
-}
-
-/**
- * Variable assignment info for data flow
- */
-interface VariableAssignmentInfo {
-  variableId: string;
-  sourceId: string | null;
-  sourceName?: string;
-  sourceType: string;
-  file?: string;
-}
 
 /**
  * Call info extracted from CallExpression (REG-223)

package/src/plugins/analysis/ast/visitors/index.ts

@@ -34,3 +34,5 @@ export { ClassVisitor } from './ClassVisitor.js';
 export { CallExpressionVisitor } from './CallExpressionVisitor.js';
 
 export { TypeScriptVisitor } from './TypeScriptVisitor.js';
+
+export { PropertyAccessVisitor } from './PropertyAccessVisitor.js';

package/src/plugins/discovery/DiscoveryPlugin.ts

@@ -5,6 +5,22 @@
  * 1. Поиск сервисов/компонентов в проекте
  * 2. Создание SERVICE нод
  * 3. Возврат манифеста для последующих фаз
+ *
+ * IMPORTANT CONTRACT:
+ * Discovery plugins MUST return found services via `result.metadata.services`
+ * (not `result.data.services` which doesn't exist in PluginResult interface).
+ *
+ * Example:
+ * ```typescript
+ * return createSuccessResult(
+ *   { nodes: services.length, edges: 0 },
+ *   { services: foundServices }  // <-- This becomes result.metadata.services
+ * );
+ * ```
+ *
+ * The Orchestrator reads services from result.metadata.services to build
+ * the indexing queue. If services are not returned here, they won't be indexed
+ * even if SERVICE nodes were created in the graph.
  */
 
 import { Plugin } from '../Plugin.js';
@@ -19,7 +35,6 @@ export abstract class DiscoveryPlugin extends Plugin {
     return {
       name: this.constructor.name,
       phase: 'DISCOVERY',
-      priority: 100,
       creates: {
         nodes: ['SERVICE'],
         edges: []
@@ -35,16 +50,32 @@ export abstract class DiscoveryPlugin extends Plugin {
    * context.projectPath - корневая директория проекта
    *
    * @returns Promise<PluginResult>
-   * result.metadata.services - массив найденных сервисов
-   * [
-   *   {
-   *     id: string,
-   *     name: string,
-   *     path: string,
-   *     type: string,
-   *     metadata: Object
-   *   }
-   * ]
+   *
+   * CRITICAL: Services MUST be returned via result.metadata.services:
+   *
+   * ```typescript
+   * return createSuccessResult(
+   *   { nodes: services.length, edges: 0 },
+   *   { services: foundServices }  // <-- metadata.services
+   * );
+   * ```
+   *
+   * ServiceInfo interface:
+   * ```typescript
+   * interface ServiceInfo {
+   *   id: string;        // Unique service identifier
+   *   name: string;      // Human-readable name
+   *   path: string;      // Directory path
+   *   type: string;      // Service type (e.g., 'express', 'fastify')
+   *   metadata: {
+   *     entrypoint?: string;  // Main file path (e.g., 'src/index.ts')
+   *     // ... other service-specific metadata
+   *   };
+   * }
+   * ```
+   *
+   * If services are created in graph but NOT returned via metadata.services,
+   * Orchestrator will show "0 services" and won't index anything.
    */
   abstract execute(context: PluginContext): Promise<PluginResult>;
 }

package/src/plugins/discovery/MonorepoServiceDiscovery.ts

@@ -47,7 +47,6 @@ export class MonorepoServiceDiscovery extends DiscoveryPlugin {
     return {
       name: 'MonorepoServiceDiscovery',
       phase: 'DISCOVERY',
-      priority: 100,
       creates: {
         nodes: ['SERVICE'],
         edges: []
@@ -112,7 +111,8 @@ export class MonorepoServiceDiscovery extends DiscoveryPlugin {
         { services }
       );
     } catch (error) {
-      return createErrorResult(error as Error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      return createErrorResult(err);
     }
   }
 }

package/src/plugins/discovery/SimpleProjectDiscovery.ts

@@ -45,7 +45,6 @@ export class SimpleProjectDiscovery extends Plugin {
     return {
       name: 'SimpleProjectDiscovery',
       phase: 'DISCOVERY',
-      priority: 50, // Lower priority than specialized discovery plugins
       creates: {
         nodes: ['SERVICE'],
         edges: []
@@ -101,7 +100,8 @@ export class SimpleProjectDiscovery extends Plugin {
 
       return createSuccessResult({ nodes: 1, edges: 0 }, { services: [service] });
     } catch (error) {
-      return createErrorResult(error as Error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      return createErrorResult(err);
     }
   }
 }

package/src/plugins/discovery/WorkspaceDiscovery.ts

@@ -42,7 +42,6 @@ export class WorkspaceDiscovery extends DiscoveryPlugin {
     return {
       name: 'WorkspaceDiscovery',
       phase: 'DISCOVERY',
-      priority: 110, // Higher than MonorepoServiceDiscovery (100)
       creates: {
         nodes: ['SERVICE'],
         edges: []
@@ -97,7 +96,8 @@ export class WorkspaceDiscovery extends DiscoveryPlugin {
           throw new Error(`Unknown workspace type: ${detection.type}`);
       }
     } catch (error) {
-      return createErrorResult(error as Error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      return createErrorResult(err);
     }
 
     logger.debug('Workspace config parsed', {

package/src/plugins/discovery/workspaces/globResolver.ts

@@ -5,7 +5,7 @@
  * Uses minimatch for pattern matching.
  */
 
-import { readdirSync, statSync, existsSync, readFileSync, lstatSync } from 'fs';
+import { readdirSync, existsSync, readFileSync, lstatSync } from 'fs';
 import { join, relative } from 'path';
 import { minimatch } from 'minimatch';
 import type { WorkspaceConfig } from './parsers.js';

package/src/plugins/enrichment/AliasTracker.ts

@@ -71,11 +71,11 @@ export class AliasTracker extends Plugin {
     return {
       name: 'AliasTracker',
       phase: 'ENRICHMENT',
-      priority: 60, // После MethodCallResolver (50)
       creates: {
         nodes: [],
         edges: ['CALLS', 'ALIAS_OF']
-      }
+      },
+      dependencies: ['MethodCallResolver']
     };
   }
 

package/src/plugins/enrichment/ArgumentParameterLinker.ts

@@ -63,7 +63,6 @@ export class ArgumentParameterLinker extends Plugin {
     return {
       name: 'ArgumentParameterLinker',
       phase: 'ENRICHMENT',
-      priority: 45, // Runs AFTER MethodCallResolver (50) which creates required CALLS edges
       creates: {
         nodes: [],
         edges: ['RECEIVES_ARGUMENT']

package/src/plugins/enrichment/ClosureCaptureEnricher.ts

@@ -51,7 +51,6 @@ export class ClosureCaptureEnricher extends Plugin {
     return {
       name: 'ClosureCaptureEnricher',
       phase: 'ENRICHMENT',
-      priority: 40, // Lower number = runs later. Runs after ImportExportLinker (90)
       creates: {
         nodes: [],
         edges: ['CAPTURES']

package/src/plugins/enrichment/ExpressHandlerLinker.ts

@@ -0,0 +1,178 @@
+/**
+ * ExpressHandlerLinker - creates HANDLED_BY edges connecting
+ * http:route nodes to their handler FUNCTION nodes.
+ *
+ * This enricher runs AFTER ExpressRouteAnalyzer (analysis phase) and
+ * creates cross-references between routes and functions.
+ *
+ * Strategy:
+ * 1. For inline handlers (arrow/function expressions): match by byte offset (start)
+ * 2. For named handlers (Identifier references): match by function name
+ *
+ * This approach avoids duplicating semantic ID computation logic
+ * (which is solely owned by JSASTAnalyzer/ScopeTracker).
+ */
+
+import { Plugin, createSuccessResult } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+import type { BaseNodeRecord } from '@grafema/types';
+
+/**
+ * Extended http:route node with handler identification fields.
+ * Note: These fields are stored at the top level after metadata parsing,
+ * not nested under a metadata object.
+ */
+interface HttpRouteNode extends BaseNodeRecord {
+  type: 'http:route';
+  handlerStart?: number;  // Byte offset for inline handlers
+  handlerName?: string;   // Function name for named handlers
+}
+
+/**
+ * Extended FUNCTION node with start field
+ */
+interface FunctionNode extends BaseNodeRecord {
+  type: 'FUNCTION';
+  start?: number;
+}
+
+export class ExpressHandlerLinker extends Plugin {
+  get metadata(): PluginMetadata {
+    return {
+      name: 'ExpressHandlerLinker',
+      phase: 'ENRICHMENT',
+      creates: {
+        nodes: [],
+        edges: ['HANDLED_BY']
+      },
+      dependencies: ['JSASTAnalyzer', 'ExpressRouteAnalyzer']
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    const { graph, onProgress } = context;
+    const logger = this.log(context);
+
+    logger.info('Starting Express handler linking');
+
+    const startTime = Date.now();
+
+    let routesProcessed = 0;
+    let edgesCreated = 0;
+    let noHandlerInfo = 0;
+    let handlerNotFound = 0;
+
+    // Collect all http:route nodes
+    const routeNodes: HttpRouteNode[] = [];
+    for await (const node of graph.queryNodes({ type: 'http:route' })) {
+      routeNodes.push(node as HttpRouteNode);
+    }
+
+    logger.info('Found routes to process', { count: routeNodes.length });
+
+    if (routeNodes.length === 0) {
+      return createSuccessResult({ nodes: 0, edges: 0 });
+    }
+
+    // Group routes by file for efficient batch lookup
+    const routesByFile = new Map<string, HttpRouteNode[]>();
+    for (const route of routeNodes) {
+      const file = route.file;
+      if (!file) continue;
+      const routes = routesByFile.get(file) || [];
+      routes.push(route);
+      routesByFile.set(file, routes);
+    }
+
+    // Process routes file by file
+    for (const [file, fileRoutes] of routesByFile) {
+      // Build function lookup maps for this file
+      const functionsByStart = new Map<number, string>(); // start -> nodeId
+      const functionsByName = new Map<string, string>();  // name -> nodeId (first match)
+
+      for await (const fn of graph.queryNodes({ type: 'FUNCTION', file })) {
+        const funcNode = fn as FunctionNode;
+        if (funcNode.start !== undefined) {
+          functionsByStart.set(funcNode.start, funcNode.id);
+        }
+        if (funcNode.name && !functionsByName.has(funcNode.name)) {
+          functionsByName.set(funcNode.name, funcNode.id);
+        }
+      }
+
+      // Link routes to handlers
+      for (const route of fileRoutes) {
+        routesProcessed++;
+
+        // Report progress
+        if (onProgress && routesProcessed % 20 === 0) {
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+          onProgress({
+            phase: 'enrichment',
+            currentPlugin: 'ExpressHandlerLinker',
+            message: `Linking handlers ${routesProcessed}/${routeNodes.length} (${elapsed}s)`,
+            totalFiles: routeNodes.length,
+            processedFiles: routesProcessed
+          });
+        }
+
+        // Handler identification is stored at top level after metadata parsing
+        const handlerStart = route.handlerStart;
+        const handlerName = route.handlerName;
+
+        // Try to find handler function
+        let handlerId: string | undefined;
+
+        if (handlerStart !== undefined) {
+          // Inline handler: lookup by byte offset
+          handlerId = functionsByStart.get(handlerStart);
+        } else if (handlerName !== undefined) {
+          // Named handler: lookup by name
+          handlerId = functionsByName.get(handlerName);
+        } else {
+          noHandlerInfo++;
+          continue;
+        }
+
+        if (!handlerId) {
+          handlerNotFound++;
+          logger.debug('Handler not found', {
+            route: route.id,
+            handlerStart,
+            handlerName,
+            file
+          });
+          continue;
+        }
+
+        // Create HANDLED_BY edge: route -> handler function
+        await graph.addEdge({
+          type: 'HANDLED_BY',
+          src: route.id,
+          dst: handlerId
+        });
+        edgesCreated++;
+      }
+    }
+
+    const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+    logger.info('Complete', {
+      routesProcessed,
+      edgesCreated,
+      noHandlerInfo,
+      handlerNotFound,
+      time: `${totalTime}s`
+    });
+
+    return createSuccessResult(
+      { nodes: 0, edges: edgesCreated },
+      {
+        routesProcessed,
+        edgesCreated,
+        noHandlerInfo,
+        handlerNotFound,
+        timeMs: Date.now() - startTime
+      }
+    );
+  }
+}

package/src/plugins/enrichment/ExternalCallResolver.ts

@@ -47,7 +47,6 @@ export class ExternalCallResolver extends Plugin {
     return {
       name: 'ExternalCallResolver',
       phase: 'ENRICHMENT',
-      priority: 70, // After FunctionCallResolver (80)
       creates: {
         nodes: ['EXTERNAL_MODULE'],
         edges: ['CALLS']

package/src/plugins/enrichment/FunctionCallResolver.ts

@@ -16,6 +16,7 @@ import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { BaseNodeRecord } from '@grafema/types';
 import { dirname, resolve } from 'path';
 import { StrictModeError } from '../../errors/GrafemaError.js';
+import { resolveModulePath as resolveModulePathUtil } from '../../utils/moduleResolution.js';
 
 // === INTERFACES ===
 
@@ -36,10 +37,6 @@ interface ExportNode extends BaseNodeRecord {
   source?: string; // Re-export source (if re-exporting)
 }
 
-interface ExportIndexEntry {
-  node: ExportNode;
-  exportKey: string; // "default" | "named:functionName"
-}
 
 interface ExternalModuleResult {
   type: 'external';
@@ -58,7 +55,6 @@ export class FunctionCallResolver extends Plugin {
     return {
       name: 'FunctionCallResolver',
       phase: 'ENRICHMENT',
-      priority: 80, // After ImportExportLinker (90)
       creates: {
         nodes: ['EXTERNAL_MODULE'],
         edges: ['CALLS']
@@ -353,22 +349,21 @@ export class FunctionCallResolver extends Plugin {
    * @param fileIndex - Set or Map of known file paths for existence checking
    * @returns Resolved file path or null if not found
    */
+  /**
+   * Resolve module path using in-memory file index.
+   * Uses shared utility from moduleResolution.ts (REG-320).
+   * Now supports all extensions (.mjs, .cjs, etc.) - fixes previous bug.
+   */
   private resolveModulePath(
     currentDir: string,
     specifier: string,
     fileIndex: Set<string>
   ): string | null {
     const basePath = resolve(currentDir, specifier);
-    const extensions = ['', '.js', '.ts', '.jsx', '.tsx', '/index.js', '/index.ts'];
-
-    for (const ext of extensions) {
-      const testPath = basePath + ext;
-      if (fileIndex.has(testPath)) {
-        return testPath;
-      }
-    }
-
-    return null;
+    return resolveModulePathUtil(basePath, {
+      useFilesystem: false,
+      fileIndex
+    });
   }
 
   /**

package/src/plugins/enrichment/HTTPConnectionEnricher.ts

@@ -12,6 +12,7 @@
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { BaseNodeRecord } from '@grafema/types';
+import { StrictModeError, ValidationError } from '../../errors/GrafemaError.js';
 
 /**
  * HTTP route node
@@ -28,10 +29,13 @@ interface HTTPRouteNode extends BaseNodeRecord {
  */
 interface HTTPRequestNode extends BaseNodeRecord {
   method?: string;
+  methodSource?: MethodSource;
   url?: string;
   responseDataNode?: string;  // ID of response.json() CALL node (set by FetchAnalyzer)
 }
 
+type MethodSource = 'explicit' | 'default' | 'unknown';
+
 /**
  * Connection info for logging
  */
@@ -47,7 +51,6 @@ export class HTTPConnectionEnricher extends Plugin {
     return {
       name: 'HTTPConnectionEnricher',
       phase: 'ENRICHMENT',
-      priority: 50,  // После основных enrichers
       creates: {
         nodes: [],
         edges: ['INTERACTS_WITH', 'HTTP_RECEIVES']
@@ -88,25 +91,65 @@ export class HTTPConnectionEnricher extends Plugin {
       });
 
       let edgesCreated = 0;
+      const errors: Error[] = [];
       const connections: ConnectionInfo[] = [];
 
       // Для каждого request ищем matching route
       for (const request of uniqueRequests) {
-        // Пропускаем dynamic URLs
-        if (request.url === 'dynamic' || !request.url) {
+        const methodSource = request.methodSource ?? 'explicit';
+        const method = request.method ? request.method.toUpperCase() : null;
+        const url = request.url;
+
+        if (methodSource === 'unknown') {
+          const urlLabel = url ?? 'unknown';
+          const message = `Unknown HTTP method for request ${urlLabel}`;
+          if (context.strictMode) {
+            errors.push(new StrictModeError(
+              message,
+              'STRICT_UNKNOWN_HTTP_METHOD',
+              {
+                filePath: request.file,
+                lineNumber: request.line as number | undefined,
+                phase: 'ENRICHMENT',
+                plugin: 'HTTPConnectionEnricher',
+                requestId: request.id,
+              },
+              'Provide method as a string literal or resolvable const (e.g., method: \"POST\")'
+            ));
+          } else {
+            errors.push(new ValidationError(
+              message,
+              'WARN_HTTP_METHOD_UNKNOWN',
+              {
+                filePath: request.file,
+                lineNumber: request.line as number | undefined,
+                phase: 'ENRICHMENT',
+                plugin: 'HTTPConnectionEnricher',
+                requestId: request.id,
+              },
+              'Provide method as a string literal or resolvable const (e.g., method: \"POST\")',
+              'warning'
+            ));
+          }
           continue;
         }
 
-        const method = (request.method || 'GET').toUpperCase();
-        const url = request.url;
+        // Пропускаем dynamic URLs
+        if (url === 'dynamic' || !url) {
+          continue;
+        }
 
         // Ищем matching route
         for (const route of uniqueRoutes) {
-          const routeMethod = (route.method || 'GET').toUpperCase();
+          const routeMethod = route.method ? route.method.toUpperCase() : null;
           // Use fullPath (from MountPointResolver) if available, fallback to local path
           const routePath = route.fullPath || route.path;
 
-          if (routePath && method === routeMethod && this.pathsMatch(url, routePath)) {
+          if (!routeMethod) continue;
+          if (methodSource === 'default' && routeMethod !== 'GET') continue;
+          if (methodSource === 'explicit' && (!method || method !== routeMethod)) continue;
+
+          if (routePath && this.pathsMatch(url, routePath)) {
             // 1. Create INTERACTS_WITH edge (existing)
             await graph.addEdge({
               type: 'INTERACTS_WITH',
@@ -137,8 +180,9 @@ export class HTTPConnectionEnricher extends Plugin {
               }
             }
 
+            const requestLabel = `${method ?? 'UNKNOWN'} ${url}`;
             connections.push({
-              request: `${method} ${url}`,
+              request: requestLabel,
               route: `${routeMethod} ${routePath}`,
               requestFile: request.file,
               routeFile: route.file
@@ -163,7 +207,8 @@ export class HTTPConnectionEnricher extends Plugin {
           connections: connections.length,
           routesAnalyzed: uniqueRoutes.length,
           requestsAnalyzed: uniqueRequests.length
-        }
+        },
+        errors
       );
 
     } catch (error) {
@@ -178,7 +223,7 @@ export class HTTPConnectionEnricher extends Plugin {
    */
   private normalizeUrl(url: string): string {
     return url
-      .replace(/:[^/]+/g, '{param}')      // :id -> {param}
+      .replace(/:[A-Za-z0-9_]+/g, '{param}')      // :id -> {param}
       .replace(/\$\{[^}]*\}/g, '{param}'); // ${...} -> {param}, ${userId} -> {param}
   }
 
@@ -214,11 +259,17 @@ export class HTTPConnectionEnricher extends Plugin {
 
     // Handle case where request has concrete value (e.g., '/users/123')
     // and route has param (e.g., '/users/{param}')
-    const routeRegex = normRoute
-      .replace(/\{param\}/g, '[^/]+')  // {param} -> [^/]+
-      .replace(/\//g, '\\/');           // / -> \/
+    return this.buildParamRegex(normRoute).test(normRequest);
+  }
+
+  private escapeRegExp(value: string): string {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
 
-    return new RegExp(`^${routeRegex}$`).test(normRequest);
+  private buildParamRegex(normalizedRoute: string): RegExp {
+    const parts = normalizedRoute.split('{param}');
+    const pattern = parts.map(part => this.escapeRegExp(part)).join('[^/]+');
+    return new RegExp(`^${pattern}$`);
   }
 
   /**

package/src/plugins/enrichment/ImportExportLinker.ts

@@ -39,7 +39,6 @@ export class ImportExportLinker extends Plugin {
     return {
       name: 'ImportExportLinker',
       phase: 'ENRICHMENT',
-      priority: 90, // Run early in enrichment, after analysis
       creates: {
         nodes: [],
         edges: ['IMPORTS', 'IMPORTS_FROM']

package/src/plugins/enrichment/InstanceOfResolver.ts

@@ -48,11 +48,11 @@ export class InstanceOfResolver extends Plugin {
     return {
       name: 'InstanceOfResolver',
       phase: 'ENRICHMENT',
-      priority: 100,  // Высокий приоритет - должен выполняться перед другими enrichment плагинами
       creates: {
         nodes: [],
         edges: ['INSTANCE_OF']  // Пере-создаёт INSTANCE_OF edges
-      }
+      },
+      dependencies: ['JSASTAnalyzer']
     };
   }