@grafema/core 0.1.1-alpha → 0.2.0-beta

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

@@ -21,7 +21,9 @@ import type {
   FunctionDeclaration,
   ClassDeclaration,
   Identifier,
-  Node
+  Node,
+  CallExpression,
+  TemplateLiteral
 } from '@babel/types';
 import type { NodePath } from '@babel/traverse';
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
@@ -49,6 +51,9 @@ interface ImportInfo {
   specifiers: ImportSpecifierInfo[];
   line: number;
   column?: number;
+  isDynamic?: boolean;         // true for dynamic import() expressions
+  isResolvable?: boolean;      // true if path is a string literal (statically analyzable)
+  dynamicPath?: string;        // original expression for template/variable paths
 }
 
 /**
@@ -132,10 +137,116 @@ export class ImportExportVisitor extends ASTVisitor {
           line: getLine(node),
           column: getColumn(node)
         });
+      },
+
+      /**
+       * Handle dynamic import() expressions
+       * Examples:
+       * - import('./module.js')                    -> isResolvable: true
+       * - import(`./plugins/${name}.js`)           -> isResolvable: false, source: './plugins/'
+       * - import(modulePath)                       -> isResolvable: false, source: '<dynamic>'
+       */
+      CallExpression: (path: NodePath) => {
+        const node = path.node as CallExpression;
+
+        // Check if this is an import() call
+        if (node.callee.type !== 'Import') {
+          return;
+        }
+
+        const arg = node.arguments[0];
+        if (!arg) return;
+
+        let source: string;
+        let isResolvable: boolean;
+        let dynamicPath: string | undefined;
+
+        if (arg.type === 'StringLiteral') {
+          // import('./module.js') - literal path, fully resolvable
+          source = arg.value;
+          isResolvable = true;
+        } else if (arg.type === 'TemplateLiteral') {
+          // import(`./plugins/${name}.js`) - template literal
+          const templateArg = arg as TemplateLiteral;
+          const firstQuasi = templateArg.quasis[0];
+
+          // Extract static prefix (part before first expression)
+          const prefix = firstQuasi?.value?.raw || '';
+
+          if (prefix) {
+            source = prefix;
+          } else {
+            // No static prefix - e.g., import(`${baseDir}/loader.js`)
+            source = '<dynamic>';
+          }
+
+          isResolvable = false;
+          // Capture the original template for debugging/analysis
+          dynamicPath = this.templateLiteralToString(templateArg);
+        } else if (arg.type === 'Identifier') {
+          // import(modulePath) - variable path
+          source = '<dynamic>';
+          isResolvable = false;
+          dynamicPath = (arg as Identifier).name;
+        } else {
+          // Other expressions (e.g., function calls, member expressions)
+          source = '<dynamic>';
+          isResolvable = false;
+        }
+
+        // Find the receiving variable name from parent
+        // Patterns: const mod = await import(...) or const mod = import(...)
+        let localName = '*';  // Default for side-effect imports
+        const parent = path.parent;
+
+        if (parent?.type === 'AwaitExpression') {
+          // const mod = await import(...)
+          const awaitParent = path.parentPath?.parent;
+          if (awaitParent?.type === 'VariableDeclarator' &&
+              awaitParent.id?.type === 'Identifier') {
+            localName = awaitParent.id.name;
+          }
+        } else if (parent?.type === 'VariableDeclarator' &&
+                   parent.id?.type === 'Identifier') {
+          // const mod = import(...) (without await)
+          localName = parent.id.name;
+        }
+
+        (imports as ImportInfo[]).push({
+          source,
+          specifiers: [{
+            imported: '*',  // Dynamic imports are always namespace imports
+            local: localName
+          }],
+          line: getLine(node),
+          column: getColumn(node),
+          isDynamic: true,
+          isResolvable,
+          dynamicPath
+        });
       }
     };
   }
 
