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

package/dist/plugins/analysis/JSASTAnalyzer.js

@@ -4,6 +4,7 @@
  */
 import { readFileSync } from 'fs';
 import { createHash } from 'crypto';
+import { basename } from 'path';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import * as t from '@babel/types';
@@ -25,19 +26,22 @@ import { ImportExportVisitor, VariableVisitor, FunctionVisitor, ClassVisitor, Ca
 import { Task } from '../../core/Task.js';
 import { PriorityQueue } from '../../core/PriorityQueue.js';
 import { WorkerPool } from '../../core/WorkerPool.js';
+import { ASTWorkerPool } from '../../core/ASTWorkerPool.js';
 import { ConditionParser } from './ast/ConditionParser.js';
+import { getLine, getColumn } from './ast/utils/location.js';
 import { Profiler } from '../../core/Profiler.js';
+import { ScopeTracker } from '../../core/ScopeTracker.js';
+import { computeSemanticId } from '../../core/SemanticId.js';
+import { ExpressionNode } from '../../core/nodes/ExpressionNode.js';
 export class JSASTAnalyzer extends Plugin {
     graphBuilder;
     analyzedModules;
     profiler;
-    _cacheCleared;
     constructor() {
         super();
         this.graphBuilder = new GraphBuilder();
         this.analyzedModules = new Set();
         this.profiler = new Profiler('JSASTAnalyzer');
-        this._cacheCleared = false;
     }
     get metadata() {
         return {
@@ -110,12 +114,12 @@ export class JSASTAnalyzer extends Plugin {
         return true;
     }
     async execute(context) {
+        const logger = this.log(context);
         try {
             const { manifest, graph, forceAnalysis = false } = context;
             const projectPath = manifest?.projectPath ?? '';
-            if (forceAnalysis && !this._cacheCleared) {
+            if (forceAnalysis) {
                 this.analyzedModules.clear();
-                this._cacheCleared = true;
             }
             const allModules = await this.getModuleNodes(graph);
             const modulesToAnalyze = [];
@@ -132,11 +136,15 @@ export class JSASTAnalyzer extends Plugin {
                     skippedCount++;
                 }
             }
-            console.log(`[JSASTAnalyzer] Starting parallel analysis of ${modulesToAnalyze.length} modules (${skippedCount} cached)...`);
+            logger.info('Starting module analysis', { toAnalyze: modulesToAnalyze.length, cached: skippedCount });
             if (modulesToAnalyze.length === 0) {
-                console.log(`[JSASTAnalyzer] All modules are up-to-date, skipping analysis`);
+                logger.info('All modules up-to-date, skipping analysis');
                 return createSuccessResult({ nodes: 0, edges: 0 });
             }
+            // Use ASTWorkerPool for true parallel parsing with worker_threads if enabled
+            if (context.parallelParsing) {
+                return await this.executeParallel(modulesToAnalyze, graph, projectPath, context);
+            }
             const queue = new PriorityQueue();
             const pool = new WorkerPool(context.workerCount || 10);
             pool.registerHandler('ANALYZE_MODULE', async (task) => {
@@ -171,7 +179,7 @@ export class JSASTAnalyzer extends Plugin {
             pool.on('worker:task:completed', () => {
                 completed++;
                 if (completed % 10 === 0 || completed === modulesToAnalyze.length) {
-                    console.log(`[JSASTAnalyzer] Progress: ${completed}/${modulesToAnalyze.length}`);
+                    logger.debug('Analysis progress', { completed, total: modulesToAnalyze.length });
                 }
             });
             await pool.processQueue(queue);
@@ -193,17 +201,86 @@ export class JSASTAnalyzer extends Plugin {
                     edgesCreated += task.result.edges;
                 }
             }
-            console.log(`[JSASTAnalyzer] Analyzed ${modulesToAnalyze.length} modules, created ${nodesCreated} nodes`);
-            console.log(`[JSASTAnalyzer] Stats:`, stats);
+            logger.info('Analysis complete', { modulesAnalyzed: modulesToAnalyze.length, nodesCreated });
+            logger.debug('Worker stats', { ...stats });
             this.profiler.printSummary();
             return createSuccessResult({ nodes: nodesCreated, edges: edgesCreated }, { modulesAnalyzed: modulesToAnalyze.length, workerStats: stats });
         }
         catch (error) {
-            console.error(`[JSASTAnalyzer] Error:`, error);
+            logger.error('Analysis failed', { error: error instanceof Error ? error.message : String(error) });
             const err = error instanceof Error ? error : new Error(String(error));
             return createErrorResult(err);
         }
     }
+    /**
+     * Execute parallel analysis using ASTWorkerPool (worker_threads).
+     *
+     * This method uses actual OS threads for true parallel CPU-intensive parsing.
+     * Workers generate semantic IDs using ScopeTracker, matching sequential behavior.
+     *
+     * @param modules - Modules to analyze
+     * @param graph - Graph backend for writing results
+     * @param projectPath - Project root path
+     * @param context - Analysis context with options
+     * @returns Plugin result with node/edge counts
+     */
+    async executeParallel(modules, graph, projectPath, context) {
+        const logger = this.log(context);
+        const workerCount = context.workerCount || 4;
+        const pool = new ASTWorkerPool(workerCount);
+        logger.debug('Starting parallel parsing', { workerCount });
+        try {
+            await pool.init();
+            // Convert ModuleNode to ASTModuleInfo format
+            const moduleInfos = modules.map(m => ({
+                id: m.id,
+                file: m.file,
+                name: m.name
+            }));
+            // Parse all modules in parallel using worker threads
+            const results = await pool.parseModules(moduleInfos);
+            let nodesCreated = 0;
+            let edgesCreated = 0;
+            let errors = 0;
+            // Process results - collections already have semantic IDs from workers
+            for (const result of results) {
+                if (result.error) {
+                    logger.warn('Parse error', { file: result.module.file, error: result.error.message });
+                    errors++;
+                    continue;
+                }
+                if (result.collections) {
+                    // Find original module for metadata
+                    const module = modules.find(m => m.id === result.module.id);
+                    if (!module)
+                        continue;
+                    // Pass collections directly to GraphBuilder - IDs already semantic
+                    // Cast is safe because ASTWorker.ASTCollections is structurally compatible
+                    // with ast/types.ASTCollections (METHOD extends FUNCTION semantically)
+                    const buildResult = await this.graphBuilder.build(module, graph, projectPath, result.collections);
+                    if (typeof buildResult === 'object' && buildResult !== null) {
+                        nodesCreated += buildResult.nodes || 0;
+                        edgesCreated += buildResult.edges || 0;
+                    }
+                }
+                // Report progress
+                if (context.onProgress) {
+                    context.onProgress({
+                        phase: 'analysis',
+                        currentPlugin: 'JSASTAnalyzer',
+                        message: `Processed ${result.module.file.replace(projectPath, '')}`,
+                        totalFiles: modules.length,
+                        processedFiles: results.indexOf(result) + 1
+                    });
+                }
+            }
+            logger.info('Parallel parsing complete', { nodesCreated, edgesCreated, errors });
+            return createSuccessResult({ nodes: nodesCreated, edges: edgesCreated }, { modulesAnalyzed: modules.length - errors, parallelParsing: true });
+        }
+        finally {
+            await pool.terminate();
+        }
+    }
     /**
      * Extract variable names from destructuring patterns
      * Uses t.isX() type guards to avoid casts
@@ -313,8 +390,8 @@ export class JSASTAnalyzer extends Plugin {
                 sourceId: null,
                 sourceType: 'CALL_SITE',
                 callName: initExpression.callee.name,
-                callLine: initExpression.loc.start.line,
-                callColumn: initExpression.loc.start.column
+                callLine: getLine(initExpression),
+                callColumn: getColumn(initExpression)
             });
             return;
         }
@@ -324,7 +401,7 @@ export class JSASTAnalyzer extends Plugin {
             const objectName = callee.object.type === 'Identifier' ? callee.object.name : (callee.object.type === 'ThisExpression' ? 'this' : 'unknown');
             const methodName = callee.property.type === 'Identifier' ? callee.property.name : 'unknown';
             const fullName = `${objectName}.${methodName}`;
-            const methodCallId = `CALL#${fullName}#${module.file}#${initExpression.loc.start.line}:${initExpression.loc.start.column}:inline`;
+            const methodCallId = `CALL#${fullName}#${module.file}#${getLine(initExpression)}:${getColumn(initExpression)}:inline`;
             const existing = variableAssignments.find(a => a.sourceId === methodCallId);
             if (!existing) {
                 const extractedArgs = [];
@@ -332,15 +409,15 @@ export class JSASTAnalyzer extends Plugin {
                     if (arg.type !== 'SpreadElement') {
                         const argLiteralValue = ExpressionEvaluator.extractLiteralValue(arg);
                         if (argLiteralValue !== null) {
-                            const literalId = `LITERAL#arg${index}#${module.file}#${initExpression.loc.start.line}:${initExpression.loc.start.column}:${literalCounterRef.value++}`;
+                            const literalId = `LITERAL#arg${index}#${module.file}#${getLine(initExpression)}:${getColumn(initExpression)}:${literalCounterRef.value++}`;
                             literals.push({
                                 id: literalId,
                                 type: 'LITERAL',
                                 value: argLiteralValue,
                                 valueType: typeof argLiteralValue,
                                 file: module.file,
-                                line: arg.loc?.start.line || initExpression.loc.start.line,
-                                column: arg.loc?.start.column || initExpression.loc.start.column,
+                                line: arg.loc?.start.line || getLine(initExpression),
+                                column: arg.loc?.start.column || getColumn(initExpression),
                                 parentCallId: methodCallId,
                                 argIndex: index
                             });
@@ -359,8 +436,8 @@ export class JSASTAnalyzer extends Plugin {
                     method: methodName,
                     file: module.file,
                     arguments: extractedArgs,
-                    line: initExpression.loc.start.line,
-                    column: initExpression.loc.start.column
+                    line: getLine(initExpression),
+                    column: getColumn(initExpression)
                 });
             }
             variableAssignments.push({
@@ -414,7 +491,8 @@ export class JSASTAnalyzer extends Plugin {
             const computedPropertyVar = initExpression.computed && initExpression.property.type === 'Identifier'
                 ? initExpression.property.name
                 : null;
-            const expressionId = `EXPRESSION#${objectName}.${propertyName}#${module.file}#${line}:${initExpression.start}`;
+            const column = initExpression.start ?? 0;
+            const expressionId = ExpressionNode.generateId('MemberExpression', module.file, line, column);
             variableAssignments.push({
                 variableId,
                 sourceType: 'EXPRESSION',
@@ -426,13 +504,15 @@ export class JSASTAnalyzer extends Plugin {
                 computedPropertyVar,
                 objectSourceName: initExpression.object.type === 'Identifier' ? initExpression.object.name : null,
                 file: module.file,
-                line: line
+                line: line,
+                column: column
             });
             return;
         }
         // 8. BinaryExpression
         if (initExpression.type === 'BinaryExpression') {
-            const expressionId = `EXPRESSION#binary#${module.file}#${line}:${initExpression.start}`;
+            const column = initExpression.start ?? 0;
+            const expressionId = ExpressionNode.generateId('BinaryExpression', module.file, line, column);
             variableAssignments.push({
                 variableId,
                 sourceType: 'EXPRESSION',
@@ -442,13 +522,15 @@ export class JSASTAnalyzer extends Plugin {
                 leftSourceName: initExpression.left.type === 'Identifier' ? initExpression.left.name : null,
                 rightSourceName: initExpression.right.type === 'Identifier' ? initExpression.right.name : null,
                 file: module.file,
-                line: line
+                line: line,
+                column: column
             });
             return;
         }
         // 9. ConditionalExpression
         if (initExpression.type === 'ConditionalExpression') {
-            const expressionId = `EXPRESSION#conditional#${module.file}#${line}:${initExpression.start}`;
+            const column = initExpression.start ?? 0;
+            const expressionId = ExpressionNode.generateId('ConditionalExpression', module.file, line, column);
             variableAssignments.push({
                 variableId,
                 sourceType: 'EXPRESSION',
@@ -457,7 +539,8 @@ export class JSASTAnalyzer extends Plugin {
                 consequentSourceName: initExpression.consequent.type === 'Identifier' ? initExpression.consequent.name : null,
                 alternateSourceName: initExpression.alternate.type === 'Identifier' ? initExpression.alternate.name : null,
                 file: module.file,
-                line: line
+                line: line,
+                column: column
             });
             this.trackVariableAssignment(initExpression.consequent, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
             this.trackVariableAssignment(initExpression.alternate, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
@@ -465,7 +548,8 @@ export class JSASTAnalyzer extends Plugin {
         }
         // 10. LogicalExpression
         if (initExpression.type === 'LogicalExpression') {
-            const expressionId = `EXPRESSION#logical#${module.file}#${line}:${initExpression.start}`;
+            const column = initExpression.start ?? 0;
+            const expressionId = ExpressionNode.generateId('LogicalExpression', module.file, line, column);
             variableAssignments.push({
                 variableId,
                 sourceType: 'EXPRESSION',
@@ -475,7 +559,8 @@ export class JSASTAnalyzer extends Plugin {
                 leftSourceName: initExpression.left.type === 'Identifier' ? initExpression.left.name : null,
                 rightSourceName: initExpression.right.type === 'Identifier' ? initExpression.right.name : null,
                 file: module.file,
-                line: line
+                line: line,
+                column: column
             });
             this.trackVariableAssignment(initExpression.left, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
             this.trackVariableAssignment(initExpression.right, variableId, variableName, module, line, literals, variableAssignments, literalCounterRef);
@@ -483,7 +568,8 @@ export class JSASTAnalyzer extends Plugin {
         }
         // 11. TemplateLiteral
         if (initExpression.type === 'TemplateLiteral' && initExpression.expressions.length > 0) {
-            const expressionId = `EXPRESSION#template#${module.file}#${line}:${initExpression.start}`;
+            const column = initExpression.start ?? 0;
+            const expressionId = ExpressionNode.generateId('TemplateLiteral', module.file, line, column);
             const expressionSourceNames = initExpression.expressions
                 .filter((expr) => expr.type === 'Identifier')
                 .map(expr => expr.name);
@@ -494,7 +580,8 @@ export class JSASTAnalyzer extends Plugin {
                 expressionType: 'TemplateLiteral',
                 expressionSourceNames,
                 file: module.file,
-                line: line
+                line: line,
+                column: column
             });
             for (const expr of initExpression.expressions) {
                 // Filter out TSType nodes (only in TypeScript code)
@@ -531,6 +618,9 @@ export class JSASTAnalyzer extends Plugin {
                 plugins: ['jsx', 'typescript']
             });
             this.profiler.end('babel_parse');
+            // Create ScopeTracker for semantic ID generation
+            // Use basename for shorter, more readable semantic IDs
+            const scopeTracker = new ScopeTracker(basename(module.file));
             const functions = [];
             const parameters = [];
             const scopes = [];
@@ -552,6 +642,15 @@ export class JSASTAnalyzer extends Plugin {
             const typeAliases = [];
             const enums = [];
             const decorators = [];
+            // Object/Array literal tracking for data flow
+            const objectLiterals = [];
+            const objectProperties = [];
+            const arrayLiterals = [];
+            const arrayElements = [];
+            // Array mutation tracking for FLOWS_INTO edges
+            const arrayMutations = [];
+            // Object mutation tracking for FLOWS_INTO edges
+            const objectMutations = [];
             const ifScopeCounterRef = { value: 0 };
             const scopeCounterRef = { value: 0 };
             const varDeclCounterRef = { value: 0 };
@@ -560,6 +659,8 @@ export class JSASTAnalyzer extends Plugin {
             const httpRequestCounterRef = { value: 0 };
             const literalCounterRef = { value: 0 };
             const anonymousFunctionCounterRef = { value: 0 };
+            const objectLiteralCounterRef = { value: 0 };
+            const arrayLiteralCounterRef = { value: 0 };
             const processedNodes = {
                 functions: new Set(),
                 classes: new Set(),
@@ -579,34 +680,40 @@ export class JSASTAnalyzer extends Plugin {
             this.profiler.end('traverse_imports');
             // Variables
             this.profiler.start('traverse_variables');
-            const variableVisitor = new VariableVisitor(module, { variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef }, this.extractVariableNamesFromPattern.bind(this), this.trackVariableAssignment.bind(this));
+            const variableVisitor = new VariableVisitor(module, { variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef }, this.extractVariableNamesFromPattern.bind(this), this.trackVariableAssignment.bind(this), scopeTracker // Pass ScopeTracker for semantic ID generation
+            );
             traverse(ast, variableVisitor.getHandlers());
             this.profiler.end('traverse_variables');
-            // Module-level scope context for consistent anonymous naming
-            const moduleScopeCtx = {
-                semanticPath: module.name,
-                siblingCounters: new Map()
-            };
             const allCollections = {
                 functions, parameters, scopes, variableDeclarations, callSites, methodCalls,
                 eventListeners, methodCallbacks, callArguments, classInstantiations, classDeclarations,
                 httpRequests, literals, variableAssignments,
                 // TypeScript-specific collections
                 interfaces, typeAliases, enums, decorators,
+                // Object/Array literal tracking
+                objectLiterals, objectProperties, arrayLiterals, arrayElements,
+                // Array mutation tracking
+                arrayMutations,
+                // Object mutation tracking
+                objectMutations,
+                objectLiteralCounterRef, arrayLiteralCounterRef,
                 ifScopeCounterRef, scopeCounterRef, varDeclCounterRef,
                 callSiteCounterRef, functionCounterRef, httpRequestCounterRef,
                 literalCounterRef, anonymousFunctionCounterRef, processedNodes,
-                imports, exports, moduleScopeCtx, code,
+                imports, exports, code,
                 // VisitorCollections compatibility
                 classes: classDeclarations,
                 methods: [],
                 variables: variableDeclarations,
                 sideEffects: [],
-                variableCounterRef: varDeclCounterRef
+                variableCounterRef: varDeclCounterRef,
+                // ScopeTracker for semantic ID generation
+                scopeTracker
             };
             // Functions
             this.profiler.start('traverse_functions');
-            const functionVisitor = new FunctionVisitor(module, allCollections, this.analyzeFunctionBody.bind(this));
+            const functionVisitor = new FunctionVisitor(module, allCollections, this.analyzeFunctionBody.bind(this), scopeTracker // Pass ScopeTracker for semantic ID generation
+            );
             traverse(ast, functionVisitor.getHandlers());
             this.profiler.end('traverse_functions');
             // AssignmentExpression (module-level function assignments)
@@ -631,20 +738,20 @@ export class JSASTAnalyzer extends Plugin {
                             functionName = assignNode.left.name;
                         }
                         const funcNode = assignNode.right;
-                        const functionId = `FUNCTION#${functionName}#${module.file}#${assignNode.loc.start.line}:${assignNode.loc.start.column}`;
+                        // Use semantic ID as primary ID (matching FunctionVisitor pattern)
+                        const functionId = computeSemanticId('FUNCTION', functionName, scopeTracker.getContext());
                         functions.push({
                             id: functionId,
-                            stableId: functionId,
                             type: 'FUNCTION',
                             name: functionName,
                             file: module.file,
-                            line: assignNode.loc.start.line,
-                            column: assignNode.loc.start.column,
+                            line: getLine(assignNode),
+                            column: getColumn(assignNode),
                             async: funcNode.async || false,
                             generator: funcNode.type === 'FunctionExpression' ? funcNode.generator : false,
                             isAssignment: true
                         });
-                        const funcBodyScopeId = `SCOPE#${functionName}:body#${module.file}#${assignNode.loc.start.line}`;
+                        const funcBodyScopeId = `SCOPE#${functionName}:body#${module.file}#${getLine(assignNode)}`;
                         scopes.push({
                             id: funcBodyScopeId,
                             type: 'SCOPE',
@@ -653,28 +760,31 @@ export class JSASTAnalyzer extends Plugin {
                             semanticId: `${functionName}:function_body[0]`,
                             conditional: false,
                             file: module.file,
-                            line: assignNode.loc.start.line,
+                            line: getLine(assignNode),
                             parentFunctionId: functionId
                         });
                         const funcPath = assignPath.get('right');
-                        // Create scope context for analyzing the function body
-                        const funcScopeCtx = {
-                            semanticPath: functionName,
-                            siblingCounters: new Map()
-                        };
-                        this.analyzeFunctionBody(funcPath, funcBodyScopeId, module, allCollections, funcScopeCtx);
+                        // Enter function scope for semantic ID generation and analyze
+                        scopeTracker.enterScope(functionName, 'function');
+                        this.analyzeFunctionBody(funcPath, funcBodyScopeId, module, allCollections);
+                        scopeTracker.exitScope();
                     }
+                    // Check for indexed array assignment at module level: arr[i] = value
+                    this.detectIndexedArrayAssignment(assignNode, module, arrayMutations);
+                    // Check for object property assignment at module level: obj.prop = value
+                    this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
                 }
             });
             this.profiler.end('traverse_assignments');
             // Classes
             this.profiler.start('traverse_classes');
-            const classVisitor = new ClassVisitor(module, allCollections, this.analyzeFunctionBody.bind(this));
+            const classVisitor = new ClassVisitor(module, allCollections, this.analyzeFunctionBody.bind(this), scopeTracker // Pass ScopeTracker for semantic ID generation
+            );
             traverse(ast, classVisitor.getHandlers());
             this.profiler.end('traverse_classes');
             // TypeScript-specific constructs (interfaces, type aliases, enums)
             this.profiler.start('traverse_typescript');
-            const typescriptVisitor = new TypeScriptVisitor(module, allCollections);
+            const typescriptVisitor = new TypeScriptVisitor(module, allCollections, scopeTracker);
             traverse(ast, typescriptVisitor.getHandlers());
             this.profiler.end('traverse_typescript');
             // Module-level callbacks
@@ -686,22 +796,22 @@ export class JSASTAnalyzer extends Plugin {
                     if (functionParent)
                         return;
                     if (funcPath.parent && funcPath.parent.type === 'CallExpression') {
-                        const funcName = funcNode.id ? funcNode.id.name : this.generateAnonymousName(moduleScopeCtx);
-                        const functionId = `FUNCTION#${funcName}#${module.file}#${funcNode.loc.start.line}:${funcNode.loc.start.column}`;
+                        const funcName = funcNode.id ? funcNode.id.name : this.generateAnonymousName(scopeTracker);
+                        // Use semantic ID as primary ID (matching FunctionVisitor pattern)
+                        const functionId = computeSemanticId('FUNCTION', funcName, scopeTracker.getContext());
                         functions.push({
                             id: functionId,
-                            stableId: functionId,
                             type: 'FUNCTION',
                             name: funcName,
                             file: module.file,
-                            line: funcNode.loc.start.line,
-                            column: funcNode.loc.start.column,
+                            line: getLine(funcNode),
+                            column: getColumn(funcNode),
                             async: funcNode.async || false,
                             generator: funcNode.generator || false,
                             isCallback: true,
                             parentScopeId: module.id
                         });
-                        const callbackScopeId = `SCOPE#${funcName}:body#${module.file}#${funcNode.loc.start.line}`;
+                        const callbackScopeId = `SCOPE#${funcName}:body#${module.file}#${getLine(funcNode)}`;
                         scopes.push({
                             id: callbackScopeId,
                             type: 'SCOPE',
@@ -710,15 +820,13 @@ export class JSASTAnalyzer extends Plugin {
                             semanticId: `${funcName}:callback_body[0]`,
                             conditional: false,
                             file: module.file,
-                            line: funcNode.loc.start.line,
+                            line: getLine(funcNode),
                             parentFunctionId: functionId
                         });
-                        // Create scope context for analyzing the callback body
-                        const callbackScopeCtx = {
-                            semanticPath: funcName,
-                            siblingCounters: new Map()
-                        };
-                        this.analyzeFunctionBody(funcPath, callbackScopeId, module, allCollections, callbackScopeCtx);
+                        // Enter callback scope for semantic ID generation and analyze
+                        scopeTracker.enterScope(funcName, 'callback');
+                        this.analyzeFunctionBody(funcPath, callbackScopeId, module, allCollections);
+                        scopeTracker.exitScope();
                         funcPath.skip();
                     }
                 }
@@ -726,7 +834,7 @@ export class JSASTAnalyzer extends Plugin {
             this.profiler.end('traverse_callbacks');
             // Call expressions
             this.profiler.start('traverse_calls');
-            const callExpressionVisitor = new CallExpressionVisitor(module, allCollections);
+            const callExpressionVisitor = new CallExpressionVisitor(module, allCollections, scopeTracker);
             traverse(ast, callExpressionVisitor.getHandlers());
             this.profiler.end('traverse_calls');
             // Module-level IfStatements
@@ -739,37 +847,37 @@ export class JSASTAnalyzer extends Plugin {
                     const ifNode = ifPath.node;
                     const condition = code.substring(ifNode.test.start, ifNode.test.end) || 'condition';
                     const counterId = ifScopeCounterRef.value++;
-                    const ifScopeId = `SCOPE#if#${module.file}#${ifNode.loc.start.line}:${ifNode.loc.start.column}:${counterId}`;
+                    const ifScopeId = `SCOPE#if#${module.file}#${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`;
                     const constraints = ConditionParser.parse(ifNode.test);
-                    const ifSemanticId = this.generateSemanticId('if_statement', moduleScopeCtx);
+                    const ifSemanticId = this.generateSemanticId('if_statement', scopeTracker);
                     scopes.push({
                         id: ifScopeId,
                         type: 'SCOPE',
                         scopeType: 'if_statement',
-                        name: `if:${ifNode.loc.start.line}:${ifNode.loc.start.column}:${counterId}`,
+                        name: `if:${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`,
                         semanticId: ifSemanticId,
                         conditional: true,
                         condition,
                         constraints: constraints.length > 0 ? constraints : undefined,
                         file: module.file,
-                        line: ifNode.loc.start.line,
+                        line: getLine(ifNode),
                         parentScopeId: module.id
                     });
                     if (ifNode.alternate && ifNode.alternate.type !== 'IfStatement') {
                         const elseCounterId = ifScopeCounterRef.value++;
-                        const elseScopeId = `SCOPE#else#${module.file}#${ifNode.alternate.loc.start.line}:${ifNode.alternate.loc.start.column}:${elseCounterId}`;
+                        const elseScopeId = `SCOPE#else#${module.file}#${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`;
                         const negatedConstraints = constraints.length > 0 ? ConditionParser.negate(constraints) : undefined;
-                        const elseSemanticId = this.generateSemanticId('else_statement', moduleScopeCtx);
+                        const elseSemanticId = this.generateSemanticId('else_statement', scopeTracker);
                         scopes.push({
                             id: elseScopeId,
                             type: 'SCOPE',
                             scopeType: 'else_statement',
-                            name: `else:${ifNode.alternate.loc.start.line}:${ifNode.alternate.loc.start.column}:${elseCounterId}`,
+                            name: `else:${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`,
                             semanticId: elseSemanticId,
                             conditional: true,
                             constraints: negatedConstraints,
                             file: module.file,
-                            line: ifNode.alternate.loc.start.line,
+                            line: getLine(ifNode.alternate),
                             parentScopeId: module.id
                         });
                     }
@@ -799,55 +907,428 @@ export class JSASTAnalyzer extends Plugin {
                 interfaces,
                 typeAliases,
                 enums,
-                decorators
+                decorators,
+                // Array mutation tracking
+                arrayMutations,
+                // Object mutation tracking
+                objectMutations,
+                // Object/Array literal tracking - use allCollections refs as visitors may have created new arrays
+                objectLiterals: allCollections.objectLiterals || objectLiterals,
+                arrayLiterals: allCollections.arrayLiterals || arrayLiterals
             });
             this.profiler.end('graph_build');
             nodesCreated = result.nodes;
             edgesCreated = result.edges;
         }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            console.error(`[JSASTAnalyzer] Error analyzing ${module.file}:`, err.message);
-            console.error(err.stack);
+        catch {
+            // Error analyzing module - silently skip, caller handles the result
         }
         return { nodes: nodesCreated, edges: edgesCreated };
     }
     /**
-     * Helper to generate semantic ID for a scope and update counters
+     * Helper to generate semantic ID for a scope using ScopeTracker.
+     * Format: "scopePath:scopeType[index]" e.g. "MyClass->myMethod:if_statement[0]"
      */
-    generateSemanticId(scopeType, scopeCtx) {
-        if (!scopeCtx)
+    generateSemanticId(scopeType, scopeTracker) {
+        if (!scopeTracker)
             return undefined;
-        const siblingIndex = scopeCtx.siblingCounters.get(scopeType) || 0;
-        scopeCtx.siblingCounters.set(scopeType, siblingIndex + 1);
-        return `${scopeCtx.semanticPath}:${scopeType}[${siblingIndex}]`;
+        const scopePath = scopeTracker.getScopePath();
+        const siblingIndex = scopeTracker.getItemCounter(`semanticId:${scopeType}`);
+        return `${scopePath}:${scopeType}[${siblingIndex}]`;
     }
     /**
-     * Helper to create child scope context from a semantic ID
+     * Generate a unique anonymous function name within the current scope.
+     * Uses ScopeTracker.getSiblingIndex() for stable naming.
      */
-    createChildScopeContext(semanticId) {
-        if (!semanticId)
-            return undefined;
+    generateAnonymousName(scopeTracker) {
+        if (!scopeTracker)
+            return 'anonymous';
+        const index = scopeTracker.getSiblingIndex('anonymous');
+        return `anonymous[${index}]`;
+    }
+    /**
+     * Factory method to create loop scope handlers.
+     * All loop statements (for, for-in, for-of, while, do-while) follow the same pattern:
+     * 1. Create scope with SCOPE#<scopeType>#file#line:counter
+     * 2. Generate semantic ID
+     * 3. Push to scopes array
+     * 4. Enter/exit scope tracker
+     *
+     * @param trackerScopeType - Scope type for ScopeTracker (e.g., 'for', 'for-in', 'while')
+     * @param scopeType - Scope type for the graph node (e.g., 'for-loop', 'for-in-loop')
+     * @param parentScopeId - Parent scope ID for the scope node
+     * @param module - Module context
+     * @param scopes - Collection to push scope nodes to
+     * @param scopeCounterRef - Counter for unique scope IDs
+     * @param scopeTracker - Tracker for semantic ID generation
+     */
+    /**
+     * Handles VariableDeclaration nodes within function bodies.
+     *
+     * Extracts variable names from patterns (including destructuring), determines
+     * if the variable should be CONSTANT or VARIABLE, generates semantic or legacy IDs,
+     * and tracks class instantiations and variable assignments.
+     *
+     * @param varPath - The NodePath for the VariableDeclaration
+     * @param parentScopeId - Parent scope ID for the variable
+     * @param module - Module context with file info
+     * @param variableDeclarations - Collection to push variable declarations to
+     * @param classInstantiations - Collection to push class instantiations to
+     * @param literals - Collection for literal tracking
+     * @param variableAssignments - Collection for variable assignment tracking
+     * @param varDeclCounterRef - Counter for unique variable declaration IDs
+     * @param literalCounterRef - Counter for unique literal IDs
+     * @param scopeTracker - Tracker for semantic ID generation
+     * @param parentScopeVariables - Set to track variables for closure analysis
+     */
+    handleVariableDeclaration(varPath, parentScopeId, module, variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker, parentScopeVariables) {
+        const varNode = varPath.node;
+        const isConst = varNode.kind === 'const';
+        varNode.declarations.forEach(declarator => {
+            const variables = this.extractVariableNamesFromPattern(declarator.id);
+            variables.forEach(varInfo => {
+                const literalValue = declarator.init ? ExpressionEvaluator.extractLiteralValue(declarator.init) : null;
+                const isLiteral = literalValue !== null;
+                const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
+                const shouldBeConstant = isConst && (isLiteral || isNewExpression);
+                const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
+                // Generate semantic ID (primary) or legacy ID (fallback)
+                const legacyId = `${nodeType}#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+                const varId = scopeTracker
+                    ? computeSemanticId(nodeType, varInfo.name, scopeTracker.getContext())
+                    : legacyId;
+                parentScopeVariables.add({
+                    name: varInfo.name,
+                    id: varId,
+                    scopeId: parentScopeId
+                });
+                if (shouldBeConstant) {
+                    const constantData = {
+                        id: varId,
+                        type: 'CONSTANT',
+                        name: varInfo.name,
+                        file: module.file,
+                        line: varInfo.loc.start.line,
+                        parentScopeId
+                    };
+                    if (isLiteral) {
+                        constantData.value = literalValue;
+                    }
+                    variableDeclarations.push(constantData);
+                    const init = declarator.init;
+                    if (isNewExpression && t.isNewExpression(init) && t.isIdentifier(init.callee)) {
+                        const className = init.callee.name;
+                        classInstantiations.push({
+                            variableId: varId,
+                            variableName: varInfo.name,
+                            className: className,
+                            line: varInfo.loc.start.line,
+                            parentScopeId
+                        });
+                    }
+                }
+                else {
+                    variableDeclarations.push({
+                        id: varId,
+                        type: 'VARIABLE',
+                        name: varInfo.name,
+                        file: module.file,
+                        line: varInfo.loc.start.line,
+                        parentScopeId
+                    });
+                }
+                if (declarator.init) {
+                    this.trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
+                }
+            });
+        });
+    }
+    createLoopScopeHandler(trackerScopeType, scopeType, parentScopeId, module, scopes, scopeCounterRef, scopeTracker) {
         return {
-            semanticPath: semanticId,
-            siblingCounters: new Map()
+            enter: (path) => {
+                const node = path.node;
+                const scopeId = `SCOPE#${scopeType}#${module.file}#${getLine(node)}:${scopeCounterRef.value++}`;
+                const semanticId = this.generateSemanticId(scopeType, scopeTracker);
+                scopes.push({
+                    id: scopeId,
+                    type: 'SCOPE',
+                    scopeType,
+                    semanticId,
+                    file: module.file,
+                    line: getLine(node),
+                    parentScopeId
+                });
+                // Enter scope for semantic ID generation
+                if (scopeTracker) {
+                    scopeTracker.enterCountedScope(trackerScopeType);
+                }
+            },
+            exit: () => {
+                // Exit scope
+                if (scopeTracker) {
+                    scopeTracker.exitScope();
+                }
+            }
         };
     }
     /**
-     * Generate a unique anonymous function name within the current scope
-     * Uses scopeCtx.siblingCounters to ensure stability across JS/TS versions
+     * Process VariableDeclarations within a try/catch/finally block.
+     * This is a simplified version that doesn't track parentScopeVariables or class instantiations.
+     *
+     * @param blockPath - The NodePath for the block to process
+     * @param blockScopeId - The scope ID for variables in this block
+     * @param module - Module context
+     * @param variableDeclarations - Collection to push variable declarations to
+     * @param literals - Collection for literal tracking
+     * @param variableAssignments - Collection for variable assignment tracking
+     * @param varDeclCounterRef - Counter for unique variable declaration IDs
+     * @param literalCounterRef - Counter for unique literal IDs
+     * @param scopeTracker - Tracker for semantic ID generation
      */
-    generateAnonymousName(scopeCtx) {
-        if (!scopeCtx)
-            return 'anonymous';
-        const index = scopeCtx.siblingCounters.get('anonymous') || 0;
-        scopeCtx.siblingCounters.set('anonymous', index + 1);
-        return `anonymous[${index}]`;
+    processBlockVariables(blockPath, blockScopeId, module, variableDeclarations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker) {
+        blockPath.traverse({
+            VariableDeclaration: (varPath) => {
+                const varNode = varPath.node;
+                const isConst = varNode.kind === 'const';
+                varNode.declarations.forEach(declarator => {
+                    const variables = this.extractVariableNamesFromPattern(declarator.id);
+                    variables.forEach(varInfo => {
+                        const literalValue = declarator.init ? ExpressionEvaluator.extractLiteralValue(declarator.init) : null;
+                        const isLiteral = literalValue !== null;
+                        const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
+                        const shouldBeConstant = isConst && (isLiteral || isNewExpression);
+                        const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
+                        const legacyId = `${nodeType}#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+                        const varId = scopeTracker
+                            ? computeSemanticId(nodeType, varInfo.name, scopeTracker.getContext())
+                            : legacyId;
+                        variableDeclarations.push({
+                            id: varId,
+                            type: nodeType,
+                            name: varInfo.name,
+                            file: module.file,
+                            line: varInfo.loc.start.line,
+                            parentScopeId: blockScopeId
+                        });
+                        if (declarator.init) {
+                            this.trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
+                        }
+                    });
+                });
+            }
+        });
+    }
+    /**
+     * Handles TryStatement nodes within function bodies.
+     * Creates try, catch (with optional error parameter), and finally scopes,
+     * and processes variable declarations within each block.
+     *
+     * @param tryPath - The NodePath for the TryStatement
+     * @param parentScopeId - Parent scope ID for the scope nodes
+     * @param module - Module context
+     * @param scopes - Collection to push scope nodes to
+     * @param variableDeclarations - Collection to push variable declarations to
+     * @param literals - Collection for literal tracking
+     * @param variableAssignments - Collection for variable assignment tracking
+     * @param scopeCounterRef - Counter for unique scope IDs
+     * @param varDeclCounterRef - Counter for unique variable declaration IDs
+     * @param literalCounterRef - Counter for unique literal IDs
+     * @param scopeTracker - Tracker for semantic ID generation
+     */
+    handleTryStatement(tryPath, parentScopeId, module, scopes, variableDeclarations, literals, variableAssignments, scopeCounterRef, varDeclCounterRef, literalCounterRef, scopeTracker) {
+        const tryNode = tryPath.node;
+        // Create and process try block
+        const tryScopeId = `SCOPE#try-block#${module.file}#${getLine(tryNode)}:${scopeCounterRef.value++}`;
+        const trySemanticId = this.generateSemanticId('try-block', scopeTracker);
+        scopes.push({
+            id: tryScopeId,
+            type: 'SCOPE',
+            scopeType: 'try-block',
+            semanticId: trySemanticId,
+            file: module.file,
+            line: getLine(tryNode),
+            parentScopeId
+        });
+        if (scopeTracker) {
+            scopeTracker.enterCountedScope('try');
+        }
+        this.processBlockVariables(tryPath.get('block'), tryScopeId, module, variableDeclarations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker);
+        if (scopeTracker) {
+            scopeTracker.exitScope();
+        }
+        // Create and process catch block if present
+        if (tryNode.handler) {
+            const catchBlock = tryNode.handler;
+            const catchScopeId = `SCOPE#catch-block#${module.file}#${getLine(catchBlock)}:${scopeCounterRef.value++}`;
+            const catchSemanticId = this.generateSemanticId('catch-block', scopeTracker);
+            scopes.push({
+                id: catchScopeId,
+                type: 'SCOPE',
+                scopeType: 'catch-block',
+                semanticId: catchSemanticId,
+                file: module.file,
+                line: getLine(catchBlock),
+                parentScopeId
+            });
+            if (scopeTracker) {
+                scopeTracker.enterCountedScope('catch');
+            }
+            // Handle catch parameter (e.g., catch (e))
+            if (catchBlock.param) {
+                const errorVarInfo = this.extractVariableNamesFromPattern(catchBlock.param);
+                errorVarInfo.forEach(varInfo => {
+                    const legacyId = `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
+                    const varId = scopeTracker
+                        ? computeSemanticId('VARIABLE', varInfo.name, scopeTracker.getContext())
+                        : legacyId;
+                    variableDeclarations.push({
+                        id: varId,
+                        type: 'VARIABLE',
+                        name: varInfo.name,
+                        file: module.file,
+                        line: varInfo.loc.start.line,
+                        parentScopeId: catchScopeId
+                    });
+                });
+            }
+            this.processBlockVariables(tryPath.get('handler.body'), catchScopeId, module, variableDeclarations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker);
+            if (scopeTracker) {
+                scopeTracker.exitScope();
+            }
+        }
+        // Create and process finally block if present
+        if (tryNode.finalizer) {
+            const finallyScopeId = `SCOPE#finally-block#${module.file}#${getLine(tryNode.finalizer)}:${scopeCounterRef.value++}`;
+            const finallySemanticId = this.generateSemanticId('finally-block', scopeTracker);
+            scopes.push({
+                id: finallyScopeId,
+                type: 'SCOPE',
+                scopeType: 'finally-block',
+                semanticId: finallySemanticId,
+                file: module.file,
+                line: getLine(tryNode.finalizer),
+                parentScopeId
+            });
+            if (scopeTracker) {
+                scopeTracker.enterCountedScope('finally');
+            }
+            const finalizerPath = tryPath.get('finalizer');
+            if (finalizerPath.node) {
+                this.processBlockVariables(finalizerPath, finallyScopeId, module, variableDeclarations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker);
+            }
+            if (scopeTracker) {
+                scopeTracker.exitScope();
+            }
+        }
+        tryPath.skip();
+    }
+    /**
+     * Factory method to create IfStatement handler.
+     * Creates if scope with condition parsing and optional else scope.
+     * Tracks if/else scope transitions via ifElseScopeMap.
+     *
+     * @param parentScopeId - Parent scope ID for the scope nodes
+     * @param module - Module context
+     * @param scopes - Collection to push scope nodes to
+     * @param ifScopeCounterRef - Counter for unique if scope IDs
+     * @param scopeTracker - Tracker for semantic ID generation
+     * @param sourceCode - Source code for extracting condition text
+     * @param ifElseScopeMap - Map to track if/else scope transitions
+     */
+    createIfStatementHandler(parentScopeId, module, scopes, ifScopeCounterRef, scopeTracker, sourceCode, ifElseScopeMap) {
+        return {
+            enter: (ifPath) => {
+                const ifNode = ifPath.node;
+                const condition = sourceCode.substring(ifNode.test.start, ifNode.test.end) || 'condition';
+                const counterId = ifScopeCounterRef.value++;
+                const ifScopeId = `SCOPE#if#${module.file}#${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`;
+                // Parse condition to extract constraints
+                const constraints = ConditionParser.parse(ifNode.test);
+                const ifSemanticId = this.generateSemanticId('if_statement', scopeTracker);
+                scopes.push({
+                    id: ifScopeId,
+                    type: 'SCOPE',
+                    scopeType: 'if_statement',
+                    name: `if:${getLine(ifNode)}:${getColumn(ifNode)}:${counterId}`,
+                    semanticId: ifSemanticId,
+                    conditional: true,
+                    condition,
+                    constraints: constraints.length > 0 ? constraints : undefined,
+                    file: module.file,
+                    line: getLine(ifNode),
+                    parentScopeId
+                });
+                // Enter scope for semantic ID generation
+                if (scopeTracker) {
+                    scopeTracker.enterCountedScope('if');
+                }
+                // Handle else branch if present
+                if (ifNode.alternate && !t.isIfStatement(ifNode.alternate)) {
+                    // Only create else scope for actual else block, not else-if
+                    const elseCounterId = ifScopeCounterRef.value++;
+                    const elseScopeId = `SCOPE#else#${module.file}#${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`;
+                    const negatedConstraints = constraints.length > 0 ? ConditionParser.negate(constraints) : undefined;
+                    const elseSemanticId = this.generateSemanticId('else_statement', scopeTracker);
+                    scopes.push({
+                        id: elseScopeId,
+                        type: 'SCOPE',
+                        scopeType: 'else_statement',
+                        name: `else:${getLine(ifNode.alternate)}:${getColumn(ifNode.alternate)}:${elseCounterId}`,
+                        semanticId: elseSemanticId,
+                        conditional: true,
+                        constraints: negatedConstraints,
+                        file: module.file,
+                        line: getLine(ifNode.alternate),
+                        parentScopeId
+                    });
+                    // Store info to switch to else scope when we enter alternate
+                    ifElseScopeMap.set(ifNode, { inElse: false, hasElse: true });
+                }
+                else {
+                    ifElseScopeMap.set(ifNode, { inElse: false, hasElse: false });
+                }
+            },
+            exit: (ifPath) => {
+                const ifNode = ifPath.node;
+                // Exit the current scope (either if or else)
+                if (scopeTracker) {
+                    scopeTracker.exitScope();
+                }
+                // If we were in else, we already exited else scope
+                // If we only had if, we exit if scope (done above)
+                ifElseScopeMap.delete(ifNode);
+            }
+        };
     }
     /**
-     * Анализирует тело функции и извлекает переменные, вызовы, условные блоки
+     * Factory method to create BlockStatement handler for tracking if/else transitions.
+     * When entering an else block, switches scope from if to else.
+     *
+     * @param scopeTracker - Tracker for semantic ID generation
+     * @param ifElseScopeMap - Map to track if/else scope transitions
      */
-    analyzeFunctionBody(funcPath, parentScopeId, module, collections, scopeCtx) {
+    createIfElseBlockStatementHandler(scopeTracker, ifElseScopeMap) {
+        return {
+            enter: (blockPath) => {
+                // Check if this block is the alternate of an IfStatement
+                const parent = blockPath.parent;
+                if (t.isIfStatement(parent) && parent.alternate === blockPath.node) {
+                    const scopeInfo = ifElseScopeMap.get(parent);
+                    if (scopeInfo && scopeInfo.hasElse && !scopeInfo.inElse && scopeTracker) {
+                        // Exit if scope, enter else scope
+                        scopeTracker.exitScope();
+                        scopeTracker.enterCountedScope('else');
+                        scopeInfo.inElse = true;
+                    }
+                }
+            }
+        };
+    }
+    /**
+     * Анализирует тело функции и извлекает переменные, вызовы, условные блоки.
+     * Uses ScopeTracker from collections for semantic ID generation.
+     */
+    analyzeFunctionBody(funcPath, parentScopeId, module, collections) {
         // Extract with defaults for optional properties
         const functions = (collections.functions ?? []);
         const scopes = (collections.scopes ?? []);
@@ -868,6 +1349,7 @@ export class JSASTAnalyzer extends Plugin {
         const httpRequestCounterRef = (collections.httpRequestCounterRef ?? { value: 0 });
         const literalCounterRef = (collections.literalCounterRef ?? { value: 0 });
         const anonymousFunctionCounterRef = (collections.anonymousFunctionCounterRef ?? { value: 0 });
+        const scopeTracker = collections.scopeTracker;
         const processedNodes = collections.processedNodes ?? {
             functions: new Set(),
             classes: new Set(),
@@ -884,223 +1366,73 @@ export class JSASTAnalyzer extends Plugin {
         const processedVarDecls = processedNodes.varDecls;
         const processedMethodCalls = processedNodes.methodCalls;
         const processedEventListeners = processedNodes.eventListeners;
+        // Track if/else scope transitions
+        const ifElseScopeMap = new Map();
         funcPath.traverse({
             VariableDeclaration: (varPath) => {
-                const varNode = varPath.node;
-                const isConst = varNode.kind === 'const';
-                varNode.declarations.forEach(declarator => {
-                    const variables = this.extractVariableNamesFromPattern(declarator.id);
-                    variables.forEach(varInfo => {
-                        const literalValue = declarator.init ? ExpressionEvaluator.extractLiteralValue(declarator.init) : null;
-                        const isLiteral = literalValue !== null;
-                        const isNewExpression = declarator.init && declarator.init.type === 'NewExpression';
-                        const shouldBeConstant = isConst && (isLiteral || isNewExpression);
-                        const varId = shouldBeConstant
-                            ? `CONSTANT#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`
-                            : `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
-                        parentScopeVariables.add({
-                            name: varInfo.name,
-                            id: varId,
-                            scopeId: parentScopeId
-                        });
-                        if (shouldBeConstant) {
-                            const constantData = {
-                                id: varId,
-                                type: 'CONSTANT',
-                                name: varInfo.name,
-                                file: module.file,
-                                line: varInfo.loc.start.line,
-                                parentScopeId
-                            };
-                            if (isLiteral) {
-                                constantData.value = literalValue;
-                            }
-                            variableDeclarations.push(constantData);
-                            const init = declarator.init;
-                            if (isNewExpression && t.isNewExpression(init) && t.isIdentifier(init.callee)) {
-                                const className = init.callee.name;
-                                classInstantiations.push({
-                                    variableId: varId,
-                                    variableName: varInfo.name,
-                                    className: className,
-                                    line: varInfo.loc.start.line,
-                                    parentScopeId
-                                });
-                            }
-                        }
-                        else {
-                            variableDeclarations.push({
-                                id: varId,
-                                type: 'VARIABLE',
-                                name: varInfo.name,
-                                file: module.file,
-                                line: varInfo.loc.start.line,
-                                parentScopeId
-                            });
-                        }
-                        if (declarator.init) {
-                            this.trackVariableAssignment(declarator.init, varId, varInfo.name, module, varInfo.loc.start.line, literals, variableAssignments, literalCounterRef);
-                        }
-                    });
-                });
-            },
-            ForStatement: (forPath) => {
-                const forNode = forPath.node;
-                const scopeId = `SCOPE#for-loop#${module.file}#${forNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('for-loop', scopeCtx);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType: 'for-loop',
-                    semanticId,
-                    file: module.file,
-                    line: forNode.loc.start.line,
-                    parentScopeId
-                });
-            },
-            ForInStatement: (forPath) => {
-                const forNode = forPath.node;
-                const scopeId = `SCOPE#for-in-loop#${module.file}#${forNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('for-in-loop', scopeCtx);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType: 'for-in-loop',
-                    semanticId,
-                    file: module.file,
-                    line: forNode.loc.start.line,
-                    parentScopeId
-                });
-            },
-            ForOfStatement: (forPath) => {
-                const forNode = forPath.node;
-                const scopeId = `SCOPE#for-of-loop#${module.file}#${forNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('for-of-loop', scopeCtx);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType: 'for-of-loop',
-                    semanticId,
-                    file: module.file,
-                    line: forNode.loc.start.line,
-                    parentScopeId
-                });
-            },
-            WhileStatement: (whilePath) => {
-                const whileNode = whilePath.node;
-                const scopeId = `SCOPE#while-loop#${module.file}#${whileNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('while-loop', scopeCtx);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType: 'while-loop',
-                    semanticId,
-                    file: module.file,
-                    line: whileNode.loc.start.line,
-                    parentScopeId
-                });
-            },
-            DoWhileStatement: (doPath) => {
-                const doNode = doPath.node;
-                const scopeId = `SCOPE#do-while-loop#${module.file}#${doNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('do-while-loop', scopeCtx);
-                scopes.push({
-                    id: scopeId,
-                    type: 'SCOPE',
-                    scopeType: 'do-while-loop',
-                    semanticId,
-                    file: module.file,
-                    line: doNode.loc.start.line,
-                    parentScopeId
-                });
+                this.handleVariableDeclaration(varPath, parentScopeId, module, variableDeclarations, classInstantiations, literals, variableAssignments, varDeclCounterRef, literalCounterRef, scopeTracker, parentScopeVariables);
             },
-            TryStatement: (tryPath) => {
-                const tryNode = tryPath.node;
-                const tryScopeId = `SCOPE#try-block#${module.file}#${tryNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const trySemanticId = this.generateSemanticId('try-block', scopeCtx);
-                scopes.push({
-                    id: tryScopeId,
-                    type: 'SCOPE',
-                    scopeType: 'try-block',
-                    semanticId: trySemanticId,
-                    file: module.file,
-                    line: tryNode.loc.start.line,
-                    parentScopeId
-                });
-                if (tryNode.handler) {
-                    const catchBlock = tryNode.handler;
-                    const catchScopeId = `SCOPE#catch-block#${module.file}#${catchBlock.loc.start.line}:${scopeCounterRef.value++}`;
-                    const catchSemanticId = this.generateSemanticId('catch-block', scopeCtx);
-                    scopes.push({
-                        id: catchScopeId,
-                        type: 'SCOPE',
-                        scopeType: 'catch-block',
-                        semanticId: catchSemanticId,
-                        file: module.file,
-                        line: catchBlock.loc.start.line,
-                        parentScopeId
-                    });
-                    if (catchBlock.param) {
-                        const errorVarInfo = this.extractVariableNamesFromPattern(catchBlock.param);
-                        errorVarInfo.forEach(varInfo => {
-                            const varId = `VARIABLE#${varInfo.name}#${module.file}#${varInfo.loc.start.line}:${varInfo.loc.start.column}:${varDeclCounterRef.value++}`;
-                            variableDeclarations.push({
-                                id: varId,
-                                type: 'VARIABLE',
-                                name: varInfo.name,
-                                file: module.file,
-                                line: varInfo.loc.start.line,
-                                parentScopeId: catchScopeId
-                            });
-                        });
-                    }
+            // Detect indexed array assignments: arr[i] = value
+            AssignmentExpression: (assignPath) => {
+                const assignNode = assignPath.node;
+                // Initialize collection if not exists
+                if (!collections.arrayMutations) {
+                    collections.arrayMutations = [];
                 }
-                if (tryNode.finalizer) {
-                    const finallyScopeId = `SCOPE#finally-block#${module.file}#${tryNode.finalizer.loc.start.line}:${scopeCounterRef.value++}`;
-                    const finallySemanticId = this.generateSemanticId('finally-block', scopeCtx);
-                    scopes.push({
-                        id: finallyScopeId,
-                        type: 'SCOPE',
-                        scopeType: 'finally-block',
-                        semanticId: finallySemanticId,
-                        file: module.file,
-                        line: tryNode.finalizer.loc.start.line,
-                        parentScopeId
-                    });
+                const arrayMutations = collections.arrayMutations;
+                // Check for indexed array assignment: arr[i] = value
+                this.detectIndexedArrayAssignment(assignNode, module, arrayMutations);
+                // Initialize object mutations collection if not exists
+                if (!collections.objectMutations) {
+                    collections.objectMutations = [];
                 }
+                const objectMutations = collections.objectMutations;
+                // Check for object property assignment: obj.prop = value
+                this.detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker);
+            },
+            ForStatement: this.createLoopScopeHandler('for', 'for-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
+            ForInStatement: this.createLoopScopeHandler('for-in', 'for-in-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
+            ForOfStatement: this.createLoopScopeHandler('for-of', 'for-of-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
+            WhileStatement: this.createLoopScopeHandler('while', 'while-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
+            DoWhileStatement: this.createLoopScopeHandler('do-while', 'do-while-loop', parentScopeId, module, scopes, scopeCounterRef, scopeTracker),
+            TryStatement: (tryPath) => {
+                this.handleTryStatement(tryPath, parentScopeId, module, scopes, variableDeclarations, literals, variableAssignments, scopeCounterRef, varDeclCounterRef, literalCounterRef, scopeTracker);
             },
             SwitchStatement: (switchPath) => {
                 const switchNode = switchPath.node;
-                const scopeId = `SCOPE#switch-case#${module.file}#${switchNode.loc.start.line}:${scopeCounterRef.value++}`;
-                const semanticId = this.generateSemanticId('switch-case', scopeCtx);
+                const scopeId = `SCOPE#switch-case#${module.file}#${getLine(switchNode)}:${scopeCounterRef.value++}`;
+                const semanticId = this.generateSemanticId('switch-case', scopeTracker);
                 scopes.push({
                     id: scopeId,
                     type: 'SCOPE',
                     scopeType: 'switch-case',
                     semanticId,
                     file: module.file,
-                    line: switchNode.loc.start.line,
+                    line: getLine(switchNode),
                     parentScopeId
                 });
             },
             FunctionExpression: (funcPath) => {
                 const node = funcPath.node;
-                const funcName = node.id ? node.id.name : this.generateAnonymousName(scopeCtx);
-                const functionId = `FUNCTION#${funcName}#${module.file}#${node.loc.start.line}:${node.loc.start.column}:${functionCounterRef.value++}`;
+                const funcName = node.id ? node.id.name : this.generateAnonymousName(scopeTracker);
+                // Use semantic ID as primary ID when scopeTracker available
+                const legacyId = `FUNCTION#${funcName}#${module.file}#${getLine(node)}:${getColumn(node)}:${functionCounterRef.value++}`;
+                const functionId = scopeTracker
+                    ? computeSemanticId('FUNCTION', funcName, scopeTracker.getContext())
+                    : legacyId;
                 functions.push({
                     id: functionId,
-                    stableId: functionId,
                     type: 'FUNCTION',
                     name: funcName,
                     file: module.file,
-                    line: node.loc.start.line,
-                    column: node.loc.start.column,
+                    line: getLine(node),
+                    column: getColumn(node),
                     async: node.async || false,
                     generator: node.generator || false,
                     parentScopeId
                 });
-                const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${node.loc.start.line}`;
-                const closureSemanticId = this.generateSemanticId('closure', scopeCtx);
+                const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${getLine(node)}`;
+                const closureSemanticId = this.generateSemanticId('closure', scopeTracker);
                 scopes.push({
                     id: nestedScopeId,
                     type: 'SCOPE',
@@ -1109,22 +1441,24 @@ export class JSASTAnalyzer extends Plugin {
                     semanticId: closureSemanticId,
                     conditional: false,
                     file: module.file,
-                    line: node.loc.start.line,
+                    line: getLine(node),
                     parentFunctionId: functionId,
                     capturesFrom: parentScopeId
                 });
-                // For nested function, create new context with function name as semantic path
-                const nestedFuncCtx = {
-                    semanticPath: scopeCtx ? `${scopeCtx.semanticPath}.${funcName}` : funcName,
-                    siblingCounters: new Map()
-                };
-                this.analyzeFunctionBody(funcPath, nestedScopeId, module, collections, nestedFuncCtx);
+                // Enter nested function scope for semantic ID generation
+                if (scopeTracker) {
+                    scopeTracker.enterScope(funcName, 'function');
+                }
+                this.analyzeFunctionBody(funcPath, nestedScopeId, module, collections);
+                if (scopeTracker) {
+                    scopeTracker.exitScope();
+                }
                 funcPath.skip();
             },
             ArrowFunctionExpression: (arrowPath) => {
                 const node = arrowPath.node;
-                const line = node.loc.start.line;
-                const column = node.loc.start.column;
+                const line = getLine(node);
+                const column = getColumn(node);
                 // Определяем имя (anonymous если не присвоено переменной)
                 const parent = arrowPath.parent;
                 let funcName;
@@ -1133,12 +1467,15 @@ export class JSASTAnalyzer extends Plugin {
                 }
                 else {
                     // Используем scope-level счётчик для стабильного semanticId
-                    funcName = this.generateAnonymousName(scopeCtx);
+                    funcName = this.generateAnonymousName(scopeTracker);
                 }
-                const functionId = `FUNCTION#${funcName}:${line}:${column}:${functionCounterRef.value++}`;
+                // Use semantic ID as primary ID when scopeTracker available
+                const legacyId = `FUNCTION#${funcName}:${line}:${column}:${functionCounterRef.value++}`;
+                const functionId = scopeTracker
+                    ? computeSemanticId('FUNCTION', funcName, scopeTracker.getContext())
+                    : legacyId;
                 functions.push({
                     id: functionId,
-                    stableId: functionId,
                     type: 'FUNCTION',
                     name: funcName,
                     file: module.file,
@@ -1150,7 +1487,7 @@ export class JSASTAnalyzer extends Plugin {
                 });
                 if (node.body.type === 'BlockStatement') {
                     const nestedScopeId = `SCOPE#${funcName}:body#${module.file}#${line}`;
-                    const arrowSemanticId = this.generateSemanticId('arrow_body', scopeCtx);
+                    const arrowSemanticId = this.generateSemanticId('arrow_body', scopeTracker);
                     scopes.push({
                         id: nestedScopeId,
                         type: 'SCOPE',
@@ -1163,12 +1500,14 @@ export class JSASTAnalyzer extends Plugin {
                         parentFunctionId: functionId,
                         capturesFrom: parentScopeId
                     });
-                    // For arrow function, create new context with function name as semantic path
-                    const arrowFuncCtx = {
-                        semanticPath: scopeCtx ? `${scopeCtx.semanticPath}.${funcName}` : funcName,
-                        siblingCounters: new Map()
-                    };
-                    this.analyzeFunctionBody(arrowPath, nestedScopeId, module, collections, arrowFuncCtx);
+                    // Enter arrow function scope for semantic ID generation
+                    if (scopeTracker) {
+                        scopeTracker.enterScope(funcName, 'arrow');
+                    }
+                    this.analyzeFunctionBody(arrowPath, nestedScopeId, module, collections);
+                    if (scopeTracker) {
+                        scopeTracker.exitScope();
+                    }
                 }
                 arrowPath.skip();
             },
@@ -1188,191 +1527,552 @@ export class JSASTAnalyzer extends Plugin {
                             scope.modifies.push({
                                 variableId: variable.id,
                                 variableName: varName,
-                                line: updateNode.loc.start.line
+                                line: getLine(updateNode)
                             });
                         }
                     }
                 }
             },
             // IF statements - создаём условные scope и обходим содержимое для CALL узлов
-            IfStatement: (ifPath) => {
-                const ifNode = ifPath.node;
-                const sourceCode = collections.code ?? '';
-                const condition = sourceCode.substring(ifNode.test.start, ifNode.test.end) || 'condition';
-                const counterId = ifScopeCounterRef.value++;
-                const ifScopeId = `SCOPE#if#${module.file}#${ifNode.loc.start.line}:${ifNode.loc.start.column}:${counterId}`;
-                // Parse condition to extract constraints
-                const constraints = ConditionParser.parse(ifNode.test);
-                const ifSemanticId = this.generateSemanticId('if_statement', scopeCtx);
-                scopes.push({
-                    id: ifScopeId,
-                    type: 'SCOPE',
-                    scopeType: 'if_statement',
-                    name: `if:${ifNode.loc.start.line}:${ifNode.loc.start.column}:${counterId}`,
-                    semanticId: ifSemanticId,
-                    conditional: true,
-                    condition,
-                    constraints: constraints.length > 0 ? constraints : undefined,
-                    file: module.file,
-                    line: ifNode.loc.start.line,
-                    parentScopeId
-                });
-                // Обходим содержимое if-блока (consequent)
-                ifPath.get('consequent').traverse({
-                    CallExpression: (callPath) => {
-                        const callNode = callPath.node;
-                        if (callNode.callee.type === 'Identifier') {
-                            const nodeKey = `${callNode.start}:${callNode.end}`;
-                            if (processedCallSites.has(nodeKey)) {
-                                return;
-                            }
-                            processedCallSites.add(nodeKey);
-                            callSites.push({
-                                id: `CALL#${callNode.callee.name}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`,
-                                type: 'CALL',
-                                name: callNode.callee.name,
-                                file: module.file,
-                                line: callNode.loc.start.line,
-                                parentScopeId: ifScopeId,
-                                targetFunctionName: callNode.callee.name
-                            });
-                        }
-                    },
-                    NewExpression: (newPath) => {
-                        const newNode = newPath.node;
-                        if (newNode.callee.type === 'Identifier') {
-                            const nodeKey = `new:${newNode.start}:${newNode.end}`;
-                            if (processedCallSites.has(nodeKey)) {
-                                return;
-                            }
-                            processedCallSites.add(nodeKey);
-                            callSites.push({
-                                id: `CALL#new:${newNode.callee.name}#${module.file}#${newNode.loc.start.line}:${newNode.loc.start.column}:${callSiteCounterRef.value++}`,
-                                type: 'CALL',
-                                name: newNode.callee.name,
-                                file: module.file,
-                                line: newNode.loc.start.line,
-                                parentScopeId: ifScopeId,
-                                targetFunctionName: newNode.callee.name,
-                                isNew: true
-                            });
-                        }
+            IfStatement: this.createIfStatementHandler(parentScopeId, module, scopes, ifScopeCounterRef, scopeTracker, collections.code ?? '', ifElseScopeMap),
+            // Track when we enter the alternate (else) block of an IfStatement
+            BlockStatement: this.createIfElseBlockStatementHandler(scopeTracker, ifElseScopeMap),
+            // Function call expressions
+            CallExpression: (callPath) => {
+                this.handleCallExpression(callPath.node, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, parentScopeId, collections);
+            },
+            // NewExpression (constructor calls)
+            NewExpression: (newPath) => {
+                const newNode = newPath.node;
+                // Handle simple constructor: new Foo()
+                if (newNode.callee.type === 'Identifier') {
+                    const nodeKey = `new:${newNode.start}:${newNode.end}`;
+                    if (processedCallSites.has(nodeKey)) {
+                        return;
                     }
-                });
-                // Handle else branch if present
-                if (ifNode.alternate) {
-                    const elseCounterId = ifScopeCounterRef.value++;
-                    const elseScopeId = `SCOPE#else#${module.file}#${ifNode.alternate.loc.start.line}:${ifNode.alternate.loc.start.column}:${elseCounterId}`;
-                    // Negate constraints for else branch
-                    const negatedConstraints = constraints.length > 0 ? ConditionParser.negate(constraints) : undefined;
-                    const elseSemanticId = this.generateSemanticId('else_statement', scopeCtx);
-                    scopes.push({
-                        id: elseScopeId,
-                        type: 'SCOPE',
-                        scopeType: 'else_statement',
-                        name: `else:${ifNode.alternate.loc.start.line}:${ifNode.alternate.loc.start.column}:${elseCounterId}`,
-                        semanticId: elseSemanticId,
-                        conditional: true,
-                        constraints: negatedConstraints,
+                    processedCallSites.add(nodeKey);
+                    // Generate semantic ID (primary) or legacy ID (fallback)
+                    const constructorName = newNode.callee.name;
+                    const legacyId = `CALL#new:${constructorName}#${module.file}#${getLine(newNode)}:${getColumn(newNode)}:${callSiteCounterRef.value++}`;
+                    let newCallId = legacyId;
+                    if (scopeTracker) {
+                        const discriminator = scopeTracker.getItemCounter(`CALL:new:${constructorName}`);
+                        newCallId = computeSemanticId('CALL', `new:${constructorName}`, scopeTracker.getContext(), { discriminator });
+                    }
+                    callSites.push({
+                        id: newCallId,
+                        type: 'CALL',
+                        name: constructorName,
                         file: module.file,
-                        line: ifNode.alternate.loc.start.line,
-                        parentScopeId
-                    });
-                    // Traverse else block
-                    ifPath.get('alternate').traverse({
-                        CallExpression: (callPath) => {
-                            const callNode = callPath.node;
-                            if (callNode.callee.type === 'Identifier') {
-                                const nodeKey = `${callNode.start}:${callNode.end}`;
-                                if (processedCallSites.has(nodeKey)) {
-                                    return;
-                                }
-                                processedCallSites.add(nodeKey);
-                                callSites.push({
-                                    id: `CALL#${callNode.callee.name}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`,
-                                    type: 'CALL',
-                                    name: callNode.callee.name,
-                                    file: module.file,
-                                    line: callNode.loc.start.line,
-                                    parentScopeId: elseScopeId,
-                                    targetFunctionName: callNode.callee.name
-                                });
-                            }
-                        },
-                        NewExpression: (newPath) => {
-                            const newNode = newPath.node;
-                            if (newNode.callee.type === 'Identifier') {
-                                const nodeKey = `new:${newNode.start}:${newNode.end}`;
-                                if (processedCallSites.has(nodeKey)) {
-                                    return;
-                                }
-                                processedCallSites.add(nodeKey);
-                                callSites.push({
-                                    id: `CALL#new:${newNode.callee.name}#${module.file}#${newNode.loc.start.line}:${newNode.loc.start.column}:${callSiteCounterRef.value++}`,
-                                    type: 'CALL',
-                                    name: newNode.callee.name,
-                                    file: module.file,
-                                    line: newNode.loc.start.line,
-                                    parentScopeId: elseScopeId,
-                                    targetFunctionName: newNode.callee.name,
-                                    isNew: true
-                                });
-                            }
-                        }
+                        line: getLine(newNode),
+                        parentScopeId,
+                        targetFunctionName: constructorName,
+                        isNew: true
                     });
                 }
-                // Останавливаем дальнейший обход, чтобы не обрабатывать вызовы дважды
-                ifPath.skip();
-            },
-            // Вызовы функций на безусловном уровне (вне if/for/while)
-            CallExpression: (callPath) => {
-                // Проверяем что вызов не внутри if/for/while (их мы обрабатываем отдельно)
-                const parent = callPath.parent;
-                if (parent.type !== 'IfStatement' && parent.type !== 'ForStatement' && parent.type !== 'WhileStatement') {
-                    const callNode = callPath.node;
-                    // Обычные вызовы функций (greet(), main())
-                    if (callNode.callee.type === 'Identifier') {
-                        const nodeKey = `${callNode.start}:${callNode.end}`;
-                        if (processedCallSites.has(nodeKey)) {
+                // Handle namespaced constructor: new ns.Constructor()
+                else if (newNode.callee.type === 'MemberExpression') {
+                    const memberCallee = newNode.callee;
+                    const object = memberCallee.object;
+                    const property = memberCallee.property;
+                    if (object.type === 'Identifier' && property.type === 'Identifier') {
+                        const nodeKey = `new:${newNode.start}:${newNode.end}`;
+                        if (processedMethodCalls.has(nodeKey)) {
                             return;
                         }
-                        processedCallSites.add(nodeKey);
-                        callSites.push({
-                            id: `CALL#${callNode.callee.name}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`,
+                        processedMethodCalls.add(nodeKey);
+                        const objectName = object.name;
+                        const constructorName = property.name;
+                        const fullName = `${objectName}.${constructorName}`;
+                        // Generate semantic ID for method-style constructor call
+                        const legacyId = `CALL#new:${fullName}#${module.file}#${getLine(newNode)}:${getColumn(newNode)}:${callSiteCounterRef.value++}`;
+                        let newMethodCallId = legacyId;
+                        if (scopeTracker) {
+                            const discriminator = scopeTracker.getItemCounter(`CALL:new:${fullName}`);
+                            newMethodCallId = computeSemanticId('CALL', `new:${fullName}`, scopeTracker.getContext(), { discriminator });
+                        }
+                        methodCalls.push({
+                            id: newMethodCallId,
                             type: 'CALL',
-                            name: callNode.callee.name,
+                            name: fullName,
+                            object: objectName,
+                            method: constructorName,
                             file: module.file,
-                            line: callNode.loc.start.line,
+                            line: getLine(newNode),
+                            column: getColumn(newNode),
                             parentScopeId,
-                            targetFunctionName: callNode.callee.name
+                            isNew: true
                         });
                     }
                 }
-            },
-            // NewExpression на безусловном уровне
-            NewExpression: (newPath) => {
-                const parent = newPath.parent;
-                if (parent.type !== 'IfStatement' && parent.type !== 'ForStatement' && parent.type !== 'WhileStatement') {
-                    const newNode = newPath.node;
-                    if (newNode.callee.type === 'Identifier') {
-                        const nodeKey = `new:${newNode.start}:${newNode.end}`;
-                        if (processedCallSites.has(nodeKey)) {
-                            return;
+            }
+        });
+    }
+    /**
+     * Handle CallExpression nodes: direct function calls (greet(), main())
+     * and method calls (obj.method(), data.process()).
+     *
+     * Handles:
+     * - Direct function calls (Identifier callee) → callSites collection
+     * - Method calls (MemberExpression callee) → methodCalls collection
+     * - Array mutation detection (push, unshift, splice)
+     * - Object.assign() detection
+     *
+     * @param callNode - The call expression AST node
+     * @param processedCallSites - Set of already processed call site keys to avoid duplicates
+     * @param processedMethodCalls - Set of already processed method call keys to avoid duplicates
+     * @param callSites - Collection for direct function calls
+     * @param methodCalls - Collection for method calls
+     * @param module - Current module being analyzed
+     * @param callSiteCounterRef - Counter for legacy ID generation
+     * @param scopeTracker - Optional scope tracker for semantic ID generation
+     * @param parentScopeId - ID of the parent scope containing this call
+     * @param collections - Full collections object for array/object mutations
+     */
+    handleCallExpression(callNode, processedCallSites, processedMethodCalls, callSites, methodCalls, module, callSiteCounterRef, scopeTracker, parentScopeId, collections) {
+        // Handle direct function calls (greet(), main())
+        if (callNode.callee.type === 'Identifier') {
+            const nodeKey = `${callNode.start}:${callNode.end}`;
+            if (processedCallSites.has(nodeKey)) {
+                return;
+            }
+            processedCallSites.add(nodeKey);
+            // Generate semantic ID (primary) or legacy ID (fallback)
+            const calleeName = callNode.callee.name;
+            const legacyId = `CALL#${calleeName}#${module.file}#${getLine(callNode)}:${getColumn(callNode)}:${callSiteCounterRef.value++}`;
+            let callId = legacyId;
+            if (scopeTracker) {
+                const discriminator = scopeTracker.getItemCounter(`CALL:${calleeName}`);
+                callId = computeSemanticId('CALL', calleeName, scopeTracker.getContext(), { discriminator });
+            }
+            callSites.push({
+                id: callId,
+                type: 'CALL',
+                name: calleeName,
+                file: module.file,
+                line: getLine(callNode),
+                parentScopeId,
+                targetFunctionName: calleeName
+            });
+        }
+        // Handle method calls (obj.method(), data.process())
+        else if (callNode.callee.type === 'MemberExpression') {
+            const memberCallee = callNode.callee;
+            const object = memberCallee.object;
+            const property = memberCallee.property;
+            const isComputed = memberCallee.computed;
+            if ((object.type === 'Identifier' || object.type === 'ThisExpression') && property.type === 'Identifier') {
+                const nodeKey = `${callNode.start}:${callNode.end}`;
+                if (processedMethodCalls.has(nodeKey)) {
+                    return;
+                }
+                processedMethodCalls.add(nodeKey);
+                const objectName = object.type === 'Identifier' ? object.name : 'this';
+                const methodName = isComputed ? '<computed>' : property.name;
+                const fullName = `${objectName}.${methodName}`;
+                // Generate semantic ID (primary) or legacy ID (fallback)
+                const legacyId = `CALL#${fullName}#${module.file}#${getLine(callNode)}:${getColumn(callNode)}:${callSiteCounterRef.value++}`;
+                let methodCallId = legacyId;
+                if (scopeTracker) {
+                    const discriminator = scopeTracker.getItemCounter(`CALL:${fullName}`);
+                    methodCallId = computeSemanticId('CALL', fullName, scopeTracker.getContext(), { discriminator });
+                }
+                methodCalls.push({
+                    id: methodCallId,
+                    type: 'CALL',
+                    name: fullName,
+                    object: objectName,
+                    method: methodName,
+                    computed: isComputed,
+                    computedPropertyVar: isComputed ? property.name : null,
+                    file: module.file,
+                    line: getLine(callNode),
+                    column: getColumn(callNode),
+                    parentScopeId
+                });
+                // Check for array mutation methods (push, unshift, splice)
+                const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
+                if (ARRAY_MUTATION_METHODS.includes(methodName)) {
+                    // Initialize collection if not exists
+                    if (!collections.arrayMutations) {
+                        collections.arrayMutations = [];
+                    }
+                    const arrayMutations = collections.arrayMutations;
+                    this.detectArrayMutationInFunction(callNode, objectName, methodName, module, arrayMutations, scopeTracker);
+                }
+                // Check for Object.assign() calls
+                if (objectName === 'Object' && methodName === 'assign') {
+                    // Initialize collection if not exists
+                    if (!collections.objectMutations) {
+                        collections.objectMutations = [];
+                    }
+                    const objectMutations = collections.objectMutations;
+                    this.detectObjectAssignInFunction(callNode, module, objectMutations, scopeTracker);
+                }
+            }
+            // REG-117: Nested array mutations like obj.arr.push(item)
+            // object is MemberExpression, property is the method name
+            else if (object.type === 'MemberExpression' && property.type === 'Identifier') {
+                const nestedMember = object;
+                const methodName = property.name;
+                const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
+                if (ARRAY_MUTATION_METHODS.includes(methodName)) {
+                    // Extract base object and property from nested MemberExpression
+                    const base = nestedMember.object;
+                    const prop = nestedMember.property;
+                    // Only handle single-level nesting: obj.arr.push() or this.items.push()
+                    if ((base.type === 'Identifier' || base.type === 'ThisExpression') &&
+                        !nestedMember.computed &&
+                        prop.type === 'Identifier') {
+                        const baseObjectName = base.type === 'Identifier' ? base.name : 'this';
+                        const propertyName = prop.name;
+                        // Initialize collection if not exists
+                        if (!collections.arrayMutations) {
+                            collections.arrayMutations = [];
                         }
-                        processedCallSites.add(nodeKey);
-                        callSites.push({
-                            id: `CALL#new:${newNode.callee.name}#${module.file}#${newNode.loc.start.line}:${newNode.loc.start.column}:${callSiteCounterRef.value++}`,
-                            type: 'CALL',
-                            name: newNode.callee.name,
-                            file: module.file,
-                            line: newNode.loc.start.line,
-                            parentScopeId,
-                            targetFunctionName: newNode.callee.name,
-                            isNew: true
-                        });
+                        const arrayMutations = collections.arrayMutations;
+                        this.detectArrayMutationInFunction(callNode, `${baseObjectName}.${propertyName}`, // arrayName for ID purposes
+                        methodName, module, arrayMutations, scopeTracker, true, // isNested
+                        baseObjectName, propertyName);
                     }
                 }
             }
+        }
+    }
+    /**
+     * Detect array mutation calls (push, unshift, splice) inside functions
+     * and collect mutation info for FLOWS_INTO edge creation in GraphBuilder
+     *
+     * REG-117: Added isNested, baseObjectName, propertyName for nested mutations
+     *
+     * @param callNode - The call expression node
+     * @param arrayName - Name of the array being mutated
+     * @param method - The mutation method (push, unshift, splice)
+     * @param module - Current module being analyzed
+     * @param arrayMutations - Collection to push mutation info into
+     * @param scopeTracker - Optional scope tracker for semantic IDs
+     * @param isNested - REG-117: true if this is a nested mutation (obj.arr.push)
+     * @param baseObjectName - REG-117: base object name for nested mutations
+     * @param propertyName - REG-117: property name for nested mutations
+     */
+    detectArrayMutationInFunction(callNode, arrayName, method, module, arrayMutations, scopeTracker, isNested, baseObjectName, propertyName) {
+        const mutationArgs = [];
+        // For splice, only arguments from index 2 onwards are insertions
+        // splice(start, deleteCount, item1, item2, ...)
+        callNode.arguments.forEach((arg, index) => {
+            // Skip start and deleteCount for splice
+            if (method === 'splice' && index < 2)
+                return;
+            const argInfo = {
+                argIndex: method === 'splice' ? index - 2 : index,
+                isSpread: arg.type === 'SpreadElement',
+                valueType: 'EXPRESSION' // Default
+            };
+            let actualArg = arg;
+            if (arg.type === 'SpreadElement') {
+                actualArg = arg.argument;
+            }
+            // Determine value type
+            const literalValue = ExpressionEvaluator.extractLiteralValue(actualArg);
+            if (literalValue !== null) {
+                argInfo.valueType = 'LITERAL';
+                argInfo.literalValue = literalValue;
+            }
+            else if (actualArg.type === 'Identifier') {
+                argInfo.valueType = 'VARIABLE';
+                argInfo.valueName = actualArg.name;
+            }
+            else if (actualArg.type === 'ObjectExpression') {
+                argInfo.valueType = 'OBJECT_LITERAL';
+            }
+            else if (actualArg.type === 'ArrayExpression') {
+                argInfo.valueType = 'ARRAY_LITERAL';
+            }
+            else if (actualArg.type === 'CallExpression') {
+                argInfo.valueType = 'CALL';
+                argInfo.callLine = actualArg.loc?.start.line;
+                argInfo.callColumn = actualArg.loc?.start.column;
+            }
+            mutationArgs.push(argInfo);
         });
+        // Only record if there are actual insertions
+        if (mutationArgs.length > 0) {
+            const line = callNode.loc?.start.line ?? 0;
+            const column = callNode.loc?.start.column ?? 0;
+            // Generate semantic ID for array mutation if scopeTracker available
+            let mutationId;
+            if (scopeTracker) {
+                const discriminator = scopeTracker.getItemCounter(`ARRAY_MUTATION:${arrayName}.${method}`);
+                mutationId = computeSemanticId('ARRAY_MUTATION', `${arrayName}.${method}`, scopeTracker.getContext(), { discriminator });
+            }
+            arrayMutations.push({
+                id: mutationId,
+                arrayName,
+                mutationMethod: method,
+                file: module.file,
+                line,
+                column,
+                insertedValues: mutationArgs,
+                // REG-117: Nested mutation fields
+                isNested,
+                baseObjectName,
+                propertyName
+            });
+        }
+    }
+    /**
+     * Detect indexed array assignment: arr[i] = value
+     * Creates ArrayMutationInfo for FLOWS_INTO edge generation in GraphBuilder
+     *
+     * @param assignNode - The assignment expression node
+     * @param module - Current module being analyzed
+     * @param arrayMutations - Collection to push mutation info into
+     */
+    detectIndexedArrayAssignment(assignNode, module, arrayMutations) {
+        // Check for indexed array assignment: arr[i] = value
+        if (assignNode.left.type === 'MemberExpression' && assignNode.left.computed) {
+            const memberExpr = assignNode.left;
+            // Only process NumericLiteral keys - those are clearly array indexed assignments
+            // e.g., arr[0] = value, arr[1] = value
+            // All other computed keys (StringLiteral, Identifier, expressions) are handled as object mutations
+            // This avoids duplicate edge creation for ambiguous cases like obj[key] = value
+            if (memberExpr.property.type !== 'NumericLiteral') {
+                return;
+            }
+            // Get array name (only simple identifiers for now)
+            if (memberExpr.object.type === 'Identifier') {
+                const arrayName = memberExpr.object.name;
+                const value = assignNode.right;
+                const argInfo = {
+                    argIndex: 0,
+                    isSpread: false,
+                    valueType: 'EXPRESSION'
+                };
+                // Determine value type
+                const literalValue = ExpressionEvaluator.extractLiteralValue(value);
+                if (literalValue !== null) {
+                    argInfo.valueType = 'LITERAL';
+                    argInfo.literalValue = literalValue;
+                }
+                else if (value.type === 'Identifier') {
+                    argInfo.valueType = 'VARIABLE';
+                    argInfo.valueName = value.name;
+                }
+                else if (value.type === 'ObjectExpression') {
+                    argInfo.valueType = 'OBJECT_LITERAL';
+                }
+                else if (value.type === 'ArrayExpression') {
+                    argInfo.valueType = 'ARRAY_LITERAL';
+                }
+                else if (value.type === 'CallExpression') {
+                    argInfo.valueType = 'CALL';
+                    argInfo.callLine = value.loc?.start.line;
+                    argInfo.callColumn = value.loc?.start.column;
+                }
+                // Use defensive loc checks instead of ! assertions
+                const line = assignNode.loc?.start.line ?? 0;
+                const column = assignNode.loc?.start.column ?? 0;
+                arrayMutations.push({
+                    arrayName,
+                    mutationMethod: 'indexed',
+                    file: module.file,
+                    line: line,
+                    column: column,
+                    insertedValues: [argInfo]
+                });
+            }
+        }
+    }
+    /**
+     * Detect object property assignment: obj.prop = value, obj['prop'] = value
+     * Creates ObjectMutationInfo for FLOWS_INTO edge generation in GraphBuilder
+     *
+     * @param assignNode - The assignment expression node
+     * @param module - Current module being analyzed
+     * @param objectMutations - Collection to push mutation info into
+     * @param scopeTracker - Optional scope tracker for semantic IDs
+     */
+    detectObjectPropertyAssignment(assignNode, module, objectMutations, scopeTracker) {
+        // Check for property assignment: obj.prop = value or obj['prop'] = value
+        if (assignNode.left.type !== 'MemberExpression')
+            return;
+        const memberExpr = assignNode.left;
+        // Skip NumericLiteral indexed assignment (handled by array mutation handler)
+        // Array mutation handler processes: arr[0] (numeric literal index)
+        // Object mutation handler processes: obj.prop, obj['prop'], obj[key], obj[expr]
+        if (memberExpr.computed && memberExpr.property.type === 'NumericLiteral') {
+            return; // Let array mutation handler deal with this
+        }
+        // Get object name and enclosing class context for 'this'
+        let objectName;
+        let enclosingClassName;
+        if (memberExpr.object.type === 'Identifier') {
+            objectName = memberExpr.object.name;
+        }
+        else if (memberExpr.object.type === 'ThisExpression') {
+            objectName = 'this';
+            // REG-152: Extract enclosing class name from scope context
+            if (scopeTracker) {
+                enclosingClassName = scopeTracker.getEnclosingScope('CLASS');
+            }
+        }
+        else {
+            // Complex expressions like obj.nested.prop = value
+            // For now, skip these (documented limitation)
+            return;
+        }
+        // Get property name
+        let propertyName;
+        let mutationType;
+        let computedPropertyVar;
+        if (!memberExpr.computed) {
+            // obj.prop
+            if (memberExpr.property.type === 'Identifier') {
+                propertyName = memberExpr.property.name;
+                mutationType = 'property';
+            }
+            else {
+                return; // Unexpected property type
+            }
+        }
+        else {
+            // obj['prop'] or obj[key]
+            if (memberExpr.property.type === 'StringLiteral') {
+                propertyName = memberExpr.property.value;
+                mutationType = 'property'; // String literal is effectively a property name
+            }
+            else {
+                propertyName = '<computed>';
+                mutationType = 'computed';
+                // Capture variable name for later resolution in enrichment phase
+                if (memberExpr.property.type === 'Identifier') {
+                    computedPropertyVar = memberExpr.property.name;
+                }
+            }
+        }
+        // Extract value info
+        const value = assignNode.right;
+        const valueInfo = this.extractMutationValue(value);
+        // Use defensive loc checks
+        const line = assignNode.loc?.start.line ?? 0;
+        const column = assignNode.loc?.start.column ?? 0;
+        // Generate semantic ID if scopeTracker available
+        let mutationId;
+        if (scopeTracker) {
+            const discriminator = scopeTracker.getItemCounter(`OBJECT_MUTATION:${objectName}.${propertyName}`);
+            mutationId = computeSemanticId('OBJECT_MUTATION', `${objectName}.${propertyName}`, scopeTracker.getContext(), { discriminator });
+        }
+        objectMutations.push({
+            id: mutationId,
+            objectName,
+            enclosingClassName, // REG-152: Class name for 'this' mutations
+            propertyName,
+            mutationType,
+            computedPropertyVar,
+            file: module.file,
+            line,
+            column,
+            value: valueInfo
+        });
+    }
+    /**
+     * Extract value information from an expression for mutation tracking
+     */
+    extractMutationValue(value) {
+        const valueInfo = {
+            valueType: 'EXPRESSION' // Default
+        };
+        const literalValue = ExpressionEvaluator.extractLiteralValue(value);
+        if (literalValue !== null) {
+            valueInfo.valueType = 'LITERAL';
+            valueInfo.literalValue = literalValue;
+        }
+        else if (value.type === 'Identifier') {
+            valueInfo.valueType = 'VARIABLE';
+            valueInfo.valueName = value.name;
+        }
+        else if (value.type === 'ObjectExpression') {
+            valueInfo.valueType = 'OBJECT_LITERAL';
+        }
+        else if (value.type === 'ArrayExpression') {
+            valueInfo.valueType = 'ARRAY_LITERAL';
+        }
+        else if (value.type === 'CallExpression') {
+            valueInfo.valueType = 'CALL';
+            valueInfo.callLine = value.loc?.start.line;
+            valueInfo.callColumn = value.loc?.start.column;
+        }
+        return valueInfo;
+    }
+    /**
+     * Detect Object.assign() calls inside functions
+     * Creates ObjectMutationInfo for FLOWS_INTO edge generation in GraphBuilder
+     */
+    detectObjectAssignInFunction(callNode, module, objectMutations, scopeTracker) {
+        // Need at least 2 arguments: target and at least one source
+        if (callNode.arguments.length < 2)
+            return;
+        // First argument is target
+        const targetArg = callNode.arguments[0];
+        let targetName;
+        if (targetArg.type === 'Identifier') {
+            targetName = targetArg.name;
+        }
+        else if (targetArg.type === 'ObjectExpression') {
+            targetName = '<anonymous>';
+        }
+        else {
+            return;
+        }
+        const line = callNode.loc?.start.line ?? 0;
+        const column = callNode.loc?.start.column ?? 0;
+        for (let i = 1; i < callNode.arguments.length; i++) {
+            let arg = callNode.arguments[i];
+            let isSpread = false;
+            if (arg.type === 'SpreadElement') {
+                isSpread = true;
+                arg = arg.argument;
+            }
+            const valueInfo = {
+                valueType: 'EXPRESSION',
+                argIndex: i - 1,
+                isSpread
+            };
+            const literalValue = ExpressionEvaluator.extractLiteralValue(arg);
+            if (literalValue !== null) {
+                valueInfo.valueType = 'LITERAL';
+                valueInfo.literalValue = literalValue;
+            }
+            else if (arg.type === 'Identifier') {
+                valueInfo.valueType = 'VARIABLE';
+                valueInfo.valueName = arg.name;
+            }
+            else if (arg.type === 'ObjectExpression') {
+                valueInfo.valueType = 'OBJECT_LITERAL';
+            }
+            else if (arg.type === 'ArrayExpression') {
+                valueInfo.valueType = 'ARRAY_LITERAL';
+            }
+            else if (arg.type === 'CallExpression') {
+                valueInfo.valueType = 'CALL';
+                valueInfo.callLine = arg.loc?.start.line;
+                valueInfo.callColumn = arg.loc?.start.column;
+            }
+            let mutationId;
+            if (scopeTracker) {
+                const discriminator = scopeTracker.getItemCounter(`OBJECT_MUTATION:Object.assign:${targetName}`);
+                mutationId = computeSemanticId('OBJECT_MUTATION', `Object.assign:${targetName}`, scopeTracker.getContext(), { discriminator });
+            }
+            objectMutations.push({
+                id: mutationId,
+                objectName: targetName,
+                propertyName: '<assign>',
+                mutationType: 'assign',
+                file: module.file,
+                line,
+                column,
+                value: valueInfo
+            });
+        }
     }
 }