@grafema/core 0.2.5-beta → 0.2.7

package/dist/plugins/analysis/ast/utils/extractNamesFromPattern.d.ts

@@ -0,0 +1,81 @@
+/**
+ * extractNamesFromPattern - Extract variable names from destructuring patterns
+ *
+ * Shared utility for extracting variable bindings from ObjectPattern, ArrayPattern,
+ * and nested destructuring patterns. Used by both VariableVisitor (for variable
+ * declarations) and createParameterNodes (for function parameters).
+ *
+ * Handles:
+ * - Object destructuring: { x, y }
+ * - Nested object destructuring: { data: { user } }
+ * - Property renaming: { old: newName }
+ * - Array destructuring: [first, second]
+ * - Sparse array destructuring: [, , third]
+ * - Rest elements: { a, ...rest } or [first, ...rest]
+ * - Default values: { x = 42 } or [x = 10]
+ * - Mixed patterns: { items: [first, second] }
+ *
+ * REG-201: Original implementation for variable destructuring
+ * REG-399: Extended for parameter destructuring support
+ */
+import * as t from '@babel/types';
+/**
+ * Information about an extracted variable from a destructuring pattern.
+ * Used for both VARIABLE nodes (declarations) and PARAMETER nodes (function params).
+ */
+export interface ExtractedVariable {
+    /** Variable name (the binding identifier) */
+    name: string;
+    /** Source location for the binding */
+    loc: {
+        start: {
+            line: number;
+            column: number;
+        };
+    };
+    /** Property path for nested object destructuring (e.g., ['data', 'user'] for { data: { user } }) */
+    propertyPath?: string[];
+    /** Array index for array destructuring (e.g., 0 for first element in [first, second]) */
+    arrayIndex?: number;
+    /** True for rest elements ({ a, ...rest } or [first, ...rest]) */
+    isRest?: boolean;
+    /** True if this binding has a default value (tracked during AssignmentPattern recursion) */
+    hasDefault?: boolean;
+}
+/**
+ * Extract all variable names from a destructuring pattern.
+ *
+ * Pure function - no side effects, no instance state dependencies.
+ * Recursively processes nested patterns and accumulates bindings.
+ *
+ * @param pattern - AST node (ObjectPattern, ArrayPattern, Identifier, etc.)
+ * @param variables - Accumulator for extracted variables (internal)
+ * @param propertyPath - Current property path for nested destructuring (internal)
+ * @param hasDefault - Whether current pattern is wrapped in AssignmentPattern (internal)
+ * @returns Array of extracted variable bindings with metadata
+ *
+ * @example
+ * // Simple object destructuring
+ * const { x, y } = obj;
+ * // Returns: [
+ * //   { name: 'x', loc: {...}, propertyPath: ['x'] },
+ * //   { name: 'y', loc: {...}, propertyPath: ['y'] }
+ * // ]
+ *
+ * @example
+ * // Nested with defaults
+ * const { data: { user = 'guest' } } = response;
+ * // Returns: [
+ * //   { name: 'user', loc: {...}, propertyPath: ['data', 'user'], hasDefault: true }
+ * // ]
+ *
+ * @example
+ * // Array with rest
+ * const [first, ...rest] = items;
+ * // Returns: [
+ * //   { name: 'first', loc: {...}, arrayIndex: 0 },
+ * //   { name: 'rest', loc: {...}, arrayIndex: 1, isRest: true }
+ * // ]
+ */
+export declare function extractNamesFromPattern(pattern: t.Node | null | undefined, variables?: ExtractedVariable[], propertyPath?: string[], hasDefault?: boolean): ExtractedVariable[];
+//# sourceMappingURL=extractNamesFromPattern.d.ts.map

