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

package/dist/config/ConfigLoader.js

@@ -0,0 +1,187 @@
+import { readFileSync, existsSync, statSync } from 'fs';
+import { join } from 'path';
+import { parse as parseYAML } from 'yaml';
+/**
+ * Default plugin configuration.
+ * Matches current DEFAULT_PLUGINS in analyze.ts and config.ts (MCP).
+ */
+export const DEFAULT_CONFIG = {
+    plugins: {
+        discovery: [],
+        indexing: ['JSModuleIndexer'],
+        analysis: [
+            'JSASTAnalyzer',
+            'ExpressRouteAnalyzer',
+            'SocketIOAnalyzer',
+            'DatabaseAnalyzer',
+            'FetchAnalyzer',
+            'ServiceLayerAnalyzer',
+        ],
+        enrichment: [
+            'MethodCallResolver',
+            'AliasTracker',
+            'ValueDomainAnalyzer',
+            'MountPointResolver',
+            'PrefixEvaluator',
+            'ImportExportLinker',
+            'HTTPConnectionEnricher',
+        ],
+        validation: [
+            'CallResolverValidator',
+            'EvalBanValidator',
+            'SQLInjectionValidator',
+            'ShadowingDetector',
+            'GraphConnectivityValidator',
+            'DataFlowValidator',
+            'TypeScriptDeadCodeValidator',
+        ],
+    },
+    services: [], // Empty by default (uses auto-discovery)
+};
+/**
+ * Load Grafema config from project directory.
+ *
+ * Priority:
+ * 1. config.yaml (preferred)
+ * 2. config.json (deprecated, fallback)
+ * 3. DEFAULT_CONFIG (if neither exists)
+ *
+ * Warnings:
+ * - Logs deprecation warning if config.json is used
+ * - Logs parse errors but doesn't throw (returns defaults)
+ *
+ * @param projectPath - Absolute path to project root
+ * @param logger - Optional logger for warnings (defaults to console.warn)
+ * @returns Parsed config or defaults
+ */
+export function loadConfig(projectPath, logger = console) {
+    const grafemaDir = join(projectPath, '.grafema');
+    const yamlPath = join(grafemaDir, 'config.yaml');
+    const jsonPath = join(grafemaDir, 'config.json');
+    // 1. Try YAML first (preferred)
+    if (existsSync(yamlPath)) {
+        let parsed;
+        try {
+            const content = readFileSync(yamlPath, 'utf-8');
+            parsed = parseYAML(content);
+            // Validate structure - ensure plugins sections are arrays if they exist
+            if (parsed.plugins) {
+                for (const phase of ['discovery', 'indexing', 'analysis', 'enrichment', 'validation']) {
+                    const value = parsed.plugins[phase];
+                    if (value !== undefined && value !== null && !Array.isArray(value)) {
+                        throw new Error(`plugins.${phase} must be an array, got ${typeof value}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            logger.warn(`Failed to parse config.yaml: ${error.message}`);
+            logger.warn('Using default configuration');
+            return DEFAULT_CONFIG;
+        }
+        // Validate services array if present (THROWS on error per Linus review)
+        // This is OUTSIDE try-catch - config errors MUST throw
+        validateServices(parsed.services, projectPath);
+        // Merge with defaults (user config may be partial)
+        return mergeConfig(DEFAULT_CONFIG, parsed);
+    }
+    // 2. Fallback to JSON (migration path)
+    if (existsSync(jsonPath)) {
+        logger.warn('⚠ config.json is deprecated. Run "grafema init --force" to migrate to config.yaml');
+        let parsed;
+        try {
+            const content = readFileSync(jsonPath, 'utf-8');
+            parsed = JSON.parse(content);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            logger.warn(`Failed to parse config.json: ${error.message}`);
+            logger.warn('Using default configuration');
+            return DEFAULT_CONFIG;
+        }
+        // Validate services array if present (THROWS on error)
+        // This is OUTSIDE try-catch - config errors MUST throw
+        validateServices(parsed.services, projectPath);
+        return mergeConfig(DEFAULT_CONFIG, parsed);
+    }
+    // 3. No config file - return defaults
+    return DEFAULT_CONFIG;
+}
+/**
+ * Validate services array structure.
+ * THROWS on error (fail loudly per Linus review).
+ *
+ * @param services - Parsed services array (may be undefined)
+ * @param projectPath - Project root for path validation
+ */
+function validateServices(services, projectPath) {
+    // undefined/null is valid (means use defaults)
+    if (services === undefined || services === null) {
+        return;
+    }
+    // Must be an array
+    if (!Array.isArray(services)) {
+        throw new Error(`Config error: services must be an array, got ${typeof services}`);
+    }
+    // Validate each service
+    for (let i = 0; i < services.length; i++) {
+        const svc = services[i];
+        // Must be an object
+        if (typeof svc !== 'object' || svc === null) {
+            throw new Error(`Config error: services[${i}] must be an object`);
+        }
+        // Name validation - required, non-empty string
+        if (typeof svc.name !== 'string') {
+            throw new Error(`Config error: services[${i}].name must be a string, got ${typeof svc.name}`);
+        }
+        if (!svc.name.trim()) {
+            throw new Error(`Config error: services[${i}].name cannot be empty or whitespace-only`);
+        }
+        // Path validation - required, non-empty string
+        if (typeof svc.path !== 'string') {
+            throw new Error(`Config error: services[${i}].path must be a string, got ${typeof svc.path}`);
+        }
+        if (!svc.path.trim()) {
+            throw new Error(`Config error: services[${i}].path cannot be empty or whitespace-only`);
+        }
+        // Path validation - must be relative (reject absolute paths per Linus review)
+        if (svc.path.startsWith('/') || svc.path.startsWith('~')) {
+            throw new Error(`Config error: services[${i}].path must be relative to project root, got "${svc.path}"`);
+        }
+        // Path validation - must exist
+        const absolutePath = join(projectPath, svc.path);
+        if (!existsSync(absolutePath)) {
+            throw new Error(`Config error: services[${i}].path "${svc.path}" does not exist`);
+        }
+        // Path validation - must be directory
+        if (!statSync(absolutePath).isDirectory()) {
+            throw new Error(`Config error: services[${i}].path "${svc.path}" must be a directory`);
+        }
+        // entryPoint validation (optional field) - must be non-empty string if provided
+        if (svc.entryPoint !== undefined) {
+            if (typeof svc.entryPoint !== 'string') {
+                throw new Error(`Config error: services[${i}].entryPoint must be a string, got ${typeof svc.entryPoint}`);
+            }
+            if (!svc.entryPoint.trim()) {
+                throw new Error(`Config error: services[${i}].entryPoint cannot be empty or whitespace-only`);
+            }
+        }
+    }
+}
+/**
+ * Merge user config with defaults.
+ * User config takes precedence, but missing sections use defaults.
+ */
+function mergeConfig(defaults, user) {
+    return {
+        plugins: {
+            discovery: user.plugins?.discovery ?? defaults.plugins.discovery,
+            indexing: user.plugins?.indexing ?? defaults.plugins.indexing,
+            analysis: user.plugins?.analysis ?? defaults.plugins.analysis,
+            enrichment: user.plugins?.enrichment ?? defaults.plugins.enrichment,
+            validation: user.plugins?.validation ?? defaults.plugins.validation,
+        },
+        services: user.services ?? defaults.services,
+    };
+}

package/dist/config/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Configuration loading utilities
+ */
+export { loadConfig, DEFAULT_CONFIG } from './ConfigLoader.js';
+export type { GrafemaConfig } from './ConfigLoader.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/config/index.js

@@ -0,0 +1,4 @@
+/**
+ * Configuration loading utilities
+ */
+export { loadConfig, DEFAULT_CONFIG } from './ConfigLoader.js';

package/dist/core/ASTWorker.d.ts

@@ -3,32 +3,13 @@
  *
  * Receives: { filePath, moduleId, moduleName }
  * Returns: { collections } - extracted AST data for GraphBuilder
+ *
+ * Uses ScopeTracker for semantic ID generation (REG-133).
+ * IDs are stable and don't change when unrelated code is added/removed.
  */
-/**
- * Import node structure
- */
-interface ImportNode {
-    id: string;
-    type: 'IMPORT';
-    name: string;
-    importedName: string;
-    source: string;
-    file: string;
-    line: number;
-}
-/**
- * Export node structure
- */
-interface ExportNode {
-    id: string;
-    type: 'EXPORT';
-    name: string;
-    exportType?: string;
-    localName?: string;
-    isDefault?: boolean;
-    file: string;
-    line: number;
-}
+import { type ClassNodeRecord } from './nodes/ClassNode.js';
+import { type ImportNodeRecord } from './nodes/ImportNode.js';
+import { type ExportNodeRecord } from './nodes/ExportNode.js';
 /**
  * Variable declaration node
  */
@@ -56,7 +37,6 @@ interface ClassInstantiationInfo {
  */
 interface FunctionNode {
     id: string;
-    stableId: string;
     type: 'FUNCTION' | 'METHOD';
     name: string;
     file: string;
@@ -84,15 +64,10 @@ interface ParameterNode {
     line: number;
 }
 /**
- * Class declaration node
+ * Class declaration node (matches ClassNodeRecord from ClassNode factory)
+ * Workers use legacy line-based IDs
  */
-interface ClassDeclarationNode {
-    id: string;
-    type: 'CLASS';
-    name: string;
-    file: string;
-    line: number;
-    superClass: string | null;
+interface ClassDeclarationNode extends ClassNodeRecord {
 }
 /**
  * Call site node
@@ -123,8 +98,8 @@ export interface ASTCollections {
     classDeclarations: ClassDeclarationNode[];
     methodCallbacks: unknown[];
     callArguments: unknown[];
-    imports: ImportNode[];
-    exports: ExportNode[];
+    imports: ImportNodeRecord[];
+    exports: ExportNodeRecord[];
     httpRequests: unknown[];
     literals: unknown[];
     variableAssignments: unknown[];

package/dist/core/ASTWorker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ASTWorker.d.ts","sourceRoot":"","sources":["../../src/core/ASTWorker.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ASTWorker.d.ts","sourceRoot":"","sources":["../../src/core/ASTWorker.ts"],"names":[],"mappings":"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"}

package/dist/core/ASTWorker.js

@@ -3,17 +3,30 @@
  *
  * Receives: { filePath, moduleId, moduleName }
  * Returns: { collections } - extracted AST data for GraphBuilder
+ *
+ * Uses ScopeTracker for semantic ID generation (REG-133).
+ * IDs are stable and don't change when unrelated code is added/removed.
  */
 import { parentPort } from 'worker_threads';
 import { readFileSync } from 'fs';
+import { basename } from 'path';
 import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
+import { ClassNode } from './nodes/ClassNode.js';
+import { ImportNode } from './nodes/ImportNode.js';
+import { ExportNode } from './nodes/ExportNode.js';
+import { ScopeTracker } from './ScopeTracker.js';
+import { computeSemanticId } from './SemanticId.js';
+import { getLine, getColumn } from '../plugins/analysis/ast/utils/location.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const traverse = traverseModule.default || traverseModule;
 // Simplified visitors for extraction (no graph access needed)
 import { ExpressionEvaluator } from '../plugins/analysis/ast/ExpressionEvaluator.js';
 /**
  * Parse a single module and extract all collections
+ *
+ * Uses ScopeTracker for semantic ID generation - IDs are stable
+ * and don't change when unrelated code is added/removed.
  */
 function parseModule(filePath, moduleId, moduleName) {
     const code = readFileSync(filePath, 'utf-8');
@@ -21,6 +34,9 @@ function parseModule(filePath, moduleId, moduleName) {
         sourceType: 'module',
         plugins: ['jsx', 'typescript']
     });
+    // Create ScopeTracker for semantic ID generation
+    // Use basename for shorter, more readable IDs
+    const scopeTracker = new ScopeTracker(basename(filePath));
     // Collections to extract
     const collections = {
         functions: [],
@@ -40,17 +56,7 @@ function parseModule(filePath, moduleId, moduleName) {
         literals: [],
         variableAssignments: []
     };
-    // Counters for unique IDs
-    const counters = {
-        ifScope: 0,
-        scope: 0,
-        varDecl: 0,
-        callSite: 0,
-        function: 0,
-        httpRequest: 0,
-        literal: 0
-    };
-    // Processed nodes tracking
+    // Processed nodes tracking (still needed for deduplication)
     const processed = {
         callSites: new Set(),
         methodCalls: new Set(),
@@ -78,54 +84,35 @@ function parseModule(filePath, moduleId, moduleName) {
                     importedName = spec.imported?.name || spec.local.name;
                     localName = spec.local.name;
                 }
-                collections.imports.push({
-                    id: `IMPORT#${localName}#${filePath}#${node.loc.start.line}`,
-                    type: 'IMPORT',
-                    name: localName,
-                    importedName,
-                    source,
-                    file: filePath,
-                    line: node.loc.start.line
-                });
+                // Babel AST guarantees node.loc exists with locations: true option
+                const importNode = ImportNode.create(localName, // name
+                filePath, // file
+                getLine(node), // line (non-null - Babel guarantees location)
+                0, // column (not available in this worker)
+                source, // source
+                { imported: importedName, local: localName });
+                collections.imports.push(importNode);
             });
         }
     });
