@grafema/core 0.1.0-alpha.5 → 0.2.0-beta

package/dist/plugins/analysis/ast/visitors/ClassVisitor.d.ts

@@ -10,14 +10,17 @@
  */
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
 import type { AnalyzeFunctionBodyCallback } from './FunctionVisitor.js';
+import { ScopeTracker } from '../../../../core/ScopeTracker.js';
 export declare class ClassVisitor extends ASTVisitor {
     private analyzeFunctionBody;
+    private scopeTracker;
     /**
      * @param module - Current module being analyzed
      * @param collections - Must contain arrays and counter refs
      * @param analyzeFunctionBody - Callback to analyze method internals
+     * @param scopeTracker - REQUIRED for semantic ID generation
      */
-    constructor(module: VisitorModule, collections: VisitorCollections, analyzeFunctionBody: AnalyzeFunctionBodyCallback);
+    constructor(module: VisitorModule, collections: VisitorCollections, analyzeFunctionBody: AnalyzeFunctionBodyCallback, scopeTracker: ScopeTracker);
     /**
      * Extract decorator information from a Decorator node
      */

package/dist/plugins/analysis/ast/visitors/ClassVisitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClassVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/ClassVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAaH,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAChH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAqDxE,qBAAa,YAAa,SAAQ,UAAU;IAC1C,OAAO,CAAC,mBAAmB,CAA8B;IAEzD;;;;OAIG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,mBAAmB,EAAE,2BAA2B;IAMlD;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA6C5B,WAAW,IAAI,eAAe;CAqM/B"}
+{"version":3,"file":"ClassVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/ClassVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAaH,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAChH,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAC;AAIxE,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAgDhE,qBAAa,YAAa,SAAQ,UAAU;IAC1C,OAAO,CAAC,mBAAmB,CAA8B;IACzD,OAAO,CAAC,YAAY,CAAe;IAEnC;;;;;OAKG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,mBAAmB,EAAE,2BAA2B,EAChD,YAAY,EAAE,YAAY;IAO5B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA+C5B,WAAW,IAAI,eAAe;CAqP/B"}

package/dist/plugins/analysis/ast/visitors/ClassVisitor.js

@@ -10,16 +10,24 @@
  */
 import { ASTVisitor } from './ASTVisitor.js';
 import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+import { createParameterNodes } from '../utils/createParameterNodes.js';
+import { ClassNode } from '../../../../core/nodes/ClassNode.js';
+import { computeSemanticId } from '../../../../core/SemanticId.js';
+import { getLine, getColumn } from '../utils/location.js';
 export class ClassVisitor extends ASTVisitor {
     analyzeFunctionBody;
+    scopeTracker;
     /**
      * @param module - Current module being analyzed
      * @param collections - Must contain arrays and counter refs
      * @param analyzeFunctionBody - Callback to analyze method internals
+     * @param scopeTracker - REQUIRED for semantic ID generation
      */
-    constructor(module, collections, analyzeFunctionBody) {
+    constructor(module, collections, analyzeFunctionBody, scopeTracker // REQUIRED, not optional
+    ) {
         super(module, collections);
         this.analyzeFunctionBody = analyzeFunctionBody;
+        this.scopeTracker = scopeTracker;
     }
     /**
      * Extract decorator information from a Decorator node
@@ -50,14 +58,16 @@ export class ClassVisitor extends ASTVisitor {
         else {
             return null; // Unsupported decorator type
         }
-        const decoratorId = `DECORATOR#${decoratorName}#${module.file}#${decorator.loc.start.line}:${decorator.loc.start.column}`;
+        const decoratorLine = getLine(decorator);
+        const decoratorColumn = getColumn(decorator);
+        const decoratorId = `DECORATOR#${decoratorName}#${module.file}#${decoratorLine}:${decoratorColumn}`;
         return {
             id: decoratorId,
             type: 'DECORATOR',
             name: decoratorName,
             file: module.file,
-            line: decorator.loc.start.line,
-            column: decorator.loc.start.column,
+            line: decoratorLine,
+            column: decoratorColumn,
             arguments: decoratorArgs,
             targetId,
             targetType
@@ -65,20 +75,24 @@ export class ClassVisitor extends ASTVisitor {
     }
     getHandlers() {
         const { module } = this;
-        const { functions, scopes, classDeclarations, decorators } = this.collections;
+        const { functions, scopes, classDeclarations, decorators, parameters } = this.collections;
         const analyzeFunctionBody = this.analyzeFunctionBody;
         const collections = this.collections;
+        const scopeTracker = this.scopeTracker;
         return {
             ClassDeclaration: (classPath) => {
                 const classNode = classPath.node;
                 if (!classNode.id)
                     return; // Skip anonymous classes
                 const className = classNode.id.name;
-                // Create CLASS node for declaration
-                const classId = `CLASS#${className}#${module.file}#${classNode.loc.start.line}`;
+                // Extract superClass name
                 const superClassName = classNode.superClass?.type === 'Identifier'
                     ? classNode.superClass.name
                     : null;
+                const classLine = getLine(classNode);
+                const classColumn = getColumn(classNode);
+                // Create CLASS node using NodeFactory with semantic ID
+                const classRecord = ClassNode.createWithContext(className, scopeTracker.getContext(), { line: classLine, column: classColumn }, { superClass: superClassName || undefined });
                 // Extract implements (TypeScript)
                 const implementsNames = [];
                 const classNodeWithImplements = classNode;
@@ -89,22 +103,18 @@ export class ClassVisitor extends ASTVisitor {
                         }
                     }
                 }
+                // Store ClassNodeRecord + TypeScript metadata
                 classDeclarations.push({
-                    id: classId,
-                    type: 'CLASS',
-                    name: className,
-                    file: module.file,
-                    line: classNode.loc.start.line,
-                    column: classNode.loc.start.column,
-                    superClass: superClassName,
-                    implements: implementsNames.length > 0 ? implementsNames : undefined,
-                    methods: []
+                    ...classRecord,
+                    implements: implementsNames.length > 0 ? implementsNames : undefined
                 });
+                // Enter class scope for tracking methods
+                scopeTracker.enterScope(className, 'CLASS');
                 // Extract class decorators
                 const classNodeWithDecorators = classNode;
                 if (classNodeWithDecorators.decorators && classNodeWithDecorators.decorators.length > 0 && decorators) {
                     for (const decorator of classNodeWithDecorators.decorators) {
-                        const decoratorInfo = this.extractDecoratorInfo(decorator, classId, 'CLASS', module);
+                        const decoratorInfo = this.extractDecoratorInfo(decorator, classRecord.id, 'CLASS', module);
                         if (decoratorInfo) {
                             decorators.push(decoratorInfo);
                         }
@@ -124,11 +134,13 @@ export class ClassVisitor extends ASTVisitor {
                         const propName = propNode.key.type === 'Identifier'
                             ? propNode.key.name
                             : propNode.key.value || 'anonymous';
+                        const propLine = getLine(propNode);
+                        const propColumn = getColumn(propNode);
                         // Extract property decorators (even for non-function properties)
                         const propNodeWithDecorators = propNode;
                         if (propNodeWithDecorators.decorators && propNodeWithDecorators.decorators.length > 0 && decorators) {
                             // For function properties, target will be set later; for regular properties, create a target ID
-                            const propertyTargetId = `PROPERTY#${className}.${propName}#${module.file}#${propNode.loc.start.line}`;
+                            const propertyTargetId = `PROPERTY#${className}.${propName}#${module.file}#${propLine}`;
                             for (const decorator of propNodeWithDecorators.decorators) {
                                 const decoratorInfo = this.extractDecoratorInfo(decorator, propertyTargetId, 'PROPERTY', module);
                                 if (decoratorInfo) {
@@ -141,37 +153,49 @@ export class ClassVisitor extends ASTVisitor {
                             (propNode.value.type === 'ArrowFunctionExpression' ||
                                 propNode.value.type === 'FunctionExpression')) {
                             const funcNode = propNode.value;
-                            const functionId = `FUNCTION#${className}.${propName}#${module.file}#${propNode.loc.start.line}:${propNode.loc.start.column}`;
+                            // Use semantic ID as primary ID (matching FunctionVisitor pattern)
+                            const legacyId = `FUNCTION#${className}.${propName}#${module.file}#${propLine}:${propColumn}`;
+                            const functionId = computeSemanticId('FUNCTION', propName, scopeTracker.getContext());
                             // Add method to class methods list for CONTAINS edges
                             currentClass.methods.push(functionId);
                             functions.push({
                                 id: functionId,
-                                stableId: functionId,
                                 type: 'FUNCTION',
                                 name: propName,
                                 file: module.file,
-                                line: propNode.loc.start.line,
-                                column: propNode.loc.start.column,
+                                line: propLine,
+                                column: propColumn,
                                 async: funcNode.async || false,
                                 generator: funcNode.type === 'FunctionExpression' ? funcNode.generator || false : false,
                                 arrowFunction: funcNode.type === 'ArrowFunctionExpression',
                                 isClassProperty: true,
-                                className: className
+                                className: className,
+                                legacyId // Keep for debugging/migration purposes
                             });
+                            // Enter method scope for tracking
+                            scopeTracker.enterScope(propName, 'FUNCTION');
+                            // Create PARAMETER nodes for class property function parameters (REG-134)
+                            if (parameters) {
+                                createParameterNodes(funcNode.params, functionId, module.file, propLine, parameters, scopeTracker);
+                            }
                             // Create SCOPE for property function body
-                            const propBodyScopeId = `SCOPE#${className}.${propName}:body#${module.file}#${propNode.loc.start.line}`;
+                            const propBodyScopeId = `SCOPE#${className}.${propName}:body#${module.file}#${propLine}`;
+                            const propBodySemanticId = computeSemanticId('SCOPE', 'body', scopeTracker.getContext());
                             scopes.push({
                                 id: propBodyScopeId,
+                                semanticId: propBodySemanticId,
                                 type: 'SCOPE',
                                 scopeType: 'property_body',
                                 name: `${className}.${propName}:body`,
                                 conditional: false,
                                 file: module.file,
-                                line: propNode.loc.start.line,
+                                line: propLine,
                                 parentFunctionId: functionId
                             });
                             const funcPath = propPath.get('value');
                             analyzeFunctionBody(funcPath, propBodyScopeId, module, collections);
+                            // Exit method scope
+                            scopeTracker.exitScope();
                         }
                     },
                     ClassMethod: (methodPath) => {
@@ -183,22 +207,26 @@ export class ClassVisitor extends ASTVisitor {
                         if (methodPath.parent !== classNode.body) {
                             return;
                         }
-                        const functionId = `FUNCTION#${className}.${methodName}#${module.file}#${methodNode.loc.start.line}:${methodNode.loc.start.column}`;
+                        const methodLine = getLine(methodNode);
+                        const methodColumn = getColumn(methodNode);
+                        // Use semantic ID as primary ID (matching FunctionVisitor pattern)
+                        const legacyId = `FUNCTION#${className}.${methodName}#${module.file}#${methodLine}:${methodColumn}`;
+                        const functionId = computeSemanticId('FUNCTION', methodName, scopeTracker.getContext());
                         // Add method to class methods list for CONTAINS edges
                         currentClass.methods.push(functionId);
                         const funcData = {
                             id: functionId,
-                            stableId: functionId,
                             type: 'FUNCTION',
                             name: methodName,
                             file: module.file,
-                            line: methodNode.loc.start.line,
-                            column: methodNode.loc.start.column,
+                            line: methodLine,
+                            column: methodColumn,
                             async: methodNode.async || false,
                             generator: methodNode.generator || false,
                             isClassMethod: true,
                             className: className,
-                            methodKind: methodNode.kind
+                            methodKind: methodNode.kind,
+                            legacyId // Keep for debugging/migration purposes
                         };
                         functions.push(funcData);
                         // Extract method decorators
@@ -211,21 +239,33 @@ export class ClassVisitor extends ASTVisitor {
                                 }
                             }
                         }
+                        // Enter method scope for tracking
+                        scopeTracker.enterScope(methodName, 'FUNCTION');
+                        // Create PARAMETER nodes for class method parameters (REG-134)
+                        if (parameters) {
+                            createParameterNodes(methodNode.params, functionId, module.file, methodLine, parameters, scopeTracker);
+                        }
                         // Create SCOPE for method body
-                        const methodBodyScopeId = `SCOPE#${className}.${methodName}:body#${module.file}#${methodNode.loc.start.line}`;
+                        const methodBodyScopeId = `SCOPE#${className}.${methodName}:body#${module.file}#${methodLine}`;
+                        const methodBodySemanticId = computeSemanticId('SCOPE', 'body', scopeTracker.getContext());
                         scopes.push({
                             id: methodBodyScopeId,
+                            semanticId: methodBodySemanticId,
                             type: 'SCOPE',
                             scopeType: 'method_body',
                             name: `${className}.${methodName}:body`,
                             conditional: false,
                             file: module.file,
-                            line: methodNode.loc.start.line,
+                            line: methodLine,
                             parentFunctionId: functionId
                         });
                         analyzeFunctionBody(methodPath, methodBodyScopeId, module, collections);
+                        // Exit method scope
+                        scopeTracker.exitScope();
                     }
                 });
+                // Exit class scope
+                scopeTracker.exitScope();
             }
         };
     }

package/dist/plugins/analysis/ast/visitors/FunctionVisitor.d.ts

@@ -8,18 +8,31 @@
 import type { Function } from '@babel/types';
 import type { NodePath } from '@babel/traverse';
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
+import { ScopeTracker } from '../../../../core/ScopeTracker.js';
 /**
  * Callback type for analyzing function bodies
  */
 export type AnalyzeFunctionBodyCallback = (path: NodePath<Function>, scopeId: string, module: VisitorModule, collections: VisitorCollections) => void;
 export declare class FunctionVisitor extends ASTVisitor {
     private analyzeFunctionBody;
+    private scopeTracker;
     /**
      * @param module - Current module being analyzed
      * @param collections - Must contain arrays and counter refs
      * @param analyzeFunctionBody - Callback to analyze function internals
+     * @param scopeTracker - REQUIRED for semantic ID generation
      */
-    constructor(module: VisitorModule, collections: VisitorCollections, analyzeFunctionBody: AnalyzeFunctionBodyCallback);
+    constructor(module: VisitorModule, collections: VisitorCollections, analyzeFunctionBody: AnalyzeFunctionBodyCallback, scopeTracker: ScopeTracker);
     getHandlers(): VisitorHandlers;
+    /**
+     * REG-334: Detect if this function is a Promise executor callback.
+     * If so, register the context so resolve/reject calls can be linked.
+     *
+     * Pattern: new Promise((resolve, reject) => { ... })
+     *
+     * Must be called BEFORE analyzeFunctionBody so the context is available
+     * when resolve/reject calls are processed.
+     */
+    private detectPromiseExecutorContext;
 }
 //# sourceMappingURL=FunctionVisitor.d.ts.map

package/dist/plugins/analysis/ast/visitors/FunctionVisitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/FunctionVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAEV,QAAQ,EAOT,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAmB,MAAM,iBAAiB,CAAC;AAuDjI;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG,CACxC,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,EACxB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,KAC5B,IAAI,CAAC;AAEV,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,OAAO,CAAC,mBAAmB,CAA8B;IAEzD;;;;OAIG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,mBAAmB,EAAE,2BAA2B;IAMlD,WAAW,IAAI,eAAe;CA2K/B"}
+{"version":3,"file":"FunctionVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/FunctionVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAEV,QAAQ,EAUT,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAmB,MAAM,iBAAiB,CAAC;AAEjI,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAyChE;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG,CACxC,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,EACxB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,KAC5B,IAAI,CAAC;AAEV,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,OAAO,CAAC,mBAAmB,CAA8B;IACzD,OAAO,CAAC,YAAY,CAAe;IAEnC;;;;;OAKG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,mBAAmB,EAAE,2BAA2B,EAChD,YAAY,EAAE,YAAY;IAO5B,WAAW,IAAI,eAAe;IA+P9B;;;;;;;;OAQG;IACH,OAAO,CAAC,4BAA4B;CAqDrC"}