@grafema/core 0.1.0-alpha.1

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

@@ -0,0 +1,377 @@
+/**
+ * CallExpressionVisitor - handles function calls and constructor invocations at module level
+ *
+ * Handles:
+ * - Direct function calls: foo()
+ * - Method calls: obj.method()
+ * - Event handlers: obj.on('event', handler)
+ * - Constructor calls: new Foo(), new Function()
+ */
+import { ASTVisitor } from './ASTVisitor.js';
+import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+export class CallExpressionVisitor extends ASTVisitor {
+    constructor(module, collections) {
+        super(module, collections);
+    }
+    /**
+     * Extract argument information for PASSES_ARGUMENT edges
+     */
+    extractArguments(args, callId, module, callArguments, literals, literalCounterRef) {
+        args.forEach((arg, index) => {
+            const argInfo = {
+                callId,
+                argIndex: index,
+                file: module.file,
+                line: arg.loc?.start.line || 0,
+                column: arg.loc?.start.column || 0
+            };
+            // Check for spread: ...arg
+            let actualArg = arg;
+            if (arg.type === 'SpreadElement') {
+                argInfo.isSpread = true;
+                actualArg = arg.argument; // Get the actual argument
+            }
+            // Literal value
+            const literalValue = ExpressionEvaluator.extractLiteralValue(actualArg);
+            if (literalValue !== null) {
+                const literalId = `LITERAL#arg${index}#${module.file}#${argInfo.line}:${argInfo.column}:${literalCounterRef.value++}`;
+                literals.push({
+                    id: literalId,
+                    type: 'LITERAL',
+                    value: literalValue,
+                    valueType: typeof literalValue,
+                    file: module.file,
+                    line: argInfo.line,
+                    column: argInfo.column,
+                    parentCallId: callId,
+                    argIndex: index
+                });
+                argInfo.targetType = 'LITERAL';
+                argInfo.targetId = literalId;
+                argInfo.literalValue = literalValue;
+            }
+            // Variable reference
+            else if (actualArg.type === 'Identifier') {
+                argInfo.targetType = 'VARIABLE';
+                argInfo.targetName = actualArg.name; // Will be resolved in GraphBuilder
+            }
+            // Function expression (callback)
+            else if (actualArg.type === 'ArrowFunctionExpression' || actualArg.type === 'FunctionExpression') {
+                argInfo.targetType = 'FUNCTION';
+                argInfo.functionLine = actualArg.loc?.start.line;
+                argInfo.functionColumn = actualArg.loc?.start.column;
+            }
+            // Call expression (nested call)
+            else if (actualArg.type === 'CallExpression') {
+                argInfo.targetType = 'CALL';
+                // Nested calls will be processed separately, link by position
+                argInfo.nestedCallLine = actualArg.loc?.start.line;
+                argInfo.nestedCallColumn = actualArg.loc?.start.column;
+            }
+            // Member expression: obj.prop or obj[x]
+            else if (actualArg.type === 'MemberExpression') {
+                const memberExpr = actualArg;
+                argInfo.targetType = 'EXPRESSION';
+                argInfo.expressionType = 'MemberExpression';
+                if (memberExpr.object.type === 'Identifier') {
+                    argInfo.objectName = memberExpr.object.name;
+                }
+                if (!memberExpr.computed && memberExpr.property.type === 'Identifier') {
+                    argInfo.propertyName = memberExpr.property.name;
+                }
+            }
+            // Binary/Logical expression: a + b, a && b
+            else if (actualArg.type === 'BinaryExpression' || actualArg.type === 'LogicalExpression') {
+                const expr = actualArg;
+                const operator = expr.operator || '?';
+                const exprName = `<${actualArg.type}:${operator}>`;
+                const expressionId = `EXPRESSION#${exprName}#${module.file}#${argInfo.line}:${argInfo.column}:${literalCounterRef.value++}`;
+                // Create EXPRESSION node
+                literals.push({
+                    id: expressionId,
+                    type: 'EXPRESSION',
+                    expressionType: actualArg.type,
+                    operator: operator,
+                    name: exprName,
+                    file: module.file,
+                    line: argInfo.line,
+                    column: argInfo.column,
+                    parentCallId: callId,
+                    argIndex: index
+                });
+                argInfo.targetType = 'EXPRESSION';
+                argInfo.targetId = expressionId;
+                argInfo.expressionType = actualArg.type;
+                // Track DERIVES_FROM edges for identifiers in expression
+                const identifiers = this.extractIdentifiers(actualArg);
+                const { variableAssignments } = this.collections;
+                if (variableAssignments) {
+                    for (const identName of identifiers) {
+                        variableAssignments.push({
+                            variableId: expressionId,
+                            sourceId: null,
+                            sourceName: identName,
+                            sourceType: 'DERIVES_FROM_VARIABLE',
+                            file: module.file
+                        });
+                    }
+                }
+            }
+            // Object literal
+            else if (actualArg.type === 'ObjectExpression') {
+                argInfo.targetType = 'OBJECT_LITERAL';
+            }
+            // Array literal
+            else if (actualArg.type === 'ArrayExpression') {
+                argInfo.targetType = 'ARRAY_LITERAL';
+            }
+            // Other expression types
+            else {
+                argInfo.targetType = 'EXPRESSION';
+                argInfo.expressionType = actualArg.type;
+            }
+            callArguments.push(argInfo);
+        });
+    }
+    /**
+     * Extract all Identifier names from an expression (recursively)
+     * Used for BinaryExpression/LogicalExpression to track DERIVES_FROM edges
+     */
+    extractIdentifiers(node, identifiers = new Set()) {
+        if (!node)
+            return Array.from(identifiers);
+        if (node.type === 'Identifier') {
+            identifiers.add(node.name);
+        }
+        else if (node.type === 'BinaryExpression' || node.type === 'LogicalExpression') {
+            const expr = node;
+            this.extractIdentifiers(expr.left, identifiers);
+            this.extractIdentifiers(expr.right, identifiers);
+        }
+        else if (node.type === 'UnaryExpression') {
+            const expr = node;
+            this.extractIdentifiers(expr.argument, identifiers);
+        }
+        else if (node.type === 'ConditionalExpression') {
+            const expr = node;
+            this.extractIdentifiers(expr.test, identifiers);
+            this.extractIdentifiers(expr.consequent, identifiers);
+            this.extractIdentifiers(expr.alternate, identifiers);
+        }
+        else if (node.type === 'MemberExpression') {
+            const memberExpr = node;
+            // For obj.prop - track obj (but not prop as it's a property name)
+            if (memberExpr.object.type === 'Identifier') {
+                identifiers.add(memberExpr.object.name);
+            }
+            else {
+                this.extractIdentifiers(memberExpr.object, identifiers);
+            }
+        }
+        else if (node.type === 'CallExpression') {
+            const callExpr = node;
+            // For func() - track func if identifier, and all arguments
+            if (callExpr.callee.type === 'Identifier') {
+                identifiers.add(callExpr.callee.name);
+            }
+            for (const arg of callExpr.arguments) {
+                if (arg.type !== 'SpreadElement') {
+                    this.extractIdentifiers(arg, identifiers);
+                }
+                else {
+                    this.extractIdentifiers(arg.argument, identifiers);
+                }
+            }
+        }
+        return Array.from(identifiers);
+    }
+    /**
+     * Get a stable scope ID for a function parent
+     * Format must match what FunctionVisitor creates:
+     * - FunctionDeclaration: FUNCTION#name#file#line
+     * - ArrowFunctionExpression: FUNCTION#name#file#line:col:counter
+     *
+     * NOTE: We don't have access to the counter here, so for arrow functions
+     * we try to match by name+file+line:col. This may not always work for
+     * multiple arrow functions on the same line.
+     */
+    getFunctionScopeId(functionParent, module) {
+        const funcNode = functionParent.node;
+        const line = funcNode.loc?.start.line || 0;
+        const col = funcNode.loc?.start.column || 0;
+        // FunctionDeclaration with name
+        if (funcNode.type === 'FunctionDeclaration' && funcNode.id?.name) {
+            return `FUNCTION#${funcNode.id.name}#${module.file}#${line}`;
+        }
+        // For arrow functions and other cases, we can't perfectly match the ID
+        // because FunctionVisitor uses a counter. For now, use module.id as fallback
+        // to avoid creating invalid edges. The CALL node will be connected to MODULE
+        // instead of the specific function.
+        return module.id;
+    }
+    getHandlers() {
+        const { module } = this;
+        const callSites = this.collections.callSites ?? [];
+        const methodCalls = this.collections.methodCalls ?? [];
+        const eventListeners = this.collections.eventListeners ?? [];
+        const methodCallbacks = this.collections.methodCallbacks ?? [];
+        const literals = this.collections.literals ?? [];
+        const callArguments = this.collections.callArguments ?? [];
+        const callSiteCounterRef = (this.collections.callSiteCounterRef ?? { value: 0 });
+        const literalCounterRef = (this.collections.literalCounterRef ?? { value: 0 });
+        const processedNodes = this.collections.processedNodes ?? { callSites: new Set(), methodCalls: new Set(), eventListeners: new Set() };
+        return {
+            CallExpression: (path) => {
+                const callNode = path.node;
+                const functionParent = path.getFunctionParent();
+                // Determine parent scope - if inside a function, use function's scope, otherwise module
+                const parentScopeId = functionParent ? this.getFunctionScopeId(functionParent, module) : module.id;
+                // Identifier calls (direct function calls)
+                if (callNode.callee.type === 'Identifier') {
+                    const callee = callNode.callee;
+                    const callId = `CALL#${callee.name}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`;
+                    callSites.push({
+                        id: callId,
+                        type: 'CALL',
+                        name: callee.name,
+                        file: module.file,
+                        line: callNode.loc.start.line,
+                        column: callNode.loc.start.column,
+                        parentScopeId,
+                        targetFunctionName: callee.name
+                    });
+                    // Extract arguments for PASSES_ARGUMENT edges
+                    if (callNode.arguments.length > 0) {
+                        this.extractArguments(callNode.arguments, callId, module, callArguments, literals, literalCounterRef);
+                    }
+                }
+                // MemberExpression calls (method calls at module level)
+                else if (callNode.callee.type === 'MemberExpression') {
+                    const memberCallee = callNode.callee;
+                    const object = memberCallee.object;
+                    const property = memberCallee.property;
+                    const isComputed = memberCallee.computed;
+                    if ((object.type === 'Identifier' || object.type === 'ThisExpression') && property.type === 'Identifier') {
+                        const objectName = object.type === 'Identifier' ? object.name : 'this';
+                        // For computed access obj[x](), methodName is '<computed>' but we save the variable name
+                        const methodName = isComputed ? '<computed>' : property.name;
+                        const computedPropertyVar = isComputed ? property.name : null;
+                        // Special handling for .on() event handlers
+                        if (methodName === 'on' && callNode.arguments.length >= 2) {
+                            const firstArg = callNode.arguments[0];
+                            const secondArg = callNode.arguments[1];
+                            if (firstArg.type === 'StringLiteral') {
+                                const eventName = firstArg.value;
+                                // Dedup check
+                                const nodeKey = `${callNode.start}:${callNode.end}`;
+                                if (processedNodes.eventListeners.has(nodeKey)) {
+                                    return;
+                                }
+                                processedNodes.eventListeners.add(nodeKey);
+                                eventListeners.push({
+                                    id: `event:listener#${eventName}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`,
+                                    type: 'event:listener',
+                                    name: eventName,
+                                    object: objectName,
+                                    file: module.file,
+                                    line: callNode.loc.start.line,
+                                    parentScopeId,
+                                    callbackArg: secondArg
+                                });
+                            }
+                        }
+                        else {
+                            // Regular method call
+                            const nodeKey = `${callNode.start}:${callNode.end}`;
+                            if (processedNodes.methodCalls.has(nodeKey)) {
+                                return;
+                            }
+                            processedNodes.methodCalls.add(nodeKey);
+                            const fullName = `${objectName}.${methodName}`;
+                            const methodCallId = `CALL#${fullName}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`;
+                            methodCalls.push({
+                                id: methodCallId,
+                                type: 'CALL',
+                                name: fullName,
+                                object: objectName,
+                                method: methodName,
+                                computed: isComputed,
+                                computedPropertyVar, // Variable name used in obj[x]() calls
+                                file: module.file,
+                                line: callNode.loc.start.line,
+                                column: callNode.loc.start.column,
+                                parentScopeId
+                            });
+                            // Extract arguments for PASSES_ARGUMENT edges
+                            if (callNode.arguments.length > 0) {
+                                this.extractArguments(callNode.arguments, methodCallId, module, callArguments, literals, literalCounterRef);
+                                // Also track callbacks for HAS_CALLBACK edges
+                                callNode.arguments.forEach((arg) => {
+                                    if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
+                                        methodCallbacks.push({
+                                            methodCallId,
+                                            callbackLine: arg.loc.start.line,
+                                            callbackColumn: arg.loc.start.column,
+                                            callbackType: arg.type
+                                        });
+                                    }
+                                });
+                            }
+                        }
+                    }
+                }
+            },
+            // NewExpression: new Foo(), new Function(), new Map(), etc.
+            NewExpression: (path) => {
+                const newNode = path.node;
+                const functionParent = path.getFunctionParent();
+                const parentScopeId = functionParent ? this.getFunctionScopeId(functionParent, module) : module.id;
+                // Dedup check
+                const nodeKey = `new:${newNode.start}:${newNode.end}`;
+                if (processedNodes.methodCalls.has(nodeKey)) {
+                    return;
+                }
+                processedNodes.methodCalls.add(nodeKey);
+                // new Foo() - Identifier callee
+                if (newNode.callee.type === 'Identifier') {
+                    const callee = newNode.callee;
+                    const constructorName = callee.name;
+                    callSites.push({
+                        id: `CALL#new:${constructorName}#${module.file}#${newNode.loc.start.line}:${newNode.loc.start.column}:${callSiteCounterRef.value++}`,
+                        type: 'CALL',
+                        name: constructorName,
+                        file: module.file,
+                        line: newNode.loc.start.line,
+                        column: newNode.loc.start.column,
+                        parentScopeId,
+                        targetFunctionName: constructorName,
+                        isNew: true // Mark as constructor call
+                    });
+                }
+                // new obj.Constructor() - MemberExpression callee
+                else if (newNode.callee.type === 'MemberExpression') {
+                    const memberCallee = newNode.callee;
+                    const object = memberCallee.object;
+                    const property = memberCallee.property;
+                    if (object.type === 'Identifier' && property.type === 'Identifier') {
+                        const objectName = object.name;
+                        const constructorName = property.name;
+                        const fullName = `${objectName}.${constructorName}`;
+                        methodCalls.push({
+                            id: `CALL#new:${fullName}#${module.file}#${newNode.loc.start.line}:${newNode.loc.start.column}:${callSiteCounterRef.value++}`,
+                            type: 'CALL',
+                            name: fullName,
+                            object: objectName,
+                            method: constructorName,
+                            file: module.file,
+                            line: newNode.loc.start.line,
+                            column: newNode.loc.start.column,
+                            parentScopeId,
+                            isNew: true // Mark as constructor call
+                        });
+                    }
+                }
+            }
+        };
+    }
+}

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

