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

package/analyzer-template/packages/ai/src/lib/dataStructure/equivalencyManagers/frameworks/ReactFrameworkManager.ts

@@ -408,90 +408,126 @@ export class ReactFrameworkManager implements EquivalencyManager {
     let propagated = false;
     const functionCallSignature = getFunctionCallSignature(subPathParts);
 
-    const relevantUseStateInfo = this.findUseStateInfo(functionCallSignature);
+    let relevantUseStateInfo = this.findUseStateInfo(functionCallSignature);
+
+    // If we didn't find a useState call directly, check if the function being called
+    // is a setter variable (e.g., setWorkouts from useState)
+    if (!relevantUseStateInfo && functionCallSignature) {
+      // Extract the function name from the call (e.g., "setWorkouts" from "setWorkouts(data || [])")
+      const fnName = functionCallSignature.split('(')[0];
+      relevantUseStateInfo = this.useStateInfos.find(
+        (info) => info.setter === fnName,
+      );
+    }
 
     if (relevantUseStateInfo) {
       const pathParts = scopeDataStructure.splitPath(path);
-      if (pathParts.length < 3) return false;
 
-      const basePath = scopeDataStructure.joinPathParts([
-        ...pathParts.slice(0, 2),
-        pathParts[2],
-      ]);
+      // Check if this is a direct setter variable call (e.g., setWorkouts(data).signature[0])
+      // rather than a useState path (e.g., useState<X>().functionCallReturnValue[1].signature[0])
+      const fnName = functionCallSignature?.split('(')[0];
+      const isDirectSetterCall = fnName === relevantUseStateInfo.setter;
+
+      if (isDirectSetterCall && pathParts.length === 2) {
+        // Handle direct setter calls like setWorkouts(data || []).signature[0] = data
+        const lastPart = pathParts[1];
+        if (lastPart === 'signature[0]') {
+          // Get the value being passed to the setter from the equivalency
+          const originScopeInfoName =
+            equivalencyValueChain[0]?.currentPath?.scopeNodeName;
+          if (!originScopeInfoName) return propagated;
+
+          const originScope =
+            scopeDataStructure.getScopeOrFunctionCallInfo(originScopeInfoName);
+          const setterCallEquiv = originScope?.equivalencies?.[path];
+          if (!setterCallEquiv || setterCallEquiv.length === 0)
+            return propagated;
+
+          const argumentPath = setterCallEquiv[0].schemaPath;
+          const argumentScopeName = setterCallEquiv[0].scopeNodeName;
+
+          // Create equivalency: useState<X>().functionCallReturnValue[0] = argumentPath
+          propagated = true;
+          const valuePath = `${relevantUseStateInfo.useStateCall}.functionCallReturnValue[0]`;
+          const useStateScopeInfo =
+            scopeDataStructure.getScopeOrFunctionCallInfo(
+              relevantUseStateInfo.scopeNodeName,
+            ) as ScopeNode;
 
-      const expectedSetterBasePath = scopeDataStructure.joinPathParts([
-        functionCallSignature,
-        'functionCallReturnValue[1]',
-      ]);
+          scopeDataStructure.addEquivalency(
+            valuePath,
+            argumentPath,
+            argumentScopeName,
+            useStateScopeInfo,
+            'useState setter call equivalency (direct)',
+            equivalencyValueChain,
+            traceId,
+          );
+        }
+      } else if (pathParts.length >= 3) {
+        // Original logic for useState path patterns
+        const basePath = scopeDataStructure.joinPathParts([
+          ...pathParts.slice(0, 2),
+          pathParts[2],
+        ]);
 
-      // if (traceId) {
-      //   console.info(
-      //     'Debug Propagation: useState base path',
-      //     JSON.stringify(
-      //       {
-      //         traceId,
-      //         basePath,
-      //         expectedValueBasePath,
-      //         expectedSetterBasePath,
-      //       },
-      //       null,
-      //       2,
-      //     ),
-      //   );
-      // }
-
-      if (basePath === expectedSetterBasePath) {
-        const originScopeInfoName =
-          equivalencyValueChain[0].currentPath?.scopeNodeName;
-        const setterScope =
-          scopeDataStructure.getScopeOrFunctionCallInfo(originScopeInfoName);
-        const setterEquivalencyPath = Object.keys(
-          setterScope.equivalencies,
-        ).find((p) => {
-          if (!p.startsWith(relevantUseStateInfo.setter)) return false;
-          const pParts = scopeDataStructure.splitPath(p);
-
-          const valid = pathParts
-            .slice(3)
-            .reverse()
-            .every((part, index) => [...pParts].reverse()[index] === part);
-
-          // if (p.includes('.title') && valid)
-          //   console.info({ p, pParts, pathParts: pathParts.slice(3) });
-
-          return valid;
-        });
-
-        if (!setterEquivalencyPath) return;
-
-        const setterEquivalencyPathParts = scopeDataStructure.splitPath(
-          setterEquivalencyPath,
-        );
-        const setterEquivalentVariable =
-          setterScope.equivalencies[setterEquivalencyPath][0].schemaPath;
+        const expectedSetterBasePath = scopeDataStructure.joinPathParts([
+          functionCallSignature,
+          'functionCallReturnValue[1]',
+        ]);
 
-        if (setterEquivalentVariable === expectedSetterBasePath) return;
+        if (basePath === expectedSetterBasePath) {
+          const originScopeInfoName =
+            equivalencyValueChain[0].currentPath?.scopeNodeName;
+          const setterScope =
+            scopeDataStructure.getScopeOrFunctionCallInfo(originScopeInfoName);
+          const setterEquivalencyPath = Object.keys(
+            setterScope.equivalencies,
+          ).find((p) => {
+            if (!p.startsWith(relevantUseStateInfo.setter)) return false;
+            const pParts = scopeDataStructure.splitPath(p);
+
+            const valid = pathParts
+              .slice(3)
+              .reverse()
+              .every((part, index) => [...pParts].reverse()[index] === part);
+
+            return valid;
+          });
+
+          if (!setterEquivalencyPath) return propagated;
+
+          const setterEquivalencyPathParts = scopeDataStructure.splitPath(
+            setterEquivalencyPath,
+          );
+          const setterEquivalentVariable =
+            setterScope.equivalencies[setterEquivalencyPath][0].schemaPath;
 
-        propagated = true;
-        const valuePath = `${functionCallSignature}.functionCallReturnValue[0]`;
-        const useStateScopeInfo = scopeDataStructure.getScopeOrFunctionCallInfo(
-          relevantUseStateInfo.scopeNodeName,
-        ) as ScopeNode;
+          if (setterEquivalentVariable === expectedSetterBasePath)
+            return propagated;
 
-        const fullValuePath = scopeDataStructure.joinPathParts([
-          valuePath,
-          ...setterEquivalencyPathParts.slice(2),
-        ]);
+          propagated = true;
+          const valuePath = `${functionCallSignature}.functionCallReturnValue[0]`;
+          const useStateScopeInfo =
+            scopeDataStructure.getScopeOrFunctionCallInfo(
+              relevantUseStateInfo.scopeNodeName,
+            ) as ScopeNode;
+
+          const fullValuePath = scopeDataStructure.joinPathParts([
+            valuePath,
+            ...setterEquivalencyPathParts.slice(2),
+          ]);
 
-        scopeDataStructure.addEquivalency(
-          fullValuePath,
-          setterEquivalentVariable,
-          originScopeInfoName,
-          useStateScopeInfo,
-          'useState setter call equivalency',
-          equivalencyValueChain,
-          traceId,
-        );
+          scopeDataStructure.addEquivalency(
+            fullValuePath,
+            setterEquivalentVariable,
+            originScopeInfoName,
+            useStateScopeInfo,
+            'useState setter call equivalency',
+            equivalencyValueChain,
+            traceId,
+          );
+        }
       }
     }
 

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/cleanNonObjectFunctions.ts

@@ -983,6 +983,17 @@ function clearAttributes(
   for (const key in mapping) {
     const value = mapping[key];
     if (knownTypes.has(value)) {
+      // Don't add string-typed array element paths (ending with []) to knownBasePaths.
+      // When an array element is typed as 'string' but has child paths (like data[].id),
+      // it's actually an object - the 'string' type is incorrect. The child paths
+      // describe the array element structure and should not be deleted.
+      //
+      // However, array-typed [] paths (like matrix[] where matrix is array of arrays)
+      // should still be in knownBasePaths so their method calls (filter, map, etc.)
+      // get cleaned up properly.
+      if (key.endsWith('[]') && value === 'string') {
+        continue;
+      }
       knownBasePaths.add(key);
     }
   }

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/convertNullToUndefinedBySchema.ts

@@ -0,0 +1,98 @@
+/**
+ * Converts null values to undefined (removes them) based on schema type constraints.
+ *
+ * When the LLM generates mock data, it uses `null` to represent "no value" because
+ * JSON doesn't support `undefined`. However, TypeScript types like `string | undefined`
+ * don't accept `null`.
+ *
+ * This function traverses data and schema together:
+ * - If schema type is "T | undefined" (but NOT "T | null"), convert null → undefined (delete key)
+ * - If schema type includes "null" (e.g., "T | null" or "T | null | undefined"), preserve null
+ * - If field not in schema, preserve as-is
+ *
+ * @param data The data object with potential null values
+ * @param schema The schema describing expected types
+ * @returns The data with null→undefined conversions applied (mutates original)
+ */
+export default function convertNullToUndefinedBySchema<T>(
+  data: T,
+  schema: unknown,
+): T {
+  // Handle null/undefined data
+  if (data === null || data === undefined) {
+    return data;
+  }
+
+  // Only process objects
+  if (typeof data !== 'object') {
+    return data;
+  }
+
+  // Handle arrays
+  if (Array.isArray(data)) {
+    // For arrays, the schema should be an array with one element describing the item type
+    const itemSchema = Array.isArray(schema) ? schema[0] : undefined;
+    for (let i = 0; i < data.length; i++) {
+      data[i] = convertNullToUndefinedBySchema(data[i], itemSchema);
+    }
+    return data;
+  }
+
+  // Handle objects
+  const dataObj = data as Record<string, unknown>;
+  const schemaObj = schema as Record<string, unknown> | undefined;
+
+  for (const key of Object.keys(dataObj)) {
+    const value = dataObj[key];
+    const fieldSchema = schemaObj?.[key];
+
+    if (value === null) {
+      // Check if schema allows null
+      if (shouldConvertNullToUndefined(fieldSchema)) {
+        // Delete the key (converts null to undefined)
+        delete dataObj[key];
+      }
+      // If schema allows null, preserve it
+    } else if (typeof value === 'object' && value !== null) {
+      // Recursively process nested objects/arrays
+      convertNullToUndefinedBySchema(value, fieldSchema);
+    }
+  }
+
+  return data;
+}
+
+/**
+ * Determines if a null value should be converted to undefined based on schema type.
+ *
+ * @param fieldSchema The schema type string or object for the field
+ * @returns true if null should be converted to undefined, false if null should be preserved
+ */
+function shouldConvertNullToUndefined(fieldSchema: unknown): boolean {
+  // If no schema for this field, preserve null (be conservative)
+  if (fieldSchema === undefined || fieldSchema === null) {
+    return false;
+  }
+
+  // If schema is a string type definition, check if it allows null
+  if (typeof fieldSchema === 'string') {
+    // Schema types that include "null" should preserve null values
+    // e.g., "string | null", "number | null | undefined", "null"
+    const allowsNull = fieldSchema.includes('null');
+    const allowsUndefined = fieldSchema.includes('undefined');
+
+    // If type allows undefined but NOT null, convert null to undefined
+    // e.g., "string | undefined" → convert null to undefined
+    // e.g., "string | null" → preserve null
+    // e.g., "string | null | undefined" → preserve null
+    if (allowsUndefined && !allowsNull) {
+      return true;
+    }
+
+    return false;
+  }
+
+  // If schema is an object or array, it's a nested structure
+  // Don't convert the container itself, just recurse into it
+  return false;
+}

package/analyzer-template/packages/ai/src/lib/deepEqual.ts

@@ -0,0 +1,30 @@
+export default function deepEqual(obj1: unknown, obj2: unknown): boolean {
+  // Handle primitive types and null/undefined
+  if (obj1 === obj2) return true;
+  if (obj1 == null || obj2 == null) return false;
+  if (typeof obj1 !== 'object' || typeof obj2 !== 'object') return false;
+
+  // Handle Date objects
+  if (obj1 instanceof Date && obj2 instanceof Date) {
+    return obj1.getTime() === obj2.getTime();
+  }
+
+  // Handle Array objects
+  if (Array.isArray(obj1) && Array.isArray(obj2)) {
+    if (obj1.length !== obj2.length) return false;
+    return obj1.every((item, index) => deepEqual(item, obj2[index]));
+  }
+
+  // Handle regular objects
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+
+  if (keys1.length !== keys2.length) return false;
+
+  return keys1.every((key) => {
+    if (!Object.prototype.hasOwnProperty.call(obj2, key)) return false;
+    const obj1AsAny = obj1 as any;
+    const obj2AsAny = obj2 as any;
+    return deepEqual(obj1AsAny[key], obj2AsAny[key]);
+  });
+}

package/analyzer-template/packages/ai/src/lib/findMatchingAttribute.ts

@@ -74,29 +74,36 @@ export default function findMatchingAttribute(
     return equivalent;
   } else {
     const normalizedPath = normalizeKey(attributePath);
-    const matchingAttribute = attributesList.find(
+    // Filter out undefined values to prevent normalizeKey from crashing
+    // This can happen when key attributes have undefined internalPath
+    const validAttributes = attributesList.filter(
+      (attr): attr is string => attr !== undefined && attr !== null,
+    );
+    const matchingAttribute = validAttributes.find(
       (attr) => normalizeKey(attr) === normalizedPath,
     );
 
-    // If no exact match find the attribute that matches the most characters starting from the beginning
-    if (!matchingAttribute) {
-      const options = attributesList;
-      const normalizedPathCharacters = normalizedPath.split('');
-      for (const attr of options) {
-        const attrCharacters = normalizeKey(attr).split('');
-        const matchLength = normalizedPathCharacters.findIndex(
-          (char, index) => char !== attrCharacters[index],
-        );
-        if (matchLength !== -1) {
-          const matchedPrefix = normalizedPathCharacters.slice(0, matchLength);
-          if (matchedPrefix.length > 0) {
-            return attr;
-          }
-        }
+    if (matchingAttribute) return matchingAttribute;
+
+    // Fallback: LLM may return dataStructurePath format (e.g., "useLoaderData<typeof loader>().currentBranch")
+    // when we expect localVariable format (e.g., "currentBranch").
+    // Try matching suffix parts of the path against the attributes list.
+    const pathParts = splitOutsideParenthesesAndArrays(attributePath);
+    for (let i = 1; i < pathParts.length; i++) {
+      const suffixPath = joinParenthesesAndArrays(pathParts.slice(i));
+      if (validAttributes.includes(suffixPath)) {
+        return suffixPath;
+      }
+      // Also try normalized comparison for the suffix
+      const normalizedSuffix = normalizeKey(suffixPath);
+      const suffixMatch = validAttributes.find(
+        (attr) => normalizeKey(attr) === normalizedSuffix,
+      );
+      if (suffixMatch) {
+        return suffixMatch;
       }
     }
 
-    if (matchingAttribute) return matchingAttribute;
     return null;
   }
 }