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

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,21 @@
 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;
 }
 //# 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,EAQT,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;AAwChE;;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;CAqP/B"}

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

@@ -6,16 +6,23 @@
  * - ArrowFunctionExpression (module-level)
  */
 import { ASTVisitor } from './ASTVisitor.js';
+import { typeNodeToString } from './TypeScriptVisitor.js';
+import { IdGenerator } from '../IdGenerator.js';
+import { createParameterNodes } from '../utils/createParameterNodes.js';
+import { getLine, getColumn } from '../utils/location.js';
 export class FunctionVisitor extends ASTVisitor {
     analyzeFunctionBody;
+    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, collections, analyzeFunctionBody) {
+    constructor(module, collections, analyzeFunctionBody, scopeTracker) {
         super(module, collections);
         this.analyzeFunctionBody = analyzeFunctionBody;
+        this.scopeTracker = scopeTracker;
     }
     getHandlers() {
         const { module } = this;
@@ -23,71 +30,96 @@ export class FunctionVisitor extends ASTVisitor {
         const parameters = this.collections.parameters ?? [];
         const scopes = this.collections.scopes ?? [];
         const functionCounterRef = (this.collections.functionCounterRef ?? { value: 0 });
-        const moduleScopeCtx = this.collections.moduleScopeCtx;
+        const scopeTracker = this.scopeTracker;
         const analyzeFunctionBody = this.analyzeFunctionBody;
         const collections = this.collections;
         // Helper function to generate stable anonymous function name
         const generateAnonymousName = () => {
-            if (!moduleScopeCtx)
-                return 'anonymous';
-            const index = moduleScopeCtx.siblingCounters.get('anonymous') || 0;
-            moduleScopeCtx.siblingCounters.set('anonymous', index + 1);
+            const index = scopeTracker.getSiblingIndex('anonymous');
             return `anonymous[${index}]`;
         };
-        // Helper function to create PARAMETER nodes for function params
-        const createParameterNodes = (params, functionId, file, line) => {
-            if (!parameters)
-                return; // Guard for backward compatibility
-            params.forEach((param, index) => {
-                // Handle different parameter types
+        // Helper function to extract parameter names and types from function params
+        const extractParamInfo = (params) => {
+            const names = [];
+            const types = [];
+            params.forEach((param) => {
                 if (param.type === 'Identifier') {
-                    const paramId = `PARAMETER#${param.name}#${file}#${line}:${index}`;
-                    parameters.push({
-                        id: paramId,
-                        type: 'PARAMETER',
-                        name: param.name,
-                        file: file,
-                        line: param.loc?.start.line || line,
-                        index: index,
-                        parentFunctionId: functionId
-                    });
+                    const id = param;
+                    names.push(id.name);
+                    // Check for type annotation
+                    const typeAnnotation = id.typeAnnotation?.typeAnnotation;
+                    types.push(typeAnnotation ? typeNodeToString(typeAnnotation) : 'any');
                 }
                 else if (param.type === 'AssignmentPattern') {
-                    // Default parameter: function(a = 1)
                     const assignmentParam = param;
                     if (assignmentParam.left.type === 'Identifier') {
-                        const paramId = `PARAMETER#${assignmentParam.left.name}#${file}#${line}:${index}`;
-                        parameters.push({
-                            id: paramId,
-                            type: 'PARAMETER',
-                            name: assignmentParam.left.name,
-                            file: file,
-                            line: assignmentParam.left.loc?.start.line || line,
-                            index: index,
-                            hasDefault: true,
-                            parentFunctionId: functionId
-                        });
+                        const id = assignmentParam.left;
+                        names.push(id.name + '?');
+                        const typeAnnotation = id.typeAnnotation?.typeAnnotation;
+                        types.push(typeAnnotation ? typeNodeToString(typeAnnotation) : 'any');
                     }
                 }
                 else if (param.type === 'RestElement') {
-                    // Rest parameter: function(...args)
                     const restParam = param;
                     if (restParam.argument.type === 'Identifier') {
-                        const paramId = `PARAMETER#${restParam.argument.name}#${file}#${line}:${index}`;
-                        parameters.push({
-                            id: paramId,
-                            type: 'PARAMETER',
-                            name: restParam.argument.name,
-                            file: file,
-                            line: restParam.argument.loc?.start.line || line,
-                            index: index,
-                            isRest: true,
-                            parentFunctionId: functionId
-                        });
+                        const id = restParam.argument;
+                        names.push('...' + id.name);
+                        const typeAnnotation = id.typeAnnotation?.typeAnnotation;
+                        types.push(typeAnnotation ? typeNodeToString(typeAnnotation) : 'any[]');
                     }
                 }
-                // ObjectPattern and ArrayPattern (destructuring parameters) can be added later
             });
+            return { names, types };
+        };
+        // Helper function to extract return type from function
+        const extractReturnType = (node) => {
+            const returnTypeAnnotation = node.returnType?.typeAnnotation;
+            if (returnTypeAnnotation) {
+                return typeNodeToString(returnTypeAnnotation);
+            }
+            return 'void';
+        };
+        // Helper function to extract JSDoc summary from leading comments
+        const extractJsdocSummary = (node) => {
+            const comments = node.leadingComments;
+            if (!comments || comments.length === 0)
+                return undefined;
+            // Find the last block comment that looks like JSDoc
+            for (let i = comments.length - 1; i >= 0; i--) {
+                const comment = comments[i];
+                if (comment.type === 'CommentBlock' && comment.value.startsWith('*')) {
+                    // Parse JSDoc - get first non-empty line after the opening
+                    const lines = comment.value.split('\n');
+                    for (const line of lines) {
+                        const trimmed = line.replace(/^\s*\*\s?/, '').trim();
+                        // Skip empty lines and @tags
+                        if (trimmed && !trimmed.startsWith('@')) {
+                            return trimmed.slice(0, 200); // Limit length
+                        }
+                    }
+                }
+            }
+            return undefined;
+        };
+        // Helper function to build function signature
+        const buildSignature = (params, paramTypes, returnType, isAsync) => {
+            const paramParts = params.map((name, i) => {
+                const type = paramTypes[i] || 'any';
+                // Handle rest params
+                if (name.startsWith('...')) {
+                    return `${name}: ${type}`;
+                }
+                // Handle optional params (with ?)
+                if (name.endsWith('?')) {
+                    return `${name}: ${type}`;
+                }
+                return `${name}: ${type}`;
+            });
+            const paramsStr = `(${paramParts.join(', ')})`;
+            const retStr = isAsync && !returnType.startsWith('Promise')
+                ? `Promise<${returnType}>`
+                : returnType;
+            return `${paramsStr} => ${retStr}`;
         };
         return {
             // Regular function declarations
@@ -95,21 +127,36 @@ export class FunctionVisitor extends ASTVisitor {
                 const node = path.node;
                 if (!node.id)
                     return; // Skip anonymous function declarations
-                const functionId = `FUNCTION#${node.id.name}#${module.file}#${node.loc.start.line}`;
+                const isAsync = node.async || false;
+                const line = getLine(node);
+                // Generate ID using centralized IdGenerator
+                const idGenerator = new IdGenerator(scopeTracker);
+                const functionId = idGenerator.generateSimple('FUNCTION', node.id.name, module.file, line);
+                // Extract type info
+                const { names: paramNames, types: paramTypes } = extractParamInfo(node.params);
+                const returnType = extractReturnType(node);
+                const jsdocSummary = extractJsdocSummary(node);
+                const signature = buildSignature(paramNames, paramTypes, returnType, isAsync);
                 functions.push({
                     id: functionId,
-                    stableId: functionId,
                     type: 'FUNCTION',
                     name: node.id.name,
                     file: module.file,
-                    line: node.loc.start.line,
-                    async: node.async || false,
-                    generator: node.generator || false
+                    line,
+                    async: isAsync,
+                    generator: node.generator || false,
+                    params: paramNames,
+                    paramTypes,
+                    returnType,
+                    signature,
+                    jsdocSummary
                 });
+                // Enter function scope BEFORE creating parameters (semantic IDs need function context)
+                scopeTracker.enterScope(node.id.name, 'FUNCTION');
                 // Create PARAMETER nodes for function parameters
-                createParameterNodes(node.params, functionId, module.file, node.loc.start.line);
+                createParameterNodes(node.params, functionId, module.file, getLine(node), parameters, scopeTracker);
                 // Create SCOPE for function body
-                const functionBodyScopeId = `SCOPE#${node.id.name}:body#${module.file}#${node.loc.start.line}`;
+                const functionBodyScopeId = idGenerator.generateScope('body', `${node.id.name}:body`, module.file, line);
                 scopes.push({
                     id: functionBodyScopeId,
                     type: 'SCOPE',
@@ -117,19 +164,22 @@ export class FunctionVisitor extends ASTVisitor {
                     name: `${node.id.name}:body`,
                     conditional: false,
                     file: module.file,
-                    line: node.loc.start.line,
+                    line,
                     parentFunctionId: functionId
                 });
                 // Analyze function body
                 analyzeFunctionBody(path, functionBodyScopeId, module, collections);
+                // Exit function scope
+                scopeTracker.exitScope();
                 // Stop traversal - analyzeFunctionBody already processed contents
                 path.skip();
             },
             // Arrow functions (module-level, assigned to variables or as callbacks)
             ArrowFunctionExpression: (path) => {
                 const node = path.node;
-                const line = node.loc.start.line;
-                const column = node.loc.start.column;
+                const line = getLine(node);
+                const column = getColumn(node);
+                const isAsync = node.async || false;
                 // Determine arrow function name (use scope-level counter for stable semanticId)
                 let functionName = generateAnonymousName();
                 // If arrow function is assigned to variable: const add = () => {}
@@ -140,22 +190,35 @@ export class FunctionVisitor extends ASTVisitor {
                         functionName = declarator.id.name;
                     }
                 }
-                const functionId = `FUNCTION#${functionName}#${module.file}#${line}:${column}:${functionCounterRef.value++}`;
+                // Generate ID using centralized IdGenerator
+                const idGenerator = new IdGenerator(scopeTracker);
+                const functionId = idGenerator.generate('FUNCTION', functionName, module.file, line, column, functionCounterRef);
+                // Extract type info
+                const { names: paramNames, types: paramTypes } = extractParamInfo(node.params);
+                const returnType = extractReturnType(node);
+                const jsdocSummary = extractJsdocSummary(node);
+                const signature = buildSignature(paramNames, paramTypes, returnType, isAsync);
                 functions.push({
                     id: functionId,
-                    stableId: functionId,
                     type: 'FUNCTION',
                     name: functionName,
                     file: module.file,
                     line,
                     column,
-                    async: node.async || false,
-                    arrowFunction: true
+                    async: isAsync,
+                    arrowFunction: true,
+                    params: paramNames,
+                    paramTypes,
+                    returnType,
+                    signature,
+                    jsdocSummary
                 });
+                // Enter function scope BEFORE creating parameters (semantic IDs need function context)
+                scopeTracker.enterScope(functionName, 'FUNCTION');
                 // Create PARAMETER nodes for arrow function parameters
-                createParameterNodes(node.params, functionId, module.file, line);
+                createParameterNodes(node.params, functionId, module.file, line, parameters, scopeTracker);
                 // Create SCOPE for arrow function body
-                const bodyScope = `SCOPE#${functionName}:body#${module.file}#${line}:${column}`;
+                const bodyScope = idGenerator.generateScope('body', `${functionName}:body`, module.file, line, column);
                 scopes.push({
                     id: bodyScope,
                     type: 'SCOPE',
@@ -166,6 +229,8 @@ export class FunctionVisitor extends ASTVisitor {
                     parentFunctionId: functionId
                 });
                 analyzeFunctionBody(path, bodyScope, module, collections);
+                // Exit function scope
+                scopeTracker.exitScope();
             }
         };
     }

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

@@ -1 +1 @@
-{"version":3,"file":"ImportExportVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/ImportExportVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAaV,IAAI,EACL,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAChH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEzD;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,EAAE,IAAI,KAAK,YAAY,EAAE,CAAC;AAuC7E,qBAAa,mBAAoB,SAAQ,UAAU;IACjD,OAAO,CAAC,+BAA+B,CAA+B;IAEtE;;;;OAIG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,+BAA+B,EAAE,4BAA4B;IAM/D,iBAAiB,IAAI,eAAe;IA+CpC,iBAAiB,IAAI,eAAe;IAqHpC,WAAW,IAAI,eAAe;CAM/B"}
+{"version":3,"file":"ImportExportVisitor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/ImportExportVisitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAaV,IAAI,EACL,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAChH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD;;GAEG;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,OAAO,EAAE,IAAI,KAAK,YAAY,EAAE,CAAC;AAwC7E,qBAAa,mBAAoB,SAAQ,UAAU;IACjD,OAAO,CAAC,+BAA+B,CAA+B;IAEtE;;;;OAIG;gBAED,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,kBAAkB,EAC/B,+BAA+B,EAAE,4BAA4B;IAM/D,iBAAiB,IAAI,eAAe;IAgDpC,iBAAiB,IAAI,eAAe;IAsHpC,WAAW,IAAI,eAAe;CAM/B"}