@@ -0,0 +1,27 @@
+/**
+ * ClassVisitor - handles class declarations and their methods
+ *
+ * Handles:
+ * - ClassDeclaration
+ * - ClassMethod (nested)
+ * - ClassProperty with function values (nested)
+ * - Implements (TypeScript)
+ * - Decorators
+ */
+import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
+import type { AnalyzeFunctionBodyCallback } from './FunctionVisitor.js';
+export declare class ClassVisitor extends ASTVisitor {
+    private analyzeFunctionBody;
+    /**
+     * @param module - Current module being analyzed
+     * @param collections - Must contain arrays and counter refs
+     * @param analyzeFunctionBody - Callback to analyze method internals
+     */
+    constructor(module: VisitorModule, collections: VisitorCollections, analyzeFunctionBody: AnalyzeFunctionBodyCallback);
+    /**
+     * Extract decorator information from a Decorator node
+     */
+    private extractDecoratorInfo;
+    getHandlers(): VisitorHandlers;
+}
+//# sourceMappingURL=ClassVisitor.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,232 @@
+/**
+ * ClassVisitor - handles class declarations and their methods
+ *
+ * Handles:
+ * - ClassDeclaration
+ * - ClassMethod (nested)
+ * - ClassProperty with function values (nested)
+ * - Implements (TypeScript)
+ * - Decorators
+ */
+import { ASTVisitor } from './ASTVisitor.js';
+import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+export class ClassVisitor extends ASTVisitor {
+    analyzeFunctionBody;
+    /**
+     * @param module - Current module being analyzed
+     * @param collections - Must contain arrays and counter refs
+     * @param analyzeFunctionBody - Callback to analyze method internals
+     */
+    constructor(module, collections, analyzeFunctionBody) {
+        super(module, collections);
+        this.analyzeFunctionBody = analyzeFunctionBody;
+    }
+    /**
+     * Extract decorator information from a Decorator node
+     */
+    extractDecoratorInfo(decorator, targetId, targetType, module) {
+        let decoratorName;
+        let decoratorArgs;
+        // @Decorator or @Decorator()
+        if (decorator.expression.type === 'Identifier') {
+            decoratorName = decorator.expression.name;
+        }
+        else if (decorator.expression.type === 'CallExpression') {
+            const callExpr = decorator.expression;
+            if (callExpr.callee.type === 'Identifier') {
+                decoratorName = callExpr.callee.name;
+                // Extract arguments (cast to Node since Babel types guarantee these are AST nodes)
+                decoratorArgs = callExpr.arguments.map(arg => {
+                    return ExpressionEvaluator.extractLiteralValue(arg);
+                }).filter(v => v !== null);
+                if (decoratorArgs.length === 0) {
+                    decoratorArgs = undefined;
+                }
+            }
+            else {
+                return null; // Complex decorator expression
+            }
+        }
+        else {
+            return null; // Unsupported decorator type
+        }
+        const decoratorId = `DECORATOR#${decoratorName}#${module.file}#${decorator.loc.start.line}:${decorator.loc.start.column}`;
+        return {
+            id: decoratorId,
+            type: 'DECORATOR',
+            name: decoratorName,
+            file: module.file,
+            line: decorator.loc.start.line,
+            column: decorator.loc.start.column,
+            arguments: decoratorArgs,
+            targetId,
+            targetType
+        };
+    }
+    getHandlers() {
+        const { module } = this;
+        const { functions, scopes, classDeclarations, decorators } = this.collections;
+        const analyzeFunctionBody = this.analyzeFunctionBody;
+        const collections = this.collections;
+        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}`;
+                const superClassName = classNode.superClass?.type === 'Identifier'
+                    ? classNode.superClass.name
+                    : null;
+                // Extract implements (TypeScript)
+                const implementsNames = [];
+                const classNodeWithImplements = classNode;
+                if (classNodeWithImplements.implements && classNodeWithImplements.implements.length > 0) {
+                    for (const impl of classNodeWithImplements.implements) {
+                        if (impl.expression.type === 'Identifier') {
+                            implementsNames.push(impl.expression.name);
+                        }
+                    }
+                }
+                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: []
+                });
+                // 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);
+                        if (decoratorInfo) {
+                            decorators.push(decoratorInfo);
+                        }
+                    }
+                }
+                // Get reference to current class for adding methods
+                const classDeclarationsTyped = classDeclarations;
+                const currentClass = classDeclarationsTyped[classDeclarationsTyped.length - 1];
+                // Process class methods and properties
+                classPath.traverse({
+                    ClassProperty: (propPath) => {
+                        const propNode = propPath.node;
+                        // Skip if not property of current class
+                        if (propPath.parent !== classNode.body) {
+                            return;
+                        }
+                        const propName = propNode.key.type === 'Identifier'
+                            ? propNode.key.name
+                            : propNode.key.value || 'anonymous';
+                        // 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}`;
+                            for (const decorator of propNodeWithDecorators.decorators) {
+                                const decoratorInfo = this.extractDecoratorInfo(decorator, propertyTargetId, 'PROPERTY', module);
+                                if (decoratorInfo) {
+                                    decorators.push(decoratorInfo);
+                                }
+                            }
+                        }
+                        // Only process if value is a function
+                        if (propNode.value &&
+                            (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}`;
+                            // 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,
+                                async: funcNode.async || false,
+                                generator: funcNode.type === 'FunctionExpression' ? funcNode.generator || false : false,
+                                arrowFunction: funcNode.type === 'ArrowFunctionExpression',
+                                isClassProperty: true,
+                                className: className
+                            });
+                            // Create SCOPE for property function body
+                            const propBodyScopeId = `SCOPE#${className}.${propName}:body#${module.file}#${propNode.loc.start.line}`;
+                            scopes.push({
+                                id: propBodyScopeId,
+                                type: 'SCOPE',
+                                scopeType: 'property_body',
+                                name: `${className}.${propName}:body`,
+                                conditional: false,
+                                file: module.file,
+                                line: propNode.loc.start.line,
+                                parentFunctionId: functionId
+                            });
+                            const funcPath = propPath.get('value');
+                            analyzeFunctionBody(funcPath, propBodyScopeId, module, collections);
+                        }
+                    },
+                    ClassMethod: (methodPath) => {
+                        const methodNode = methodPath.node;
+                        const methodName = methodNode.key.type === 'Identifier'
+                            ? methodNode.key.name
+                            : methodNode.key.value || 'anonymous';
+                        // Skip if not method of current class (nested classes)
+                        if (methodPath.parent !== classNode.body) {
+                            return;
+                        }
+                        const functionId = `FUNCTION#${className}.${methodName}#${module.file}#${methodNode.loc.start.line}:${methodNode.loc.start.column}`;
+                        // 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,
+                            async: methodNode.async || false,
+                            generator: methodNode.generator || false,
+                            isClassMethod: true,
+                            className: className,
+                            methodKind: methodNode.kind
+                        };
+                        functions.push(funcData);
+                        // Extract method decorators
+                        const methodNodeWithDecorators = methodNode;
+                        if (methodNodeWithDecorators.decorators && methodNodeWithDecorators.decorators.length > 0 && decorators) {
+                            for (const decorator of methodNodeWithDecorators.decorators) {
+                                const decoratorInfo = this.extractDecoratorInfo(decorator, functionId, 'METHOD', module);
+                                if (decoratorInfo) {
+                                    decorators.push(decoratorInfo);
+                                }
+                            }
+                        }
+                        // Create SCOPE for method body
+                        const methodBodyScopeId = `SCOPE#${className}.${methodName}:body#${module.file}#${methodNode.loc.start.line}`;
+                        scopes.push({
+                            id: methodBodyScopeId,
+                            type: 'SCOPE',
+                            scopeType: 'method_body',
+                            name: `${className}.${methodName}:body`,
+                            conditional: false,
+                            file: module.file,
+                            line: methodNode.loc.start.line,
+                            parentFunctionId: functionId
+                        });
+                        analyzeFunctionBody(methodPath, methodBodyScopeId, module, collections);
+                    }
+                });
+            }
+        };
+    }
+}

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

@@ -0,0 +1,25 @@
+/**
+ * FunctionVisitor - handles function declarations and arrow functions
+ *
+ * Handles:
+ * - FunctionDeclaration
+ * - ArrowFunctionExpression (module-level)
+ */
+import type { Function } from '@babel/types';
+import type { NodePath } from '@babel/traverse';
+import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.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;
+    /**
+     * @param module - Current module being analyzed
+     * @param collections - Must contain arrays and counter refs
+     * @param analyzeFunctionBody - Callback to analyze function internals
+     */
+    constructor(module: VisitorModule, collections: VisitorCollections, analyzeFunctionBody: AnalyzeFunctionBodyCallback);
+    getHandlers(): VisitorHandlers;
+}
+//# sourceMappingURL=FunctionVisitor.d.ts.map

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

@@ -0,0 +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"}