-    // Extract exports
+    // Extract exports using semantic IDs (via createWithContext)
     traverse(ast, {
         ExportNamedDeclaration(path) {
             const node = path.node;
             if (node.declaration) {
                 if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
-                    collections.exports.push({
-                        id: `EXPORT#${node.declaration.id.name}#${filePath}#${node.loc.start.line}`,
-                        type: 'EXPORT',
-                        name: node.declaration.id.name,
-                        exportType: 'function',
-                        file: filePath,
-                        line: node.loc.start.line
-                    });
+                    const exportNode = ExportNode.createWithContext(node.declaration.id.name, scopeTracker.getContext(), { line: getLine(node), column: 0 }, { exportType: 'named' });
+                    collections.exports.push(exportNode);
                 }
                 else if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
-                    collections.exports.push({
-                        id: `EXPORT#${node.declaration.id.name}#${filePath}#${node.loc.start.line}`,
-                        type: 'EXPORT',
-                        name: node.declaration.id.name,
-                        exportType: 'class',
-                        file: filePath,
-                        line: node.loc.start.line
-                    });
+                    const exportNode = ExportNode.createWithContext(node.declaration.id.name, scopeTracker.getContext(), { line: getLine(node), column: 0 }, { exportType: 'named' });
+                    collections.exports.push(exportNode);
                 }
                 else if (node.declaration.type === 'VariableDeclaration') {
                     node.declaration.declarations.forEach(decl => {
                         if (decl.id.type === 'Identifier') {
-                            collections.exports.push({
-                                id: `EXPORT#${decl.id.name}#${filePath}#${node.loc.start.line}`,
-                                type: 'EXPORT',
-                                name: decl.id.name,
-                                exportType: 'variable',
-                                file: filePath,
-                                line: node.loc.start.line
-                            });
+                            const exportNode = ExportNode.createWithContext(decl.id.name, scopeTracker.getContext(), { line: getLine(node), column: 0 }, { exportType: 'named' });
+                            collections.exports.push(exportNode);
                         }
                     });
                 }
@@ -135,38 +122,32 @@ function parseModule(filePath, moduleId, moduleName) {
                     if (spec.type !== 'ExportSpecifier')
                         return;
                     const exportedName = spec.exported.type === 'Identifier' ? spec.exported.name : spec.exported.value;
-                    collections.exports.push({
-                        id: `EXPORT#${exportedName}#${filePath}#${node.loc.start.line}`,
-                        type: 'EXPORT',
-                        name: exportedName,
-                        localName: spec.local.name,
-                        file: filePath,
-                        line: node.loc.start.line
+                    const exportNode = ExportNode.createWithContext(exportedName, scopeTracker.getContext(), { line: getLine(node), column: 0 }, {
+                        local: spec.local.name,
+                        exportType: 'named'
                     });
+                    collections.exports.push(exportNode);
                 });
             }
         },
         ExportDefaultDeclaration(path) {
             const node = path.node;
-            let name = 'default';
+            let localName = 'default';
             if (node.declaration.type === 'Identifier') {
-                name = node.declaration.name;
+                localName = node.declaration.name;
             }
             else if ('id' in node.declaration && node.declaration.id) {
-                name = node.declaration.id.name;
+                localName = node.declaration.id.name;
             }
-            collections.exports.push({
-                id: `EXPORT#default#${filePath}#${node.loc.start.line}`,
-                type: 'EXPORT',
-                name: 'default',
-                localName: name,
-                isDefault: true,
-                file: filePath,
-                line: node.loc.start.line
+            const exportNode = ExportNode.createWithContext('default', scopeTracker.getContext(), { line: getLine(node), column: 0 }, {
+                local: localName,
+                default: true,
+                exportType: 'default'
             });
+            collections.exports.push(exportNode);
         }
     });
-    // Extract top-level variables
+    // Extract top-level variables using semantic IDs
     traverse(ast, {
         VariableDeclaration(path) {
             if (path.getFunctionParent())
@@ -176,15 +157,14 @@ function parseModule(filePath, moduleId, moduleName) {
             node.declarations.forEach(decl => {
                 if (decl.id.type === 'Identifier') {
                     const varName = decl.id.name;
-                    const line = decl.id.loc.start.line;
-                    const column = decl.id.loc.start.column;
+                    const line = getLine(decl.id);
                     const literalValue = ExpressionEvaluator.extractLiteralValue(decl.init);
                     const isLiteral = literalValue !== null;
                     const isNewExpr = decl.init?.type === 'NewExpression';
                     const shouldBeConstant = isConst && (isLiteral || isNewExpr);
-                    const varId = shouldBeConstant
-                        ? `CONSTANT#${varName}#${filePath}#${line}:${column}:${counters.varDecl++}`
-                        : `VARIABLE#${varName}#${filePath}#${line}:${column}:${counters.varDecl++}`;
+                    // Generate semantic ID using ScopeTracker
+                    const nodeType = shouldBeConstant ? 'CONSTANT' : 'VARIABLE';
+                    const varId = computeSemanticId(nodeType, varName, scopeTracker.getContext());
                     collections.variableDeclarations.push({
                         id: varId,
                         type: shouldBeConstant ? 'CONSTANT' : 'VARIABLE',
@@ -207,7 +187,7 @@ function parseModule(filePath, moduleId, moduleName) {
             });
         }
     });
-    // Extract functions and classes
+    // Extract functions and classes using semantic IDs
     traverse(ast, {
         FunctionDeclaration(path) {
             if (path.getFunctionParent())
@@ -216,33 +196,38 @@ function parseModule(filePath, moduleId, moduleName) {
             if (!node.id)
                 return;
             const funcName = node.id.name;
-            const functionId = `FUNCTION#${funcName}#${filePath}#${node.loc.start.line}:${node.loc.start.column}`;
+            // Generate semantic ID using ScopeTracker
+            const functionId = computeSemanticId('FUNCTION', funcName, scopeTracker.getContext());
             collections.functions.push({
                 id: functionId,
-                stableId: functionId,
                 type: 'FUNCTION',
                 name: funcName,
                 file: filePath,
-                line: node.loc.start.line,
-                column: node.loc.start.column,
+                line: getLine(node),
+                column: getColumn(node),
                 async: node.async || false,
                 generator: node.generator || false,
                 exported: path.parent?.type === 'ExportNamedDeclaration' || path.parent?.type === 'ExportDefaultDeclaration'
             });
-            // Extract parameters
+            // Enter function scope for parameter extraction
+            scopeTracker.enterScope(funcName, 'FUNCTION');
+            // Extract parameters with semantic IDs
             node.params.forEach((param, index) => {
                 if (param.type === 'Identifier') {
+                    const paramId = computeSemanticId('PARAMETER', param.name, scopeTracker.getContext(), { discriminator: index });
                     collections.parameters.push({
-                        id: `PARAMETER#${param.name}#${functionId}#${index}`,
+                        id: paramId,
                         type: 'PARAMETER',
                         name: param.name,
                         index,
                         functionId,
                         file: filePath,
-                        line: param.loc.start.line
+                        line: getLine(param)
                     });
                 }
             });
+            // Exit function scope
+            scopeTracker.exitScope();
         },
         ClassDeclaration(path) {
             if (path.getFunctionParent())
@@ -251,30 +236,30 @@ function parseModule(filePath, moduleId, moduleName) {
             if (!node.id)
                 return;
             const className = node.id.name;
-            const classId = `CLASS#${className}#${filePath}#${node.loc.start.line}`;
-            collections.classDeclarations.push({
-                id: classId,
-                type: 'CLASS',
-                name: className,
-                file: filePath,
-                line: node.loc.start.line,
-                superClass: node.superClass?.name || null
-            });
-            // Extract methods
+            // Extract superClass name
+            const superClassName = node.superClass && node.superClass.type === 'Identifier'
+                ? node.superClass.name
+                : null;
+            // Create CLASS node using ClassNode.createWithContext() for semantic IDs
+            const classRecord = ClassNode.createWithContext(className, scopeTracker.getContext(), { line: getLine(node), column: getColumn(node) }, { superClass: superClassName || undefined });
+            collections.classDeclarations.push(classRecord);
+            // Enter class scope for method extraction
+            scopeTracker.enterScope(className, 'CLASS');
+            // Extract methods with semantic IDs (including class scope)
             node.body.body.forEach(member => {
                 if (member.type === 'ClassMethod' && member.key.type === 'Identifier') {
                     const methodName = member.key.name;
-                    const methodId = `METHOD#${className}.${methodName}#${filePath}#${member.loc.start.line}`;
+                    // Method ID includes class scope: file->ClassName->FUNCTION->methodName
+                    const methodId = computeSemanticId('FUNCTION', methodName, scopeTracker.getContext());
                     collections.functions.push({
                         id: methodId,
-                        stableId: methodId,
                         type: 'METHOD',
                         name: methodName,
                         className,
-                        classId,
+                        classId: classRecord.id,
                         file: filePath,
-                        line: member.loc.start.line,
-                        column: member.loc.start.column,
+                        line: getLine(member),
+                        column: getColumn(member),
                         async: member.async || false,
                         isClassMethod: true,
                         isConstructor: member.kind === 'constructor',
@@ -282,9 +267,11 @@ function parseModule(filePath, moduleId, moduleName) {
                     });
                 }
             });
+            // Exit class scope
+            scopeTracker.exitScope();
         }
     });
-    // Extract call expressions at module level
+    // Extract call expressions at module level using semantic IDs with discriminators
     traverse(ast, {
         CallExpression(path) {
             if (path.getFunctionParent())
@@ -295,14 +282,18 @@ function parseModule(filePath, moduleId, moduleName) {
                 if (processed.callSites.has(nodeKey))
                     return;
                 processed.callSites.add(nodeKey);
+                // Get discriminator for same-named calls in current scope
+                const calleeName = node.callee.name;
+                const discriminator = scopeTracker.getItemCounter(`CALL:${calleeName}`);
+                const callId = computeSemanticId('CALL', calleeName, scopeTracker.getContext(), { discriminator });
                 collections.callSites.push({
-                    id: `CALL#${node.callee.name}#${filePath}#${node.loc.start.line}:${node.loc.start.column}:${counters.callSite++}`,
+                    id: callId,
                     type: 'CALL',
-                    name: node.callee.name,
+                    name: calleeName,
                     file: filePath,
-                    line: node.loc.start.line,
+                    line: getLine(node),
                     parentScopeId: moduleId,
-                    targetFunctionName: node.callee.name
+                    targetFunctionName: calleeName
                 });
             }
             else if (node.callee.type === 'MemberExpression') {
@@ -315,14 +306,17 @@ function parseModule(filePath, moduleId, moduleName) {
                     const objectName = obj.type === 'Identifier' ? obj.name : 'this';
                     const methodName = prop.name;
                     const fullName = `${objectName}.${methodName}`;
+                    // Get discriminator for same-named method calls
+                    const discriminator = scopeTracker.getItemCounter(`CALL:${fullName}`);
+                    const callId = computeSemanticId('CALL', fullName, scopeTracker.getContext(), { discriminator });
                     collections.methodCalls.push({
-                        id: `CALL#${fullName}#${filePath}#${node.loc.start.line}:${node.loc.start.column}:${counters.callSite++}`,
+                        id: callId,
                         type: 'CALL',
                         name: fullName,
                         object: objectName,
                         method: methodName,
                         file: filePath,
-                        line: node.loc.start.line,
+                        line: getLine(node),
                         parentScopeId: moduleId
                     });
                 }