package/dist/plugins/analysis/ast/utils/extractNamesFromPattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractNamesFromPattern.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/utils/extractNamesFromPattern.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAElC;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,GAAG,EAAE;QAAE,KAAK,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACjD,oGAAoG;IACpG,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,yFAAyF;IACzF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,4FAA4F;IAC5F,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,EAClC,SAAS,GAAE,iBAAiB,EAAO,EACnC,YAAY,GAAE,MAAM,EAAO,EAC3B,UAAU,GAAE,OAAe,GAC1B,iBAAiB,EAAE,CAmFrB"}

package/dist/plugins/analysis/ast/utils/extractNamesFromPattern.js

@@ -0,0 +1,140 @@
+/**
+ * extractNamesFromPattern - Extract variable names from destructuring patterns
+ *
+ * Shared utility for extracting variable bindings from ObjectPattern, ArrayPattern,
+ * and nested destructuring patterns. Used by both VariableVisitor (for variable
+ * declarations) and createParameterNodes (for function parameters).
+ *
+ * Handles:
+ * - Object destructuring: { x, y }
+ * - Nested object destructuring: { data: { user } }
+ * - Property renaming: { old: newName }
+ * - Array destructuring: [first, second]
+ * - Sparse array destructuring: [, , third]
+ * - Rest elements: { a, ...rest } or [first, ...rest]
+ * - Default values: { x = 42 } or [x = 10]
+ * - Mixed patterns: { items: [first, second] }
+ *
+ * REG-201: Original implementation for variable destructuring
+ * REG-399: Extended for parameter destructuring support
+ */
+import * as t from '@babel/types';
+/**
+ * Extract all variable names from a destructuring pattern.
+ *
+ * Pure function - no side effects, no instance state dependencies.
+ * Recursively processes nested patterns and accumulates bindings.
+ *
+ * @param pattern - AST node (ObjectPattern, ArrayPattern, Identifier, etc.)
+ * @param variables - Accumulator for extracted variables (internal)
+ * @param propertyPath - Current property path for nested destructuring (internal)
+ * @param hasDefault - Whether current pattern is wrapped in AssignmentPattern (internal)
+ * @returns Array of extracted variable bindings with metadata
+ *
+ * @example
+ * // Simple object destructuring
+ * const { x, y } = obj;
+ * // Returns: [
+ * //   { name: 'x', loc: {...}, propertyPath: ['x'] },
+ * //   { name: 'y', loc: {...}, propertyPath: ['y'] }
+ * // ]
+ *
+ * @example
+ * // Nested with defaults
+ * const { data: { user = 'guest' } } = response;
+ * // Returns: [
+ * //   { name: 'user', loc: {...}, propertyPath: ['data', 'user'], hasDefault: true }
+ * // ]
+ *
+ * @example
+ * // Array with rest
+ * const [first, ...rest] = items;
+ * // Returns: [
+ * //   { name: 'first', loc: {...}, arrayIndex: 0 },
+ * //   { name: 'rest', loc: {...}, arrayIndex: 1, isRest: true }
+ * // ]
+ */
+export function extractNamesFromPattern(pattern, variables = [], propertyPath = [], hasDefault = false) {
+    if (!pattern)
+        return variables;
+    // Base case: Identifier (leaf node)
+    if (t.isIdentifier(pattern)) {
+        variables.push({
+            name: pattern.name,
+            loc: pattern.loc?.start ? { start: pattern.loc.start } : { start: { line: 0, column: 0 } },
+            propertyPath: propertyPath.length > 0 ? [...propertyPath] : undefined,
+            hasDefault: hasDefault || undefined // Only set if true
+        });
+    }
+    // Object destructuring: { x, y, data: { user } }
+    else if (t.isObjectPattern(pattern)) {
+        pattern.properties.forEach((prop) => {
+            // Rest element: { a, ...rest }
+            if (t.isRestElement(prop)) {
+                const restVars = extractNamesFromPattern(prop.argument, [], [], hasDefault);
+                restVars.forEach(v => {
+                    v.isRest = true;
+                    v.propertyPath = propertyPath.length > 0 ? [...propertyPath] : undefined;
+                    variables.push(v);
+                });
+            }
+            // Regular property: { x } or { data: { user } }
+            else if (t.isObjectProperty(prop) && prop.value) {
+                // Extract property key (name in source object)
+                const key = t.isIdentifier(prop.key) ? prop.key.name :
+                    (t.isStringLiteral(prop.key) || t.isNumericLiteral(prop.key) ? String(prop.key.value) : null);
+                if (key !== null) {
+                    // Extend property path for nested destructuring
+                    const newPath = [...propertyPath, key];
+                    extractNamesFromPattern(prop.value, variables, newPath, hasDefault);
+                }
+                else {
+                    // Computed property names - skip path tracking
+                    extractNamesFromPattern(prop.value, variables, propertyPath, hasDefault);
+                }
+            }
+        });
+    }
+    // Array destructuring: [first, second] or [, , third]
+    else if (t.isArrayPattern(pattern)) {
+        pattern.elements.forEach((element, index) => {
+            if (element) {
+                // Rest element: [first, ...rest]
+                if (t.isRestElement(element)) {
+                    const restVars = extractNamesFromPattern(element.argument, [], [], hasDefault);
+                    restVars.forEach(v => {
+                        v.isRest = true;
+                        v.arrayIndex = index;
+                        v.propertyPath = propertyPath.length > 0 ? [...propertyPath] : undefined;
+                        variables.push(v);
+                    });
+                }
+                // Regular element: [first] or [{ x }] (nested)
+                else {
+                    const extracted = extractNamesFromPattern(element, [], propertyPath, hasDefault);
+                    extracted.forEach(v => {
+                        v.arrayIndex = index;
+                        variables.push(v);
+                    });
+                }
+            }
+            // null/undefined element (sparse array: [, , third])
+            // Skip - no binding
+        });
+    }
+    // Rest element (standalone, handled by parent patterns)
+    else if (t.isRestElement(pattern)) {
+        const restVars = extractNamesFromPattern(pattern.argument, [], propertyPath, hasDefault);
+        restVars.forEach(v => {
+            v.isRest = true;
+            variables.push(v);
+        });
+    }
+    // AssignmentPattern: default values (x = 42, { x } = {}, [x] = [])
+    else if (t.isAssignmentPattern(pattern)) {
+        // Recurse on the left side (the pattern), marking hasDefault=true
+        extractNamesFromPattern(pattern.left, variables, propertyPath, true);
+    }
+    return variables;
+}
+//# sourceMappingURL=extractNamesFromPattern.js.map

