@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.596f0eb

package/packages/ai/src/lib/dataStructure/helpers/PathManager.js

@@ -0,0 +1,178 @@
+/**
+ * PathManager
+ *
+ * Centralized utility for schema path manipulation with built-in caching.
+ * Handles splitting, joining, and validating schema paths used throughout
+ * the ScopeDataStructure analysis.
+ *
+ * ## Context in the Analysis Pipeline
+ *
+ * Schema paths are dot-separated strings representing data access patterns:
+ * - `signature[0].user.id` - First argument's user.id property
+ * - `items[].name` - name property of array elements
+ * - `functionCallReturnValue(fetch).data` - Return value from fetch() call
+ *
+ * These paths are created during AST analysis and used extensively in:
+ * 1. **Equivalency tracking** - Linking data flow between scopes
+ * 2. **Schema building** - Determining the shape of function inputs/outputs
+ * 3. **Database queries** - Finding source/usage relationships
+ *
+ * ## Performance Notes
+ *
+ * Path operations are called thousands of times per analysis. Caching
+ * provides ~10x speedup for repeated operations on the same paths.
+ *
+ * ## Related Modules
+ *
+ * - `splitOutsideParentheses.ts` - Low-level split/join with parentheses awareness
+ * - `cleanPath.ts` - Normalizes paths by removing noise
+ * - `uniqueIdUtils.ts` - Creates unique keys from scope+path combinations
+ */
+import { joinParenthesesAndArrays, splitOutsideParenthesesAndArrays, } from "../../splitOutsideParentheses.js";
+import cleanOutBoundary from "../../cleanOutBoundary.js";
+export class PathManager {
+    constructor() {
+        this.pathPartsCache = new Map();
+        this.pathJoinCache = new Map();
+        this.isValidPathCache = new Map();
+        this.stripGenericsCache = new Map();
+    }
+    /**
+     * Splits a schema path into its component parts.
+     * Results are cached for performance.
+     *
+     * IMPORTANT: The returned array must NOT be mutated by callers.
+     * This allows us to return the cached array directly without cloning,
+     * providing significant performance gains (structuredClone is expensive).
+     *
+     * @example
+     * splitPath('user.profile.name') // ['user', 'profile', 'name']
+     * splitPath('items[].id') // ['items[]', 'id']
+     */
+    splitPath(path) {
+        const cached = this.pathPartsCache.get(path);
+        if (cached) {
+            return cached;
+        }
+        const pathParts = splitOutsideParenthesesAndArrays(path);
+        this.pathPartsCache.set(path, pathParts);
+        return pathParts;
+    }
+    /**
+     * Joins path parts back into a schema path string.
+     * Results are cached for performance.
+     *
+     * @example
+     * joinPathParts(['user', 'profile', 'name']) // 'user.profile.name'
+     */
+    joinPathParts(pathParts) {
+        const cacheKey = pathParts.join('|');
+        if (this.pathJoinCache.has(cacheKey)) {
+            return this.pathJoinCache.get(cacheKey);
+        }
+        const result = joinParenthesesAndArrays(pathParts);
+        this.pathJoinCache.set(cacheKey, result);
+        return result;
+    }
+    /**
+     * Validates whether a string is a valid schema path.
+     * Results are cached for performance since this is called very frequently.
+     * Rejects:
+     * - Non-strings
+     * - Empty strings
+     * - Boolean literals ('true', 'false')
+     * - Numeric strings
+     * - Quoted strings (starting with ' or ")
+     * - Paths containing whitespace outside of brackets
+     */
+    isValidPath(path) {
+        // Quick type checks (not cacheable)
+        if (typeof path !== 'string' || !path) {
+            return false;
+        }
+        // Check cache first
+        if (this.isValidPathCache.has(path)) {
+            return this.isValidPathCache.get(path);
+        }
+        // Compute validity
+        let result = true;
+        if (path === 'true' || path === 'false') {
+            result = false;
+        }
+        else if (!isNaN(Number(path))) {
+            result = false;
+        }
+        else if (path.charCodeAt(0) === 39 || path.charCodeAt(0) === 34) {
+            // Check for ' (39) or " (34) at start - faster than regex
+            result = false;
+        }
+        else {
+            // Check for whitespace in path parts
+            result = this.splitPath(path).every((part) => {
+                const cleaned = cleanOutBoundary(cleanOutBoundary(cleanOutBoundary(part, '<', '>'), '[', ']'));
+                // Use indexOf instead of regex for speed
+                return (cleaned.indexOf(' ') === -1 &&
+                    cleaned.indexOf('\t') === -1 &&
+                    cleaned.indexOf('\n') === -1);
+            });
+        }
+        this.isValidPathCache.set(path, result);
+        return result;
+    }
+    /**
+     * Strips generic type parameters from a name.
+     * Cached for performance since this is called frequently.
+     *
+     * @example
+     * stripGenerics('MyComponent<Props>') // 'MyComponent'
+     * stripGenerics('Array<T>') // 'Array'
+     * stripGenerics('Simple') // 'Simple'
+     */
+    stripGenerics(name) {
+        if (this.stripGenericsCache.has(name)) {
+            return this.stripGenericsCache.get(name);
+        }
+        // Find position of '<' - if not found, return original
+        const ltIndex = name.indexOf('<');
+        const result = ltIndex === -1 ? name : name.slice(0, ltIndex);
+        this.stripGenericsCache.set(name, result);
+        return result;
+    }
+    /**
+     * Clears all caches. Useful for testing or memory management.
+     */
+    clearCache() {
+        this.pathPartsCache.clear();
+        this.pathJoinCache.clear();
+        this.isValidPathCache.clear();
+        this.stripGenericsCache.clear();
+    }
+    /**
+     * Returns cache statistics for debugging/monitoring.
+     */
+    getCacheStats() {
+        return {
+            pathParts: this.pathPartsCache.size,
+            pathJoin: this.pathJoinCache.size,
+            isValidPath: this.isValidPathCache.size,
+            stripGenerics: this.stripGenericsCache.size,
+        };
+    }
+}
+// Default instance for simple use cases
+export const defaultPathManager = new PathManager();
+// Convenience functions that use the default instance
+// These can be used when a shared cache is acceptable
+export function splitPath(path) {
+    return defaultPathManager.splitPath(path);
+}
+export function joinPathParts(pathParts) {
+    return defaultPathManager.joinPathParts(pathParts);
+}
+export function isValidPath(path) {
+    return defaultPathManager.isValidPath(path);
+}
+export function stripGenerics(name) {
+    return defaultPathManager.stripGenerics(name);
+}
+//# sourceMappingURL=PathManager.js.map

