@grafema/core 0.1.0-alpha.1

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

@@ -0,0 +1,1077 @@
+/**
+ * GraphBuilder - создание узлов и рёбер графа из собранных AST данных
+ * OPTIMIZED: Uses batched writes to reduce FFI overhead
+ */
+import { dirname, resolve } from 'path';
+export class GraphBuilder {
+    // Track singleton nodes to avoid duplicates (net:stdio, net:request, etc.)
+    _createdSingletons = new Set();
+    // Batching buffers for optimized writes
+    _nodeBuffer = [];
+    _edgeBuffer = [];
+    /**
+     * Buffer a node for batched writing
+     */
+    _bufferNode(node) {
+        this._nodeBuffer.push(node);
+    }
+    /**
+     * Buffer an edge for batched writing
+     */
+    _bufferEdge(edge) {
+        this._edgeBuffer.push(edge);
+    }
+    /**
+     * Flush all buffered nodes to the graph
+     */
+    async _flushNodes(graph) {
+        if (this._nodeBuffer.length > 0) {
+            // Cast to unknown first since GraphNode is more permissive than NodeRecord
+            await graph.addNodes(this._nodeBuffer);
+            const count = this._nodeBuffer.length;
+            this._nodeBuffer = [];
+            return count;
+        }
+        return 0;
+    }
+    /**
+     * Flush all buffered edges to the graph
+     * Note: skip_validation=true because nodes were just flushed
+     */
+    async _flushEdges(graph) {
+        if (this._edgeBuffer.length > 0) {
+            await graph.addEdges(this._edgeBuffer, true /* skip_validation */);
+            const count = this._edgeBuffer.length;
+            this._edgeBuffer = [];
+            return count;
+        }
+        return 0;
+    }
+    /**
+     * Создаёт ноды и рёбра в графе (BATCHED VERSION)
+     */
+    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;
+        // Reset buffers for this build
+        this._nodeBuffer = [];
+        this._edgeBuffer = [];
+        // 1. Buffer all functions (without edges)
+        for (const func of functions) {
+            const { parentScopeId, ...funcData } = func;
+            this._bufferNode(funcData);
+        }
+        // 2. Buffer all SCOPE (without edges)
+        for (const scope of scopes) {
+            const { parentFunctionId, parentScopeId, capturesFrom, modifies, ...scopeData } = scope;
+            this._bufferNode(scopeData);
+        }
+        // 3. Buffer variables
+        for (const varDecl of variableDeclarations) {
+            const { parentScopeId, ...varData } = varDecl;
+            this._bufferNode(varData);
+        }
+        // 3.5. Buffer PARAMETER nodes and HAS_PARAMETER edges
+        for (const param of parameters) {
+            const { functionId, ...paramData } = param;
+            // Keep parentFunctionId on the node for queries
+            this._bufferNode(paramData);
+            if (param.parentFunctionId) {
+                this._bufferEdge({
+                    type: 'HAS_PARAMETER',
+                    src: param.parentFunctionId,
+                    dst: param.id,
+                    index: param.index
+                });
+            }
+        }
+        // 4. Buffer CALL_SITE
+        for (const callSite of callSites) {
+            const { parentScopeId, targetFunctionName, ...callData } = callSite;
+            this._bufferNode(callData);
+        }
+        // 5. Buffer edges for functions
+        this.bufferFunctionEdges(module, functions);
+        // 6. Buffer edges for SCOPE
+        this.bufferScopeEdges(scopes, variableDeclarations);
+        // 7. Buffer edges for variables
+        this.bufferVariableEdges(variableDeclarations);
+        // 8. Buffer edges for CALL_SITE
+        this.bufferCallSiteEdges(callSites, functions);
+        // 9. Buffer METHOD_CALL nodes and CONTAINS edges
+        this.bufferMethodCalls(methodCalls);
+        // 10. Buffer net:stdio and WRITES_TO edges for console.log/error
+        this.bufferStdioNodes(methodCalls);
+        // 11. Buffer CLASS nodes for class declarations and CONTAINS edges
+        this.bufferClassDeclarationNodes(classDeclarations);
+        // 12. Buffer CLASS nodes and INSTANCE_OF edges for NewExpression
+        this.bufferClassNodes(module, classInstantiations, classDeclarations);
+        // 13. Buffer PASSES_ARGUMENT edges (METHOD_CALL -> FUNCTION)
+        this.bufferCallbackEdges(methodCallbacks, functions);
+        // 14. Buffer IMPORT nodes
+        this.bufferImportNodes(module, imports);
+        // 15. Buffer EXPORT nodes
+        this.bufferExportNodes(module, exports);
+        // 16. Buffer EVENT_LISTENER nodes and HANDLED_BY edges
+        this.bufferEventListeners(eventListeners, functions);
+        // 17. Buffer HTTP requests
+        this.bufferHttpRequests(httpRequests, functions);
+        // 18. Buffer LITERAL nodes
+        this.bufferLiterals(literals);
+        // 19. Buffer ASSIGNED_FROM edges for data flow (some need to create EXPRESSION nodes)
+        this.bufferAssignmentEdges(variableAssignments, variableDeclarations, callSites, methodCalls, functions, classInstantiations, parameters);
+        // 20. Buffer PASSES_ARGUMENT edges (CALL -> argument)
+        this.bufferArgumentEdges(callArguments, variableDeclarations, functions, callSites, methodCalls);
+        // 21. Buffer INTERFACE nodes and EXTENDS edges
+        this.bufferInterfaceNodes(module, interfaces);
+        // 22. Buffer TYPE nodes
+        this.bufferTypeAliasNodes(module, typeAliases);
+        // 23. Buffer ENUM nodes
+        this.bufferEnumNodes(module, enums);
+        // 24. Buffer DECORATOR nodes and DECORATED_BY edges
+        this.bufferDecoratorNodes(decorators);
+        // 25. Buffer IMPLEMENTS edges (CLASS -> INTERFACE)
+        this.bufferImplementsEdges(classDeclarations, interfaces);
+        // 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 };
+    }
+    // ============= BUFFERED METHODS (synchronous, no awaits) =============
+    bufferFunctionEdges(module, functions) {
+        for (const func of functions) {
+            const { parentScopeId, ...funcData } = func;
+            // MODULE -> CONTAINS -> FUNCTION (для функций верхнего уровня)
+            // или SCOPE -> CONTAINS -> FUNCTION (для вложенных функций)
+            if (parentScopeId) {
+                this._bufferEdge({
+                    type: 'CONTAINS',
+                    src: parentScopeId,
+                    dst: funcData.id
+                });
+            }
+            else {
+                this._bufferEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: funcData.id
+                });
+            }
+        }
+    }
+    bufferScopeEdges(scopes, variableDeclarations) {
+        for (const scope of scopes) {
+            const { parentFunctionId, parentScopeId, capturesFrom, modifies, ...scopeData } = scope;
+            // FUNCTION -> HAS_SCOPE -> SCOPE (для function_body)
+            if (parentFunctionId) {
+                this._bufferEdge({
+                    type: 'HAS_SCOPE',
+                    src: parentFunctionId,
+                    dst: scopeData.id
+                });
+            }
+            // SCOPE -> CONTAINS -> SCOPE (для вложенных scope, типа if внутри function)
+            if (parentScopeId) {
+                this._bufferEdge({
+                    type: 'CONTAINS',
+                    src: parentScopeId,
+                    dst: scopeData.id
+                });
+            }
+            // CAPTURES - замыкания захватывают переменные из родительского scope
+            if (capturesFrom && scopeData.scopeType === 'closure') {
+                const parentVars = variableDeclarations.filter(v => v.parentScopeId === capturesFrom);
+                for (const parentVar of parentVars) {
+                    this._bufferEdge({
+                        type: 'CAPTURES',
+                        src: scopeData.id,
+                        dst: parentVar.id
+                    });
+                }
+            }
+            // MODIFIES - scope модифицирует переменные (count++)
+            if (modifies && modifies.length > 0) {
+                for (const mod of modifies) {
+                    this._bufferEdge({
+                        type: 'MODIFIES',
+                        src: scopeData.id,
+                        dst: mod.variableId
+                    });
+                }
+            }
+        }
+    }
+    bufferVariableEdges(variableDeclarations) {
+        for (const varDecl of variableDeclarations) {
+            const { parentScopeId, ...varData } = varDecl;
+            // SCOPE -> DECLARES -> VARIABLE
+            this._bufferEdge({
+                type: 'DECLARES',
+                src: parentScopeId,
+                dst: varData.id
+            });
+        }
+    }
+    bufferCallSiteEdges(callSites, functions) {
+        for (const callSite of callSites) {
+            const { parentScopeId, targetFunctionName, ...callData } = callSite;
+            // SCOPE -> CONTAINS -> CALL_SITE
+            this._bufferEdge({
+                type: 'CONTAINS',
+                src: parentScopeId,
+                dst: callData.id
+            });
+            // CALL_SITE -> CALLS -> FUNCTION
+            const targetFunction = functions.find(f => f.name === targetFunctionName);
+            if (targetFunction) {
+                this._bufferEdge({
+                    type: 'CALLS',
+                    src: callData.id,
+                    dst: targetFunction.id
+                });
+            }
+        }
+    }
+    bufferMethodCalls(methodCalls) {
+        for (const methodCall of methodCalls) {
+            const { parentScopeId, ...methodData } = methodCall;
+            // Buffer METHOD_CALL node
+            this._bufferNode(methodData);
+            // SCOPE -> CONTAINS -> METHOD_CALL
+            this._bufferEdge({
+                type: 'CONTAINS',
+                src: parentScopeId,
+                dst: methodData.id
+            });
+        }
+    }
+    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__';
+            // 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);
+            }
+            // Buffer WRITES_TO edges for console.log/error
+            for (const methodCall of consoleIOMethods) {
+                this._bufferEdge({
+                    type: 'WRITES_TO',
+                    src: methodCall.id,
+                    dst: stdioId
+                });
+            }
+        }
+    }
+    bufferClassDeclarationNodes(classDeclarations) {
+        for (const classDecl of classDeclarations) {
+            const { id, type, name, file, line, column, superClass, methods } = classDecl;
+            // Buffer CLASS node
+            this._bufferNode({
+                id,
+                type,
+                name,
+                file,
+                line,
+                column,
+                superClass
+            });
+            // Buffer CONTAINS edges: CLASS -> METHOD
+            for (const methodId of methods) {
+                this._bufferEdge({
+                    type: 'CONTAINS',
+                    src: id,
+                    dst: methodId
+                });
+            }
+            // If superClass, buffer DERIVES_FROM edge
+            if (superClass) {
+                const superClassId = `CLASS#${superClass}#${file}`;
+                this._bufferEdge({
+                    type: 'DERIVES_FROM',
+                    src: id,
+                    dst: superClassId
+                });
+            }
+        }
+    }
+    bufferClassNodes(module, classInstantiations, classDeclarations) {
+        // Create lookup map: className → declaration ID
+        const declarationMap = new Map();
+        for (const decl of classDeclarations) {
+            if (decl.file === module.file) {
+                declarationMap.set(decl.name, decl.id);
+            }
+        }
+        for (const instantiation of classInstantiations) {
+            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
+                });
+            }
+            // Buffer INSTANCE_OF edge
+            this._bufferEdge({
+                type: 'INSTANCE_OF',
+                src: variableId,
+                dst: classId
+            });
+        }
+    }
+    bufferCallbackEdges(methodCallbacks, functions) {
+        for (const callback of methodCallbacks) {
+            const { methodCallId, callbackLine, callbackColumn } = callback;
+            const callbackFunction = functions.find(f => f.line === callbackLine && f.column === callbackColumn);
+            if (callbackFunction) {
+                this._bufferEdge({
+                    type: 'HAS_CALLBACK',
+                    src: methodCallId,
+                    dst: callbackFunction.id
+                });
+            }
+        }
+    }
+    bufferImportNodes(module, imports) {
+        for (const imp of imports) {
+            const { source, specifiers, line } = 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
+                });
+                // MODULE -> CONTAINS -> IMPORT
+                this._bufferEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: importId
+                });
+                // 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
+                    });
+                    this._bufferEdge({
+                        type: 'IMPORTS',
+                        src: module.id,
+                        dst: externalModuleId
+                    });
+                }
+            }
+        }
+    }
+    bufferExportNodes(module, exports) {
+        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
+                });
+                this._bufferEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: exportId
+                });
+            }
+            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
+                        });
+                        this._bufferEdge({
+                            type: 'CONTAINS',
+                            src: module.id,
+                            dst: exportId
+                        });
+                    }
+                }
+                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
+                    });
+                    this._bufferEdge({
+                        type: 'CONTAINS',
+                        src: module.id,
+                        dst: exportId
+                    });
+                }
+            }
+            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
+                });
+                this._bufferEdge({
+                    type: 'CONTAINS',
+                    src: module.id,
+                    dst: exportId
+                });
+            }
+        }
+    }
+    bufferEventListeners(eventListeners, functions) {
+        for (const eventListener of eventListeners) {
+            const { parentScopeId, callbackArg, ...listenerData } = eventListener;
+            this._bufferNode(listenerData);
+            this._bufferEdge({
+                type: 'CONTAINS',
+                src: parentScopeId,
+                dst: listenerData.id
+            });
+            if (callbackArg && callbackArg.type === 'ArrowFunctionExpression') {
+                const callbackLine = callbackArg.loc.start.line;
+                const callbackFunction = functions.find(f => f.line === callbackLine && f.arrowFunction);
+                if (callbackFunction) {
+                    this._bufferEdge({
+                        type: 'HANDLED_BY',
+                        src: listenerData.id,
+                        dst: callbackFunction.id
+                    });
+                }
+            }
+        }
+    }
+    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);
+            }
+            for (const request of httpRequests) {
+                const { parentScopeId, ...requestData } = request;
+                this._bufferNode(requestData);
+                this._bufferEdge({
+                    type: 'CALLS',
+                    src: request.id,
+                    dst: networkId
+                });
+                if (parentScopeId) {
+                    const scopeParts = parentScopeId.split(':');
+                    if (scopeParts.length >= 3 && scopeParts[1] === 'SCOPE') {
+                        const functionName = scopeParts[2];
+                        const file = scopeParts[0];
+                        const parentFunction = functions.find(f => f.file === file && f.name === functionName);
+                        if (parentFunction) {
+                            this._bufferEdge({
+                                type: 'MAKES_REQUEST',
+                                src: parentFunction.id,
+                                dst: request.id
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    bufferLiterals(literals) {
+        for (const literal of literals) {
+            const { parentCallId, argIndex, ...literalData } = literal;
+            this._bufferNode(literalData);
+        }
+    }
+    bufferAssignmentEdges(variableAssignments, variableDeclarations, callSites, methodCalls, functions, classInstantiations, parameters) {
+        for (const assignment of variableAssignments) {
+            const { variableId, sourceId, sourceType, sourceName, sourceLine, sourceColumn, sourceFile, functionName, line, className } = assignment;
+            // Skip CLASS sourceType - handled async in createClassAssignmentEdges
+            if (sourceType === 'CLASS') {
+                continue;
+            }
+            // Direct LITERAL assignment
+            if (sourceId && sourceType !== 'EXPRESSION') {
+                this._bufferEdge({
+                    type: 'ASSIGNED_FROM',
+                    src: variableId,
+                    dst: sourceId
+                });
+            }
+            // METHOD_CALL by coordinates
+            else if (sourceType === 'METHOD_CALL' && sourceLine && sourceColumn) {
+                const methodCall = methodCalls.find(mc => mc.line === sourceLine &&
+                    mc.column === sourceColumn &&
+                    mc.file === sourceFile);
+                if (methodCall) {
+                    this._bufferEdge({
+                        type: 'ASSIGNED_FROM',
+                        src: variableId,
+                        dst: methodCall.id
+                    });
+                }
+            }
+            // CALL_SITE by coordinates
+            else if (sourceType === 'CALL_SITE') {
+                const searchLine = sourceLine || assignment.callLine;
+                const searchColumn = sourceColumn || assignment.callColumn;
+                const searchName = assignment.callName;
+                if (searchLine && searchColumn) {
+                    const callSite = callSites.find(cs => cs.line === searchLine &&
+                        cs.column === searchColumn &&
+                        (searchName ? cs.name === searchName : true));
+                    if (callSite) {
+                        this._bufferEdge({
+                            type: 'ASSIGNED_FROM',
+                            src: variableId,
+                            dst: callSite.id
+                        });
+                    }
+                }
+            }
+            // VARIABLE by name
+            else if (sourceType === 'VARIABLE' && sourceName) {
+                const varIdParts = variableId.split('#');
+                const varFile = varIdParts.length >= 3 ? varIdParts[2] : null;
+                const sourceVariable = variableDeclarations.find(v => v.name === sourceName && v.file === varFile);
+                if (sourceVariable) {
+                    this._bufferEdge({
+                        type: 'ASSIGNED_FROM',
+                        src: variableId,
+                        dst: sourceVariable.id
+                    });
+                }
+                else {
+                    const sourceParam = parameters.find(p => p.name === sourceName && p.file === varFile);
+                    if (sourceParam) {
+                        this._bufferEdge({
+                            type: 'DERIVES_FROM',
+                            src: variableId,
+                            dst: sourceParam.id
+                        });
+                    }
+                }
+            }
+            // FUNCTION (arrow function assigned to variable)
+            else if (sourceType === 'FUNCTION' && functionName && line) {
+                const sourceFunction = functions.find(f => f.name === functionName && f.line === line);
+                if (sourceFunction) {
+                    this._bufferEdge({
+                        type: 'ASSIGNED_FROM',
+                        src: variableId,
+                        dst: sourceFunction.id
+                    });
+                }
+            }
+            // EXPRESSION node creation
+            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>';
+                }
+                this._bufferNode(expressionNode);
+                this._bufferEdge({
+                    type: 'ASSIGNED_FROM',
+                    src: variableId,
+                    dst: sourceId
+                });
+                // Buffer DERIVES_FROM edges
+                const varParts = variableId.split('#');
+                const varFile = varParts.length >= 3 ? varParts[2] : null;
+                if (expressionType === 'MemberExpression' && objectSourceName) {
+                    const objectVar = variableDeclarations.find(v => v.name === objectSourceName && (!varFile || v.file === varFile));
+                    if (objectVar) {
+                        this._bufferEdge({
+                            type: 'DERIVES_FROM',
+                            src: sourceId,
+                            dst: objectVar.id
+                        });
+                    }
+                }
+                if ((expressionType === 'BinaryExpression' || expressionType === 'LogicalExpression')) {
+                    if (leftSourceName) {
+                        const leftVar = variableDeclarations.find(v => v.name === leftSourceName && (!varFile || v.file === varFile));
+                        if (leftVar) {
+                            this._bufferEdge({
+                                type: 'DERIVES_FROM',
+                                src: sourceId,
+                                dst: leftVar.id
+                            });
+                        }
+                    }
+                    if (rightSourceName) {
+                        const rightVar = variableDeclarations.find(v => v.name === rightSourceName && (!varFile || v.file === varFile));
+                        if (rightVar) {
+                            this._bufferEdge({
+                                type: 'DERIVES_FROM',
+                                src: sourceId,
+                                dst: rightVar.id
+                            });
+                        }
+                    }
+                }
+                if (expressionType === 'ConditionalExpression') {
+                    if (consequentSourceName) {
+                        const consequentVar = variableDeclarations.find(v => v.name === consequentSourceName && (!varFile || v.file === varFile));
+                        if (consequentVar) {
+                            this._bufferEdge({
+                                type: 'DERIVES_FROM',
+                                src: sourceId,
+                                dst: consequentVar.id
+                            });
+                        }
+                    }
+                    if (alternateSourceName) {
+                        const alternateVar = variableDeclarations.find(v => v.name === alternateSourceName && (!varFile || v.file === varFile));
+                        if (alternateVar) {
+                            this._bufferEdge({
+                                type: 'DERIVES_FROM',
+                                src: sourceId,
+                                dst: alternateVar.id
+                            });
+                        }
+                    }
+                }
+                if (expressionType === 'TemplateLiteral') {
+                    const { expressionSourceNames } = assignment;
+                    if (expressionSourceNames && expressionSourceNames.length > 0) {
+                        for (const exprSourceName of expressionSourceNames) {
+                            const sourceVar = variableDeclarations.find(v => v.name === exprSourceName && (!varFile || v.file === varFile));
+                            if (sourceVar) {
+                                this._bufferEdge({
+                                    type: 'DERIVES_FROM',
+                                    src: sourceId,
+                                    dst: sourceVar.id
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+            // DERIVES_FROM_VARIABLE
+            else if (sourceType === 'DERIVES_FROM_VARIABLE' && sourceName) {
+                const expressionId = variableId;
+                const exprParts = expressionId.split('#');
+                const exprFile = exprParts.length >= 3 ? exprParts[2] : assignment.file;
+                const sourceVariable = variableDeclarations.find(v => v.name === sourceName && v.file === exprFile);
+                if (sourceVariable) {
+                    this._bufferEdge({
+                        type: 'DERIVES_FROM',
+                        src: expressionId,
+                        dst: sourceVariable.id
+                    });
+                }
+                else {
+                    const sourceParam = parameters.find(p => p.name === sourceName && p.file === exprFile);
+                    if (sourceParam) {
+                        this._bufferEdge({
+                            type: 'DERIVES_FROM',
+                            src: expressionId,
+                            dst: sourceParam.id
+                        });
+                    }
+                }
+            }
+        }
+    }
+    bufferArgumentEdges(callArguments, variableDeclarations, functions, callSites, methodCalls) {
+        for (const arg of callArguments) {
+            const { callId, argIndex, targetType, targetId, targetName, file, isSpread, functionLine, functionColumn, nestedCallLine, nestedCallColumn } = arg;
+            let targetNodeId = targetId;
+            if (targetType === 'VARIABLE' && targetName) {
+                const varNode = variableDeclarations.find(v => v.name === targetName && v.file === file);
+                if (varNode) {
+                    targetNodeId = varNode.id;
+                }
+            }
+            else if (targetType === 'FUNCTION' && functionLine && functionColumn) {
+                const funcNode = functions.find(f => f.file === file && f.line === functionLine && f.column === functionColumn);
+                if (funcNode) {
+                    targetNodeId = funcNode.id;
+                }
+            }
+            else if (targetType === 'CALL' && nestedCallLine && nestedCallColumn) {
+                const nestedCall = callSites.find(c => c.file === file && c.line === nestedCallLine && c.column === nestedCallColumn) || methodCalls.find(c => c.file === file && c.line === nestedCallLine && c.column === nestedCallColumn);
+                if (nestedCall) {
+                    targetNodeId = nestedCall.id;
+                }
+            }
+            if (targetNodeId) {
+                const edgeData = {
+                    type: 'PASSES_ARGUMENT',
+                    src: callId,
+                    dst: targetNodeId,
+                    metadata: { argIndex }
+                };
+                if (isSpread) {
+                    edgeData.metadata = { ...edgeData.metadata, isSpread: true };
+                }
+                this._bufferEdge(edgeData);
+            }
+        }
+    }
+    // ============= TypeScript-specific buffer methods =============
+    /**
+     * Buffer INTERFACE nodes and EXTENDS edges
+     */
+    bufferInterfaceNodes(module, interfaces) {
+        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
+            });
+            // MODULE -> CONTAINS -> INTERFACE
+            this._bufferEdge({
+                type: 'CONTAINS',
+                src: module.id,
+                dst: iface.id
+            });
+            // INTERFACE -> EXTENDS -> INTERFACE (for each parent interface)
+            if (iface.extends && iface.extends.length > 0) {
+                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) {
+                        this._bufferEdge({
+                            type: 'EXTENDS',
+                            src: iface.id,
+                            dst: parentInterface.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
+                        });
+                        this._bufferEdge({
+                            type: 'EXTENDS',
+                            src: iface.id,
+                            dst: externalId
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Buffer TYPE alias nodes
+     */
+    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
+            });
+            // MODULE -> CONTAINS -> TYPE
+            this._bufferEdge({
+                type: 'CONTAINS',
+                src: module.id,
+                dst: typeAlias.id
+            });
+        }
+    }
+    /**
+     * Buffer ENUM nodes
+     */
+    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
+            });
+            // MODULE -> CONTAINS -> ENUM
+            this._bufferEdge({
+                type: 'CONTAINS',
+                src: module.id,
+                dst: enumDecl.id
+            });
+        }
+    }
+    /**
+     * Buffer DECORATOR nodes and DECORATED_BY edges
+     */
+    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
+            });
+            // TARGET -> DECORATED_BY -> DECORATOR
+            this._bufferEdge({
+                type: 'DECORATED_BY',
+                src: decorator.targetId,
+                dst: decorator.id
+            });
+        }
+    }
+    /**
+     * Buffer IMPLEMENTS edges (CLASS -> INTERFACE)
+     */
+    bufferImplementsEdges(classDeclarations, interfaces) {
+        for (const classDecl of classDeclarations) {
+            if (classDecl.implements && classDecl.implements.length > 0) {
+                for (const ifaceName of classDecl.implements) {
+                    // Try to find the interface in the same file
+                    const iface = interfaces.find(i => i.name === ifaceName);
+                    if (iface) {
+                        this._bufferEdge({
+                            type: 'IMPLEMENTS',
+                            src: classDecl.id,
+                            dst: iface.id
+                        });
+                    }
+                    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
+                        });
+                        this._bufferEdge({
+                            type: 'IMPLEMENTS',
+                            src: classDecl.id,
+                            dst: externalId
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Handle CLASS ASSIGNED_FROM edges asynchronously (needs graph queries)
+     */
+    async createClassAssignmentEdges(variableAssignments, graph) {
+        let edgesCreated = 0;
+        for (const assignment of variableAssignments) {
+            const { variableId, sourceType, className } = assignment;
+            if (sourceType === 'CLASS' && className) {
+                const parts = variableId.split('#');
+                const file = parts.length >= 3 ? parts[2] : null;
+                let classNode = null;
+                for await (const node of graph.queryNodes({ type: 'CLASS' })) {
+                    if (node.name === className && (!file || node.file === file)) {
+                        classNode = node;
+                        break;
+                    }
+                }
+                if (classNode) {
+                    await graph.addEdge({
+                        type: 'ASSIGNED_FROM',
+                        src: variableId,
+                        dst: classNode.id
+                    });
+                    edgesCreated++;
+                }
+            }
+        }
+        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;
+    }
+}