package/dist/plugins/analysis/ast/utils/extractNamesFromPattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractNamesFromPattern.js","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/utils/extractNamesFromPattern.ts"],"names":[],"mappings":"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"}

package/dist/plugins/analysis/ast/utils/getExpressionValue.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Extract a human-readable string representation of an AST expression value.
+ *
+ * Used to capture initial values, default values, and prop values
+ * in a readable format for graph metadata.
+ *
+ * @module getExpressionValue
+ */
+import type { Node } from '@babel/types';
+/**
+ * @example
+ * // StringLiteral "hello" => '"hello"'
+ * // NumericLiteral 42 => "42"
+ * // Identifier foo => "foo"
+ * // ObjectExpression => "{...}"
+ * // null/undefined => "undefined"
+ *
+ * @param expr - Babel AST expression node (may be undefined)
+ * @returns Human-readable string representation
+ */
+export declare function getExpressionValue(expr: Node | undefined): string;
+//# sourceMappingURL=getExpressionValue.d.ts.map

package/dist/plugins/analysis/ast/utils/getExpressionValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getExpressionValue.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/utils/getExpressionValue.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,MAAM,CAYjE"}

package/dist/plugins/analysis/ast/utils/getExpressionValue.js

@@ -0,0 +1,35 @@
+/**
+ * @example
+ * // StringLiteral "hello" => '"hello"'
+ * // NumericLiteral 42 => "42"
+ * // Identifier foo => "foo"
+ * // ObjectExpression => "{...}"
+ * // null/undefined => "undefined"
+ *
+ * @param expr - Babel AST expression node (may be undefined)
+ * @returns Human-readable string representation
+ */
+export function getExpressionValue(expr) {
+    if (!expr)
+        return 'undefined';
+    if (expr.type === 'StringLiteral')
+        return `"${expr.value}"`;
+    if (expr.type === 'NumericLiteral')
+        return String(expr.value);
+    if (expr.type === 'BooleanLiteral')
+        return String(expr.value);
+    if (expr.type === 'NullLiteral')
+        return 'null';
+    if (expr.type === 'Identifier')
+        return expr.name;
+    if (expr.type === 'ObjectExpression')
+        return '{...}';
+    if (expr.type === 'ArrayExpression')
+        return '[...]';
+    if (expr.type === 'ArrowFunctionExpression')
+        return '() => {...}';
+    if (expr.type === 'FunctionExpression')
+        return 'function() {...}';
+    return '<expression>';
+}
+//# sourceMappingURL=getExpressionValue.js.map

