@codeyam/codeyam-cli 0.1.0-staging.28f73cf → 0.1.0-staging.596f0eb

package/analyzer-template/packages/analyze/src/lib/files/scenarios/gatherDataForMocks.ts

@@ -68,128 +68,268 @@ function preprocessSchemaForMocks(
   return result;
 }
 
-export default function gatherDataForMocks(
-  importedExports: {
+/**
+ * Processes a single call (with optional variable name) and returns the mock data entry.
+ * Returns null if no valid schema is found.
+ *
+ * @param importedExport - The imported export to process
+ * @param dependencySchemas - The dependency schemas
+ * @param callIndex - The index of the call to process
+ * @param variableNameOccurrence - When a variable name is reused, this is the occurrence index
+ *                                  (e.g., first 'data' = 0, second 'data' = 1)
+ *                                  Used to disambiguate keys when the same variable is reused.
+ */
+function processCall(
+  importedExport: {
     filePath?: string;
     name: string;
     isMocked?: boolean;
     calls?: string[];
-  }[],
+    callVariableNames?: string[];
+  },
   dependencySchemas: DataStructure['dependencySchemas'],
-) {
-  return importedExports.reduce(
-    (acc, importedExport) => {
-      if (!importedExport.isMocked) return acc;
+  callIndex: number,
+  variableNameOccurrence?: number,
+): { key: string; value: JsonTypeDefinition } | null {
+  const callName = importedExport.calls?.[callIndex] ?? importedExport.name;
+  const variableName = importedExport.callVariableNames?.[callIndex];
 
-      const functionNames: string[] = [];
-
-      const isFunctionNameWithoutFunction = (
-        path: string,
-        functionName: string,
-      ) => {
-        // Check if path starts with functionName but isn't a function call
-        // Must also handle generics: useLoaderData<typeof loader>() should NOT
-        // be filtered when functionName is 'useLoaderData'
-        return (
-          path.startsWith(functionName) &&
-          !path.startsWith(functionName + '(') &&
-          !path.startsWith(functionName + '.(') &&
-          !path.startsWith(functionName + '<') // Handle generics
-        );
-      };
+  // Build the schema lookup key - use variable-qualified key if available
+  const schemaLookupKey = variableName
+    ? `${importedExport.name}::${variableName}`
+    : importedExport.name;
 
-      const rawSchema =
-        dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
-          ?.returnValueSchema ?? {};
-
-      // Preprocess to filter signatures and extract functionCallReturnValue
-      let preprocessedSchema = preprocessSchemaForMocks(rawSchema);
-
-      // Merge non-generic variants into generic variants
-      // e.g., if callName is "useFetcher<T>()", also include paths from "useFetcher()"
-      const callName = importedExport.calls?.[0] ?? importedExport.name;
-      if (callName.includes('<') && callName.includes('(')) {
-        // Extract the base function name without generics
-        const baseFunctionName = cleanFunctionName(callName.split('(')[0]);
-        const nonGenericCall = baseFunctionName + '()';
-        const genericCallPrefix = callName.endsWith(')')
-          ? callName
-          : callName + '()';
-
-        // If we have a generic call, merge paths from non-generic variant
-        const mergedSchema: Record<string, string> = { ...preprocessedSchema };
-        for (const path of Object.keys(preprocessedSchema)) {
-          if (path.startsWith(nonGenericCall)) {
-            // Create corresponding generic path
-            const genericPath =
-              genericCallPrefix + path.slice(nonGenericCall.length);
-            // Only add if the generic path doesn't already exist
-            if (!mergedSchema[genericPath]) {
-              mergedSchema[genericPath] = preprocessedSchema[path];
-            }
-          }
+  const rawSchema =
+    dependencySchemas?.[importedExport.filePath]?.[schemaLookupKey]
+      ?.returnValueSchema ?? {};
+
+  // If no schema found with variable-qualified key, fall back to base name
+  const fallbackSchema =
+    Object.keys(rawSchema).length === 0
+      ? (dependencySchemas?.[importedExport.filePath]?.[importedExport.name]
+          ?.returnValueSchema ?? {})
+      : rawSchema;
+
+  // Preprocess to filter signatures and extract functionCallReturnValue
+  let preprocessedSchema = preprocessSchemaForMocks(fallbackSchema);
+
+  const functionNames: string[] = [];
+
+  const isFunctionNameWithoutFunction = (
+    path: string,
+    functionName: string,
+  ) => {
+    // Check if path starts with functionName but isn't a function call
+    // Must also handle generics: useLoaderData<typeof loader>() should NOT
+    // be filtered when functionName is 'useLoaderData'
+    return (
+      path.startsWith(functionName) &&
+      !path.startsWith(functionName + '(') &&
+      !path.startsWith(functionName + '.(') &&
+      !path.startsWith(functionName + '<') // Handle generics
+    );
+  };
+
+  // For variable-qualified schemas, the paths also include the variable qualifier
+  // e.g., "useFetcher()::entityDiffFetcher.functionCallReturnValue.data"
+  // We need to handle both qualified and non-qualified paths
+
+  // Merge non-generic variants into generic variants
+  // e.g., if callName is "useFetcher<T>()", also include paths from "useFetcher()"
+  if (callName.includes('<') && callName.includes('(')) {
+    // Extract the base function name without generics
+    const baseFunctionName = cleanFunctionName(callName.split('(')[0]);
+    const nonGenericCall = variableName
+      ? `${baseFunctionName}()::${variableName}`
+      : baseFunctionName + '()';
+    const genericCallPrefix = variableName
+      ? `${callName.endsWith(')') ? callName : callName + '()'}::${variableName}`
+      : callName.endsWith(')')
+        ? callName
+        : callName + '()';
+
+    // If we have a generic call, merge paths from non-generic variant
+    const mergedSchema: Record<string, string> = { ...preprocessedSchema };
+    for (const path of Object.keys(preprocessedSchema)) {
+      if (path.startsWith(nonGenericCall)) {
+        // Create corresponding generic path
+        const genericPath =
+          genericCallPrefix + path.slice(nonGenericCall.length);
+        // Only add if the generic path doesn't already exist
+        if (!mergedSchema[genericPath]) {
+          mergedSchema[genericPath] = preprocessedSchema[path];
         }
-        preprocessedSchema = mergedSchema;
       }
+    }
+    preprocessedSchema = mergedSchema;
+  }
 
-      const relevantMergedDependencySchema = Object.keys(
-        preprocessedSchema,
-      ).reduce(
-        (acc, path) => {
-          if (path.endsWith(')')) {
-            const pathParts = splitOutsideParenthesesAndArrays(path);
-            const functionName = joinParenthesesAndArrays([
-              ...pathParts.slice(0, -1),
-              pathParts[pathParts.length - 1].split('(')[0],
-            ]);
-            functionNames.push(functionName);
-            for (const existingPath in acc) {
-              if (isFunctionNameWithoutFunction(existingPath, functionName)) {
-                delete acc[existingPath];
-              }
-            }
-          }
+  // Merge generic call (e.g., "foo()") data into specific argument calls (e.g., "foo(arg1, arg2)")
+  // This handles the case where the generic schema has richer nested data than the specific call
+  if (callName.includes('(') && !callName.includes('<')) {
+    // Extract the base function name and create generic call
+    const baseFunctionName = callName.split('(')[0];
 
+    // For path matching, use non-qualified call names since schema paths don't include
+    // variable qualifiers. Variable qualifiers are only for schema lookup, not path matching.
+    const genericCallForMatching = baseFunctionName + '()';
+    const specificCallForMatching = callName;
+
+    // Only merge if the callName has arguments (not just empty parens)
+    if (specificCallForMatching !== genericCallForMatching) {
+      const mergedSchema: Record<string, string> = {
+        ...preprocessedSchema,
+      };
+      for (const path of Object.keys(preprocessedSchema)) {
+        if (path.startsWith(genericCallForMatching)) {
+          // Create corresponding specific path
+          const specificPath =
+            specificCallForMatching + path.slice(genericCallForMatching.length);
+          // Add if the specific path doesn't exist, OR if it exists but is "unknown"
+          // The generic call's schema often has more precise type info than the specific call
           if (
-            functionNames.some((fn) => isFunctionNameWithoutFunction(path, fn))
+            !mergedSchema[specificPath] ||
+            mergedSchema[specificPath] === 'unknown'
           ) {
-            return acc;
+            mergedSchema[specificPath] = preprocessedSchema[path];
           }
+        }
+      }
+      preprocessedSchema = mergedSchema;
+    }
+  }
 
-          acc[path] = preprocessedSchema[path];
-          return acc;
-        },
-        {} as Record<string, string>,
-      );
-
-      const schema = convertDotNotation(
-        fillInDirectSchemaGapsAndUnknowns({
-          scopeName: importedExport.name,
-          schema: relevantMergedDependencySchema,
-        }),
-      );
-
-      // Determine if this is an object-style or hook-style dependency:
-      // - Hook-style: calls = ['useAuth()'] - call starts with name + '('
-      // - Object-style: calls = ['supabase.from(...)'] - call starts with name + '.'
-      //
-      // After convertDotNotation:
-      // - Hook-style schema has the callName as top-level key: schema['useAuth()']
-      // - Object-style schema has the import name as top-level key: schema['supabase']
-      // Note: callName is already defined above for generic/non-generic merging
-      const isObjectStyle =
-        callName.startsWith(importedExport.name + '.') ||
-        (!callName.includes('(') && callName === importedExport.name);
-
-      const schemaKey = isObjectStyle ? importedExport.name : callName;
-      const outputKey = isObjectStyle ? importedExport.name : callName;
-      const returnValue = schema[schemaKey] ?? schema['returnValue'];
-
-      if (!returnValue) {
+  const relevantMergedDependencySchema = Object.keys(preprocessedSchema).reduce(
+    (acc, path) => {
+      if (path.endsWith(')')) {
+        const pathParts = splitOutsideParenthesesAndArrays(path);
+        const functionName = joinParenthesesAndArrays([
+          ...pathParts.slice(0, -1),
+          pathParts[pathParts.length - 1].split('(')[0],
+        ]);
+        functionNames.push(functionName);
+        for (const existingPath in acc) {
+          if (isFunctionNameWithoutFunction(existingPath, functionName)) {
+            delete acc[existingPath];
+          }
+        }
+      }
+
+      if (functionNames.some((fn) => isFunctionNameWithoutFunction(path, fn))) {
         return acc;
       }
 
-      acc[outputKey] = returnValue as JsonTypeDefinition;
+      acc[path] = preprocessedSchema[path];
+      return acc;
+    },
+    {} as Record<string, string>,
+  );
+
+  const schema = convertDotNotation(
+    fillInDirectSchemaGapsAndUnknowns({
+      scopeName: importedExport.name,
+      schema: relevantMergedDependencySchema,
+    }),
+  );
+
+  // Determine if this is an object-style or hook-style dependency:
+  // - Hook-style: calls = ['useAuth()'] - call starts with name + '('
+  // - Object-style: calls = ['supabase.from(...)'] - call starts with name + '.'
+  const isObjectStyle =
+    callName.startsWith(importedExport.name + '.') ||
+    (!callName.includes('(') && callName === importedExport.name);
+
+  // Build schema key with variable qualifier if present
+  const baseSchemaKey = isObjectStyle ? importedExport.name : callName;
+  const schemaKey = variableName
+    ? `${baseSchemaKey}::${variableName}`
+    : baseSchemaKey;
+
+  // Build output key - for variable-qualified, use "variableName <- functionName" format
+  // This reads naturally as "variableName receives from functionName"
+  // When a variable name is reused (variableNameOccurrence > 0), disambiguate with index
+  let outputKey: string;
+  if (variableName) {
+    // When the same variable name is used multiple times, append the occurrence index
+    // to create unique keys: "data[0] <- useFetch", "data[1] <- useFetch"
+    const disambiguator =
+      variableNameOccurrence !== undefined && variableNameOccurrence > 0
+        ? `[${variableNameOccurrence}]`
+        : '';
+    outputKey = `${variableName}${disambiguator} <- ${importedExport.name}`;
+  } else if (isObjectStyle) {
+    outputKey = importedExport.name;
+  } else {
+    outputKey = callName;
+  }
+
+  // Try to find return value - check with variable qualifier first, then without
+  let returnValue = schema[schemaKey];
+  if (!returnValue && variableName) {
+    returnValue = schema[baseSchemaKey];
+  }
+  if (!returnValue) {
+    returnValue = schema['returnValue'];
+  }
+
+  if (!returnValue) {
+    return null;
+  }
+
+  return { key: outputKey, value: returnValue as JsonTypeDefinition };
+}
+
+export default function gatherDataForMocks(
+  importedExports: {
+    filePath?: string;
+    name: string;
+    isMocked?: boolean;
+    calls?: string[];
+    callVariableNames?: string[];
+  }[],
+  dependencySchemas: DataStructure['dependencySchemas'],
+) {
+  return importedExports.reduce(
+    (acc, importedExport) => {
+      if (!importedExport.isMocked) return acc;
+
+      // Check if we have multiple calls with variable names
+      const hasMultipleCalls =
+        importedExport.calls &&
+        importedExport.calls.length > 1 &&
+        importedExport.callVariableNames &&
+        importedExport.callVariableNames.length === importedExport.calls.length;
+
+      if (hasMultipleCalls) {
+        // Track how many times each variable name has been seen
+        // to disambiguate keys when the same variable is reused
+        const variableNameCounts: Record<string, number> = {};
+
+        // Process each call separately with its variable name
+        for (let i = 0; i < importedExport.calls!.length; i++) {
+          const varName = importedExport.callVariableNames![i];
+
+          // Calculate the occurrence index for this variable name
+          const occurrence = variableNameCounts[varName] ?? 0;
+          variableNameCounts[varName] = occurrence + 1;
+
+          const result = processCall(
+            importedExport,
+            dependencySchemas,
+            i,
+            occurrence,
+          );
+          if (result) {
+            acc[result.key] = result.value;
+          }
+        }
+      } else {
+        // Original behavior for single calls or calls without variable names
+        const result = processCall(importedExport, dependencySchemas, 0);
+        if (result) {
+          acc[result.key] = result.value;
+        }
+      }
 
       return acc;
     },

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateDataStructure.ts

@@ -31,12 +31,6 @@ export default function generateDataStructure({
     awsLog('CodeYam: Generating data structure for', {
       filePath: entity.filePath,
       entityName: entity.name,
-      // dependentAnalyses: Object.keys(dependentAnalyses).flatMap((path) =>
-      //   Object.keys(dependentAnalyses[path]).flatMap((entityName) => ({
-      //     path,
-      //     entityName,
-      //   })),
-      // ),
     });
 
     const allImportedExports = [
@@ -51,6 +45,58 @@ export default function generateDataStructure({
           ),
       ),
     ];
+
+    // For implicit dependencies (like root.tsx layouts), include their mocked nodeModuleImports
+    // This ensures layout file dependencies (like useLoaderData in root.tsx) are included in dataForMocks
+    // when simulating routes that are wrapped by those layout files
+    for (const importedExport of entity.metadata.importedExports ?? []) {
+      if (
+        !('isImplicitDependency' in importedExport) ||
+        !importedExport.isImplicitDependency
+      ) {
+        continue;
+      }
+
+      // Look up the implicit dependency's analysis
+      const implicitDepAnalysis =
+        dependentAnalyses[importedExport.filePath]?.[importedExport.name];
+
+      // Access nodeModuleImports from the entity attached to the analysis
+      const nodeModuleImports =
+        implicitDepAnalysis?.entity?.metadata?.nodeModuleImports;
+      if (!nodeModuleImports) {
+        continue;
+      }
+
+      // Add the implicit dependency's mocked nodeModuleImports to allImportedExports
+      for (const moduleName of Object.keys(nodeModuleImports)) {
+        const moduleImports = nodeModuleImports[moduleName] || [];
+        for (const imported of moduleImports) {
+          if (!imported.isMocked) continue;
+
+          // Only add if not already present (avoid duplicates)
+          const alreadyExists = allImportedExports.some(
+            (existing) =>
+              existing.filePath === moduleName &&
+              existing.name === imported.name,
+          );
+
+          if (!alreadyExists) {
+            allImportedExports.push({
+              filePath: moduleName,
+              name: imported.name,
+              isDefault: imported.isDefault,
+              isMocked: imported.isMocked,
+              calls: imported.calls ? [...imported.calls] : undefined,
+              callVariableNames: imported.callVariableNames
+                ? [...imported.callVariableNames]
+                : undefined,
+            });
+          }
+        }
+      }
+    }
+
     const nonMockedDependentAnalyses: ReadonlyAnalysisMap =
       allImportedExports.reduce((acc, importedExport) => {
         if (importedExport.isMocked) return acc;
@@ -63,6 +109,55 @@ export default function generateDataStructure({
         const relevantDependencyAnalysis =
           dependentAnalyses[lookupPath]?.[importedExport.name];
 
+        // DEBUG: Track buildBranchFileMap and fileComparisons
+        if (
+          importedExport.name === 'buildBranchFileMap' ||
+          entity.name === 'GitView'
+        ) {
+          console.log('🔍 DEBUG generateDataStructure:', {
+            entityName: entity.name,
+            importedExportName: importedExport.name,
+            lookupPath,
+            hasAnalysis: !!relevantDependencyAnalysis,
+            signatureSchema:
+              relevantDependencyAnalysis?.metadata?.mergedDataStructure
+                ?.signatureSchema,
+            dependencySchemas: relevantDependencyAnalysis?.metadata
+              ?.mergedDataStructure?.dependencySchemas
+              ? Object.keys(
+                  relevantDependencyAnalysis.metadata.mergedDataStructure
+                    .dependencySchemas,
+                )
+              : null,
+          });
+          if (
+            relevantDependencyAnalysis?.metadata?.mergedDataStructure
+              ?.signatureSchema
+          ) {
+            const sig =
+              relevantDependencyAnalysis.metadata.mergedDataStructure
+                .signatureSchema;
+            console.log(
+              '🔍 DEBUG buildBranchFileMap signature keys:',
+              Object.keys(sig),
+            );
+            // Look for fileComparisons in the signature
+            for (const key of Object.keys(sig)) {
+              if (
+                key.includes('fileComparisons') ||
+                key.includes('entityDiff')
+              ) {
+                console.log(
+                  '🔍 DEBUG Found relevant key:',
+                  key,
+                  '=',
+                  JSON.stringify(sig[key], null, 2),
+                );
+              }
+            }
+          }
+        }
+
         if (!relevantDependencyAnalysis) {
           // console.info(
           //   'CodeYam Warn: No relevant dependency analysis found for importedExport',
@@ -129,6 +224,7 @@ export default function generateDataStructure({
     // );
 
     const { isolatedDataStructure } = entity.metadata;
+
     const mergedDataStructure = mergeInDependentDataStructure({
       importedExports: allImportedExports,
       dependentAnalyses: nonMockedDependentAnalyses,
@@ -143,6 +239,39 @@ export default function generateDataStructure({
       dependencySchemas: isolatedDataStructure?.dependencySchemas || {},
     });
 
+    // DEBUG: Check merged result for GitView
+    if (entity.name === 'GitView') {
+      console.log(
+        '🔍 DEBUG GitView mergedDataStructure dependency schemas:',
+        Object.keys(mergedDataStructure.dependencySchemas || {}),
+      );
+      for (const filePath of Object.keys(
+        mergedDataStructure.dependencySchemas || {},
+      )) {
+        for (const depName of Object.keys(
+          mergedDataStructure.dependencySchemas[filePath] || {},
+        )) {
+          const depSchema =
+            mergedDataStructure.dependencySchemas[filePath][depName];
+          console.log(
+            `🔍 DEBUG Merged dep ${filePath}/${depName} signature keys:`,
+            Object.keys(depSchema.signatureSchema || {}),
+          );
+          // Look for fileComparisons
+          for (const key of Object.keys(depSchema.signatureSchema || {})) {
+            if (key.includes('fileComparisons') || key.includes('entityDiff')) {
+              console.log(
+                '🔍 DEBUG MERGED Found relevant key:',
+                key,
+                '=',
+                JSON.stringify(depSchema.signatureSchema[key], null, 2),
+              );
+            }
+          }
+        }
+      }
+    }
+
     mergedDataStructure.environmentVariables =
       isolatedDataStructure.environmentVariables || [];
 
@@ -202,6 +331,28 @@ export default function generateDataStructure({
       mergedDataStructure.dependencySchemas,
     );
 
+    // DEBUG: Check dataForMocks for GitView
+    if (entity.name === 'GitView') {
+      console.log(
+        '🔍 DEBUG GitView dataForMocks keys:',
+        Object.keys(dataForMocks),
+      );
+      for (const key of Object.keys(dataForMocks)) {
+        if (
+          key.includes('buildBranchFileMap') ||
+          key.includes('fileComparisons') ||
+          key.includes('entityDiff')
+        ) {
+          console.log(
+            '🔍 DEBUG dataForMocks relevant key:',
+            key,
+            '=',
+            JSON.stringify(dataForMocks[key], null, 2),
+          );
+        }
+      }
+    }
+
     // console.info(
     //   'CODEYAM DEBUG: dataForMocks',
     //   JSON.stringify(
@@ -215,6 +366,24 @@ export default function generateDataStructure({
     //   ),
     // );
 
+    // Log union types in signatureSchema before processing
+    const unionTypeEntries = Object.entries(
+      mergedDataStructure.signatureSchema,
+    ).filter(
+      ([_, value]) =>
+        typeof value === 'string' &&
+        value.includes("'") &&
+        value.includes(' | '),
+    );
+    if (unionTypeEntries.length > 0) {
+      console.log(
+        `[UNION-TYPE] generateDataStructure for ${entity.name}: Found union types in signatureSchema:`,
+      );
+      unionTypeEntries.forEach(([key, value]) => {
+        console.log(`[UNION-TYPE]   "${key}": ${value}`);
+      });
+    }
+
     const finalizedArgumentsSchema = fillInDirectSchemaGapsAndUnknowns({
       schema: { ...mergedDataStructure.signatureSchema },
     });

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateKeyAttributes.ts

@@ -74,6 +74,7 @@ export default async function generateKeyAttributes({
       () =>
         generateEntityKeyAttributes({
           entity,
+          mergedDataStructure: analysis.metadata.mergedDataStructure,
           model,
         }),
       `Generating entity key attributes`,
@@ -82,6 +83,7 @@ export default async function generateKeyAttributes({
 
     const relevantDependentKeyAttributes = gatherRelevantDependentKeyAttributes(
       entity,
+      analysis.metadata.mergedDataStructure,
       dependentAnalyses,
     );
 
@@ -92,6 +94,10 @@ export default async function generateKeyAttributes({
         // Spread to convert readonly arrays to mutable arrays (with fallback for undefined)
         validValueOptions: [...(ka.validValueOptions ?? [])],
         errorValueOptions: [...(ka.errorValueOptions ?? [])],
+        // Convert readonly dependencies array to mutable if present
+        ...(ka.dependencies && {
+          dependencies: ka.dependencies.map((dep) => ({ ...dep })),
+        }),
       })),
     ].filter(
       (ka, index, self) =>

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateScenarioData.ts

@@ -61,20 +61,24 @@ export function gatherDataForMocks(
     for (const importedExport of allImportedExports) {
       const localDataForMocks =
         activeAnalysis.metadata?.scenariosDataStructure?.dataForMocks ?? {};
-      const relevantKey = Object.keys(localDataForMocks).find((key) =>
-        key.startsWith(importedExport.name),
+      // Find relevant keys - handle both old format (starts with name)
+      // and new variable-qualified format ("varName <- functionName")
+      const relevantKeys = Object.keys(localDataForMocks).filter(
+        (key) =>
+          key.startsWith(importedExport.name) ||
+          key.endsWith(` <- ${importedExport.name}`),
       );
 
       // console.info('CODEYAM DEBUG: Processing import', {
       //   importedExportName: importedExport.name,
       //   importedExportFilePath: importedExport.filePath,
-      //   relevantKey,
+      //   relevantKeys,
       //   hasLocalDataForMocks: Object.keys(localDataForMocks).length > 0,
       //   localDataForMocksKeys: Object.keys(localDataForMocks),
       // });
 
       // First, if we have local data for this mock, add it
-      if (relevantKey) {
+      for (const relevantKey of relevantKeys) {
         const localDataForMock = localDataForMocks[relevantKey];
 
         // console.info('CODEYAM DEBUG: Found relevantKey', {