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

package/src/core/ASTWorker.ts

@@ -3,14 +3,24 @@
  *
  * 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, ParserPlugin } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import type { Node, ImportDeclaration, ExportNamedDeclaration, ExportDefaultDeclaration, VariableDeclaration, FunctionDeclaration, ClassDeclaration, CallExpression, Identifier, ExportSpecifier } from '@babel/types';
 import type { NodePath, Visitor } from '@babel/traverse';
+import { ClassNode, type ClassNodeRecord } from './nodes/ClassNode.js';
+import { ImportNode, type ImportNodeRecord } from './nodes/ImportNode.js';
+import { ExportNode, type ExportNodeRecord } 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 as any).default || traverseModule;
@@ -35,32 +45,6 @@ interface ExitMessage {
 
 type WorkerMessage = ParseMessage | ExitMessage;
 
-/**
- * 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;
-}
 
 /**
  * Variable declaration node
@@ -91,7 +75,6 @@ interface ClassInstantiationInfo {
  */
 interface FunctionNode {
   id: string;
-  stableId: string;
   type: 'FUNCTION' | 'METHOD';
   name: string;
   file: string;
@@ -121,15 +104,11 @@ interface ParameterNode {
 }
 
 /**
- * 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 {
+  // All fields inherited from ClassNodeRecord
 }
 
 /**
@@ -162,8 +141,8 @@ export interface ASTCollections {
   classDeclarations: ClassDeclarationNode[];
   methodCallbacks: unknown[];
   callArguments: unknown[];
-  imports: ImportNode[];
-  exports: ExportNode[];
+  imports: ImportNodeRecord[];
+  exports: ExportNodeRecord[];
   httpRequests: unknown[];
   literals: unknown[];
   variableAssignments: unknown[];
@@ -171,6 +150,7 @@ export interface ASTCollections {
 
 /**
  * Counters for unique IDs
+ * @deprecated Use ScopeTracker.getItemCounter() instead
  */
 interface Counters {
   ifScope: number;
@@ -203,6 +183,9 @@ interface ModuleInfo {
 
 /**
  * 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: string, moduleId: string, moduleName: string): ASTCollections {
   const code = readFileSync(filePath, 'utf-8');
@@ -212,6 +195,10 @@ function parseModule(filePath: string, moduleId: string, moduleName: string): AS
     plugins: ['jsx', 'typescript'] as ParserPlugin[]
   });
 
+  // Create ScopeTracker for semantic ID generation
+  // Use basename for shorter, more readable IDs
+  const scopeTracker = new ScopeTracker(basename(filePath));
+
   // Collections to extract
   const collections: ASTCollections = {
     functions: [],
@@ -232,18 +219,7 @@ function parseModule(filePath: string, moduleId: string, moduleName: string): AS
     variableAssignments: []
   };
 
-  // Counters for unique IDs
-  const counters: 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: ProcessedNodes = {
     callSites: new Set(),
     methodCalls: new Set(),
@@ -274,54 +250,52 @@ function parseModule(filePath: string, moduleId: string, moduleName: string): AS
           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: NodePath<ExportNamedDeclaration>) {
       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);
             }
           });
         }
@@ -331,41 +305,45 @@ function parseModule(filePath: string, moduleId: string, moduleName: string): AS
         node.specifiers.forEach(spec => {
           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 as ExportSpecifier).local.name,
-            file: filePath,
-            line: node.loc!.start.line
-          });
+          const exportNode = ExportNode.createWithContext(
+            exportedName,
+            scopeTracker.getContext(),
+            { line: getLine(node), column: 0 },
+            {
+              local: (spec as ExportSpecifier).local.name,
+              exportType: 'named'
+            }
+          );
+          collections.exports.push(exportNode);
         });
       }
     },
 
     ExportDefaultDeclaration(path: NodePath<ExportDefaultDeclaration>) {
       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 as Identifier).name;
+        localName = (node.declaration.id as Identifier).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: NodePath<VariableDeclaration>) {
       if (path.getFunctionParent()) return;
@@ -376,17 +354,16 @@ function parseModule(filePath: string, moduleId: string, moduleName: string): AS
       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,
@@ -412,7 +389,7 @@ function parseModule(filePath: string, moduleId: string, moduleName: string): AS
     }
   });
 
-  // Extract functions and classes
+  // Extract functions and classes using semantic IDs
   traverse(ast, {
     FunctionDeclaration(path: NodePath<FunctionDeclaration>) {
       if (path.getFunctionParent()) return;
@@ -421,35 +398,42 @@ function parseModule(filePath: string, moduleId: string, moduleName: string): AS
       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: NodePath<ClassDeclaration>) {
@@ -459,33 +443,41 @@ function parseModule(filePath: string, moduleId: string, moduleName: string): AS
       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 as Identifier)?.name || null
-      });
+      // Extract superClass name
+      const superClassName = node.superClass && node.superClass.type === 'Identifier'
+        ? (node.superClass as Identifier).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 }
+      );
 
-      // Extract methods
+      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',
@@ -493,10 +485,13 @@ function parseModule(filePath: string, moduleId: string, moduleName: string): AS
           });
         }
       });
+
+      // 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: NodePath<CallExpression>) {
       if (path.getFunctionParent()) return;
@@ -508,14 +503,19 @@ function parseModule(filePath: string, moduleId: string, moduleName: string): AS
         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') {
         const obj = node.callee.object;
@@ -529,14 +529,18 @@ function parseModule(filePath: string, moduleId: string, moduleName: string): AS
           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
           });
         }