package/dist/plugins/analysis/ast/utils/getExpressionValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getExpressionValue.js","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/utils/getExpressionValue.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAsB;IACvD,IAAI,CAAC,IAAI;QAAE,OAAO,WAAW,CAAC;IAC9B,IAAI,IAAI,CAAC,IAAI,KAAK,eAAe;QAAE,OAAO,IAAK,IAA0B,CAAC,KAAK,GAAG,CAAC;IACnF,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB;QAAE,OAAO,MAAM,CAAE,IAA0B,CAAC,KAAK,CAAC,CAAC;IACrF,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB;QAAE,OAAO,MAAM,CAAE,IAA2B,CAAC,KAAK,CAAC,CAAC;IACtF,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa;QAAE,OAAO,MAAM,CAAC;IAC/C,IAAI,IAAI,CAAC,IAAI,KAAK,YAAY;QAAE,OAAQ,IAAyB,CAAC,IAAI,CAAC;IACvE,IAAI,IAAI,CAAC,IAAI,KAAK,kBAAkB;QAAE,OAAO,OAAO,CAAC;IACrD,IAAI,IAAI,CAAC,IAAI,KAAK,iBAAiB;QAAE,OAAO,OAAO,CAAC;IACpD,IAAI,IAAI,CAAC,IAAI,KAAK,yBAAyB;QAAE,OAAO,aAAa,CAAC;IAClE,IAAI,IAAI,CAAC,IAAI,KAAK,oBAAoB;QAAE,OAAO,kBAAkB,CAAC;IAClE,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/dist/plugins/analysis/ast/utils/getMemberExpressionName.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Extract full dotted name from a MemberExpression AST node.
+ *
+ * Recursively walks the member expression to build
+ * a dotted string like "localStorage.setItem" or "window.history.pushState".
+ *
+ * Returns the Identifier name for non-MemberExpression nodes,
+ * or '<unknown>' / '<computed>' for unresolvable parts.
+ *
+ * @module getMemberExpressionName
+ */
+import type { Node } from '@babel/types';
+/**
+ * @example
+ * // For AST node representing `localStorage.setItem`:
+ * getMemberExpressionName(node) // => "localStorage.setItem"
+ *
+ * // For a plain Identifier node:
+ * getMemberExpressionName(identNode) // => "someVar"
+ *
+ * @param node - Babel AST node (MemberExpression or Identifier)
+ * @returns Dotted name string
+ */
+export declare function getMemberExpressionName(node: Node): string;
+//# sourceMappingURL=getMemberExpressionName.d.ts.map

package/dist/plugins/analysis/ast/utils/getMemberExpressionName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMemberExpressionName.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/utils/getMemberExpressionName.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAQ1D"}

package/dist/plugins/analysis/ast/utils/getMemberExpressionName.js

