@codeyam/codeyam-cli 0.1.0-bleeding-edge.8afd3ee → 0.1.0-staging.09652b8

package/packages/ai/src/lib/dataStructure/ScopeDataStructure.js

@@ -34,10 +34,12 @@ const ROOT_SCOPE_NAME = 'root';
 export let maxEquivalencyChainDepth = 0;
 export let addToSchemaCallCount = 0;
 export let followEquivalenciesCallCount = 0;
+export let addEquivalencyCallCount = 0;
 export function resetScopeDataStructureMetrics() {
     maxEquivalencyChainDepth = 0;
     addToSchemaCallCount = 0;
     followEquivalenciesCallCount = 0;
+    addEquivalencyCallCount = 0;
 }
 export class ScopeDataStructure {
     constructor(managers, scopeName = ROOT_SCOPE_NAME, scopeText, scopeAnalysis) {
@@ -58,6 +60,10 @@ export class ScopeDataStructure {
         // Inverted index: maps uniqueId -> EquivalencyDatabaseEntry for O(1) lookup
         this.intermediatesOrderIndex = new Map();
         this.globalVisited = new Set();
+        // Separate visited set for addComplexSourcePathVariables - uses scope::path only (not value)
+        // This allows addComplexSourcePathVariables to run for each unique scope+path combo,
+        // while the main globalVisited uses scope+path+value for fine-grained deduplication
+        this.complexSourceVisited = new Set();
         this.equivalencyManagers.push(...managers);
         this.scopeTree.name = scopeName;
         this.addScopeAnalysis(scopeName, scopeText, scopeAnalysis);
@@ -179,6 +185,16 @@ export class ScopeDataStructure {
     }
     addToSchema({ path, value, scopeNode, equivalencyValueChain = [], traceId, }) {
         addToSchemaCallCount++;
+        // DEBUG: Detect infinite loops
+        if (addToSchemaCallCount > 500000) {
+            console.error('INFINITE LOOP DETECTED in addToSchema', {
+                callCount: addToSchemaCallCount,
+                path,
+                value,
+                scopeNodeName: scopeNode?.name,
+            });
+            throw new Error(`Infinite loop detected: addToSchema called ${addToSchemaCallCount} times`);
+        }
         // Track max chain depth
         if (equivalencyValueChain.length > maxEquivalencyChainDepth) {
             maxEquivalencyChainDepth = equivalencyValueChain.length;
@@ -265,6 +281,7 @@ export class ScopeDataStructure {
         //   throw new Error('STOP ON ADD');
         // }
         const equivalenciesDatabaseEntry = this.getEquivalenciesDatabaseEntry(scopeNode.name, path);
+        // Call addComplexSourcePathVariables like the original code (before visited check)
         this.addComplexSourcePathVariables(equivalenciesDatabaseEntry, scopeNode, path, equivalencyValueChain, traceId);
         const uniqueIdentifier = `${scopeNode.name}::${path}::${value}`;
         if (this.globalVisited.has(uniqueIdentifier)) {
@@ -414,6 +431,19 @@ export class ScopeDataStructure {
     }
     addEquivalency(path, equivalentPath, equivalentScopeName, scopeNode, equivalencyReason, equivalencyValueChain, traceId) {
         var _a;
+        // DEBUG: Detect infinite loops
+        addEquivalencyCallCount++;
+        if (addEquivalencyCallCount > 50000) {
+            console.error('INFINITE LOOP DETECTED in addEquivalency', {
+                callCount: addEquivalencyCallCount,
+                path,
+                equivalentPath,
+                equivalentScopeName,
+                scopeNodeName: scopeNode.name,
+                equivalencyReason,
+            });
+            throw new Error(`Infinite loop detected: addEquivalency called ${addEquivalencyCallCount} times`);
+        }
         // Temporary debugging to track down unnecessary equivalencies
         if (![
             'original equivalency',
@@ -441,6 +471,8 @@ export class ScopeDataStructure {
             'implicit parent equivalency - rerouted via useCallback', // 1 failure
             'Spread operator equivalency key update: implicit parent equivalency', // 1 failure
             'Array.from() equivalency',
+            'propagated sub-property equivalency',
+            'propagated function call return sub-property equivalency',
         ].includes(equivalencyReason)) {
             if ([
                 'signature of functionCall',
@@ -471,8 +503,41 @@ export class ScopeDataStructure {
         }
         (_a = scopeNode.equivalencies)[path] || (_a[path] = []);
         const existing = scopeNode.equivalencies[path];
-        if (existing.find((v) => v.schemaPath === equivalentPath &&
-            v.scopeNodeName === equivalentScopeName)) {
+        const existingEquivalency = existing.find((v) => v.schemaPath === equivalentPath &&
+            v.scopeNodeName === equivalentScopeName);
+        if (existingEquivalency) {
+            // During Phase 2 (onlyEquivalencies=false), we need to still process the equivalency
+            // to build the chain and add to the database, even if the equivalency already exists
+            if (!this.onlyEquivalencies) {
+                const equivalentScopeNode = this.getScopeOrFunctionCallInfo(equivalentScopeName);
+                if (equivalentScopeNode) {
+                    // Extract function call name from path if it looks like a function call path
+                    // e.g., "ChildComponent().signature[0].dataItem" -> "ChildComponent"
+                    const pathMatch = path.match(/^([^().]+)\(\)/);
+                    const previousPathScopeNodeName = pathMatch
+                        ? pathMatch[1]
+                        : scopeNode.name;
+                    this.addToSchema({
+                        path: equivalentPath,
+                        value: 'unknown',
+                        scopeNode: equivalentScopeNode,
+                        equivalencyValueChain: [
+                            ...(equivalencyValueChain ?? []),
+                            {
+                                id: existingEquivalency.id,
+                                source: 'duplicate equivalency - Phase 2',
+                                reason: equivalencyReason,
+                                previousPath: {
+                                    scopeNodeName: previousPathScopeNodeName,
+                                    schemaPath: path,
+                                    value: scopeNode.schema[path],
+                                },
+                            },
+                        ],
+                        traceId,
+                    });
+                }
+            }
             return;
         }
         const id = ++this.lastEquivalencyId;
@@ -834,6 +899,52 @@ export class ScopeDataStructure {
                 path = cleanPath(path.replace(/::cyDuplicateKey\d+::/g, ''), allPaths);
                 equivalentValue = cleanPath(equivalentValue.replace(/::cyDuplicateKey\d+::/g, ''), allPaths);
                 this.addEquivalency(path, equivalentValue, scopeNode.name, scopeNode, 'original equivalency');
+                // Propagate sub-property equivalencies when the equivalentValue is a simple variable
+                // that has sub-properties defined in the isolatedEquivalentVariables.
+                // This handles cases like: dataItem={{ structure: completeDataStructure }}
+                // where completeDataStructure has sub-properties like completeDataStructure['Function Arguments']
+                // We need to propagate these to create: dataItem.structure['Function Arguments'] equivalencies
+                const isSimpleVariable = !equivalentValue.startsWith('signature[') &&
+                    !equivalentValue.includes('functionCallReturnValue') &&
+                    !equivalentValue.includes('.') &&
+                    !equivalentValue.includes('[');
+                if (isSimpleVariable) {
+                    // Look in current scope and all parent scopes for sub-properties
+                    const scopesToCheck = [scopeNode.name, ...scopeNode.tree];
+                    for (const scopeName of scopesToCheck) {
+                        const checkScope = this.scopeNodes[scopeName];
+                        if (!checkScope?.analysis?.isolatedEquivalentVariables)
+                            continue;
+                        for (const [subPath, subValue] of Object.entries(checkScope.analysis.isolatedEquivalentVariables)) {
+                            // Check if this is a sub-property of the equivalentValue variable
+                            // e.g., completeDataStructure['Function Arguments'] or completeDataStructure.foo
+                            const matchesDot = subPath.startsWith(equivalentValue + '.');
+                            const matchesBracket = subPath.startsWith(equivalentValue + '[');
+                            if (matchesDot || matchesBracket) {
+                                const subPropertyPath = subPath.substring(equivalentValue.length);
+                                const newPath = cleanPath(path + subPropertyPath, allPaths);
+                                const newEquivalentValue = cleanPath(subValue.replace(/::cyDuplicateKey\d+::/g, ''), allPaths);
+                                if (newEquivalentValue &&
+                                    this.isValidPath(newEquivalentValue)) {
+                                    this.addEquivalency(newPath, newEquivalentValue, checkScope.name, // Use the scope where the sub-property was found
+                                    scopeNode, 'propagated sub-property equivalency');
+                                }
+                            }
+                            // Also check if equivalentValue itself maps to a functionCallReturnValue
+                            // e.g., result = useMemo(...).functionCallReturnValue
+                            if (subPath === equivalentValue &&
+                                typeof subValue === 'string' &&
+                                subValue.endsWith('.functionCallReturnValue')) {
+                                this.propagateFunctionCallReturnSubProperties(path, subValue, scopeNode, allPaths);
+                            }
+                        }
+                    }
+                }
+                // Handle function call return values by propagating returnValue.* sub-properties
+                // from the callback scope to the usage path
+                if (equivalentValue.endsWith('.functionCallReturnValue')) {
+                    this.propagateFunctionCallReturnSubProperties(path, equivalentValue, scopeNode, allPaths);
+                }
             }
         }
         for (const key of Array.from(allPaths)) {
@@ -867,6 +978,182 @@ export class ScopeDataStructure {
         }
         this.validateSchema(scopeNode, false, false);
     }
+    /**
+     * Propagates returnValue.* sub-properties from a callback scope to the usage path.
+     *
+     * When we have an equivalency like:
+     *   DataItemEditor().signature[0].structure -> getData().functionCallReturnValue
+     *
+     * And the callback scope for getData has:
+     *   returnValue.args -> dataStructure.arguments
+     *
+     * This method creates the transitive equivalency:
+     *   DataItemEditor().signature[0].structure.args -> signature[0].dataStructure.arguments
+     *
+     * It also resolves variable references through parent scopes (e.g., dataStructure -> signature[0].dataStructure)
+     * and ensures the database entry is updated with the usage path.
+     */
+    propagateFunctionCallReturnSubProperties(path, equivalentValue, scopeNode, allPaths) {
+        // Try to find the callback scope name from different patterns:
+        // 1. "getData().functionCallReturnValue" → look up getData variable to find scope
+        // 2. "useMemo(cyScope1(), [...]).functionCallReturnValue" → extract cyScope1 directly
+        let callbackScopeName;
+        // Pattern 1: Simple function call like getData().functionCallReturnValue
+        const simpleFunctionMatch = equivalentValue.match(/^(\w+)\(\)\.functionCallReturnValue$/);
+        if (simpleFunctionMatch) {
+            const functionName = simpleFunctionMatch[1];
+            // Find the function reference in current or parent scopes
+            const scopesToCheck = [scopeNode.name, ...scopeNode.tree];
+            for (const scopeName of scopesToCheck) {
+                const checkScope = this.scopeNodes[scopeName];
+                if (!checkScope?.analysis?.isolatedEquivalentVariables)
+                    continue;
+                const functionRef = checkScope.analysis.isolatedEquivalentVariables[functionName];
+                if (typeof functionRef === 'string' && functionRef.endsWith('F')) {
+                    callbackScopeName = functionRef.slice(0, -1);
+                    break;
+                }
+            }
+        }
+        // Pattern 2: useMemo/useCallback with callback scope
+        // e.g., "useMemo(cyScope1(), [deps]).functionCallReturnValue"
+        if (!callbackScopeName) {
+            const useMemoMatch = equivalentValue.match(/^useMemo\((\w+)\(\),\s*\[.*\]\)\.functionCallReturnValue$/);
+            if (useMemoMatch) {
+                callbackScopeName = useMemoMatch[1];
+            }
+        }
+        if (!callbackScopeName)
+            return;
+        const callbackScope = this.scopeNodes[callbackScopeName];
+        if (!callbackScope)
+            return;
+        // Look for returnValue.* sub-properties in the callback scope
+        if (!callbackScope.analysis?.isolatedEquivalentVariables)
+            return;
+        const isolatedVars = callbackScope.analysis.isolatedEquivalentVariables;
+        // First, check if returnValue is an alias to another variable (e.g., returnValue = intermediate)
+        // If so, we need to look for that variable's sub-properties too
+        const returnValueAlias = typeof isolatedVars.returnValue === 'string' &&
+            !isolatedVars.returnValue.includes('.')
+            ? isolatedVars.returnValue
+            : undefined;
+        // Pattern 3: Object.keys(X).reduce() - the reduce result has the same sub-properties as X
+        // When returnValue = "Object.keys(source).reduce(...).functionCallReturnValue", look for source.* sub-properties
+        let reduceSourceVar;
+        if (typeof isolatedVars.returnValue === 'string') {
+            const reduceMatch = isolatedVars.returnValue.match(/^Object\.keys\((\w+)\)\.reduce\(.*\)\.functionCallReturnValue$/);
+            if (reduceMatch) {
+                reduceSourceVar = reduceMatch[1];
+            }
+        }
+        for (const [subPath, subValue] of Object.entries(isolatedVars)) {
+            // Check for direct returnValue.* sub-properties
+            const isReturnValueSub = subPath.startsWith('returnValue.') ||
+                subPath.startsWith('returnValue[');
+            // Also check for alias.* sub-properties (e.g., intermediate.args when returnValue = intermediate)
+            const isAliasSub = returnValueAlias &&
+                (subPath.startsWith(returnValueAlias + '.') ||
+                    subPath.startsWith(returnValueAlias + '['));
+            // Also check for reduce source.* sub-properties (e.g., source['Function Arguments'] when returnValue = Object.keys(source).reduce())
+            const isReduceSourceSub = reduceSourceVar &&
+                (subPath.startsWith(reduceSourceVar + '.') ||
+                    subPath.startsWith(reduceSourceVar + '['));
+            if (typeof subValue !== 'string' ||
+                (!isReturnValueSub && !isAliasSub && !isReduceSourceSub))
+                continue;
+            // Convert alias/reduceSource paths to returnValue paths
+            let effectiveSubPath = subPath;
+            if (isAliasSub && !isReturnValueSub) {
+                // Replace the alias prefix with returnValue
+                effectiveSubPath =
+                    'returnValue' + subPath.substring(returnValueAlias.length);
+            }
+            else if (isReduceSourceSub && !isReturnValueSub && !isAliasSub) {
+                // Replace the reduce source prefix with returnValue
+                effectiveSubPath =
+                    'returnValue' + subPath.substring(reduceSourceVar.length);
+            }
+            const subPropertyPath = effectiveSubPath.substring('returnValue'.length);
+            const newPath = cleanPath(path + subPropertyPath, allPaths);
+            let newEquivalentValue = cleanPath(subValue.replace(/::cyDuplicateKey\d+::/g, ''), allPaths);
+            // Resolve variable references through parent scope equivalencies
+            const resolved = this.resolveVariableThroughParentScopes(newEquivalentValue, callbackScope, allPaths);
+            newEquivalentValue = resolved.resolvedPath;
+            const equivalentScopeName = resolved.scopeName;
+            if (!newEquivalentValue || !this.isValidPath(newEquivalentValue))
+                continue;
+            this.addEquivalency(newPath, newEquivalentValue, equivalentScopeName, scopeNode, 'propagated function call return sub-property equivalency');
+            // Ensure the database entry has the usage path
+            this.addUsageToEquivalencyDatabaseEntry(newPath, newEquivalentValue, equivalentScopeName, scopeNode.name);
+        }
+    }
+    /**
+     * Resolves a variable path through parent scope equivalencies.
+     *
+     * For example, if the path is "dataStructure.arguments" and the parent scope has
+     * dataStructure -> signature[0].dataStructure, this returns:
+     *   { resolvedPath: "signature[0].dataStructure.arguments", scopeName: "ParentScope" }
+     */
+    resolveVariableThroughParentScopes(path, callbackScope, allPaths) {
+        if (!path)
+            return { resolvedPath: undefined, scopeName: callbackScope.name };
+        // Extract the root variable name
+        const dotIndex = path.indexOf('.');
+        const bracketIndex = path.indexOf('[');
+        let firstDelimiter = -1;
+        if (dotIndex > -1 && bracketIndex > -1) {
+            firstDelimiter = Math.min(dotIndex, bracketIndex);
+        }
+        else {
+            firstDelimiter = dotIndex > -1 ? dotIndex : bracketIndex;
+        }
+        if (firstDelimiter === -1)
+            return { resolvedPath: path, scopeName: callbackScope.name };
+        const rootVar = path.substring(0, firstDelimiter);
+        const restOfPath = path.substring(firstDelimiter);
+        // Look in parent scopes for the root variable's equivalency
+        for (const parentScopeName of callbackScope.tree || []) {
+            const parentScope = this.scopeNodes[parentScopeName];
+            if (!parentScope?.analysis?.isolatedEquivalentVariables)
+                continue;
+            const rootEquiv = parentScope.analysis.isolatedEquivalentVariables[rootVar];
+            if (typeof rootEquiv === 'string') {
+                return {
+                    resolvedPath: cleanPath(rootEquiv + restOfPath, allPaths),
+                    scopeName: parentScopeName,
+                };
+            }
+        }
+        return { resolvedPath: path, scopeName: callbackScope.name };
+    }
+    /**
+     * Adds a usage path to the equivalency database entry that has the given source.
+     *
+     * The addEquivalency call creates the equivalency but doesn't always properly
+     * link the usage in the database, so we need to do it explicitly.
+     */
+    addUsageToEquivalencyDatabaseEntry(usagePath, sourcePath, sourceScopeName, fallbackScopeName) {
+        const usageEntry = {
+            scopeNodeName: usagePath.match(/^([^().]+)\(\)/)
+                ? (usagePath.match(/^([^().]+)\(\)/)?.[1] ?? fallbackScopeName)
+                : fallbackScopeName,
+            schemaPath: usagePath,
+        };
+        const sourceKey = `${sourceScopeName}::${sourcePath}`;
+        for (const entry of this.equivalencyDatabase) {
+            if (entry.intermediatesOrder[sourceKey] === 0 ||
+                entry.sourceCandidates.some((sc) => sc.scopeNodeName === sourceScopeName &&
+                    sc.schemaPath === sourcePath)) {
+                const usageExists = entry.usages.some((u) => u.scopeNodeName === usageEntry.scopeNodeName &&
+                    u.schemaPath === usageEntry.schemaPath);
+                if (!usageExists) {
+                    entry.usages.push(usageEntry);
+                }
+                break;
+            }
+        }
+    }
     checkForArrayItemPath(pathParts, scopeNode, equivalencyValueChain) {
         const arrayItemPath = joinParenthesesAndArrays([...pathParts, '[]']);
         if (scopeNode.equivalencies[arrayItemPath]) {
@@ -1054,6 +1341,13 @@ export class ScopeDataStructure {
                         return;
                     }
                     const usageScopeNode = this.getScopeOrFunctionCallInfo(usageEquivalency.scopeNodeName);
+                    // Guard against infinite recursion by tracking which paths we've already
+                    // added from addComplexSourcePathVariables
+                    const complexPathKey = `${usageScopeNode.name}::${newUsageEquivalentPath}`;
+                    if (this.complexSourceVisited.has(complexPathKey)) {
+                        continue;
+                    }
+                    this.complexSourceVisited.add(complexPathKey);
                     this.addToSchema({
                         path: newUsageEquivalentPath,
                         value: 'unknown',
@@ -1162,6 +1456,7 @@ export class ScopeDataStructure {
         }
         for (let i = 0; i < cleanEquivalencyValueChain.length; ++i) {
             const pathInfo = cleanEquivalencyValueChain[i].currentPath;
+            const previousPath = cleanEquivalencyValueChain[i].previousPath;
             const schemaPathParts = this.splitPath(pathInfo.schemaPath);
             const isSignaturePath = schemaPathParts.findIndex((p) => p.startsWith('signature[')) > 0;
             if (schemaPathParts[0].startsWith('returnValue') ||
@@ -1171,6 +1466,17 @@ export class ScopeDataStructure {
             ) {
                 databaseEntry.usages.push(pathInfo);
             }
+            // Also add previousPath as a usage if it matches the criteria
+            // This handles propagated sub-property equivalencies where the JSX prop path
+            // is in previousPath and should be tracked as a usage
+            if (previousPath) {
+                const prevSchemaPathParts = this.splitPath(previousPath.schemaPath);
+                const isPrevSignaturePath = prevSchemaPathParts.findIndex((p) => p.startsWith('signature[')) > 0;
+                if (prevSchemaPathParts[0].startsWith('returnValue') ||
+                    isPrevSignaturePath) {
+                    databaseEntry.usages.push(previousPath);
+                }
+            }
             const pathId = this.uniqueId(pathInfo);
             let intermediateIndex = cleanEquivalencyValueChain.length - i - 1;
             const existingIntermediateIndex = databaseEntry.intermediatesOrder[pathId];