package/packages/ai/src/lib/dataStructure/helpers/PathManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PathManager.js","sourceRoot":"","sources":["../../../../../../../../packages/ai/src/lib/dataStructure/helpers/PathManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,EACL,wBAAwB,EACxB,gCAAgC,GACjC,MAAM,+BAA+B,CAAC;AACvC,OAAO,gBAAgB,MAAM,wBAAwB,CAAC;AAEtD,MAAM,OAAO,WAAW;IAAxB;QACU,mBAAc,GAA0B,IAAI,GAAG,EAAE,CAAC;QAClD,kBAAa,GAAwB,IAAI,GAAG,EAAE,CAAC;QAC/C,qBAAgB,GAAyB,IAAI,GAAG,EAAE,CAAC;QACnD,uBAAkB,GAAwB,IAAI,GAAG,EAAE,CAAC;IA4I9D,CAAC;IA1IC;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,IAAY;QACpB,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,MAAM,SAAS,GAAG,gCAAgC,CAAC,IAAI,CAAC,CAAC;QACzD,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QACzC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;;;;OAMG;IACH,aAAa,CAAC,SAA4B;QACxC,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YACrC,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAE,CAAC;QAC3C,CAAC;QACD,MAAM,MAAM,GAAG,wBAAwB,CAAC,SAAqB,CAAC,CAAC;QAC/D,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACzC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;;;;;OAUG;IACH,WAAW,CAAC,IAAY;QACtB,oCAAoC;QACpC,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;YACtC,OAAO,KAAK,CAAC;QACf,CAAC;QAED,oBAAoB;QACpB,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACpC,OAAO,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC;QAC1C,CAAC;QAED,mBAAmB;QACnB,IAAI,MAAM,GAAG,IAAI,CAAC;QAElB,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;YACxC,MAAM,GAAG,KAAK,CAAC;QACjB,CAAC;aAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAChC,MAAM,GAAG,KAAK,CAAC;QACjB,CAAC;aAAM,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC;YAClE,0DAA0D;YAC1D,MAAM,GAAG,KAAK,CAAC;QACjB,CAAC;aAAM,CAAC;YACN,qCAAqC;YACrC,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE;gBAC3C,MAAM,OAAO,GAAG,gBAAgB,CAC9B,gBAAgB,CAAC,gBAAgB,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAC7D,CAAC;gBACF,yCAAyC;gBACzC,OAAO,CACL,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;oBAC3B,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBAC5B,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAC7B,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACxC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;;;;;;;OAQG;IACH,aAAa,CAAC,IAAY;QACxB,IAAI,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACtC,OAAO,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC;QAC5C,CAAC;QAED,uDAAuD;QACvD,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;QAE9D,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC1C,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,UAAU;QACR,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAC5B,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;QAC9B,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,aAAa;QAMX,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,IAAI;YACnC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI;YACjC,WAAW,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI;YACvC,aAAa,EAAE,IAAI,CAAC,kBAAkB,CAAC,IAAI;SAC5C,CAAC;IACJ,CAAC;CACF;AAED,wCAAwC;AACxC,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,WAAW,EAAE,CAAC;AAEpD,sDAAsD;AACtD,sDAAsD;AACtD,MAAM,UAAU,SAAS,CAAC,IAAY;IACpC,OAAO,kBAAkB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;AAC5C,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,SAA4B;IACxD,OAAO,kBAAkB,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;AACrD,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,IAAY;IACtC,OAAO,kBAAkB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;AAC9C,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;AAChD,CAAC"}