@@ -0,0 +1,21 @@
+/**
+ * @example
+ * // For AST node representing `localStorage.setItem`:
+ * getMemberExpressionName(node) // => "localStorage.setItem"
+ *
+ * // For a plain Identifier node:
+ * getMemberExpressionName(identNode) // => "someVar"
+ *
+ * @param node - Babel AST node (MemberExpression or Identifier)
+ * @returns Dotted name string
+ */
+export function getMemberExpressionName(node) {
+    if (node.type !== 'MemberExpression') {
+        return node.name || '<unknown>';
+    }
+    const memExpr = node;
+    const object = getMemberExpressionName(memExpr.object);
+    const property = memExpr.property.name || memExpr.property.value || '<computed>';
+    return `${object}.${property}`;
+}
+//# sourceMappingURL=getMemberExpressionName.js.map

package/dist/plugins/analysis/ast/utils/getMemberExpressionName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMemberExpressionName.js","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/utils/getMemberExpressionName.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAU;IAChD,IAAI,IAAI,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;QACrC,OAAQ,IAA0B,CAAC,IAAI,IAAI,WAAW,CAAC;IACzD,CAAC;IACD,MAAM,OAAO,GAAG,IAAqE,CAAC;IACtF,MAAM,MAAM,GAAG,uBAAuB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACvD,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,YAAY,CAAC;IACjF,OAAO,GAAG,MAAM,IAAI,QAAQ,EAAE,CAAC;AACjC,CAAC"}

package/dist/plugins/analysis/ast/utils/index.d.ts

@@ -3,4 +3,6 @@
  */
 export { createParameterNodes } from './createParameterNodes.js';
 export { getNodeLocation, getLine, getColumn, getEndLocation, UNKNOWN_LOCATION, type NodeLocation } from './location.js';
+export { getMemberExpressionName } from './getMemberExpressionName.js';
+export { getExpressionValue } from './getExpressionValue.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/plugins/analysis/ast/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EACL,eAAe,EACf,OAAO,EACP,SAAS,EACT,cAAc,EACd,gBAAgB,EAChB,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EACL,eAAe,EACf,OAAO,EACP,SAAS,EACT,cAAc,EACd,gBAAgB,EAChB,KAAK,YAAY,EAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/plugins/analysis/ast/utils/index.js

@@ -3,4 +3,6 @@
  */
 export { createParameterNodes } from './createParameterNodes.js';
 export { getNodeLocation, getLine, getColumn, getEndLocation, UNKNOWN_LOCATION } from './location.js';
+export { getMemberExpressionName } from './getMemberExpressionName.js';
+export { getExpressionValue } from './getExpressionValue.js';
 //# sourceMappingURL=index.js.map

package/dist/plugins/analysis/ast/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EACL,eAAe,EACf,OAAO,EACP,SAAS,EACT,cAAc,EACd,gBAAgB,EAEjB,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EACL,eAAe,EACf,OAAO,EACP,SAAS,EACT,cAAc,EACd,gBAAgB,EAEjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}

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