+  /**
+   * Convert a TemplateLiteral to a string representation for debugging
+   */
+  private templateLiteralToString(template: TemplateLiteral): string {
+    let result = '';
+    for (let i = 0; i < template.quasis.length; i++) {
+      result += template.quasis[i].value.raw;
+      if (i < template.expressions.length) {
+        const expr = template.expressions[i];
+        if (expr.type === 'Identifier') {
+          result += `\${${expr.name}}`;
+        } else {
+          result += '${...}';
+        }
+      }
+    }
+    return result;
+  }
+
   getExportHandlers(): VisitorHandlers {
     const { exports } = this.collections;
     const extractVariableNamesFromPattern = this.extractVariableNamesFromPattern;

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

@@ -29,6 +29,7 @@ export interface VariableInfo {
   loc: { start: { line: number; column: number } };
   propertyPath?: string[];
   arrayIndex?: number;
+  isRest?: boolean;
 }
 
 /**
@@ -47,7 +48,10 @@ export type TrackVariableAssignmentCallback = (
   line: number,
   literals: unknown[],
   variableAssignments: unknown[],
-  literalCounterRef: CounterRef
+  literalCounterRef: CounterRef,
+  objectLiterals: unknown[],
+  objectProperties: unknown[],
+  objectLiteralCounterRef: CounterRef
 ) => void;
 
 /**
@@ -100,11 +104,82 @@ interface VariableAssignmentInfo {
   file?: string;
 }
 
+/**
+ * Call info extracted from CallExpression (REG-223)
+ */
+interface CallInfo {
+  line: number;
+  column: number;
+  name: string;
+  isMethodCall: boolean;
+}
+
 export class VariableVisitor extends ASTVisitor {
   private extractVariableNamesFromPattern: ExtractVariableNamesCallback;
   private trackVariableAssignment: TrackVariableAssignmentCallback;
   private scopeTracker?: ScopeTracker;
 
+  /**
+   * Recursively unwrap AwaitExpression to get the underlying expression.
+   * await await fetch() -> fetch() (REG-223)
+   */
+  private unwrapAwaitExpression(node: Node): Node {
+    if (node.type === 'AwaitExpression' && (node as { argument?: Node }).argument) {
+      return this.unwrapAwaitExpression((node as { argument: Node }).argument);
+    }
+    return node;
+  }
+
+  /**
+   * Check if expression is CallExpression or AwaitExpression wrapping a call. (REG-223)
+   */
+  private isCallOrAwaitExpression(node: Node): boolean {
+    const unwrapped = this.unwrapAwaitExpression(node);
+    return unwrapped.type === 'CallExpression';
+  }
+
+  /**
+   * Extract call site information from CallExpression. (REG-223)
+   * Returns null if not a valid CallExpression.
+   */
+  private extractCallInfo(node: Node): CallInfo | null {
+    if (node.type !== 'CallExpression') {
+      return null;
+    }
+
+    const callExpr = node as { callee: Node; loc?: { start: { line: number; column: number } } };
+    const callee = callExpr.callee;
+    let name: string;
+    let isMethodCall = false;
+
+    // Direct call: fetchUser()
+    if (callee.type === 'Identifier') {
+      name = (callee as Identifier).name;
+    }
+    // Method call: obj.fetchUser() or arr.map()
+    else if (callee.type === 'MemberExpression') {
+      isMethodCall = true;
+      const memberExpr = callee as { object: Node; property: Node };
+      const objectName = memberExpr.object.type === 'Identifier'
+        ? (memberExpr.object as Identifier).name
+        : (memberExpr.object.type === 'ThisExpression' ? 'this' : 'unknown');
+      const methodName = memberExpr.property.type === 'Identifier'
+        ? (memberExpr.property as Identifier).name
+        : 'unknown';
+      name = `${objectName}.${methodName}`;
+    }
+    else {
+      return null;
+    }
+
+    return {
+      line: callExpr.loc?.start.line ?? 0,
+      column: callExpr.loc?.start.column ?? 0,
+      name,
+      isMethodCall
+    };
+  }
+
   /**
    * @param module - Current module being analyzed
    * @param collections - Must contain arrays and counter refs
@@ -131,13 +206,22 @@ export class VariableVisitor extends ASTVisitor {
     const classInstantiations = this.collections.classInstantiations ?? [];
     const literals = (this.collections.literals ?? []) as unknown[];
     const variableAssignments = this.collections.variableAssignments ?? [];
+    const scopes = (this.collections.scopes ?? []) as unknown[];
     const varDeclCounterRef = (this.collections.varDeclCounterRef ?? { value: 0 }) as CounterRef;
     const literalCounterRef = (this.collections.literalCounterRef ?? { value: 0 }) as CounterRef;
+    const scopeCounterRef = (this.collections.scopeCounterRef ?? { value: 0 }) as CounterRef;
+    // Object literal tracking collections (REG-328)
+    const objectLiterals = (this.collections.objectLiterals ?? []) as unknown[];
+    const objectProperties = (this.collections.objectProperties ?? []) as unknown[];
+    const objectLiteralCounterRef = (this.collections.objectLiteralCounterRef ?? { value: 0 }) as CounterRef;
     const scopeTracker = this.scopeTracker;
 
     const extractVariableNamesFromPattern = this.extractVariableNamesFromPattern;
     const trackVariableAssignment = this.trackVariableAssignment;
 
+    // Track which loops we've already created scopes for
+    const processedLoops = new Set<unknown>();
+
     return {
       VariableDeclaration: (path: NodePath) => {
         // Only module-level variables
@@ -146,6 +230,41 @@ export class VariableVisitor extends ASTVisitor {
           const varNode = path.node as VariableDeclaration;
           const isConst = varNode.kind === 'const';
 
+          // Check if this is a loop variable (for...of or for...in)
+          const parent = path.parent;
+          const isLoopVariable = (parent.type === 'ForOfStatement' || parent.type === 'ForInStatement')
+            && (parent as {left?: unknown}).left === varNode;
+
+          // If this is a loop variable, create the loop scope first (if not already created)
+          if (isLoopVariable && !processedLoops.has(parent)) {
+            processedLoops.add(parent);
+
+            const loopNode = parent as { type: string; loc?: { start: { line: number } } };
+            const line = loopNode.loc?.start.line ?? 0;
+            const scopeType = loopNode.type === 'ForOfStatement' ? 'for-of-loop' : 'for-in-loop';
+            const trackerType = loopNode.type === 'ForOfStatement' ? 'for-of' : 'for-in';
+            const scopeId = `SCOPE#${scopeType}#${module.file}#${line}:${scopeCounterRef.value++}`;
+
+            // Enter scope in tracker BEFORE generating semantic ID
+            if (scopeTracker) {
+              scopeTracker.enterCountedScope(trackerType);
+            }
+
+            const semanticId = scopeTracker
+              ? scopeTracker.getContext().scopePath.join('->')
+              : scopeId;
+
+            (scopes as { id: string; type: string; scopeType: string; semanticId: string; file: string; line: number; parentScopeId: string }[]).push({
+              id: scopeId,
+              type: 'SCOPE',
+              scopeType,
+              semanticId,
+              file: module.file,
+              line,
+              parentScopeId: module.id
+            });
+          }
+
           varNode.declarations.forEach((declarator: VariableDeclarator) => {
             // Extract all variable names from the pattern (handles destructuring)
             const variables = extractVariableNamesFromPattern(declarator.id);
@@ -155,9 +274,9 @@ export class VariableVisitor extends ASTVisitor {
               const isLiteral = literalValue !== null;
               const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
 
-              // For const with literal or NewExpression create CONSTANT
-              // For everything else - VARIABLE
-              const shouldBeConstant = isConst && (isLiteral || isNewExpression);
+              // Loop variables with const should be CONSTANT (they can't be reassigned in loop body)
+              // Regular variables with const are CONSTANT only if initialized with literal or new expression
+              const shouldBeConstant = isConst && (isLoopVariable || isLiteral || isNewExpression);
 
               const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
 
@@ -215,67 +334,173 @@ export class VariableVisitor extends ASTVisitor {
               }
 
               // Track assignment for data flow analysis
-              if (declarator.init) {
+              // For loop variables, the "init" is the right side of for...of/for...in
+              const initExpression = isLoopVariable
+                ? (parent as {right?: Node}).right
+                : declarator.init;
+
+              if (initExpression) {
+                // For loop variables, create DERIVES_FROM edges instead of ASSIGNED_FROM
+                // Loop variables derive their values from the collection (semantic difference)
+                if (isLoopVariable && initExpression.type === 'Identifier') {
+                  const sourceName = (initExpression as Identifier).name;
+                  (variableAssignments as unknown[]).push({
+                    variableId: varId,
+                    sourceType: 'DERIVES_FROM_VARIABLE',
+                    sourceName,
+                    file: module.file,
+                    line: varInfo.loc.start.line
+                  });
+                }
                 // Handle destructuring - create EXPRESSION for property path
-                if (varInfo.propertyPath || varInfo.arrayIndex !== undefined) {
-                  // Create EXPRESSION node for the property access
-                  const initName = declarator.init.type === 'Identifier'
-                    ? (declarator.init as Identifier).name
-                    : 'expr';
-                  let expressionPath = initName;
-
-                  if (varInfo.propertyPath) {
-                    expressionPath = `${initName}.${varInfo.propertyPath.join('.')}`;
-                  } else if (varInfo.arrayIndex !== undefined) {
-                    expressionPath = `${initName}[${varInfo.arrayIndex}]`;
-                  }
+                else if (varInfo.propertyPath || varInfo.arrayIndex !== undefined || varInfo.isRest) {
+                  // Phase 1: Simple Identifier init expressions (REG-201)
+                  if (initExpression.type === 'Identifier') {
+                    const sourceBaseName = (initExpression as Identifier).name;
+                    const expressionLine = varInfo.loc.start.line;
 
-                  // Create EXPRESSION node representing the property access
-                  const expressionType = varInfo.propertyPath ? 'MemberExpression' : 'ArrayAccess';
-                  const expressionNode = NodeFactory.createExpression(
-                    expressionType,
-                    module.file,
-                    varInfo.loc.start.line,
-                    varInfo.loc.start.column,
-                    {
-                      path: expressionPath,
-                      baseName: initName,
+                    // Handle rest elements specially - create edge to whole source
+                    if (varInfo.isRest) {
+                      (variableAssignments as unknown[]).push({
+                        variableId: varId,
+                        sourceType: 'VARIABLE',
+                        sourceName: sourceBaseName,
+                        line: expressionLine
+                      });
+                      return;
+                    }
+
+                    const expressionColumn = varInfo.loc.start.column;
+
+                    // Build property path string
+                    let fullPath = sourceBaseName;
+                    if (varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+                      fullPath = `${sourceBaseName}.${varInfo.propertyPath.join('.')}`;
+                    }
+
+                    // Generate expression ID (matches GraphBuilder expectations)
+                    const expressionId = `${module.file}:EXPRESSION:MemberExpression:${expressionLine}:${expressionColumn}`;
+
+                    // Determine property for display
+                    let property: string;
+                    if (varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+                      property = varInfo.propertyPath[varInfo.propertyPath.length - 1];
+                    } else if (varInfo.arrayIndex !== undefined) {
+                      property = String(varInfo.arrayIndex);
+                    } else {
+                      property = '';
+                    }
+
+                    // Push assignment with full metadata for GraphBuilder (REG-201)
+                    // GraphBuilder will create the EXPRESSION node from this metadata
+                    (variableAssignments as unknown[]).push({
+                      variableId: varId,
+                      sourceId: expressionId,
+                      sourceType: 'EXPRESSION',
+                      expressionType: 'MemberExpression',
+                      object: sourceBaseName,
+                      property: property,
+                      computed: varInfo.arrayIndex !== undefined,
+                      path: fullPath,
+                      objectSourceName: sourceBaseName, // Use objectSourceName for DERIVES_FROM edge creation
                       propertyPath: varInfo.propertyPath || undefined,
-                      arrayIndex: varInfo.arrayIndex
+                      arrayIndex: varInfo.arrayIndex,
+                      file: module.file,
+                      line: expressionLine,
+                      column: expressionColumn
+                    });
+                  }
+                  // Phase 2: CallExpression or AwaitExpression (REG-223)
+                  else if (this.isCallOrAwaitExpression(initExpression)) {
+                    const unwrapped = this.unwrapAwaitExpression(initExpression);
+                    const callInfo = this.extractCallInfo(unwrapped);
+
+                    if (!callInfo) {
+                      // Unsupported call pattern (computed callee, etc.)
+                      return;
                     }
-                  );
 
-                  const expressionId = expressionNode.id;
-                  (literals as LiteralExpressionInfo[]).push(expressionNode as LiteralExpressionInfo);
+                    const callRepresentation = `${callInfo.name}()`;
+                    const expressionLine = varInfo.loc.start.line;
+                    const expressionColumn = varInfo.loc.start.column;
 
-                  // Create ASSIGNED_FROM edge: VARIABLE -> EXPRESSION
-                  (variableAssignments as VariableAssignmentInfo[]).push({
-                    variableId: varId,
-                    sourceId: expressionId,
-                    sourceType: 'EXPRESSION'
-                  });
+                    // Handle rest elements - create direct CALL_SITE assignment
+                    if (varInfo.isRest) {
+                      (variableAssignments as unknown[]).push({
+                        variableId: varId,
+                        sourceType: 'CALL_SITE',
+                        callName: callInfo.name,
+                        callLine: callInfo.line,
+                        callColumn: callInfo.column,
+                        callSourceLine: callInfo.line,
+                        callSourceColumn: callInfo.column,
+                        callSourceFile: module.file,
+                        callSourceName: callInfo.name,
+                        line: expressionLine
+                      });
+                      return;
+                    }
 
-                  // Also create DERIVES_FROM edge: EXPRESSION -> base variable (if identifier)
-                  if (declarator.init.type === 'Identifier') {
-                    (variableAssignments as VariableAssignmentInfo[]).push({
-                      variableId: expressionId,
-                      sourceId: null, // Will be resolved by name
-                      sourceName: (declarator.init as Identifier).name,
-                      sourceType: 'DERIVES_FROM_VARIABLE',
-                      file: module.file
+                    // Generate expression ID (matches GraphBuilder expectations)
+                    const expressionId = `${module.file}:EXPRESSION:MemberExpression:${expressionLine}:${expressionColumn}`;
+
+                    // Determine property for display
+                    let property: string;
+                    if (varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+                      property = varInfo.propertyPath[varInfo.propertyPath.length - 1];
+                    } else if (varInfo.arrayIndex !== undefined) {
+                      property = String(varInfo.arrayIndex);
+                    } else {
+                      property = '';
+                    }
+
+                    // Build property path string: "fetchUser().data" or "fetchUser().user.name"
+                    let fullPath = callRepresentation;
+                    if (varInfo.propertyPath && varInfo.propertyPath.length > 0) {
+                      fullPath = `${callRepresentation}.${varInfo.propertyPath.join('.')}`;
+                    }
+
+                    // Push assignment with call source metadata for GraphBuilder (REG-223)
+                    (variableAssignments as unknown[]).push({
+                      variableId: varId,
+                      sourceId: expressionId,
+                      sourceType: 'EXPRESSION',
+                      expressionType: 'MemberExpression',
+                      object: callRepresentation,          // "fetchUser()" - display name
+                      property: property,
+                      computed: varInfo.arrayIndex !== undefined,
+                      path: fullPath,
+                      propertyPath: varInfo.propertyPath || undefined,
+                      arrayIndex: varInfo.arrayIndex,
+                      // Call source for DERIVES_FROM lookup (REG-223)
+                      callSourceLine: callInfo.line,
+                      callSourceColumn: callInfo.column,
+                      callSourceFile: module.file,
+                      callSourceName: callInfo.name,
+                      sourceMetadata: {
+                        sourceType: callInfo.isMethodCall ? 'method-call' : 'call'
+                      },
+                      file: module.file,
+                      line: expressionLine,
+                      column: expressionColumn
                     });
                   }
+                  // Unsupported init type (MemberExpression without call, etc.)
+                  // Skip silently
                 } else {
                   // Normal assignment tracking
                   trackVariableAssignment(
-                    declarator.init,
+                    initExpression,
                     varId,
                     varInfo.name,
                     module,
                     varInfo.loc.start.line,
                     literals,
                     variableAssignments,
-                    literalCounterRef as CounterRef
+                    literalCounterRef as CounterRef,
+                    objectLiterals,
+                    objectProperties,
+                    objectLiteralCounterRef
                   );
                 }
               }

package/src/plugins/discovery/WorkspaceDiscovery.ts

@@ -10,6 +10,8 @@
  * - lerna.json
  */
 
+import { join } from 'path';
+
 import { DiscoveryPlugin } from './DiscoveryPlugin.js';
 import { createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
@@ -124,7 +126,7 @@ export class WorkspaceDiscovery extends DiscoveryPlugin {
         metadata: {
           workspaceType: detection.type!,
           relativePath: pkg.relativePath,
-          entrypoint: serviceNode.entrypoint,
+          entrypoint: (serviceNode.metadata?.entrypoint as string | null) ?? null,
           packageJson: pkg.packageJson as Record<string, unknown>
         }
       });
@@ -146,13 +148,18 @@ export class WorkspaceDiscovery extends DiscoveryPlugin {
    */
   private createServiceNode(pkg: WorkspacePackage, workspaceType: string, _projectPath: string) {
     // Resolve entrypoint (prefer TypeScript source)
-    const entrypoint = resolveSourceEntrypoint(pkg.path, pkg.packageJson)
+    const relativeEntrypoint = resolveSourceEntrypoint(pkg.path, pkg.packageJson)
       ?? (pkg.packageJson.main as string | undefined)
       ?? null;
 
+    // Convert to absolute path (REG-247: JSModuleIndexer expects absolute paths)
+    const absoluteEntrypoint = relativeEntrypoint
+      ? join(pkg.path, relativeEntrypoint)
+      : null;
+
     const serviceNode = NodeFactory.createService(pkg.name, pkg.path, {
       discoveryMethod: 'workspace',
-      entrypoint: entrypoint ?? undefined,
+      entrypoint: absoluteEntrypoint ?? undefined,
       version: pkg.packageJson.version as string | undefined,
       description: pkg.packageJson.description as string | undefined,
       dependencies: Object.keys(pkg.packageJson.dependencies || {})
@@ -169,7 +176,7 @@ export class WorkspaceDiscovery extends DiscoveryPlugin {
       description: pkg.packageJson.description as string | undefined,
       private: pkg.packageJson.private as boolean | undefined,
       dependencies: Object.keys(pkg.packageJson.dependencies || {}),
-      entrypoint: entrypoint
+      entrypoint: absoluteEntrypoint
     };
 
     return nodeWithMetadata;

package/src/plugins/enrichment/AliasTracker.ts

@@ -16,6 +16,7 @@
 import { Plugin, createSuccessResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { BaseNodeRecord, NodeRecord } from '@grafema/types';
+import { StrictModeError } from '../../errors/GrafemaError.js';
 
 /**
  * Alias info from index
@@ -88,6 +89,7 @@ export class AliasTracker extends Plugin {
     let aliasesFound = 0;
     let edgesCreated = 0;
     let resolvedToMethod = 0;
+    const errors: Error[] = [];
 
     // Трекинг превышений глубины
     this.depthExceeded = [];
@@ -192,11 +194,30 @@ export class AliasTracker extends Plugin {
           chain: info.chain.join(' → ')
         }))
       });
+
+      // In strict mode, report as errors
+      if (context.strictMode) {
+        for (const info of this.depthExceeded) {
+          const error = new StrictModeError(
+            `Alias chain exceeded max depth (${info.depth}): ${info.name}`,
+            'STRICT_ALIAS_DEPTH_EXCEEDED',
+            {
+              filePath: info.file,
+              phase: 'ENRICHMENT',
+              plugin: 'AliasTracker',
+              aliasName: info.name,
+              chainLength: info.depth,
+            },
+            `Possible circular alias reference. Chain: ${info.chain.slice(0, 3).join(' -> ')}...`
+          );
+          errors.push(error);
+        }
+      }
     }
 
     logger.info('Summary', summary);
 
-    return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary);
+    return createSuccessResult({ nodes: 0, edges: edgesCreated }, summary, errors);
   }
 
   /**