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

package/dist/plugins/analysis/ast/GraphBuilder.js

@@ -2,7 +2,13 @@
  * GraphBuilder - создание узлов и рёбер графа из собранных AST данных
  * OPTIMIZED: Uses batched writes to reduce FFI overhead
  */
-import { dirname, resolve } from 'path';
+import { basename } from 'path';
+import { ImportNode } from '../../../core/nodes/ImportNode.js';
+import { InterfaceNode } from '../../../core/nodes/InterfaceNode.js';
+import { EnumNode } 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';
 export class GraphBuilder {
     // Track singleton nodes to avoid duplicates (net:stdio, net:request, etc.)
     _createdSingletons = new Set();
@@ -53,7 +59,13 @@ export class GraphBuilder {
     async build(module, graph, projectPath, data) {
         const { functions, parameters = [], scopes, variableDeclarations, callSites, methodCalls = [], eventListeners = [], classInstantiations = [], classDeclarations = [], methodCallbacks = [], callArguments = [], imports = [], exports = [], httpRequests = [], literals = [], variableAssignments = [], 
         // TypeScript-specific collections
-        interfaces = [], typeAliases = [], enums = [], decorators = [] } = data;
+        interfaces = [], typeAliases = [], enums = [], 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
         this._nodeBuffer = [];
         this._edgeBuffer = [];
@@ -133,14 +145,21 @@ export class GraphBuilder {
         this.bufferDecoratorNodes(decorators);
         // 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) =============
     bufferFunctionEdges(module, functions) {
@@ -253,23 +272,18 @@ export class GraphBuilder {
     bufferStdioNodes(methodCalls) {
         const consoleIOMethods = methodCalls.filter(mc => (mc.object === 'console' && (mc.method === 'log' || mc.method === 'error')));
         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);
+                this._createdSingletons.add(stdioNode.id);
             }
             // Buffer WRITES_TO edges for console.log/error
             for (const methodCall of consoleIOMethods) {
                 this._bufferEdge({
                     type: 'WRITES_TO',
                     src: methodCall.id,
-                    dst: stdioId
+                    dst: stdioNode.id
                 });
             }
         }
@@ -295,9 +309,12 @@ export class GraphBuilder {
                     dst: methodId
                 });
             }
-            // 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,
@@ -318,16 +335,11 @@ export class GraphBuilder {
             const { variableId, className, line } = instantiation;
             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
             this._bufferEdge({
@@ -352,42 +364,39 @@ export class GraphBuilder {
     }
     bufferImportNodes(module, imports) {
         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,
+                // 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,
-                    file: module.file,
-                    line: line
+                    local: spec.local
+                    // importType is auto-detected from imported field
                 });
+                this._bufferNode(importNode);
                 // 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);
+                        this._createdSingletons.add(externalModule.id);
+                    }
                     this._bufferEdge({
                         type: 'IMPORTS',
                         src: module.id,
-                        dst: externalModuleId
+                        dst: externalModule.id
                     });
                 }
             }
@@ -397,74 +406,50 @@ export class GraphBuilder {
         for (const exp of exports) {
             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);
                 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,
+                        const exportNode = NodeFactory.createExport(spec.exported, module.file, line, 0, {
                             local: spec.local,
-                            file: module.file,
-                            line: line,
-                            source: source
+                            source: source,
+                            exportType: 'named'
                         });
+                        this._bufferNode(exportNode);
                         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);
                     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);
                 this._bufferEdge({
                     type: 'CONTAINS',
                     src: module.id,
-                    dst: exportId
+                    dst: exportNode.id
                 });
             }
         }
