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

package/src/plugins/analysis/ast/GraphBuilder.ts

@@ -3,8 +3,14 @@
  * OPTIMIZED: Uses batched writes to reduce FFI overhead
  */
 
-import { dirname, resolve } from 'path';
+import { dirname, resolve, basename } from 'path';
 import type { GraphBackend } from '@grafema/types';
+import { ImportNode } from '../../../core/nodes/ImportNode.js';
+import { InterfaceNode, type InterfaceNodeRecord } from '../../../core/nodes/InterfaceNode.js';
+import { EnumNode, type EnumNodeRecord } from '../../../core/nodes/EnumNode.js';
+import { DecoratorNode } from '../../../core/nodes/DecoratorNode.js';
+import { NetworkRequestNode } from '../../../core/nodes/NetworkRequestNode.js';
+import { NodeFactory } from '../../../core/NodeFactory.js';
 import type {
   ModuleNode,
   FunctionInfo,
@@ -27,6 +33,10 @@ import type {
   TypeAliasInfo,
   EnumDeclarationInfo,
   DecoratorInfo,
+  ArrayMutationInfo,
+  ObjectMutationInfo,
+  ObjectLiteralInfo,
+  ArrayLiteralInfo,
   ASTCollections,
   GraphNode,
   GraphEdge,
@@ -108,7 +118,14 @@ export class GraphBuilder {
       interfaces = [],
       typeAliases = [],
       enums = [],
-      decorators = []
+      decorators = [],
+      // Array mutation tracking for FLOWS_INTO edges
+      arrayMutations = [],
+      // Object mutation tracking for FLOWS_INTO edges
+      objectMutations = [],
+      // Object/Array literal tracking
+      objectLiterals = [],
+      arrayLiterals = []
     } = data;
 
     // Reset buffers for this build
@@ -218,17 +235,27 @@ export class GraphBuilder {
     // 25. Buffer IMPLEMENTS edges (CLASS -> INTERFACE)
     this.bufferImplementsEdges(classDeclarations, interfaces);
 
+    // 26. Buffer FLOWS_INTO edges for array mutations (push, unshift, splice, indexed assignment)
+    this.bufferArrayMutationEdges(arrayMutations, variableDeclarations, parameters);
+
+    // 27. Buffer FLOWS_INTO edges for object mutations (property assignment, Object.assign)
+    // REG-152: Now includes classDeclarations for this.prop = value patterns
+    this.bufferObjectMutationEdges(objectMutations, variableDeclarations, parameters, functions, classDeclarations);
+
+    // 28. Buffer OBJECT_LITERAL nodes
+    this.bufferObjectLiteralNodes(objectLiterals);
+
+    // 29. Buffer ARRAY_LITERAL nodes
+    this.bufferArrayLiteralNodes(arrayLiterals);
+
     // FLUSH: Write all nodes first, then edges in single batch calls
     const nodesCreated = await this._flushNodes(graph);
     const edgesCreated = await this._flushEdges(graph);
 
-    // Handle async operations that need graph queries (IMPORTS_FROM edges)
-    const importExportEdges = await this.createImportExportEdges(module, imports, exports, graph, projectPath);
-
     // Handle async operations for ASSIGNED_FROM with CLASS lookups
     const classAssignmentEdges = await this.createClassAssignmentEdges(variableAssignments, graph);
 
-    return { nodes: nodesCreated, edges: edgesCreated + importExportEdges + classAssignmentEdges };
+    return { nodes: nodesCreated, edges: edgesCreated + classAssignmentEdges };
   }
 
   // ============= BUFFERED METHODS (synchronous, no awaits) =============
@@ -360,16 +387,12 @@ export class GraphBuilder {
     );
 
     if (consoleIOMethods.length > 0) {
-      const stdioId = 'net:stdio#__stdio__';
+      const stdioNode = NodeFactory.createExternalStdio();
+
       // Buffer net:stdio node only once (singleton)
-      if (!this._createdSingletons.has(stdioId)) {
-        this._bufferNode({
-          id: stdioId,
-          type: 'net:stdio',
-          name: '__stdio__',
-          description: 'Standard input/output stream'
-        });
-        this._createdSingletons.add(stdioId);
+      if (!this._createdSingletons.has(stdioNode.id)) {
+        this._bufferNode(stdioNode as unknown as GraphNode);
+        this._createdSingletons.add(stdioNode.id);
       }
 
       // Buffer WRITES_TO edges for console.log/error
@@ -377,7 +400,7 @@ export class GraphBuilder {
         this._bufferEdge({
           type: 'WRITES_TO',
           src: methodCall.id,
-          dst: stdioId
+          dst: stdioNode.id
         });
       }
     }
@@ -407,9 +430,13 @@ export class GraphBuilder {
         });
       }
 
-      // If superClass, buffer DERIVES_FROM edge
+      // If superClass, buffer DERIVES_FROM edge with computed ID
       if (superClass) {
-        const superClassId = `CLASS#${superClass}#${file}`;
+        // Compute superclass ID using same format as ClassNode (line 0 = unknown location)
+        // Assume superclass is in same file (most common case)
+        // When superclass is in different file, edge will be dangling until that file analyzed
+        const superClassId = `${file}:CLASS:${superClass}:0`;
+
         this._bufferEdge({
           type: 'DERIVES_FROM',
           src: id,
@@ -434,16 +461,12 @@ export class GraphBuilder {
       let classId = declarationMap.get(className);
 
       if (!classId) {
-        // External class - buffer CLASS node
-        classId = `${module.file}:CLASS:${className}:${line}`;
-        this._bufferNode({
-          id: classId,
-          type: 'CLASS',
-          name: className,
-          file: module.file,
-          line,
-          isInstantiationRef: true
-        });
+        // External class - compute ID using ClassNode format (line 0 = unknown location)
+        // Assume class is in same file (most common case)
+        // When class is in different file, edge will be dangling until that file analyzed
+        classId = `${module.file}:CLASS:${className}:0`;
+
+        // NO node creation - node will exist when class file analyzed
       }
 
       // Buffer INSTANCE_OF edge
@@ -475,49 +498,47 @@ export class GraphBuilder {
 
   private bufferImportNodes(module: ModuleNode, imports: ImportInfo[]): void {
     for (const imp of imports) {
-      const { source, specifiers, line } = imp;
+      const { source, specifiers, line, column } = imp;
 
       for (const spec of specifiers) {
-        const importType = spec.imported === 'default' ? 'default' :
-                          spec.imported === '*' ? 'namespace' : 'named';
-
-        const importId = `${module.file}:IMPORT:${source}:${spec.local}:${line}`;
-
-        this._bufferNode({
-          id: importId,
-          type: 'IMPORT',
-          source: source,
-          importType: importType,
-          imported: spec.imported,
-          local: spec.local,
-          file: module.file,
-          line: line
-        });
+        // Use ImportNode factory for proper semantic IDs and field population
+        const importNode = ImportNode.create(
+          spec.local,           // name = local binding
+          module.file,          // file
+          line,                 // line (stored as field, not in ID)
+          column || 0,          // column
+          source,               // source module
+          {
+            imported: spec.imported,
+            local: spec.local
+            // importType is auto-detected from imported field
+          }
+        );
+
+        this._bufferNode(importNode as unknown as GraphNode);
 
         // MODULE -> CONTAINS -> IMPORT
         this._bufferEdge({
           type: 'CONTAINS',
           src: module.id,
-          dst: importId
+          dst: importNode.id
         });
 
         // Create EXTERNAL_MODULE node for external modules
         const isRelative = source.startsWith('./') || source.startsWith('../');
         if (!isRelative) {
-          const externalModuleId = `EXTERNAL_MODULE:${source}`;
-
-          this._bufferNode({
-            id: externalModuleId,
-            type: 'EXTERNAL_MODULE',
-            name: source,
-            file: module.file,
-            line: line
-          });
+          const externalModule = NodeFactory.createExternalModule(source);
+
+          // Avoid duplicate EXTERNAL_MODULE nodes
+          if (!this._createdSingletons.has(externalModule.id)) {
+            this._bufferNode(externalModule as unknown as GraphNode);
+            this._createdSingletons.add(externalModule.id);
+          }
 
           this._bufferEdge({
             type: 'IMPORTS',
             src: module.id,
-            dst: externalModuleId
+            dst: externalModule.id
           });
         }
       }
@@ -529,79 +550,79 @@ export class GraphBuilder {
       const { type, line, name, specifiers, source } = exp;
 
       if (type === 'default') {
-        const exportId = `${module.file}:EXPORT:default:${line}`;
-
-        this._bufferNode({
-          id: exportId,
-          type: 'EXPORT',
-          exportType: 'default',
-          name: 'default',
-          file: module.file,
-          line: line
-        });
+        const exportNode = NodeFactory.createExport(
+          'default',
+          module.file,
+          line,
+          0,
+          { default: true, exportType: 'default' }
+        );
+
+        this._bufferNode(exportNode as unknown as GraphNode);
 
         this._bufferEdge({
           type: 'CONTAINS',
           src: module.id,
-          dst: exportId
+          dst: exportNode.id
         });
       } else if (type === 'named') {
         if (specifiers) {
           for (const spec of specifiers) {
-            const exportId = `${module.file}:EXPORT:${spec.exported}:${line}`;
-
-            this._bufferNode({
-              id: exportId,
-              type: 'EXPORT',
-              exportType: 'named',
-              name: spec.exported,
-              local: spec.local,
-              file: module.file,
-              line: line,
-              source: source
-            });
+            const exportNode = NodeFactory.createExport(
+              spec.exported,
+              module.file,
+              line,
+              0,
+              {
+                local: spec.local,
+                source: source,
+                exportType: 'named'
+              }
+            );
+
+            this._bufferNode(exportNode as unknown as GraphNode);
 
             this._bufferEdge({
               type: 'CONTAINS',
               src: module.id,
-              dst: exportId
+              dst: exportNode.id
             });
           }
         } else if (name) {
-          const exportId = `${module.file}:EXPORT:${name}:${line}`;
-
-          this._bufferNode({
-            id: exportId,
-            type: 'EXPORT',
-            exportType: 'named',
-            name: name,
-            file: module.file,
-            line: line
-          });
+          const exportNode = NodeFactory.createExport(
+            name,
+            module.file,
+            line,
+            0,
+            { exportType: 'named' }
+          );
+
+          this._bufferNode(exportNode as unknown as GraphNode);
 
           this._bufferEdge({
             type: 'CONTAINS',
             src: module.id,
-            dst: exportId
+            dst: exportNode.id
           });
         }
       } else if (type === 'all') {
-        const exportId = `${module.file}:EXPORT:*:${line}`;
-
-        this._bufferNode({
-          id: exportId,
-          type: 'EXPORT',
-          exportType: 'all',
-          name: '*',
-          file: module.file,
-          line: line,
-          source: source
-        });
+        const exportNode = NodeFactory.createExport(
+          '*',
+          module.file,
+          line,
+          0,
+          {
+            source: source,
+            exportType: 'all'
+          }
+        );
+
+        this._bufferNode(exportNode as unknown as GraphNode);
 
         this._bufferEdge({
           type: 'CONTAINS',
           src: module.id,
-          dst: exportId
+          dst: exportNode.id
         });
       }
     }
@@ -638,15 +659,12 @@ export class GraphBuilder {
 
   private bufferHttpRequests(httpRequests: HttpRequestInfo[], functions: FunctionInfo[]): void {
     if (httpRequests.length > 0) {
-      const networkId = 'net:request#__network__';
+      // Create net:request singleton using factory
+      const networkNode = NetworkRequestNode.create();
 
-      if (!this._createdSingletons.has(networkId)) {
-        this._bufferNode({
-          id: networkId,
-          type: 'net:request',
-          name: '__network__'
-        });
-        this._createdSingletons.add(networkId);
+      if (!this._createdSingletons.has(networkNode.id)) {
+        this._bufferNode(networkNode as unknown as GraphNode);
+        this._createdSingletons.add(networkNode.id);
       }
 
       for (const request of httpRequests) {
@@ -657,7 +675,7 @@ export class GraphBuilder {
         this._bufferEdge({
           type: 'CALLS',
           src: request.id,
-          dst: networkId
+          dst: networkNode.id
         });
 
         if (parentScopeId) {
@@ -766,8 +784,10 @@ export class GraphBuilder {
       }
       // VARIABLE by name
       else if (sourceType === 'VARIABLE' && sourceName) {
-        const varIdParts = variableId.split('#');
-        const varFile = varIdParts.length >= 3 ? varIdParts[2] : null;
+        // Find the current variable's file by looking it up in variableDeclarations
+        // (semantic IDs don't have predictable file positions like old hash-based IDs)
+        const currentVar = variableDeclarations.find(v => v.id === variableId);
+        const varFile = currentVar?.file ?? null;
         const sourceVariable = variableDeclarations.find(v =>
           v.name === sourceName && v.file === varFile
         );
@@ -806,7 +826,7 @@ export class GraphBuilder {
           });
         }
       }
-      // EXPRESSION node creation
+      // EXPRESSION node creation using NodeFactory
       else if (sourceType === 'EXPRESSION' && sourceId) {
         const {
           expressionType,
@@ -821,33 +841,25 @@ export class GraphBuilder {
           consequentSourceName,
           alternateSourceName,
           file: exprFile,
-          line: exprLine
+          line: exprLine,
+          column: exprColumn
         } = assignment;
 
-        const expressionNode: GraphNode = {
-          id: sourceId,
-          type: 'EXPRESSION',
-          expressionType,
-          file: exprFile,
-          line: exprLine
-        };
-
-        if (expressionType === 'MemberExpression') {
-          expressionNode.object = object;
-          expressionNode.property = property;
-          expressionNode.computed = computed;
-          if (computedPropertyVar) {
-            expressionNode.computedPropertyVar = computedPropertyVar;
+        // Create node from upstream metadata using factory
+        const expressionNode = NodeFactory.createExpressionFromMetadata(
+          expressionType || 'Unknown',
+          exprFile || '',
+          exprLine || 0,
+          exprColumn || 0,
+          {
+            id: sourceId,  // ID from JSASTAnalyzer
+            object,
+            property,
+            computed,
+            computedPropertyVar: computedPropertyVar ?? undefined,
+            operator
           }
-          expressionNode.name = `${object}.${property}`;
-        } else if (expressionType === 'BinaryExpression' || expressionType === 'LogicalExpression') {
-          expressionNode.operator = operator;
-          expressionNode.name = `<${expressionType}>`;
-        } else if (expressionType === 'ConditionalExpression') {
-          expressionNode.name = '<ternary>';
-        } else if (expressionType === 'TemplateLiteral') {
-          expressionNode.name = '<template>';
-        }
+        );
 
         this._bufferNode(expressionNode);
 
@@ -1051,54 +1063,66 @@ export class GraphBuilder {
 
   /**
    * Buffer INTERFACE nodes and EXTENDS edges
+   *
+   * Uses two-pass approach:
+   * 1. First pass: create all interface nodes, store in Map
+   * 2. Second pass: create EXTENDS edges using stored node IDs
    */
   private bufferInterfaceNodes(module: ModuleNode, interfaces: InterfaceDeclarationInfo[]): void {
+    // First pass: create all interface nodes and store them
+    const interfaceNodes = new Map<string, InterfaceNodeRecord>();
+
     for (const iface of interfaces) {
-      // Buffer INTERFACE node
-      this._bufferNode({
-        id: iface.id,
-        type: 'INTERFACE',
-        name: iface.name,
-        file: iface.file,
-        line: iface.line,
-        column: iface.column,
-        properties: iface.properties,
-        extends: iface.extends
-      });
+      const interfaceNode = InterfaceNode.create(
+        iface.name,
+        iface.file,
+        iface.line,
+        iface.column || 0,
+        {
+          extends: iface.extends,
+          properties: iface.properties
+        }
+      );
+      interfaceNodes.set(iface.name, interfaceNode);
+      this._bufferNode(interfaceNode as unknown as GraphNode);
 
       // MODULE -> CONTAINS -> INTERFACE
       this._bufferEdge({
         type: 'CONTAINS',
         src: module.id,
-        dst: iface.id
+        dst: interfaceNode.id
       });
+    }
 
-      // INTERFACE -> EXTENDS -> INTERFACE (for each parent interface)
+    // Second pass: create EXTENDS edges
+    for (const iface of interfaces) {
       if (iface.extends && iface.extends.length > 0) {
+        const srcNode = interfaceNodes.get(iface.name)!;
+
         for (const parentName of iface.extends) {
-          // Try to find the parent interface in the same file
-          const parentInterface = interfaces.find(i => i.name === parentName);
-          if (parentInterface) {
+          const parentNode = interfaceNodes.get(parentName);
+
+          if (parentNode) {
+            // Same-file interface
             this._bufferEdge({
               type: 'EXTENDS',
-              src: iface.id,
-              dst: parentInterface.id
+              src: srcNode.id,
+              dst: parentNode.id
             });
           } else {
             // External interface - create a reference node
-            const externalId = `INTERFACE#${parentName}#${iface.file}#external`;
-            this._bufferNode({
-              id: externalId,
-              type: 'INTERFACE',
-              name: parentName,
-              file: iface.file,
-              line: iface.line,
-              isExternal: true
-            });
+            const externalInterface = NodeFactory.createInterface(
+              parentName,
+              iface.file,
+              iface.line,
+              0,
+              { isExternal: true }
+            );
+            this._bufferNode(externalInterface as unknown as GraphNode);
             this._bufferEdge({
               type: 'EXTENDS',
-              src: iface.id,
-              dst: externalId
+              src: srcNode.id,
+              dst: externalInterface.id
             });
           }
         }
@@ -1111,48 +1135,51 @@ export class GraphBuilder {
    */
   private bufferTypeAliasNodes(module: ModuleNode, typeAliases: TypeAliasInfo[]): void {
     for (const typeAlias of typeAliases) {
-      // Buffer TYPE node
-      this._bufferNode({
-        id: typeAlias.id,
-        type: 'TYPE',
-        name: typeAlias.name,
-        file: typeAlias.file,
-        line: typeAlias.line,
-        column: typeAlias.column,
-        aliasOf: typeAlias.aliasOf
-      });
+      // Create TYPE node using factory
+      const typeNode = NodeFactory.createType(
+        typeAlias.name,
+        typeAlias.file,
+        typeAlias.line,
+        typeAlias.column || 0,
+        { aliasOf: typeAlias.aliasOf }
+      );
+      this._bufferNode(typeNode as unknown as GraphNode);
 
       // MODULE -> CONTAINS -> TYPE
       this._bufferEdge({
         type: 'CONTAINS',
         src: module.id,
-        dst: typeAlias.id
+        dst: typeNode.id
       });
     }
   }
 
   /**
    * Buffer ENUM nodes
+   * Uses EnumNode.create() to ensure consistent ID format (colon separator)
    */
   private bufferEnumNodes(module: ModuleNode, enums: EnumDeclarationInfo[]): void {
     for (const enumDecl of enums) {
-      // Buffer ENUM node
-      this._bufferNode({
-        id: enumDecl.id,
-        type: 'ENUM',
-        name: enumDecl.name,
-        file: enumDecl.file,
-        line: enumDecl.line,
-        column: enumDecl.column,
-        isConst: enumDecl.isConst,
-        members: enumDecl.members
-      });
+      // Use EnumNode.create() to generate proper ID (colon format)
+      // Do NOT use enumDecl.id which has legacy # format from TypeScriptVisitor
+      const enumNode = EnumNode.create(
+        enumDecl.name,
+        enumDecl.file,
+        enumDecl.line,
+        enumDecl.column || 0,
+        {
+          isConst: enumDecl.isConst || false,
+          members: enumDecl.members || []
+        }
+      );
+
+      this._bufferNode(enumNode as unknown as GraphNode);
 
       // MODULE -> CONTAINS -> ENUM
       this._bufferEdge({
         type: 'CONTAINS',
         src: module.id,
-        dst: enumDecl.id
+        dst: enumNode.id  // Use factory-generated ID (colon format)
       });
     }
   }
@@ -1162,23 +1189,24 @@ export class GraphBuilder {
    */
   private bufferDecoratorNodes(decorators: DecoratorInfo[]): void {
     for (const decorator of decorators) {
-      // Buffer DECORATOR node
-      this._bufferNode({
-        id: decorator.id,
-        type: 'DECORATOR',
-        name: decorator.name,
-        file: decorator.file,
-        line: decorator.line,
-        column: decorator.column,
-        arguments: decorator.arguments,
-        targetType: decorator.targetType
-      });
+      // Create DECORATOR node using factory (generates colon-format ID)
+      const decoratorNode = DecoratorNode.create(
+        decorator.name,
+        decorator.file,
+        decorator.line,
+        decorator.column || 0,
+        decorator.targetId,  // Now included in the node!
+        decorator.targetType,
+        { arguments: decorator.arguments }
+      );
+
+      this._bufferNode(decoratorNode as unknown as GraphNode);
 
       // TARGET -> DECORATED_BY -> DECORATOR
       this._bufferEdge({
         type: 'DECORATED_BY',
         src: decorator.targetId,
-        dst: decorator.id
+        dst: decoratorNode.id  // Use factory-generated ID (colon format)
       });
     }
   }
@@ -1193,26 +1221,28 @@ export class GraphBuilder {
           // Try to find the interface in the same file
           const iface = interfaces.find(i => i.name === ifaceName);
           if (iface) {
+            // Compute interface ID using same formula as InterfaceNode.create()
+            // Format: {file}:INTERFACE:{name}:{line}
+            const interfaceId = `${iface.file}:INTERFACE:${iface.name}:${iface.line}`;
             this._bufferEdge({
               type: 'IMPLEMENTS',
               src: classDecl.id,
-              dst: iface.id
+              dst: interfaceId
             });
           } else {
             // External interface - create a reference node
-            const externalId = `INTERFACE#${ifaceName}#${classDecl.file}#external`;
-            this._bufferNode({
-              id: externalId,
-              type: 'INTERFACE',
-              name: ifaceName,
-              file: classDecl.file,
-              line: classDecl.line,
-              isExternal: true
-            });
+            const externalInterface = NodeFactory.createInterface(
+              ifaceName,
+              classDecl.file,
+              classDecl.line,
+              0,
+              { isExternal: true }
+            );
+            this._bufferNode(externalInterface as unknown as GraphNode);
             this._bufferEdge({
               type: 'IMPLEMENTS',
               src: classDecl.id,
-              dst: externalId
+              dst: externalInterface.id
             });
           }
         }
@@ -1220,6 +1250,202 @@ export class GraphBuilder {
     }
   }
 
+  /**
+   * Buffer FLOWS_INTO edges for array mutations (push, unshift, splice, indexed assignment)
+   * Creates edges from inserted values to the array variable
+   *
+   * REG-117: Now handles nested mutations like obj.arr.push(item):
+   * - For nested mutations, falls back to base object if array property not found
+   * - Adds nestedProperty metadata for tracking
+   *
+   * OPTIMIZED: Uses Map-based lookup cache for O(1) variable lookups instead of O(n) find()
+   */
+  private bufferArrayMutationEdges(
+    arrayMutations: ArrayMutationInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    parameters: ParameterInfo[]
+  ): void {
+    // Build lookup cache once: O(n) instead of O(n*m) with find() per mutation
+    const varLookup = new Map<string, VariableDeclarationInfo>();
+    for (const v of variableDeclarations) {
+      varLookup.set(`${v.file}:${v.name}`, v);
+    }
+
+    // Build parameter lookup cache for function-level mutations
+    const paramLookup = new Map<string, ParameterInfo>();
+    for (const p of parameters) {
+      paramLookup.set(`${p.file}:${p.name}`, p);
+    }
+
+    for (const mutation of arrayMutations) {
+      const { arrayName, mutationMethod, insertedValues, file, isNested, baseObjectName, propertyName } = mutation;
+
+      // REG-117: For nested mutations (obj.arr.push), resolve target node
+      // First try direct lookup, then fallback to base object
+      let targetNodeId: string | null = null;
+      let nestedProperty: string | undefined;
+
+      if (isNested && baseObjectName) {
+        // Skip 'this.items.push' - 'this' is not a variable node
+        if (baseObjectName === 'this') continue;
+
+        // Nested mutation: try base object lookup
+        const baseVar = varLookup.get(`${file}:${baseObjectName}`);
+        const baseParam = !baseVar ? paramLookup.get(`${file}:${baseObjectName}`) : null;
+        targetNodeId = baseVar?.id ?? baseParam?.id ?? null;
+        nestedProperty = propertyName;
+      } else {
+        // Direct mutation: arr.push()
+        const arrayVar = varLookup.get(`${file}:${arrayName}`);
+        const arrayParam = !arrayVar ? paramLookup.get(`${file}:${arrayName}`) : null;
+        targetNodeId = arrayVar?.id ?? arrayParam?.id ?? null;
+      }
+
+      if (!targetNodeId) continue;
+
+      // Create FLOWS_INTO edges for each inserted value
+      for (const arg of insertedValues) {
+        if (arg.valueType === 'VARIABLE' && arg.valueName) {
+          // O(1) lookup instead of O(n) find
+          const sourceVar = varLookup.get(`${file}:${arg.valueName}`);
+          const sourceParam = !sourceVar ? paramLookup.get(`${file}:${arg.valueName}`) : null;
+          const sourceNodeId = sourceVar?.id ?? sourceParam?.id;
+
+          if (sourceNodeId) {
+            const edgeData: GraphEdge = {
+              type: 'FLOWS_INTO',
+              src: sourceNodeId,
+              dst: targetNodeId,
+              mutationMethod,
+              argIndex: arg.argIndex
+            };
+            if (arg.isSpread) {
+              edgeData.isSpread = true;
+            }
+            // REG-117: Add nested property metadata
+            if (nestedProperty) {
+              edgeData.nestedProperty = nestedProperty;
+            }
+            this._bufferEdge(edgeData);
+          }
+        }
+        // For literals, object literals, etc. - we could create edges from LITERAL nodes
+        // but for now we just track variable -> array flows
+      }
+    }
+  }
+
+  /**
+   * Buffer FLOWS_INTO edges for object mutations (property assignment, Object.assign)
+   * Creates edges from source values to the object variable being mutated.
+   *
+   * REG-152: For 'this.prop = value' patterns inside classes, creates edges
+   * to the CLASS node with mutationType: 'this_property'.
+   */
+  private bufferObjectMutationEdges(
+    objectMutations: ObjectMutationInfo[],
+    variableDeclarations: VariableDeclarationInfo[],
+    parameters: ParameterInfo[],
+    functions: FunctionInfo[],
+    classDeclarations: ClassDeclarationInfo[]
+  ): void {
+    for (const mutation of objectMutations) {
+      const { objectName, propertyName, mutationType, computedPropertyVar, value, file, enclosingClassName } = mutation;
+
+      // Find the target node (object variable, parameter, or class for 'this')
+      let objectNodeId: string | null = null;
+      let effectiveMutationType: 'property' | 'computed' | 'assign' | 'spread' | 'this_property' = mutationType;
+
+      if (objectName !== 'this') {
+        // Regular object - find variable or parameter
+        const objectVar = variableDeclarations.find(v => v.name === objectName && v.file === file);
+        const objectParam = !objectVar ? parameters.find(p => p.name === objectName && p.file === file) : null;
+        objectNodeId = objectVar?.id ?? objectParam?.id ?? null;
+        if (!objectNodeId) continue;
+      } else {
+        // REG-152: 'this' mutations - find the CLASS node
+        if (!enclosingClassName) continue;  // Skip if no class context (e.g., standalone function)
+
+        // Compare using basename since classes use scopeTracker.file (basename)
+        // but mutations use module.file (full path)
+        const fileBasename = basename(file);
+        const classDecl = classDeclarations.find(c => c.name === enclosingClassName && c.file === fileBasename);
+        objectNodeId = classDecl?.id ?? null;
+
+        if (!objectNodeId) continue;  // Skip if class not found
+
+        // Use special mutation type to distinguish from regular property mutations
+        effectiveMutationType = 'this_property';
+      }
+
+      // Create FLOWS_INTO edge for VARIABLE value type
+      if (value.valueType === 'VARIABLE' && value.valueName) {
+        // Find the source: can be variable, parameter, or function (arrow functions assigned to const)
+        const sourceVar = variableDeclarations.find(v => v.name === value.valueName && v.file === file);
+        const sourceParam = !sourceVar ? parameters.find(p => p.name === value.valueName && p.file === file) : null;
+        const sourceFunc = !sourceVar && !sourceParam ? functions.find(f => f.name === value.valueName && f.file === file) : null;
+        const sourceNodeId = sourceVar?.id ?? sourceParam?.id ?? sourceFunc?.id;
+
+        if (sourceNodeId && objectNodeId) {
+          const edgeData: GraphEdge = {
+            type: 'FLOWS_INTO',
+            src: sourceNodeId,
+            dst: objectNodeId,
+            mutationType: effectiveMutationType,
+            propertyName,
+            computedPropertyVar  // For enrichment phase resolution
+          };
+          if (value.argIndex !== undefined) {
+            edgeData.argIndex = value.argIndex;
+          }
+          if (value.isSpread) {
+            edgeData.isSpread = true;
+          }
+          this._bufferEdge(edgeData);
+        }
+      }
+      // For literals, object literals, etc. - we just track variable -> object flows for now
+    }
+  }
+
+  /**
+   * Buffer OBJECT_LITERAL nodes to the graph.
+   * These are object literals passed as function arguments or nested in other literals.
+   */
+  private bufferObjectLiteralNodes(objectLiterals: ObjectLiteralInfo[]): void {
+    for (const obj of objectLiterals) {
+      this._bufferNode({
+        id: obj.id,
+        type: obj.type,
+        name: '<object>',
+        file: obj.file,
+        line: obj.line,
+        column: obj.column,
+        parentCallId: obj.parentCallId,
+        argIndex: obj.argIndex
+      } as GraphNode);
+    }
+  }
+
+  /**
+   * Buffer ARRAY_LITERAL nodes to the graph.
+   * These are array literals passed as function arguments or nested in other literals.
+   */
+  private bufferArrayLiteralNodes(arrayLiterals: ArrayLiteralInfo[]): void {
+    for (const arr of arrayLiterals) {
+      this._bufferNode({
+        id: arr.id,
+        type: arr.type,
+        name: '<array>',
+        file: arr.file,
+        line: arr.line,
+        column: arr.column,
+        parentCallId: arr.parentCallId,
+        argIndex: arr.argIndex
+      } as GraphNode);
+    }
+  }
+
   /**
    * Handle CLASS ASSIGNED_FROM edges asynchronously (needs graph queries)
    */
@@ -1254,118 +1480,4 @@ export class GraphBuilder {
 
     return edgesCreated;
   }
-
-  /**
-   * Create IMPORTS_FROM edges linking imports to their target exports
-   */
-  private async createImportExportEdges(
-    module: ModuleNode,
-    imports: ImportInfo[],
-    _exports: ExportInfo[],
-    graph: GraphBackend,
-    _projectPath: string
-  ): Promise<number> {
-    let edgesCreated = 0;
-
-    for (const imp of imports) {
-      const { source, specifiers, line } = imp;
-
-      // Только для относительных импортов
-      const isRelative = source.startsWith('./') || source.startsWith('../');
-      if (!isRelative) {
-        continue;
-      }
-
-      // Резолвим целевой модуль
-      const currentDir = dirname(module.file);
-      let targetPath = resolve(currentDir, source);
-
-      // Пытаемся найти файл с расширениями .js, .ts, .jsx, .tsx
-      const extensions = ['', '.js', '.ts', '.jsx', '.tsx', '/index.js', '/index.ts'];
-      let targetModule: { id: string; file: string } | null = null;
-
-      // Ищем MODULE ноду по file атрибуту (не по ID, т.к. формат ID изменился)
-      for (const ext of extensions) {
-        const testPath = targetPath + ext;
-
-        // Ищем MODULE с этим file path
-        for await (const node of graph.queryNodes({ type: 'MODULE' })) {
-          if (node.file === testPath) {
-            targetModule = node as { id: string; file: string };
-            targetPath = testPath;
-            break;
-          }
-        }
-        if (targetModule) break;
-      }
-
-      if (!targetModule) {
-        // Целевой модуль не найден в графе
-        continue;
-      }
-
-      // Создаём IMPORTS edge от MODULE к MODULE (для совместимости с тестами)
-      await graph.addEdge({
-        type: 'IMPORTS',
-        src: module.id,
-        dst: targetModule.id
-      });
-      edgesCreated++;
-
-      // Для каждого импортированного идентификатора создаём ребро к соответствующему EXPORT
-      for (const spec of specifiers) {
-        const importId = `${module.file}:IMPORT:${source}:${spec.local}:${line}`;
-        const importType = spec.imported === 'default' ? 'default' :
-                          spec.imported === '*' ? 'namespace' : 'named';
-
-        if (importType === 'namespace') {
-          // import * as foo - связываем со всем модулем
-          await graph.addEdge({
-            type: 'IMPORTS_FROM',
-            src: importId,
-            dst: targetModule.id
-          });
-          edgesCreated++;
-        } else if (importType === 'default') {
-          // Находим EXPORT default в целевом модуле
-          const targetExports: { id: string }[] = [];
-          for await (const node of graph.queryNodes({ type: 'EXPORT' })) {
-            const exportNode = node as { id: string; file?: string; exportType?: string };
-            if (exportNode.file === targetPath && exportNode.exportType === 'default') {
-              targetExports.push(exportNode);
-            }
-          }
-
-          if (targetExports.length > 0) {
-            await graph.addEdge({
-              type: 'IMPORTS_FROM',
-              src: importId,
-              dst: targetExports[0].id
-            });
-            edgesCreated++;
-          }
-        } else {
-          // Named import - находим соответствующий named export
-          const targetExports: { id: string }[] = [];
-          for await (const node of graph.queryNodes({ type: 'EXPORT' })) {
-            const exportNode = node as { id: string; file?: string; exportType?: string; name?: string };
-            if (exportNode.file === targetPath && exportNode.exportType === 'named' && exportNode.name === spec.imported) {
-              targetExports.push(exportNode);
-            }
-          }
-
-          if (targetExports.length > 0) {
-            await graph.addEdge({
-              type: 'IMPORTS_FROM',
-              src: importId,
-              dst: targetExports[0].id
-            });
-            edgesCreated++;
-          }
-        }
-      }
-    }
-
-    return edgesCreated;
-  }
 }