@codeyam/codeyam-cli 0.1.0-staging.eb21b2f → 0.1.0-staging.f3b710d

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

@@ -182,6 +182,7 @@ const SILENTLY_IGNORED_EQUIVALENCY_REASONS = new Set([
     'transformed non-object function equivalency - Array.from() equivalency',
     'Spread operator equivalency key update: Explicit array deconstruction equivalency value',
     // 'transformed non-object function equivalency - Explicit array deconstruction equivalency value',
+    'useState setter call equivalency (direct)',
 ]);
 export class ScopeDataStructure {
     // Getter for backward compatibility - returns the tree structure
@@ -648,9 +649,29 @@ export class ScopeDataStructure {
         delete schema[path];
     }
     addEquivalency(path, equivalentPath, equivalentScopeName, scopeNode, equivalencyReason, equivalencyValueChain, traceId) {
+        // Fast early exits that don't count toward the limit.
+        // These are "no-op" calls that would be caught further below anyway,
+        // but checking them first prevents counter inflation from redundant calls
+        // generated by managers and followEquivalencies during scope processing.
         var _a;
+        // Skip silently-ignored reasons before counting
+        if (SILENTLY_IGNORED_EQUIVALENCY_REASONS.has(equivalencyReason)) {
+            return;
+        }
+        // Skip exact duplicates before counting (Phase 1 only — Phase 2 needs
+        // to process duplicates for database chain tracking)
+        if (this.onlyEquivalencies) {
+            const existing = scopeNode.equivalencies[path];
+            if (existing?.some((v) => v.schemaPath === equivalentPath &&
+                v.scopeNodeName === equivalentScopeName)) {
+                return;
+            }
+        }
         addEquivalencyCallCount++;
-        if (addEquivalencyCallCount > 50000) {
+        const limit = typeof globalThis.__CODEYAM_EQUIVALENCY_LIMIT === 'number'
+            ? globalThis.__CODEYAM_EQUIVALENCY_LIMIT
+            : 50000;
+        if (addEquivalencyCallCount > limit) {
             console.error('INFINITE LOOP DETECTED in addEquivalency', {
                 callCount: addEquivalencyCallCount,
                 path,
@@ -663,15 +684,11 @@ export class ScopeDataStructure {
         }
         // Filter equivalency reasons - use pre-computed Sets for O(1) lookup
         if (!ALLOWED_EQUIVALENCY_REASONS.has(equivalencyReason)) {
-            if (SILENTLY_IGNORED_EQUIVALENCY_REASONS.has(equivalencyReason)) {
-                return;
-            }
-            else {
-                // Log and skip - if an equivalency reason isn't in ALLOWED or SILENTLY_IGNORED,
-                // it shouldn't be stored (was previously missing the return)
-                console.info('Not tracked equivalency reason', { equivalencyReason });
-                return;
-            }
+            // Silently-ignored reasons already handled above
+            // Log and skip - if an equivalency reason isn't in ALLOWED or SILENTLY_IGNORED,
+            // it shouldn't be stored (was previously missing the return)
+            console.info('Not tracked equivalency reason', { equivalencyReason });
+            return;
         }
         // Skip self-referential equivalencies that would create infinite loops.
         // Case 1: Direct self-reference (path === equivalentPath)
@@ -698,6 +715,27 @@ export class ScopeDataStructure {
             equivalentPath.startsWith(path + '(')) {
             return;
         }
+        // Case 3: Circular reference through scope-suffixed names (____cyScope pattern)
+        // When a named arrow function is defined inside a scope (e.g., useEffect callback):
+        //   const identifyUser = async () => { ... };
+        //   identifyUser();
+        // This creates a variable "identifyUser" and a scope "identifyUser____cyScope9F".
+        // Mutual equivalencies between these cause infinite loops in Phase 2 because
+        // processing one triggers addToSchema → followEquivalencies → addEquivalency
+        // on the reverse, which repeats indefinitely.
+        // Only block when the REVERSE direction already exists (creating a cycle).
+        // The initial one-directional equivalency is necessary for scope resolution.
+        if (path &&
+            equivalentPath &&
+            (equivalentPath.startsWith(path + '____') ||
+                path.startsWith(equivalentPath + '____'))) {
+            // Check if the reverse equivalency already exists
+            const reverseEquivalencies = scopeNode.equivalencies[equivalentPath] || [];
+            const reverseExists = reverseEquivalencies.some((v) => v.schemaPath === path);
+            if (reverseExists) {
+                return;
+            }
+        }
         if (!equivalentScopeName) {
             console.error('CodeYam Error: Missing equivalent scope name - FULL CONTEXT:', JSON.stringify({
                 path,
@@ -2306,6 +2344,21 @@ export class ScopeDataStructure {
      * ensure all sub-paths of that variable are reflected under signature[N].
      */
     propagateParameterToSignaturePaths(scopeNode) {
+        // Helper: check if a type is a concrete scalar that cannot have sub-properties.
+        const SCALAR_TYPES = new Set([
+            'string',
+            'number',
+            'boolean',
+            'bigint',
+            'symbol',
+            'void',
+            'never',
+        ]);
+        const isDefinitelyScalar = (type) => {
+            const parts = type.split('|').map((s) => s.trim());
+            const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
+            return base.length > 0 && base.every((b) => SCALAR_TYPES.has(b));
+        };
         // Find variable → signature[N] equivalencies
         for (const [varName, equivalencies] of Object.entries(scopeNode.equivalencies)) {
             // Only process simple variable names (no dots, brackets, or parens)
@@ -2327,7 +2380,37 @@ export class ScopeDataStructure {
                             const sigKey = signaturePath + suffix;
                             // Only add if the signature path doesn't already exist
                             if (!scopeNode.schema[sigKey]) {
-                                scopeNode.schema[sigKey] = scopeNode.schema[key];
+                                // Check if this path represents variable conflation:
+                                // When a standalone variable (e.g., showWorkoutForm from useState)
+                                // appears as a sub-property of a scalar-typed ancestor (e.g.,
+                                // activity_type = "string"), it's from scope conflation, not real
+                                // property access. Block these while allowing legitimate built-in
+                                // accesses like string.length or string.slice.
+                                let isConflatedPath = false;
+                                let checkPos = signaturePath.length;
+                                while (true) {
+                                    checkPos = sigKey.indexOf('.', checkPos + 1);
+                                    if (checkPos === -1)
+                                        break;
+                                    const ancestorPath = sigKey.substring(0, checkPos);
+                                    const ancestorType = scopeNode.schema[ancestorPath];
+                                    if (ancestorType && isDefinitelyScalar(ancestorType)) {
+                                        // Ancestor is scalar — check if the immediate sub-property
+                                        // is also a standalone variable (indicating conflation)
+                                        const afterDot = sigKey.substring(checkPos + 1);
+                                        const nextSep = afterDot.search(/[.\[]/);
+                                        const subPropName = nextSep === -1
+                                            ? afterDot
+                                            : afterDot.substring(0, nextSep);
+                                        if (scopeNode.schema[subPropName] !== undefined) {
+                                            isConflatedPath = true;
+                                            break;
+                                        }
+                                    }
+                                }
+                                if (!isConflatedPath) {
+                                    scopeNode.schema[sigKey] = scopeNode.schema[key];
+                                }
                             }
                         }
                     }
@@ -2900,6 +2983,23 @@ export class ScopeDataStructure {
                 }
             }
         }
+        // Helper: check if a type is a concrete scalar that cannot have sub-properties.
+        // e.g., "string", "number | undefined", "boolean | null" are scalar.
+        // "object", "array", "function", "unknown", "Workout", etc. are NOT scalar.
+        const SCALAR_TYPES = new Set([
+            'string',
+            'number',
+            'boolean',
+            'bigint',
+            'symbol',
+            'void',
+            'never',
+        ]);
+        const isDefinitelyScalarType = (type) => {
+            const parts = type.split('|').map((s) => s.trim());
+            const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
+            return base.length > 0 && base.every((b) => SCALAR_TYPES.has(b));
+        };
         // Propagate nested paths from variables to their signature equivalents
         // e.g., if workouts = signature[0].workouts, then workouts[].title becomes
         // signature[0].workouts[].title
@@ -2919,7 +3019,67 @@ export class ScopeDataStructure {
                     const signatureKey = signaturePath + suffix;
                     // Add to schema if not already present
                     if (!tempScopeNode.schema[signatureKey]) {
-                        tempScopeNode.schema[signatureKey] = schema[schemaKey];
+                        // Check if this path represents variable conflation:
+                        // When a standalone variable (e.g., showWorkoutForm from useState)
+                        // appears as a sub-property of a scalar-typed ancestor (e.g.,
+                        // activity_type = "string"), it's from scope conflation, not real
+                        // property access. Block these while allowing legitimate built-in
+                        // accesses like string.length or string.slice.
+                        let isConflatedPath = false;
+                        let checkPos = signaturePath.length;
+                        while (true) {
+                            checkPos = signatureKey.indexOf('.', checkPos + 1);
+                            if (checkPos === -1)
+                                break;
+                            const ancestorPath = signatureKey.substring(0, checkPos);
+                            const ancestorType = tempScopeNode.schema[ancestorPath];
+                            if (ancestorType && isDefinitelyScalarType(ancestorType)) {
+                                // Ancestor is scalar — check if the immediate sub-property
+                                // is also a standalone variable (indicating conflation)
+                                const afterDot = signatureKey.substring(checkPos + 1);
+                                const nextSep = afterDot.search(/[.\[]/);
+                                const subPropName = nextSep === -1 ? afterDot : afterDot.substring(0, nextSep);
+                                if (schema[subPropName] !== undefined) {
+                                    isConflatedPath = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!isConflatedPath) {
+                            tempScopeNode.schema[signatureKey] = schema[schemaKey];
+                        }
+                    }
+                }
+            }
+        }
+        // Post-process: filter out conflated signature paths.
+        // During phase 2 scope analysis, useState(false) conflation can create
+        // bad paths like signature[0].mockWorkouts[].activity_type.showWorkoutForm
+        // directly in scopeNode.schema. These flow through signatureInSchema into
+        // tempScopeNode.schema without any guard. Filter them out here by checking:
+        //   1. An ancestor in the path has a concrete scalar type (string, number, boolean, etc.)
+        //   2. The immediate sub-property of that scalar ancestor is also a standalone
+        //      variable in the schema (indicating conflation, not a real property access)
+        for (const key of Object.keys(tempScopeNode.schema)) {
+            if (!key.startsWith('signature['))
+                continue;
+            // Walk through the path looking for scalar-typed ancestors
+            let pos = 0;
+            while (true) {
+                pos = key.indexOf('.', pos + 1);
+                if (pos === -1)
+                    break;
+                const ancestorPath = key.substring(0, pos);
+                const ancestorType = tempScopeNode.schema[ancestorPath];
+                if (ancestorType && isDefinitelyScalarType(ancestorType)) {
+                    // Found a scalar ancestor — check if the sub-property name
+                    // is a standalone variable in the getSchema() result
+                    const afterDot = key.substring(pos + 1);
+                    const nextSep = afterDot.search(/[.\[]/);
+                    const subPropName = nextSep === -1 ? afterDot : afterDot.substring(0, nextSep);
+                    if (schema[subPropName] !== undefined) {
+                        delete tempScopeNode.schema[key];
+                        break;
                     }
                 }
             }
@@ -3534,7 +3694,95 @@ export class ScopeDataStructure {
         // Replace cyScope placeholders in all external function call data
         // This ensures call signatures and schema paths use actual callback text
         // instead of internal cyScope names, preventing mock data merge conflicts.
-        return this.externalFunctionCalls.map((efc) => this.cleanCyScopeFromFunctionCallInfo(efc));
+        const rootScopeName = this.scopeTreeManager.getRootName();
+        const rootSchema = this.scopeNodes[rootScopeName]?.schema ?? {};
+        return this.externalFunctionCalls.map((efc) => {
+            const cleaned = this.cleanCyScopeFromFunctionCallInfo(efc);
+            return this.filterConflatedExternalPaths(cleaned, rootSchema);
+        });
+    }
+    /**
+     * Filters out conflated paths from external function call schemas.
+     *
+     * When multiple useState(false) calls create equivalency conflation during
+     * Phase 1 analysis, standalone boolean state variables (like showWorkoutForm,
+     * showGoalForm) can bleed into external function call schemas as sub-properties
+     * of unrelated data fields (like data[].activity_type.showWorkoutForm).
+     *
+     * Detection: group sub-properties by parent path. If 2+ sub-properties of
+     * the same parent all match standalone root scope variable names, treat them
+     * as conflation artifacts and remove them.
+     */
+    filterConflatedExternalPaths(efc, rootSchema) {
+        // Build a set of top-level root scope variable names (simple names, no dots/brackets)
+        const topLevelRootVars = new Set();
+        for (const key of Object.keys(rootSchema)) {
+            if (!key.includes('.') && !key.includes('[')) {
+                topLevelRootVars.add(key);
+            }
+        }
+        if (topLevelRootVars.size === 0)
+            return efc;
+        // Group sub-property matches by their parent path.
+        // For a path like "...data[].activity_type.showWorkoutForm",
+        // parent = "...data[].activity_type", child = "showWorkoutForm"
+        const parentToConflatedKeys = new Map();
+        for (const key of Object.keys(efc.schema)) {
+            const lastDot = key.lastIndexOf('.');
+            if (lastDot === -1)
+                continue;
+            const parent = key.substring(0, lastDot);
+            const child = key.substring(lastDot + 1);
+            // Skip array access or function call patterns
+            if (child.includes('[') || child.includes('('))
+                continue;
+            // Only consider paths inside array element chains (contains []).
+            // Direct children of functionCallReturnValue are legitimate destructured
+            // return values, not conflation. Conflation happens deeper in the chain
+            // when array element fields get corrupted sub-properties.
+            if (!parent.includes('['))
+                continue;
+            if (topLevelRootVars.has(child)) {
+                if (!parentToConflatedKeys.has(parent)) {
+                    parentToConflatedKeys.set(parent, []);
+                }
+                parentToConflatedKeys.get(parent).push(key);
+            }
+        }
+        // Only filter when 2+ sub-properties of the same parent match root scope vars.
+        // This threshold avoids false positives from coincidental name matches.
+        const keysToRemove = new Set();
+        const parentsToRestore = new Set();
+        for (const [parent, conflatedKeys] of parentToConflatedKeys) {
+            if (conflatedKeys.length >= 2) {
+                for (const key of conflatedKeys) {
+                    keysToRemove.add(key);
+                }
+                parentsToRestore.add(parent);
+            }
+        }
+        if (keysToRemove.size === 0)
+            return efc;
+        // Create a new schema without the conflated paths
+        const newSchema = {};
+        for (const [key, value] of Object.entries(efc.schema)) {
+            if (keysToRemove.has(key))
+                continue;
+            // Restore parent type: if it was changed to "object" because of conflated
+            // sub-properties, and now all those sub-properties are removed, change it
+            // back to "unknown" (we don't know the original type)
+            if (parentsToRestore.has(key) && value === 'object') {
+                // Check if there are any remaining sub-properties
+                const hasRemainingSubProps = Object.keys(efc.schema).some((k) => !keysToRemove.has(k) &&
+                    k !== key &&
+                    (k.startsWith(key + '.') || k.startsWith(key + '[')));
+                newSchema[key] = hasRemainingSubProps ? value : 'unknown';
+            }
+            else {
+                newSchema[key] = value;
+            }
+        }
+        return { ...efc, schema: newSchema };
     }
     /**
      * Cleans cyScope placeholder references from a FunctionCallInfo.