@@ -493,14 +478,11 @@ export class GraphBuilder {
     }
     bufferHttpRequests(httpRequests, functions) {
         if (httpRequests.length > 0) {
-            const networkId = 'net:request#__network__';
-            if (!this._createdSingletons.has(networkId)) {
-                this._bufferNode({
-                    id: networkId,
-                    type: 'net:request',
-                    name: '__network__'
-                });
-                this._createdSingletons.add(networkId);
+            // Create net:request singleton using factory
+            const networkNode = NetworkRequestNode.create();
+            if (!this._createdSingletons.has(networkNode.id)) {
+                this._bufferNode(networkNode);
+                this._createdSingletons.add(networkNode.id);
             }
             for (const request of httpRequests) {
                 const { parentScopeId, ...requestData } = request;
@@ -508,7 +490,7 @@ export class GraphBuilder {
                 this._bufferEdge({
                     type: 'CALLS',
                     src: request.id,
-                    dst: networkId
+                    dst: networkNode.id
                 });
                 if (parentScopeId) {
                     const scopeParts = parentScopeId.split(':');
@@ -582,8 +564,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);
                 if (sourceVariable) {
                     this._bufferEdge({
@@ -614,35 +598,18 @@ export class GraphBuilder {
                     });
                 }
             }
-            // EXPRESSION node creation
+            // EXPRESSION node creation using NodeFactory
             else if (sourceType === 'EXPRESSION' && sourceId) {
-                const { expressionType, object, property, computed, computedPropertyVar, operator, objectSourceName, leftSourceName, rightSourceName, consequentSourceName, alternateSourceName, file: exprFile, line: exprLine } = assignment;
-                const expressionNode = {
-                    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;
-                    }
-                    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>';
-                }
+                const { expressionType, object, property, computed, computedPropertyVar, operator, objectSourceName, leftSourceName, rightSourceName, consequentSourceName, alternateSourceName, file: exprFile, line: exprLine, column: exprColumn } = assignment;
+                // 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
+                });
                 this._bufferNode(expressionNode);
                 this._bufferEdge({
                     type: 'ASSIGNED_FROM',
@@ -787,53 +754,50 @@ export class GraphBuilder {
     // ============= TypeScript-specific buffer methods =============
     /**
      * 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
      */
     bufferInterfaceNodes(module, interfaces) {
+        // First pass: create all interface nodes and store them
+        const interfaceNodes = new Map();
         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);
             // 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);
                         this._bufferEdge({
                             type: 'EXTENDS',
-                            src: iface.id,
-                            dst: externalId
+                            src: srcNode.id,
+                            dst: externalInterface.id
                         });
                     }
                 }
@@ -845,45 +809,35 @@ export class GraphBuilder {
      */
     bufferTypeAliasNodes(module, typeAliases) {
         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);
             // 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)
      */
     bufferEnumNodes(module, enums) {
         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);
             // MODULE -> CONTAINS -> ENUM
             this._bufferEdge({
                 type: 'CONTAINS',
                 src: module.id,
-                dst: enumDecl.id
+                dst: enumNode.id // Use factory-generated ID (colon format)
             });
         }
     }
@@ -892,22 +846,15 @@ export class GraphBuilder {
      */
     bufferDecoratorNodes(decorators) {
         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);
             // TARGET -> DECORATED_BY -> DECORATOR
             this._bufferEdge({
                 type: 'DECORATED_BY',
                 src: decorator.targetId,
-                dst: decorator.id
+                dst: decoratorNode.id // Use factory-generated ID (colon format)
             });
         }
     }
@@ -921,33 +868,203 @@ 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);
                         this._bufferEdge({
                             type: 'IMPLEMENTS',
                             src: classDecl.id,
-                            dst: externalId
+                            dst: externalInterface.id
                         });
                     }
                 }
             }
         }
     }
+    /**
+     * 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()
+     */
+    bufferArrayMutationEdges(arrayMutations, variableDeclarations, parameters) {
+        // Build lookup cache once: O(n) instead of O(n*m) with find() per mutation
+        const varLookup = new Map();
+        for (const v of variableDeclarations) {
+            varLookup.set(`${v.file}:${v.name}`, v);
+        }
+        // Build parameter lookup cache for function-level mutations
+        const paramLookup = new Map();
+        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 = null;
+            let nestedProperty;
+            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 = {
+                            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'.
+     */
+    bufferObjectMutationEdges(objectMutations, variableDeclarations, parameters, functions, classDeclarations) {
+        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 = null;
+            let effectiveMutationType = 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 = {
+                        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.
+     */
+    bufferObjectLiteralNodes(objectLiterals) {
+        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
+            });
+        }
+    }
+    /**
+     * Buffer ARRAY_LITERAL nodes to the graph.
+     * These are array literals passed as function arguments or nested in other literals.
+     */
+    bufferArrayLiteralNodes(arrayLiterals) {
+        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
+            });
+        }
+    }
     /**
      * Handle CLASS ASSIGNED_FROM edges asynchronously (needs graph queries)
      */
@@ -977,101 +1094,4 @@ export class GraphBuilder {
         }
         return edgesCreated;
     }
-    /**
-     * Create IMPORTS_FROM edges linking imports to their target exports
-     */
-    async createImportExportEdges(module, imports, _exports, graph, _projectPath) {
-        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 = 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;
-                        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 = [];
-                    for await (const node of graph.queryNodes({ type: 'EXPORT' })) {
-                        const exportNode = node;
-                        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 = [];
-                    for await (const node of graph.queryNodes({ type: 'EXPORT' })) {
-                        const exportNode = node;
-                        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;
-    }
 }