package/packages/ai/src/lib/dataStructure/helpers/ScopeTreeManager.js

@@ -0,0 +1,138 @@
+/**
+ * ScopeTreeManager
+ *
+ * Manages the hierarchical tree structure of scopes in the analysis.
+ * Tracks parent-child relationships between function scopes.
+ *
+ * ## Purpose
+ *
+ * When analyzing nested functions, we need to track which functions
+ * are defined inside other functions. This affects:
+ * - Variable scope inheritance (inner functions can access outer variables)
+ * - Equivalency propagation (data flows between parent and child scopes)
+ * - Schema merging (combining schemas from nested call hierarchies)
+ *
+ * ## Tree Structure Example
+ *
+ * For code like:
+ * ```typescript
+ * function outer(data) {
+ *   function inner(item) {
+ *     return item.name;
+ *   }
+ *   return data.map(inner);
+ * }
+ * ```
+ *
+ * The tree would be:
+ * ```
+ * outer
+ *   └── inner
+ * ```
+ *
+ * ## Key Operations
+ *
+ * - `addPath(['outer', 'inner'])` - Builds tree as scopes are discovered
+ * - `findNode('inner')` - Locates scope node for equivalency lookups
+ * - `getTree()` - Returns full tree for debugging/visualization
+ *
+ * ## Related Modules
+ *
+ * - `ScopeDataStructure.addScopeAnalysis()` - Adds paths when processing scopes
+ * - `ScopeDataStructure.getAnalysisTree()` - Exposes tree to callers
+ */
+export const ROOT_SCOPE_NAME = 'root';
+export class ScopeTreeManager {
+    constructor(rootName = ROOT_SCOPE_NAME) {
+        this.tree = { name: rootName, children: [] };
+    }
+    /**
+     * Gets the name of the root scope.
+     * This is frequently used as the default scope name throughout the analysis.
+     */
+    getRootName() {
+        return this.tree.name;
+    }
+    /**
+     * Sets the name of the root scope.
+     * Called during initialization when the actual root scope name is known.
+     */
+    setRootName(name) {
+        this.tree.name = name;
+    }
+    /**
+     * Gets the entire tree structure.
+     * Used by getAnalysisTree() to return the scope hierarchy.
+     */
+    getTree() {
+        return this.tree;
+    }
+    /**
+     * Adds a scope path to the tree.
+     * Creates intermediate nodes as needed.
+     *
+     * @param pathParts - Array of scope names representing the path from root
+     *
+     * @example
+     * // For a nested function: root -> parentFunc -> childFunc
+     * addPath(['root', 'parentFunc', 'childFunc'])
+     */
+    addPath(pathParts) {
+        let currentNode = { children: [this.tree] };
+        for (const pathPart of pathParts) {
+            const existingChild = currentNode.children.find((child) => child.name === pathPart);
+            if (existingChild) {
+                currentNode = existingChild;
+            }
+            else {
+                const newChild = {
+                    name: pathPart,
+                    children: [],
+                };
+                currentNode.children.push(newChild);
+                currentNode = newChild;
+            }
+        }
+    }
+    /**
+     * Finds a node by name in the tree (breadth-first search).
+     * Returns undefined if not found.
+     */
+    findNode(name) {
+        const queue = [this.tree];
+        while (queue.length > 0) {
+            const node = queue.shift();
+            if (node.name === name) {
+                return node;
+            }
+            queue.push(...node.children);
+        }
+        return undefined;
+    }
+    /**
+     * Gets all scope names in the tree (flattened).
+     */
+    getAllNames() {
+        const names = [];
+        const queue = [this.tree];
+        while (queue.length > 0) {
+            const node = queue.shift();
+            names.push(node.name);
+            queue.push(...node.children);
+        }
+        return names;
+    }
+    /**
+     * Returns the depth of the tree (for debugging/metrics).
+     */
+    getDepth() {
+        const getNodeDepth = (node) => {
+            if (node.children.length === 0) {
+                return 1;
+            }
+            return 1 + Math.max(...node.children.map(getNodeDepth));
+        };
+        return getNodeDepth(this.tree);
+    }
+}
+//# sourceMappingURL=ScopeTreeManager.js.map

