@codeyam/codeyam-cli 0.1.0-staging.b8a55ba → 0.1.0-staging.d0ad4ae

package/packages/ai/src/lib/checkAllAttributes.js.map

@@ -1 +1 @@
-{"version":3,"file":"checkAllAttributes.js","sourceRoot":"","sources":["../../../../../../packages/ai/src/lib/checkAllAttributes.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,IAAgC;IACzE,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,CAAC;QAC1C,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE,CAAC;gBAC5B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC;gBACjB,SAAS;YACX,CAAC;YAED,IAAI,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,QAAQ,EAAE,CAAC;gBAClC,kBAAkB,CAAC,IAAI,CAAC,GAAG,CAA+B,CAAC,CAAC;YAC9D,CAAC;iBAAM,IAAI,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,QAAQ,EAAE,CAAC;gBACzC,IAAI,CAAC,GAAG,CAAC,GAAI,IAAI,CAAC,GAAG,CAAY,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAC1D,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,KAAK,CAAC,+BAA+B,EAAE;gBAC7C,GAAG;gBACH,IAAI;gBACJ,KAAK,EAAE,CAAC;aACT,CAAC,CAAC;YACH,MAAM,CAAC,CAAC;QACV,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}
+{"version":3,"file":"checkAllAttributes.js","sourceRoot":"","sources":["../../../../../../packages/ai/src/lib/checkAllAttributes.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,IAA0C;IAE1C,wEAAwE;IACxE,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACxC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC;IACd,CAAC;IACD,4CAA4C;IAC5C,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC;IACtD,CAAC;IAED,MAAM,GAAG,GAAG,IAAkC,CAAC;IAC/C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACnC,IAAI,CAAC;YACH,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE,CAAC;gBAC3B,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC;gBAChB,SAAS;YACX,CAAC;YAED,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBAC5B,GAAG,CAAC,GAAG,CAAC,GAAI,GAAG,CAAC,GAAG,CAAe,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAC9C,kBAAkB,CAAC,IAAI,CAAC,CACzB,CAAC;YACJ,CAAC;iBAAM,IAAI,OAAO,GAAG,CAAC,GAAG,CAAC,KAAK,QAAQ,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC;gBAC7D,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;YAC/B,CAAC;iBAAM,IAAI,OAAO,GAAG,CAAC,GAAG,CAAC,KAAK,QAAQ,EAAE,CAAC;gBACxC,GAAG,CAAC,GAAG,CAAC,GAAI,GAAG,CAAC,GAAG,CAAY,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,KAAK,CAAC,+BAA+B,EAAE;gBAC7C,GAAG;gBACH,IAAI,EAAE,GAAG;gBACT,KAAK,EAAE,CAAC;aACT,CAAC,CAAC;YACH,MAAM,CAAC,CAAC;QACV,CAAC;IACH,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC"}

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

@@ -913,6 +913,17 @@ export class ScopeDataStructure {
                 const remainingKey = remainingSchemaPathParts.join('|');
                 const equivalentSchemaPath = equivalentSchemaPathMap.get(remainingKey);
                 if (equivalentSchemaPath) {
+                    // Skip propagation when there's a structural mismatch:
+                    // - schemaPath ends with [] (array element, represents an object)
+                    // - equivalentSchemaPath doesn't end with [] (non-array prop, usually a scalar)
+                    // This prevents incorrectly typing array elements as strings when they're
+                    // equivalent to scalar props like JSX keys (e.g., workouts[] ↔ Card().key)
+                    const schemaPathEndsWithArray = schemaPath.endsWith('[]');
+                    const equivalentEndsWithArray = equivalentSchemaPath.endsWith('[]');
+                    if (schemaPathEndsWithArray !== equivalentEndsWithArray) {
+                        // Don't propagate between array element paths and non-array paths
+                        continue;
+                    }
                     const value1 = scopeNode.schema[schemaPath];
                     const value2 = equivalentScopeNode.schema[equivalentSchemaPath];
                     const bestValue = selectBestValue(value1, value2);
@@ -2301,25 +2312,62 @@ export class ScopeDataStructure {
             return acc;
         }, {});
         const equivalencies = this.getEquivalencies(functionName);
+        const scopeName = functionName ?? this.scopeTreeManager.getRootName();
         for (const equivalenceKey in equivalencies ?? {}) {
             for (const equivalenceValue of equivalencies[equivalenceKey]) {
                 const schemaPath = equivalenceValue.schemaPath;
                 if (schemaPath.startsWith('signature[') &&
-                    equivalenceValue.scopeNodeName === functionName &&
+                    equivalenceValue.scopeNodeName === scopeName &&
                     !signatureInSchema[schemaPath]) {
                     signatureInSchema[schemaPath] = 'unknown';
                 }
             }
         }
         const tempScopeNode = this.createTempScopeNode(functionName ?? this.scopeTreeManager.getRootName(), signatureInSchema, equivalencies);
-        // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
-        // during this "getter" method. validateSchema triggers manager.finalize which
-        // can call addToSchema -> addToEquivalencyDatabase -> mergeEquivalencyDatabaseEntries,
-        // which would incorrectly remove entries from the database.
-        const wasOnlyEquivalencies = this.onlyEquivalencies;
-        this.onlyEquivalencies = true;
         this.validateSchema(tempScopeNode, true, fillInUnknowns);
-        this.onlyEquivalencies = wasOnlyEquivalencies;
+        // After validateSchema has filled in types, propagate nested paths from
+        // variables to their signature equivalents.
+        // e.g., workouts[].activity_type -> signature[0].workouts[].activity_type
+        //
+        // Build a map of variable names that are equivalent to signature paths
+        // e.g., { 'workouts': 'signature[0].workouts' }
+        const variableToSignatureMap = {};
+        for (const equivalenceKey in equivalencies ?? {}) {
+            for (const equivalenceValue of equivalencies[equivalenceKey]) {
+                const schemaPath = equivalenceValue.schemaPath;
+                // Track which variables map to signature paths
+                // equivalenceKey is the variable name (e.g., 'workouts')
+                // schemaPath is where it comes from (e.g., 'signature[0].workouts')
+                if (schemaPath.startsWith('signature[') &&
+                    equivalenceValue.scopeNodeName === scopeName) {
+                    variableToSignatureMap[equivalenceKey] = schemaPath;
+                }
+            }
+        }
+        // Propagate nested paths from variables to their signature equivalents
+        // e.g., if workouts = signature[0].workouts, then workouts[].title becomes
+        // signature[0].workouts[].title
+        for (const schemaKey in schema) {
+            // Skip keys that already start with signature[
+            if (schemaKey.startsWith('signature['))
+                continue;
+            // Check if this key starts with a variable that maps to a signature path
+            for (const [variableName, signaturePath] of Object.entries(variableToSignatureMap)) {
+                // Check if schemaKey starts with variableName followed by a property accessor
+                // e.g., 'workouts[]' starts with 'workouts'
+                if (schemaKey === variableName ||
+                    schemaKey.startsWith(variableName + '.') ||
+                    schemaKey.startsWith(variableName + '[')) {
+                    // Transform the path: replace the variable prefix with the signature path
+                    const suffix = schemaKey.slice(variableName.length);
+                    const signatureKey = signaturePath + suffix;
+                    // Add to schema if not already present
+                    if (!tempScopeNode.schema[signatureKey]) {
+                        tempScopeNode.schema[signatureKey] = schema[schemaKey];
+                    }
+                }
+            }
+        }
         return tempScopeNode.schema;
     }
     getReturnValue({ functionName, fillInUnknowns, }) {
@@ -2744,6 +2792,15 @@ export class ScopeDataStructure {
                     // Not all variables have schemas - fall back to rootSchema extraction
                     perVariableSchemas = undefined;
                 }
+                else {
+                    // Also check that at least one schema is non-empty
+                    // Bug fix: perCallSignatureSchemas may have entries but with empty schemas {}
+                    // In this case, we should fall through to Fallback which uses rootSchema
+                    const hasNonEmptySchema = Object.values(perVariableSchemas).some((schema) => Object.keys(schema).length > 0);
+                    if (!hasNonEmptySchema) {
+                        perVariableSchemas = undefined;
+                    }
+                }
             }
             // CASE 2: Single call signature with single variable - use perCallSignatureSchemas directly
             // This handles parameterized calls like useFetcher<ConfigData>() where each is a separate efc entry
@@ -2758,7 +2815,11 @@ export class ScopeDataStructure {
                     perVariableSchemas = { [varName]: { ...schema } };
                 }
             }
-            // CASE 3: Parameterized calls that create SEPARATE efc entries (no perCallSignatureSchemas)
+            // CASE 3: Extract from efc.schema when perCallSignatureSchemas is missing or empty
+            // This handles two scenarios:
+            // 1. Parameterized calls that create SEPARATE efc entries (no perCallSignatureSchemas)
+            // 2. Destructuring where perCallSignatureSchemas exists but has EMPTY schemas
+            //
             // When useFetcher<ConfigData>() and useFetcher<SettingsData>() are called, they create separate
             // efc entries because getFunctionCallRoot preserves type parameters. Each entry has its own
             // `schema` field, but due to variable reassignment, the schema may be contaminated with paths
@@ -2774,11 +2835,25 @@ export class ScopeDataStructure {
             //
             // We filter to only keep paths that should belong to THIS call by checking if the
             // receiving variable's equivalency points to this call's return value.
+            //
+            // BUG FIX: The old condition `!efc.perCallSignatureSchemas` was FALSE when the object
+            // existed (even with empty schemas), causing this case to be skipped. We now also check
+            // if all schemas in perCallSignatureSchemas are empty.
+            const hasNonEmptyPerCallSignatureSchemas = efc.perCallSignatureSchemas &&
+                Object.values(efc.perCallSignatureSchemas).some((schema) => Object.keys(schema).length > 0);
+            // Build the call signature prefix that paths should start with
+            const callSigPrefix = `${efc.callSignature}.functionCallReturnValue`;
+            // Check if efc.schema has variable-specific paths (indicating destructuring).
+            // Destructuring: const { entities, gitStatus } = useLoaderData()
+            // - efc.schema has paths like: useLoaderData().functionCallReturnValue.entities...
+            // Multiple calls: const x = useFetcher(); const y = useFetcher();
+            // - efc.schema has paths like: useFetcher().functionCallReturnValue.data...
+            // CASE 3 should only run for destructuring (variable-specific paths exist).
+            const hasVariableSpecificPaths = (efc.receivingVariableNames ?? []).some((varName) => Object.keys(efc.schema).some((path) => path.startsWith(`${callSigPrefix}.${varName}`)));
             if (!perVariableSchemas &&
-                !efc.perCallSignatureSchemas &&
-                numReceivingVars >= 1) {
-                // Build the call signature prefix that paths should start with
-                const callSigPrefix = `${efc.callSignature}.functionCallReturnValue`;
+                !hasNonEmptyPerCallSignatureSchemas &&
+                numReceivingVars >= 1 &&
+                hasVariableSpecificPaths) {
                 // Filter efc.schema to only include paths matching this call signature
                 const filteredSchema = {};
                 for (const [path, type] of Object.entries(efc.schema)) {
@@ -2787,16 +2862,17 @@ export class ScopeDataStructure {
                     }
                 }
                 // Build perVariableSchemas from the filtered schema
+                // For destructuring, filter paths by variable name
                 if (Object.keys(filteredSchema).length > 0) {
                     perVariableSchemas = {};
                     for (const varName of efc.receivingVariableNames ?? []) {
-                        // For each variable, extract paths and transform to functionCallReturnValue format
+                        // For destructuring, extract only paths specific to this variable
+                        const varSpecificPrefix = `${callSigPrefix}.${varName}`;
                         const varSchema = {};
                         for (const [path, type] of Object.entries(filteredSchema)) {
-                            if (path.startsWith(callSigPrefix)) {
-                                // Transform to generic functionCallReturnValue path
-                                // e.g., "useFetcher<ConfigData>().functionCallReturnValue.data.data.theme"
-                                //     -> "functionCallReturnValue.data.data.theme"
+                            if (path.startsWith(varSpecificPrefix)) {
+                                // Transform: useLoaderData().functionCallReturnValue.entities.sha
+                                //         -> functionCallReturnValue.entities.sha (keep the variable name)
                                 const suffix = path.slice(callSigPrefix.length);
                                 const returnValuePath = `functionCallReturnValue${suffix}`;
                                 varSchema[returnValuePath] = type;