@@ -0,0 +1,23 @@
+/**
+ * ArgumentExtractor — extracts argument info for PASSES_ARGUMENT edges.
+ *
+ * Handles object/array literals, primitive literals, variables, callbacks,
+ * nested calls, member expressions, and binary/logical expressions.
+ * Extracted from CallExpressionVisitor.ts (REG-424).
+ */
+import type { Node, CallExpression } from '@babel/types';
+import type { VisitorModule, VisitorCollections, CounterRef } from './ASTVisitor.js';
+import type { ScopeTracker } from '../../../../core/ScopeTracker.js';
+import type { ArgumentInfo, LiteralInfo } from './call-expression-types.js';
+export declare class ArgumentExtractor {
+    /**
+     * Extract argument information for PASSES_ARGUMENT edges.
+     */
+    static extract(args: CallExpression['arguments'], callId: string, module: VisitorModule, callArguments: ArgumentInfo[], literals: LiteralInfo[], literalCounterRef: CounterRef, collections: VisitorCollections, scopeTracker?: ScopeTracker): void;
+    /**
+     * Extract all Identifier names from an expression (recursively).
+     * Used for BinaryExpression/LogicalExpression to track DERIVES_FROM edges.
+     */
+    static extractIdentifiers(node: Node | null | undefined, identifiers?: Set<string>): string[];
+}
+//# sourceMappingURL=ArgumentExtractor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ArgumentExtractor.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/analysis/ast/visitors/ArgumentExtractor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAmE,MAAM,cAAc,CAAC;AAK1H,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACrF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAGrE,OAAO,KAAK,EAEV,YAAY,EAAE,WAAW,EAC1B,MAAM,4BAA4B,CAAC;AAEpC,qBAAa,iBAAiB;IAC5B;;OAEG;IACH,MAAM,CAAC,OAAO,CACZ,IAAI,EAAE,cAAc,CAAC,WAAW,CAAC,EACjC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,aAAa,EACrB,aAAa,EAAE,YAAY,EAAE,EAC7B,QAAQ,EAAE,WAAW,EAAE,EACvB,iBAAiB,EAAE,UAAU,EAC7B,WAAW,EAAE,kBAAkB,EAC/B,YAAY,CAAC,EAAE,YAAY,GAC1B,IAAI;IAiOP;;;OAGG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,EAAE,WAAW,GAAE,GAAG,CAAC,MAAM,CAAa,GAAG,MAAM,EAAE;CA0CzG"}

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