package/packages/ai/src/lib/dataStructure/helpers/ScopeTreeManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScopeTreeManager.js","sourceRoot":"","sources":["../../../../../../../../packages/ai/src/lib/dataStructure/helpers/ScopeTreeManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAOH,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC;AAEtC,MAAM,OAAO,gBAAgB;IAG3B,YAAY,WAAmB,eAAe;QAC5C,IAAI,CAAC,IAAI,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC;IAC/C,CAAC;IAED;;;OAGG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;IACxB,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,IAAY;QACtB,IAAI,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACxB,CAAC;IAED;;;OAGG;IACH,OAAO;QACL,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED;;;;;;;;;OASG;IACH,OAAO,CAAC,SAAmB;QACzB,IAAI,WAAW,GAAkC,EAAE,QAAQ,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAE3E,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;YACjC,MAAM,aAAa,GAAG,WAAW,CAAC,QAAQ,CAAC,IAAI,CAC7C,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CACnC,CAAC;YAEF,IAAI,aAAa,EAAE,CAAC;gBAClB,WAAW,GAAG,aAAa,CAAC;YAC9B,CAAC;iBAAM,CAAC;gBACN,MAAM,QAAQ,GAAkB;oBAC9B,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,EAAE;iBACb,CAAC;gBACF,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACpC,WAAW,GAAG,QAAQ,CAAC;YACzB,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,IAAY;QACnB,MAAM,KAAK,GAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE3C,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,EAAG,CAAC;YAC5B,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBACvB,OAAO,IAAI,CAAC;YACd,CAAC;YACD,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/B,CAAC;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,WAAW;QACT,MAAM,KAAK,GAAa,EAAE,CAAC;QAC3B,MAAM,KAAK,GAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE3C,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxB,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,EAAG,CAAC;YAC5B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACtB,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/B,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,MAAM,YAAY,GAAG,CAAC,IAAmB,EAAU,EAAE;YACnD,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBAC/B,OAAO,CAAC,CAAC;YACX,CAAC;YACD,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC;QAC1D,CAAC,CAAC;QAEF,OAAO,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;CACF"}

