@codeyam/codeyam-cli 0.1.0-staging.8e7b1bd → 0.1.0-staging.b8a55ba

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

@@ -17,6 +17,12 @@ interface UseStateInfo {
 export class ReactFrameworkManager implements EquivalencyManager {
   private useStateInfos: UseStateInfo[] = [];
   private useCallbackEquivalents: Record<string, string> = {};
+  // Track variables used as ref props - they should be typed as 'null'
+  // Format: { scopeNodeName -> Set of variable paths }
+  private refVariables: Map<string, Set<string>> = new Map();
+  // Track ref variable source paths for updating external function call schemas in finalize
+  // Format: { functionCallName -> Set of source paths (e.g., 'useAutoAnimate().functionCallReturnValue[]') }
+  private refVariableSources: Map<string, Set<string>> = new Map();
 
   postProcess(scopeNode: ScopeNode, scopeDataStructure: ScopeDataStructure) {
     this.handleUseState(scopeNode, scopeDataStructure);
@@ -139,7 +145,27 @@ export class ReactFrameworkManager implements EquivalencyManager {
     'main',
   ]);
 
-  finalize(_scopeNode: ScopeNode, _scopeDataStructure: ScopeDataStructure) {}
+  finalize(scopeNode: ScopeNode, scopeDataStructure: ScopeDataStructure) {
+    // Set all tracked ref variables to 'null' type
+    // This ensures mock data generation uses null instead of placeholder strings
+    const refVarsForScope = this.refVariables.get(scopeNode.name);
+    if (refVarsForScope) {
+      for (const refVar of refVarsForScope) {
+        scopeNode.schema[refVar] = 'null';
+      }
+    }
+
+    // Update external function call schemas with ref source paths
+    // This runs AFTER schema building is complete, so the null values won't be overwritten
+    for (const efc of scopeDataStructure.externalFunctionCalls) {
+      const refSourcePaths = this.refVariableSources.get(efc.name);
+      if (refSourcePaths) {
+        for (const sourcePath of refSourcePaths) {
+          efc.schema[sourcePath] = 'null';
+        }
+      }
+    }
+  }
 
   private findUseStateInfo(useStateCall: string) {
     return this.useStateInfos.find(
@@ -564,6 +590,102 @@ export class ReactFrameworkManager implements EquivalencyManager {
     for (const [equivalentPath, equivalentValues] of Object.entries(
       scopeNode.equivalencies,
     )) {
+      // Check if the equivalency KEY (e.g., "div().signature[0].ref") ends with .ref
+      // If so, the VALUE (e.g., "parent") should be marked as null
+      const equivalentPathParts = scopeDataStructure.splitPath(equivalentPath);
+      const pathLength = equivalentPathParts.length;
+
+      if (pathLength >= 2) {
+        const secondToLast = equivalentPathParts[pathLength - 2];
+        const last = equivalentPathParts[pathLength - 1];
+
+        if (secondToLast === 'signature[0]' && last === 'ref') {
+          // This is a ref prop usage like div().signature[0].ref -> parent
+          for (const equivalentValue of equivalentValues) {
+            propagated = true;
+
+            // Track this variable as a ref - we'll set its type to 'null' in finalize()
+            // after the schema is built (setting directly here would be overwritten)
+            // IMPORTANT: The ref variable might be defined in a parent scope, not the
+            // current scope. We need to find where the variable is actually defined by
+            // walking up the scope tree.
+            const varName = equivalentValue.schemaPath;
+            let targetScope: ScopeNode | null = scopeNode;
+
+            // Walk up the scope tree to find where this variable is defined
+            while (targetScope) {
+              // Check if this scope has the variable in its schema or equivalencies
+              const hasVariable =
+                varName in (targetScope.schema || {}) ||
+                varName in (targetScope.equivalencies || {});
+
+              if (hasVariable) {
+                if (!this.refVariables.has(targetScope.name)) {
+                  this.refVariables.set(targetScope.name, new Set());
+                }
+                this.refVariables.get(targetScope.name)!.add(varName);
+
+                // IMPORTANT: Also update the source of the ref variable in the external
+                // function call's schema. This ensures dataForMocks produces [null]
+                // instead of ["string"] for hooks like useAutoAnimate.
+                const varEquivalencies = targetScope.equivalencies?.[varName];
+                if (varEquivalencies) {
+                  for (const varEquivalency of varEquivalencies) {
+                    const sourcePath = varEquivalency.schemaPath;
+                    // Check if this comes from an external function call
+                    // (contains functionCallReturnValue which indicates it's a hook/function return)
+                    if (sourcePath.includes('functionCallReturnValue')) {
+                      // Store the source path for later - we'll update the external function
+                      // call's schema in finalize() which runs AFTER schema building is complete.
+                      // Setting it here would be overwritten by later schema building.
+                      for (const efc of scopeDataStructure.externalFunctionCalls) {
+                        if (sourcePath.startsWith(efc.name)) {
+                          if (!this.refVariableSources.has(efc.name)) {
+                            this.refVariableSources.set(efc.name, new Set());
+                          }
+                          // Store both the specific indexed path and the generic [] path
+                          this.refVariableSources
+                            .get(efc.name)!
+                            .add(sourcePath);
+                          const genericPath = sourcePath.replace(
+                            /\[\d+\]/g,
+                            '[]',
+                          );
+                          if (genericPath !== sourcePath) {
+                            this.refVariableSources
+                              .get(efc.name)!
+                              .add(genericPath);
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+
+              // Move up to parent scope
+              if (targetScope.tree && targetScope.tree.length > 0) {
+                const parentScopeName =
+                  targetScope.tree[targetScope.tree.length - 1];
+                targetScope = scopeDataStructure.getScopeOrFunctionCallInfo(
+                  parentScopeName,
+                ) as ScopeNode | null;
+              } else {
+                targetScope = null;
+              }
+            }
+
+            scopeDataStructure.removeEquivalency(
+              equivalentPath,
+              equivalentValue,
+              scopeNode,
+            );
+          }
+          continue;
+        }
+      }
+
+      // Original logic for checking the value side
       for (const equivalentValue of equivalentValues) {
         const equivalentValueParts = scopeDataStructure.splitPath(
           equivalentValue.schemaPath,

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

@@ -64,6 +64,14 @@ const protoMethodSets: Record<PrimitiveKind, Set<string>> = {
   ),
 };
 
+/** Built-in properties (not methods) that should be removed from primitives.
+ * These are properties that exist on the prototype and shouldn't appear
+ * as schema entries (they cause malformed mock data structures). */
+const protoPropertySets: Partial<Record<PrimitiveKind, Set<string>>> = {
+  array: new Set(['length']),
+  string: new Set(['length']),
+};
+
 /**
  * Extract primitive kind from a type string, handling union types.
  * E.g., "number | undefined" -> "number", "string | null" -> "string"
@@ -118,11 +126,21 @@ function scrub(
       const rootKind = rootTable.get(prefix);
       if (!rootKind) continue;
 
-      const rawMethod = keyParts[cut].split('(')[0];
+      const rawToken = keyParts[cut];
+      const rawMethod = rawToken.split('(')[0];
+
+      // Check if it's a prototype method (e.g., map, filter, toString)
       if (protoMethodSets[rootKind].has(rawMethod)) {
         onRemove(keyPath);
         break;
       }
+
+      // Check if it's a built-in property (e.g., length on arrays/strings)
+      const propertySet = protoPropertySets[rootKind];
+      if (propertySet && propertySet.has(rawToken)) {
+        onRemove(keyPath);
+        break;
+      }
     }
   }
 }

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

@@ -41,6 +41,19 @@ const isolatingArrayMethodsSet = new Set([
 // 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']);
+
+// Methods that return primitives (boolean, number) - their return values are not mockable
+// These should have their .functionCallReturnValue paths removed from the schema
+const primitiveReturningMethodsSet = new Set([
+  'some', // Returns boolean
+  'every', // Returns boolean
+  'includes', // Returns boolean
+  'indexOf', // Returns number (index)
+  'lastIndexOf', // Returns number (index from end)
+  'findIndex', // Returns number (index)
+  'findLastIndex', // Returns number (index from end)
+]);
+
 export const transformingArrayMethodsSet = new Set([
   'map',
   'reduce',
@@ -984,11 +997,20 @@ function clearAttributes(
         basePath
       )
         continue;
+      // Preserve functionCallReturnValue for non-string types, UNLESS
+      // the method is a primitive-returning method (like some, every, includes, indexOf)
+      // whose return values are not mockable
+      const methodPart = keyParts[basePathParts.length];
+      const methodName = methodPart?.split('(')[0];
+      const isPrimitiveReturning = primitiveReturningMethodsSet.has(
+        methodName ?? '',
+      );
       if (
         mapping[basePath] !== 'string' &&
         keyParts[basePathParts.length + 1]?.startsWith(
           'functionCallReturnValue',
-        )
+        ) &&
+        !isPrimitiveReturning
       )
         continue;
 

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

@@ -6,6 +6,14 @@ const STANDALONE_INDEX_RE = /^\[(\d+)\]$/;
 const isExplicitIndex = (s?: string) => !!s && INDEXED_RE.test(s);
 const isStandaloneIndex = (s?: string) => !!s && STANDALONE_INDEX_RE.test(s);
 
+// Detect .length properties that come from dynamic iteration patterns
+// These aren't useful for mock data - arrays work without explicit length,
+// and objects shouldn't have length. We filter .length that appears:
+// 1. After array notation: metadata[].length, items[][].length
+// 2. On object paths that likely come from iteration: metadata.length (when metadata has other props)
+// The regex matches any path ending with .length that has [] somewhere before it
+const DYNAMIC_LENGTH_RE = /\[\].*\.length$/;
+
 // Treat these as structural placeholders (don't commit them as concrete leaves)
 function isSkippableLeafType(t: string) {
   // 'unknown' by itself is a placeholder (but 'boolean | unknown' is not)
@@ -23,6 +31,10 @@ export default function convertDotNotation(
   const result: JsonTypeDefinition = {};
 
   for (const [rawPath, typ] of Object.entries(schema)) {
+    // Skip paths with .length after array notation from dynamic iteration
+    // e.g., metadata[].length, metadata[][].length
+    if (DYNAMIC_LENGTH_RE.test(rawPath)) continue;
+
     const parts = splitOutsideParenthesesAndArrays(rawPath);
     if (!parts || parts.length === 0) continue;
 
@@ -187,6 +199,17 @@ export default function convertDotNotation(
           i++; // consume '[]'
         } else {
           // Pattern like: "items", "[]", "id" -> items: [ { id: ... } ]
+          // But if cursor[key] is already a non-array object (from paths like "metadata: object"),
+          // don't overwrite it with an array - the object type should take precedence.
+          // This handles spurious "metadata[]" paths from dynamic iteration (Object.keys, for...in).
+          if (
+            cursor[key] !== undefined &&
+            typeof cursor[key] === 'object' &&
+            !Array.isArray(cursor[key])
+          ) {
+            // Skip this path - it's trying to treat an object as an array
+            break;
+          }
           if (!Array.isArray(cursor[key])) cursor[key] = [];
 
           // Look ahead to see what comes after '[]'

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

@@ -208,10 +208,12 @@ export default function fillInSchemaGapsAndUnknowns(
 export function fillInDirectSchemaGapsAndUnknowns({
   scopeName,
   schema,
+  mergedSchema,
   attempts = 0,
 }: {
   scopeName?: string;
   schema: Record<string, string>;
+  mergedSchema?: Record<string, string>;
   attempts?: number;
 }) {
   try {
@@ -245,7 +247,9 @@ export function fillInDirectSchemaGapsAndUnknowns({
     const guessTypeForPath = (path: string, defaultType = 'string') => {
       let knownType = checkIfKnownType(path, functionKeysMapping);
       if (!knownType) {
-        knownType = checkIfObjectOrFunction(path, schema);
+        // Use mergedSchema for type inference if available (has more complete nested paths)
+        // Fall back to schema if mergedSchema is not provided
+        knownType = checkIfObjectOrFunction(path, mergedSchema ?? schema);
       }
 
       if (knownType && schema[path] !== knownType) {
@@ -373,10 +377,39 @@ export function fillInDirectSchemaGapsAndUnknowns({
       fillInDirectSchemaGapsAndUnknowns({
         scopeName,
         schema,
+        mergedSchema,
         attempts: ++attempts,
       });
     }
 
+    // Remove .length paths when the parent is typed as 'array' or 'string' (or nullable variants).
+    // These are built-in properties that were used for type inference but shouldn't appear
+    // in the final schema (they create { length: N } objects instead of proper arrays).
+    // However, if the parent could be an 'object' or other type, keep .length as it may be
+    // a custom property.
+    for (const key of Object.keys(schema)) {
+      const parts = splitOutsideParenthesesAndArrays(key);
+      if (parts[parts.length - 1] === 'length') {
+        const parentPath = joinParenthesesAndArrays(parts.slice(0, -1));
+        const parentType = schema[parentPath];
+        if (parentType) {
+          // Split union types and filter out nullable parts
+          const typeParts = parentType.split(' | ').map((t) => t.trim());
+          const nonNullableTypes = typeParts.filter(
+            (t) => t !== 'undefined' && t !== 'null',
+          );
+          // Only remove if ALL non-nullable types are array or string
+          // This ensures we don't remove .length from potential custom objects
+          if (
+            nonNullableTypes.length > 0 &&
+            nonNullableTypes.every((t) => t === 'array' || t === 'string')
+          ) {
+            delete schema[key];
+          }
+        }
+      }
+    }
+
     return schema;
   } catch (error) {
     console.info(

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

@@ -82,37 +82,178 @@ export default function gatherRelevantDependentKeyAttributes(
       const signatureSchema = dependencySchema?.signatureSchema;
       if (!signatureSchema) return;
 
-      const sourceEquivalencies = dependencySchema?.sourceEquivalencies ?? {};
+      // Get sourceEquivalencies from the dependent analysis's mergedDataStructure,
+      // not from dependencySchemas (which doesn't store them)
+      const sourceEquivalencies =
+        dependentAnalysis?.metadata?.mergedDataStructure?.sourceEquivalencies ??
+        {};
+
+      // Build a fallback mapping from parent's usageEquivalencies
+      // This helps when the child's sourceEquivalencies don't have a mapping
+      // For example, if parent passes `entity` to child's `signature[0]`,
+      // usageEquivalencies might have: entity -> [{schemaPath: 'signature[0]', scopeNodeName: entityName}]
+      const usageEquivalencies = mergedDataStructure?.usageEquivalencies ?? {};
+      const signatureToParentPath: Record<string, string> = {};
+
+      for (const parentPath in usageEquivalencies) {
+        const usages = usageEquivalencies[parentPath];
+        for (const usage of usages) {
+          if (usage.scopeNodeName !== entityName) continue;
+
+          // Extract signature path from schemaPath
+          // Format can be:
+          // 1. "functionName(args).signature[N]" or "functionName(args).signature[N].property" (real data)
+          // 2. "signature[N]" or "signature[N].property" (simplified/test format)
+          let signaturePath: string;
+          const signatureIndex = usage.schemaPath.indexOf('.signature[');
+          if (signatureIndex !== -1) {
+            // Full format: extract "signature[N]" or "signature[N].property" after the dot
+            signaturePath = usage.schemaPath.slice(signatureIndex + 1);
+          } else if (usage.schemaPath.startsWith('signature[')) {
+            // Simplified format: already starts with signature[
+            signaturePath = usage.schemaPath;
+          } else {
+            continue;
+          }
+
+          // Map child's signature path to parent's path
+          // e.g., 'signature[0]' -> 'entity'
+          signatureToParentPath[signaturePath] = parentPath;
+        }
+      }
 
       // If sourceEquivalencies is empty but the child has mocked imports,
-      // propagate key attributes directly since they affect the parent's visual output
+      // only propagate key attributes that come from mocked data sources
+      // (not props that the parent passes to the child)
       if (Object.keys(sourceEquivalencies).length === 0) {
-        // Check both importedExports and nodeModuleImports for mocked imports
+        // Collect names of mocked imports
         const importedExports =
           dependentAnalysis.entity?.metadata?.importedExports ?? [];
         const nodeModuleImports =
           dependentAnalysis.entity?.metadata?.nodeModuleImports ?? {};
 
-        const hasMockedImportedExports = importedExports.some(
-          (imp: { isMocked?: boolean }) => imp.isMocked,
-        );
-        const hasMockedNodeModuleImports = Object.values(
-          nodeModuleImports,
-        ).some((imports: any[]) =>
-          imports?.some((imp: { isMocked?: boolean }) => imp.isMocked),
-        );
+        const mockedImportNames = new Set<string>();
 
-        const childHasMockedImports =
-          hasMockedImportedExports || hasMockedNodeModuleImports;
+        // Collect mocked names from importedExports
+        for (const imp of importedExports) {
+          if ((imp as { isMocked?: boolean }).isMocked) {
+            mockedImportNames.add((imp as { name: string }).name);
+          }
+        }
 
-        if (childHasMockedImports) {
+        // Collect mocked names from nodeModuleImports
+        for (const imports of Object.values(nodeModuleImports)) {
+          for (const imp of imports as any[]) {
+            if ((imp as { isMocked?: boolean }).isMocked) {
+              mockedImportNames.add((imp as { name: string }).name);
+            }
+          }
+        }
+
+        if (mockedImportNames.size > 0) {
           for (const dependentKeyAttribute of dependentKeyAtttributes) {
-            relevantDependentKeyAttributes.push({
-              ...dependentKeyAttribute,
-              dependentEntityName: entityName,
-              originalEntityName: entityName,
-              filePath: path,
-            } as any);
+            // Include key attributes that come from controllable data sources:
+            // 1. Mocked data sources (like getScenarioDisplayState())
+            // 2. Arguments/props passed to the child (signature[N].*)
+            // Exclude attributes that are clearly just the prop name itself (like "size")
+            const externalPath = dependentKeyAttribute.externalPath || '';
+            const dataStructurePath =
+              dependentKeyAttribute.dataStructurePath || '';
+
+            const comesFromMockedSource = Array.from(mockedImportNames).some(
+              (mockedName) =>
+                externalPath.includes(`${mockedName}(`) ||
+                externalPath.includes(`${mockedName}.`) ||
+                dataStructurePath.includes(`${mockedName}(`) ||
+                dataStructurePath.includes(`${mockedName}.`) ||
+                dataStructurePath.startsWith(mockedName),
+            );
+
+            // Check if it comes from an argument (signature[N].something.deeper)
+            // but not just a simple prop like "size" or "isOutdated"
+            const comesFromArgument =
+              externalPath.startsWith('signature[') &&
+              // Must have nested path (at least one dot after the prop name)
+              // e.g., signature[0].scenario.metadata.* is OK
+              // but signature[0].size is not (it's just a simple prop)
+              (externalPath.match(/\./g) || []).length >= 2;
+
+            if (comesFromMockedSource || comesFromArgument) {
+              relevantDependentKeyAttributes.push({
+                ...dependentKeyAttribute,
+                dependentEntityName: entityName,
+                originalEntityName: entityName,
+                filePath: path,
+              } as any);
+            }
+          }
+          return;
+        }
+
+        // No mocked imports, try usageEquivalencies fallback for direct argument usage
+        if (Object.keys(signatureToParentPath).length > 0) {
+          for (const dependentKeyAttribute of dependentKeyAtttributes) {
+            if (!dependentKeyAttribute.externalPath?.startsWith('signature['))
+              continue;
+
+            const dependentKeyAttributeExternalPathParts =
+              splitOutsideParenthesesAndArrays(
+                dependentKeyAttribute.externalPath,
+              );
+
+            // Try to find a matching signature path
+            for (
+              let i = dependentKeyAttributeExternalPathParts.length;
+              i > 0;
+              i--
+            ) {
+              const subExternalPath = joinParenthesesAndArrays(
+                dependentKeyAttributeExternalPathParts.slice(0, i),
+              );
+
+              if (signatureToParentPath[subExternalPath]) {
+                const parentPath = signatureToParentPath[subExternalPath];
+
+                // parentPath is already in parent's schema format (e.g., "signature[0].entity" or just "entity")
+                // We need to handle both cases
+                const parentPathStartsWithSignature =
+                  parentPath.startsWith('signature[');
+                let externalPath = parentPathStartsWithSignature
+                  ? parentPath
+                  : `signature[0].${parentPath}`;
+
+                // internalPath is parentPath without the signature[N]. prefix
+                let internalPath: string | undefined =
+                  parentPathStartsWithSignature
+                    ? parentPath.replace(/^signature\[\d+\]\./, '')
+                    : parentPath;
+
+                if (i < dependentKeyAttributeExternalPathParts.length) {
+                  const remainingPath = joinParenthesesAndArrays(
+                    dependentKeyAttributeExternalPathParts.slice(i),
+                  );
+                  externalPath = `${externalPath}.${remainingPath}`;
+                  internalPath = `${internalPath}.${remainingPath}`;
+                }
+
+                // Look up in associationMap for proper internal path
+                if (associationMap[externalPath]) {
+                  internalPath = associationMap[externalPath];
+                }
+
+                relevantDependentKeyAttributes.push({
+                  ...dependentKeyAttribute,
+                  dependentEntityName: entityName,
+                  originalEntityName: entityName,
+                  filePath: path,
+                  internalPath,
+                  externalPath,
+                  dataStructurePath: internalPath,
+                } as any);
+
+                break;
+              }
+            }
           }
         }
         return;
@@ -123,6 +264,8 @@ export default function gatherRelevantDependentKeyAttributes(
           splitOutsideParenthesesAndArrays(dependentKeyAttribute.externalPath);
 
         let matchFound = false;
+
+        // First, try to match using child's sourceEquivalencies
         for (
           let i = dependentKeyAttributeExternalPathParts.length;
           i > 0;
@@ -132,8 +275,8 @@ export default function gatherRelevantDependentKeyAttributes(
             dependentKeyAttributeExternalPathParts.slice(0, i),
           );
 
-          for (const sourceEquivalencyPath in dependencySchema?.sourceEquivalencies ??
-            {}) {
+          // Use the sourceEquivalencies from the child's analysis
+          for (const sourceEquivalencyPath in sourceEquivalencies) {
             const sourceEquivalencyPathParts = splitOutsideParenthesesAndArrays(
               sourceEquivalencyPath,
             );
@@ -145,8 +288,7 @@ export default function gatherRelevantDependentKeyAttributes(
             if (relevantSourceEquivalencyPath !== subExternalPath) continue;
 
             const sourcePath =
-              dependencySchema?.sourceEquivalencies[sourceEquivalencyPath][0]
-                ?.schemaPath;
+              sourceEquivalencies[sourceEquivalencyPath][0]?.schemaPath;
 
             if (!sourcePath) continue;
 
@@ -181,6 +323,8 @@ export default function gatherRelevantDependentKeyAttributes(
               filePath: path, // File path for restructuring into nested format
               internalPath,
               externalPath,
+              // Transform dataStructurePath to parent's path structure
+              dataStructurePath: internalPath,
             } as any);
 
             matchFound = true;
@@ -189,6 +333,74 @@ export default function gatherRelevantDependentKeyAttributes(
 
           if (matchFound) break;
         }
+
+        // Fallback: if no sourceEquivalency match, try using parent's usageEquivalencies
+        // This handles direct argument usage like entity.entityType
+        if (
+          !matchFound &&
+          dependentKeyAttribute.externalPath?.startsWith('signature[')
+        ) {
+          // Try to find a matching signature path in the usageEquivalencies-derived map
+          for (
+            let i = dependentKeyAttributeExternalPathParts.length;
+            i > 0;
+            i--
+          ) {
+            const subExternalPath = joinParenthesesAndArrays(
+              dependentKeyAttributeExternalPathParts.slice(0, i),
+            );
+
+            if (signatureToParentPath[subExternalPath]) {
+              const parentPath = signatureToParentPath[subExternalPath];
+
+              // parentPath is already in parent's schema format (e.g., "signature[0].entity" or just "entity")
+              // We need to handle both cases
+              const parentPathStartsWithSignature =
+                parentPath.startsWith('signature[');
+              let externalPath = parentPathStartsWithSignature
+                ? parentPath
+                : `signature[0].${parentPath}`;
+
+              // internalPath is parentPath without the signature[N]. prefix
+              let internalPath: string | undefined =
+                parentPathStartsWithSignature
+                  ? parentPath.replace(/^signature\[\d+\]\./, '')
+                  : parentPath;
+
+              if (i < dependentKeyAttributeExternalPathParts.length) {
+                const remainingPath = joinParenthesesAndArrays(
+                  dependentKeyAttributeExternalPathParts.slice(i),
+                );
+                externalPath = `${externalPath}.${remainingPath}`;
+                internalPath = `${internalPath}.${remainingPath}`;
+              }
+
+              // Look up the full external path in associationMap for proper internal path
+              const fullExternalPath = externalPath;
+              if (associationMap[fullExternalPath]) {
+                internalPath = associationMap[fullExternalPath];
+              }
+
+              const dependentEntityName =
+                dependentKeyAttribute.dependentEntityName
+                  ? `${dependentKeyAttribute.dependentEntityName} (through ${entityName})`
+                  : entityName;
+
+              relevantDependentKeyAttributes.push({
+                ...dependentKeyAttribute,
+                dependentEntityName,
+                originalEntityName: entityName,
+                filePath: path,
+                internalPath,
+                externalPath,
+                dataStructurePath: internalPath,
+              } as any);
+
+              matchFound = true;
+              break;
+            }
+          }
+        }
       }
     });
   });