@@ -0,0 +1,241 @@
+/**
+ * ArgumentExtractor — extracts argument info for PASSES_ARGUMENT edges.
+ *
+ * Handles object/array literals, primitive literals, variables, callbacks,
+ * nested calls, member expressions, and binary/logical expressions.
+ * Extracted from CallExpressionVisitor.ts (REG-424).
+ */
+import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+import { NodeFactory } from '../../../../core/NodeFactory.js';
+import { ObjectLiteralNode } from '../../../../core/nodes/ObjectLiteralNode.js';
+import { ArrayLiteralNode } from '../../../../core/nodes/ArrayLiteralNode.js';
+import { ObjectPropertyExtractor } from './ObjectPropertyExtractor.js';
+import { ArrayElementExtractor } from './ArrayElementExtractor.js';
+export class ArgumentExtractor {
+    /**
+     * Extract argument information for PASSES_ARGUMENT edges.
+     */
+    static extract(args, callId, module, callArguments, literals, literalCounterRef, collections, scopeTracker) {
+        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
+            }
+            // Object literal - check BEFORE extractLiteralValue to handle object-typed args properly
+            if (actualArg.type === 'ObjectExpression') {
+                const objectExpr = actualArg;
+                // Initialize collections if not exist (must assign back to collections!)
+                if (!collections.objectLiteralCounterRef) {
+                    collections.objectLiteralCounterRef = { value: 0 };
+                }
+                if (!collections.objectLiterals) {
+                    collections.objectLiterals = [];
+                }
+                if (!collections.objectProperties) {
+                    collections.objectProperties = [];
+                }
+                const objectLiteralCounterRef = collections.objectLiteralCounterRef;
+                // Use factory to create OBJECT_LITERAL node
+                const objectNode = ObjectLiteralNode.create(module.file, argInfo.line, argInfo.column, {
+                    parentCallId: callId,
+                    argIndex: index,
+                    counter: objectLiteralCounterRef.value++
+                });
+                // Factory guarantees line is set, cast to ObjectLiteralInfo
+                collections.objectLiterals.push(objectNode);
+                const objectId = objectNode.id;
+                // Extract properties
+                ObjectPropertyExtractor.extract(objectExpr, objectId, module, collections.objectProperties, collections.objectLiterals, objectLiteralCounterRef, literals, literalCounterRef, collections, scopeTracker);
+                argInfo.targetType = 'OBJECT_LITERAL';
+                argInfo.targetId = objectId;
+            }
+            // Array literal - check BEFORE extractLiteralValue to handle array-typed args properly
+            else if (actualArg.type === 'ArrayExpression') {
+                const arrayExpr = actualArg;
+                // Initialize collections if not exist (must assign back to collections!)
+                if (!collections.arrayLiteralCounterRef) {
+                    collections.arrayLiteralCounterRef = { value: 0 };
+                }
+                if (!collections.arrayLiterals) {
+                    collections.arrayLiterals = [];
+                }
+                if (!collections.arrayElements) {
+                    collections.arrayElements = [];
+                }
+                if (!collections.objectLiteralCounterRef) {
+                    collections.objectLiteralCounterRef = { value: 0 };
+                }
+                if (!collections.objectLiterals) {
+                    collections.objectLiterals = [];
+                }
+                if (!collections.objectProperties) {
+                    collections.objectProperties = [];
+                }
+                const arrayLiteralCounterRef = collections.arrayLiteralCounterRef;
+                // Use factory to create ARRAY_LITERAL node
+                const arrayNode = ArrayLiteralNode.create(module.file, argInfo.line, argInfo.column, {
+                    parentCallId: callId,
+                    argIndex: index,
+                    counter: arrayLiteralCounterRef.value++
+                });
+                // Factory guarantees line is set, cast to ArrayLiteralInfo
+                collections.arrayLiterals.push(arrayNode);
+                const arrayId = arrayNode.id;
+                // Extract elements
+                ArrayElementExtractor.extract(arrayExpr, arrayId, module, collections.arrayElements, collections.arrayLiterals, arrayLiteralCounterRef, collections.objectLiterals, collections.objectLiteralCounterRef, collections.objectProperties, literals, literalCounterRef, collections, scopeTracker);
+                argInfo.targetType = 'ARRAY_LITERAL';
+                argInfo.targetId = arrayId;
+            }
+            // Literal value (primitives only - objects/arrays handled above)
+            else {
+                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 counter = literalCounterRef.value++;
+                    // Create EXPRESSION node via NodeFactory
+                    const expressionNode = NodeFactory.createArgumentExpression(actualArg.type, module.file, argInfo.line, argInfo.column, {
+                        parentCallId: callId,
+                        argIndex: index,
+                        operator,
+                        counter
+                    });
+                    literals.push(expressionNode);
+                    argInfo.targetType = 'EXPRESSION';
+                    argInfo.targetId = expressionNode.id;
+                    argInfo.expressionType = actualArg.type;
+                    // Track DERIVES_FROM edges for identifiers in expression
+                    const identifiers = ArgumentExtractor.extractIdentifiers(actualArg);
+                    const { variableAssignments } = collections;
+                    if (variableAssignments) {
+                        for (const identName of identifiers) {
+                            variableAssignments.push({
+                                variableId: expressionNode.id,
+                                sourceId: null,
+                                sourceName: identName,
+                                sourceType: 'DERIVES_FROM_VARIABLE',
+                                file: module.file
+                            });
+                        }
+                    }
+                }
+                // Other expression types (fallback for unhandled 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.
+     */
+    static 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;
+            ArgumentExtractor.extractIdentifiers(expr.left, identifiers);
+            ArgumentExtractor.extractIdentifiers(expr.right, identifiers);
+        }
+        else if (node.type === 'UnaryExpression') {
+            const expr = node;
+            ArgumentExtractor.extractIdentifiers(expr.argument, identifiers);
+        }
+        else if (node.type === 'ConditionalExpression') {
+            const expr = node;
+            ArgumentExtractor.extractIdentifiers(expr.test, identifiers);
+            ArgumentExtractor.extractIdentifiers(expr.consequent, identifiers);
+            ArgumentExtractor.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 {
+                ArgumentExtractor.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') {
+                    ArgumentExtractor.extractIdentifiers(arg, identifiers);
+                }
+                else {
+                    ArgumentExtractor.extractIdentifiers(arg.argument, identifiers);
+                }
+            }
+        }
+        return Array.from(identifiers);
+    }
+}
+//# sourceMappingURL=ArgumentExtractor.js.map