package/packages/ai/src/lib/dataStructure/helpers/VisitedTracker.js

@@ -0,0 +1,199 @@
+/**
+ * VisitedTracker
+ *
+ * Manages visited state tracking for the ScopeDataStructure analysis.
+ * Prevents infinite loops and redundant processing by tracking which
+ * scope/path/value combinations have already been processed.
+ *
+ * ## Why This Exists
+ *
+ * The schema building process recursively follows equivalencies between
+ * data paths. Without cycle detection, circular references like:
+ *   `user.profile` → `currentUser` → `user.profile`
+ * would cause infinite loops.
+ *
+ * ## Two Tracking Modes
+ *
+ * ### 1. Global Visited (scope::path::value)
+ * Fine-grained deduplication for `addToSchema()`. Tracks the complete
+ * tuple so the same path can be visited with different type values.
+ *
+ * Example: `myFunc::user.id::string` and `myFunc::user.id::number`
+ * are tracked separately, allowing both types to be recorded.
+ *
+ * ### 2. Complex Source Visited (scope::path)
+ * Coarser deduplication for `addComplexSourcePathVariables()`. Ignores
+ * the type value because complex source processing should happen once
+ * per path regardless of type.
+ *
+ * ## Lifecycle
+ *
+ * - Global visited is **reset** at the start of `captureCompleteSchema()`
+ *   to allow re-processing in the schema building phase.
+ * - Complex source visited is **never reset** during normal operation.
+ *
+ * ## Related Modules
+ *
+ * - `ScopeDataStructure.addToSchema()` - Primary consumer of global visited
+ * - `ScopeDataStructure.addComplexSourcePathVariables()` - Uses complex source visited
+ */
+/**
+ * Tracks visited state to prevent infinite loops during schema building.
+ */
+export class VisitedTracker {
+    constructor() {
+        /**
+         * Fine-grained visited tracking using scope::path::value.
+         * Used by addToSchema to skip already-processed combinations.
+         */
+        this.globalVisited = new Set();
+        /**
+         * Coarser visited tracking using scope::path only (without value).
+         * Used by addComplexSourcePathVariables to allow each unique
+         * scope+path combo to be processed once, regardless of value.
+         */
+        this.complexSourceVisited = new Set();
+    }
+    /**
+     * Creates a unique key for global visited tracking.
+     * @param scopeNodeName - Name of the scope
+     * @param path - Schema path
+     * @param value - Type value
+     */
+    makeGlobalKey(scopeNodeName, path, value) {
+        return `${scopeNodeName}::${path}::${value}`;
+    }
+    /**
+     * Creates a unique key for complex source visited tracking.
+     * @param scopeNodeName - Name of the scope
+     * @param path - Schema path
+     */
+    makeComplexKey(scopeNodeName, path) {
+        return `${scopeNodeName}::${path}`;
+    }
+    /**
+     * Checks if a scope/path/value combination has been globally visited.
+     * Does NOT mark it as visited - use markGlobalVisited for that.
+     *
+     * @returns true if already visited
+     */
+    hasGlobalVisited(scopeNodeName, path, value) {
+        return this.globalVisited.has(this.makeGlobalKey(scopeNodeName, path, value));
+    }
+    /**
+     * Marks a scope/path/value combination as globally visited.
+     */
+    markGlobalVisited(scopeNodeName, path, value) {
+        this.globalVisited.add(this.makeGlobalKey(scopeNodeName, path, value));
+    }
+    /**
+     * Checks and marks a scope/path/value combination as globally visited.
+     * This is a convenience method that combines check and mark.
+     *
+     * @returns true if was already visited (should skip processing)
+     */
+    checkAndMarkGlobalVisited(scopeNodeName, path, value) {
+        const key = this.makeGlobalKey(scopeNodeName, path, value);
+        if (this.globalVisited.has(key)) {
+            return true; // Already visited
+        }
+        this.globalVisited.add(key);
+        return false; // Not visited, now marked
+    }
+    /**
+     * Checks if a scope/path combination has been visited for complex sources.
+     * Does NOT mark it as visited - use markComplexSourceVisited for that.
+     *
+     * @returns true if already visited
+     */
+    hasComplexSourceVisited(scopeNodeName, path) {
+        return this.complexSourceVisited.has(this.makeComplexKey(scopeNodeName, path));
+    }
+    /**
+     * Marks a scope/path combination as visited for complex sources.
+     */
+    markComplexSourceVisited(scopeNodeName, path) {
+        this.complexSourceVisited.add(this.makeComplexKey(scopeNodeName, path));
+    }
+    /**
+     * Checks and marks a scope/path combination as visited for complex sources.
+     * This is a convenience method that combines check and mark.
+     *
+     * @returns true if was already visited (should skip processing)
+     */
+    checkAndMarkComplexSourceVisited(scopeNodeName, path) {
+        const key = this.makeComplexKey(scopeNodeName, path);
+        if (this.complexSourceVisited.has(key)) {
+            return true; // Already visited
+        }
+        this.complexSourceVisited.add(key);
+        return false; // Not visited, now marked
+    }
+    /**
+     * Resets the global visited set.
+     * Called at the start of captureCompleteSchema() to allow
+     * re-processing in the second phase.
+     */
+    resetGlobalVisited() {
+        this.globalVisited.clear();
+    }
+    /**
+     * Resets the complex source visited set.
+     * Note: In the original code, this was never reset.
+     */
+    resetComplexSourceVisited() {
+        this.complexSourceVisited.clear();
+    }
+    /**
+     * Resets all visited tracking.
+     */
+    resetAll() {
+        this.globalVisited.clear();
+        this.complexSourceVisited.clear();
+    }
+    /**
+     * Returns statistics about the visited sets for debugging/monitoring.
+     */
+    getStats() {
+        return {
+            globalVisited: this.globalVisited.size,
+            complexSourceVisited: this.complexSourceVisited.size,
+        };
+    }
+    /**
+     * Checks if ANY variant of a scope/path was ever visited (ignores value).
+     * Useful for debugging to see if a path was processed at all.
+     *
+     * @returns true if any variant of this scope/path was visited
+     */
+    wasVisited(scopeNodeName, path) {
+        const prefix = `${scopeNodeName}::${path}::`;
+        for (const key of this.globalVisited) {
+            if (key.startsWith(prefix)) {
+                return true;
+            }
+        }
+        return this.hasComplexSourceVisited(scopeNodeName, path);
+    }
+    /**
+     * Gets all visited entries for a scope (for debugging).
+     * Returns an array of {path, value} objects.
+     */
+    getVisitedForScope(scopeNodeName) {
+        const prefix = `${scopeNodeName}::`;
+        const results = [];
+        for (const key of this.globalVisited) {
+            if (key.startsWith(prefix)) {
+                const parts = key.slice(prefix.length).split('::');
+                if (parts.length >= 2) {
+                    results.push({
+                        path: parts.slice(0, -1).join('::'), // Everything except last part
+                        value: parts[parts.length - 1], // Last part is value
+                    });
+                }
+            }
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=VisitedTracker.js.map

package/packages/ai/src/lib/dataStructure/helpers/VisitedTracker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"VisitedTracker.js","sourceRoot":"","sources":["../../../../../../../../packages/ai/src/lib/dataStructure/helpers/VisitedTracker.ts"],"names":[],"mappings":"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"}

package/packages/ai/src/lib/dataStructure/helpers/cleanNonObjectFunctions.js

@@ -23,7 +23,13 @@ export const nonTransformingArrayMethodsSet = new Set([
     'reverse',
     'entries',
 ]);
-const isolatingArrayMethodsSet = new Set(['find', 'at', 'pop', 'shift']);
+const isolatingArrayMethodsSet = new Set([
+    'find',
+    'findLast', // Returns element like find, but from end
+    'at',
+    'pop',
+    'shift',
+]);
 // Methods that are ambiguous - used on both arrays and non-arrays (e.g., router.push, history.pop)
 // Don't infer array type from these alone without additional evidence
 const ambiguousArrayMethodsSet = new Set(['push', 'pop']);
@@ -34,6 +40,12 @@ export const transformingArrayMethodsSet = new Set([
     'concat',
     'join',
     'some',
+    'every', // Returns boolean
+    'findIndex', // Returns number (index)
+    'findLastIndex', // Returns number (index from end)
+    'indexOf', // Returns number (index)
+    'lastIndexOf', // Returns number (index from end)
+    'includes', // Returns boolean
 ]);
 export const arrayMethodsSet = new Set([
     ...nonTransformingArrayMethodsSet,
@@ -174,6 +186,46 @@ export function clearAttributesFromMapping(mapping) {
     const knownBasePaths = new Set();
     clearAttributes(mapping, knownBasePaths);
 }
+/**
+ * Remove duplicate function calls (same function with different arguments) that have no return data.
+ * Example: setSelectedFilter(arg1) and setSelectedFilter(arg2) where neither has functionCallReturnValue
+ * These create invalid mock code when spread together (orphan spread statements).
+ *
+ * This is a targeted fix that can be called independently without the full clearAttributes logic,
+ * which was disabled in constructMockCode.ts due to side effects on array method calls.
+ */
+export function removeDuplicateFunctionCalls(mapping) {
+    const allKeys = Object.keys(mapping);
+    const functionCallGroups = {};
+    for (const key of allKeys) {
+        // Only process paths that:
+        // 1. Are marked as 'function'
+        // 2. END with a function call (parentheses) - not just contain one somewhere
+        // 3. Are on an object path (contain '.')
+        if (mapping[key] === 'function' && key.endsWith(')') && key.includes('.')) {
+            // Extract base path + function name (without the arguments)
+            // e.g., "returnValue.setSelectedFilter(arg)" -> "returnValue.setSelectedFilter"
+            const baseName = key.replace(/\([^)]*\)$/, '');
+            functionCallGroups[baseName] || (functionCallGroups[baseName] = []);
+            functionCallGroups[baseName].push(key);
+        }
+    }
+    // For groups with multiple calls (same function, different args), remove those without return data
+    for (const baseName in functionCallGroups) {
+        const calls = functionCallGroups[baseName];
+        if (calls.length > 1) {
+            // Multiple calls to the same function with different arguments
+            for (const callPath of calls) {
+                // Check if this call has return data
+                const hasReturnData = allKeys.some((k) => k.startsWith(callPath + '.functionCallReturnValue') ||
+                    k.startsWith(callPath + '.signature['));
+                if (!hasReturnData) {
+                    delete mapping[callPath];
+                }
+            }
+        }
+    }
+}
 function transformPath({ oldPath, newPath, scopeNode, scopeDataStructure, }) {
     const oldPathParts = splitOutsideParenthesesAndArrays(oldPath);
     for (const schemaPath in scopeNode.schema) {
@@ -450,12 +502,15 @@ function handleFunctionMapping(path, keyMapping) {
             }
         }
         // Don't add [] element for ambiguous methods without other array evidence
+        // Also don't add [] if the path was already identified as a string type
         const methodName = getMethodName(lastPart);
         const isAmbiguousMethod = ambiguousArrayMethodsSet.has(methodName);
+        const isStringType = keyMapping[previousPath] === 'string';
         if (!isValidFunctionCall(previousPart) &&
             arrayMethodsSet.has(methodName) &&
             !keyMapping[previousPath + '[]'] &&
-            !isAmbiguousMethod) {
+            !isAmbiguousMethod &&
+            !isStringType) {
             keyMapping[previousPath + '[]'] = 'unknown';
         }
         delete keyMapping[path];
@@ -638,6 +693,8 @@ function clearAttributes(mapping, knownBasePaths) {
             }
         }
     }
+    // Remove duplicate function calls (same function with different arguments) that have no return data
+    removeDuplicateFunctionCalls(mapping);
     for (const key in mapping) {
         const value = mapping[key];
         if (knownTypes.has(value)) {