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

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

@@ -5,12 +5,12 @@ import {
   Entity,
   DEFAULT_SCENARIO_NAME,
 } from '~codeyam/types';
-import deepEqual from '../../utils/deepEqual';
 import measureAndReportExecutionTime from '../../utils/measureAndReportExecutionTime';
 import {
   AI,
   generateChangesEntityScenarios,
   generateChangesEntityKeyAttributes,
+  gatherRelevantDependentKeyAttributes,
 } from '~codeyam/ai';
 import { awsLog } from '~codeyam/utils';
 import detectChangedDataStructureFields from './detectChangedDataStructureFields';
@@ -120,7 +120,54 @@ export default async function generateChangesScenarios({
     updateProgress,
   );
 
-  analysis.metadata.keyAttributes = keyAttributes;
+  // Merge in dependent key attributes (same as initial flow)
+  // This ensures dependent entity key attributes aren't incorrectly seen as "removed"
+  const relevantDependentKeyAttributes = gatherRelevantDependentKeyAttributes(
+    entity,
+    analysis.metadata.mergedDataStructure,
+    dependentAnalyses,
+  );
+
+  // Log dependent key attributes gathered
+  awsLog(`CodeYam: Dependent key attributes gathered for ${entity.name}`, {
+    dependentKeyAttributeCount: relevantDependentKeyAttributes.length,
+    dependentKeyAttributes: relevantDependentKeyAttributes.map((ka) => ({
+      internalPath: ka.internalPath,
+      externalPath: ka.externalPath,
+      dependentEntityName: (ka as any).dependentEntityName,
+      originalEntityName: (ka as any).originalEntityName,
+      filePath: (ka as any).filePath,
+    })),
+    dependentAnalysesEntities: Object.entries(dependentAnalyses).flatMap(
+      ([path, entities]) =>
+        Object.keys(entities).map((name) => ({ path, name })),
+    ),
+  });
+
+  analysis.metadata.keyAttributes = [
+    ...keyAttributes,
+    ...relevantDependentKeyAttributes.map((ka) => ({
+      ...ka,
+      // 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 })),
+      }),
+      // Convert readonly sourceLocations array to mutable if present
+      ...(ka.sourceLocations && {
+        sourceLocations: ka.sourceLocations.map((loc) => ({ ...loc })),
+      }),
+      // Convert readonly compoundConditionalIds array to mutable if present
+      ...(ka.compoundConditionalIds && {
+        compoundConditionalIds: [...ka.compoundConditionalIds],
+      }),
+    })),
+  ].filter(
+    (ka, index, self) =>
+      self.findIndex((k) => k.internalPath === ka.internalPath) === index,
+  );
 
   if (keyAttributesLLMCall) {
     analysis.metadata.llmCalls ||= [];
@@ -144,6 +191,84 @@ export default async function generateChangesScenarios({
       ),
   );
 
+  // Log key attribute changes for debugging
+  awsLog(`CodeYam: Key attribute comparison for ${entity.name}`, {
+    previousKeyAttributePaths: previousAnalysis.metadata.keyAttributes?.map(
+      (ka) => ({
+        internalPath: ka.internalPath,
+        isDependentAttr: !!(ka as any).dependentEntityName,
+        dependentEntityName: (ka as any).dependentEntityName,
+      }),
+    ),
+    currentKeyAttributePaths: analysis.metadata.keyAttributes?.map((ka) => ({
+      internalPath: ka.internalPath,
+      isDependentAttr: !!(ka as any).dependentEntityName,
+      dependentEntityName: (ka as any).dependentEntityName,
+    })),
+    addedKeyAttributePaths: addedKeyAttributes?.map((ka) => ({
+      internalPath: ka.internalPath,
+      isDependentAttr: !!(ka as any).dependentEntityName,
+      dependentEntityName: (ka as any).dependentEntityName,
+      filePath: (ka as any).filePath,
+    })),
+    removedKeyAttributePaths: removedKeyAttributes?.map((ka) => ({
+      internalPath: ka.internalPath,
+      isDependentAttr: !!(ka as any).dependentEntityName,
+      dependentEntityName: (ka as any).dependentEntityName,
+      filePath: (ka as any).filePath,
+    })),
+  });
+
+  // Detect key attributes with NEW source locations (usages)
+  // These are existing attributes that gained new conditional usages in the code
+  const modifiedKeyAttributes = analysis.metadata.keyAttributes
+    ?.filter((ka) => {
+      // Only consider attributes that existed before (not newly added)
+      const previousAttr = previousAnalysis.metadata.keyAttributes?.find(
+        (ka2) => ka.internalPath === ka2.internalPath,
+      );
+      if (!previousAttr) return false;
+
+      // Check if there are new source locations
+      const previousSnippets = new Set(
+        previousAttr.sourceLocations?.map((loc) => loc.codeSnippet) ?? [],
+      );
+      const newSourceLocations = ka.sourceLocations?.filter(
+        (loc) => !previousSnippets.has(loc.codeSnippet),
+      );
+
+      return newSourceLocations && newSourceLocations.length > 0;
+    })
+    .map((ka) => {
+      const previousAttr = previousAnalysis.metadata.keyAttributes?.find(
+        (ka2) => ka.internalPath === ka2.internalPath,
+      );
+      const previousSnippets = new Set(
+        previousAttr?.sourceLocations?.map((loc) => loc.codeSnippet) ?? [],
+      );
+      const newSourceLocations = ka.sourceLocations?.filter(
+        (loc) => !previousSnippets.has(loc.codeSnippet),
+      );
+
+      return {
+        keyAttribute: ka,
+        newSourceLocations,
+      };
+    });
+
+  // Log modified key attributes
+  if (modifiedKeyAttributes && modifiedKeyAttributes.length > 0) {
+    awsLog(`CodeYam: Modified key attributes for ${entity.name}`, {
+      modifiedKeyAttributePaths: modifiedKeyAttributes.map((mod) => ({
+        internalPath: mod.keyAttribute.internalPath,
+        isDependentAttr: !!(mod.keyAttribute as any).dependentEntityName,
+        dependentEntityName: (mod.keyAttribute as any).dependentEntityName,
+        newUsageCount: mod.newSourceLocations?.length ?? 0,
+        newUsages: mod.newSourceLocations?.map((loc) => loc.codeSnippet),
+      })),
+    });
+  }
+
   // Detect which specific data structure fields changed
   const changedDataStructureFields = detectChangedDataStructureFields(
     previousAnalysis.metadata?.scenariosDataStructure,
@@ -159,6 +284,7 @@ export default async function generateChangesScenarios({
         keyAttributes: analysis.metadata.keyAttributes,
         addedKeyAttributes,
         removedKeyAttributes,
+        modifiedKeyAttributes,
         dependentAnalyses,
         existingScenarios,
         commitDiff,

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

@@ -9,11 +9,13 @@ import {
   fillInDirectSchemaGapsAndUnknowns,
   deduplicateFunctionSchemas,
   clearAttributesFromMapping,
+  mergeJsonTypeDefinitions,
 } from '~codeyam/ai';
 import mergeInDependentDataStructure from './mergeInDependentDataStructure';
 import { awsLog } from '~codeyam/utils';
 import gatherDataForMocks from './gatherDataForMocks';
 import enrichArrayTypesFromChildSignatures from './enrichArrayTypesFromChildSignatures';
+import enrichUnknownTypesFromSourceEquivalencies from './enrichUnknownTypesFromSourceEquivalencies';
 
 export interface GenerateDataStructureArgs {
   entity: Entity;
@@ -174,6 +176,14 @@ export default function generateDataStructure({
     // child components (e.g., QuotesTableCompact inside AdminDashboard inside
     // DashboardPage) also have mocked dependencies that need mock data keys.
 
+    // Collect child dependency schemas to merge after mergeInDependentDataStructure
+    // This ensures that when we look up schemas for child imports in gatherDataForMocks,
+    // the child's schemas are available in mergedDataStructure.dependencySchemas.
+    type DependencySchemas = NonNullable<
+      Analysis['metadata']['mergedDataStructure']
+    >['dependencySchemas'];
+    const childDependencySchemas: DependencySchemas = {};
+
     // Helper function to add mocked imports from an entity to allImportedExports
     const addMockedImportsFromEntity = (childEntity: Entity | undefined) => {
       if (!childEntity?.metadata) return;
@@ -299,6 +309,71 @@ export default function generateDataStructure({
           // via their mergedDataStructure's nested dependentAnalyses
           const childMergedDataStructure =
             childAnalysis?.metadata?.mergedDataStructure;
+
+          // Collect the child's dependency schemas for merging later.
+          // This ensures schemas for child imports are available in gatherDataForMocks.
+          if (childMergedDataStructure?.dependencySchemas) {
+            for (const schemaFilePath in childMergedDataStructure.dependencySchemas) {
+              for (const schemaName in childMergedDataStructure
+                .dependencySchemas[schemaFilePath]) {
+                childDependencySchemas[schemaFilePath] ||= {};
+                const existingSchema =
+                  childDependencySchemas[schemaFilePath][schemaName];
+                const newSchema =
+                  childMergedDataStructure.dependencySchemas[schemaFilePath][
+                    schemaName
+                  ];
+
+                if (existingSchema) {
+                  // Merge schemas if the same dependency exists from multiple children
+                  childDependencySchemas[schemaFilePath][schemaName] = {
+                    signatureSchema: {
+                      ...existingSchema.signatureSchema,
+                      ...newSchema.signatureSchema,
+                    },
+                    returnValueSchema: mergeJsonTypeDefinitions(
+                      existingSchema.returnValueSchema as Record<
+                        string,
+                        unknown
+                      >,
+                      newSchema.returnValueSchema as Record<string, unknown>,
+                    ) as Record<string, string>,
+                  };
+                } else {
+                  childDependencySchemas[schemaFilePath][schemaName] = {
+                    signatureSchema: { ...newSchema.signatureSchema },
+                    returnValueSchema: { ...newSchema.returnValueSchema },
+                  };
+                }
+              }
+            }
+          }
+
+          // Also collect the child's OWN signatureSchema for enrichment.
+          // This allows enrichArrayTypesFromChildSignatures to find what fields
+          // non-mocked child components expect on their props (e.g., SurveyCard
+          // expecting survey.createdAt, survey.updatedAt, etc.)
+          if (childMergedDataStructure?.signatureSchema) {
+            childDependencySchemas[filePath] ||= {};
+            const existingSchema = childDependencySchemas[filePath][name];
+            if (existingSchema) {
+              childDependencySchemas[filePath][name] = {
+                signatureSchema: {
+                  ...existingSchema.signatureSchema,
+                  ...childMergedDataStructure.signatureSchema,
+                },
+                returnValueSchema: existingSchema.returnValueSchema,
+              };
+            } else {
+              childDependencySchemas[filePath][name] = {
+                signatureSchema: {
+                  ...childMergedDataStructure.signatureSchema,
+                },
+                returnValueSchema: {},
+              };
+            }
+          }
+
           if (childMergedDataStructure?.dependencySchemas) {
             // We need to find non-mocked child components in the dependency tree
             // These would be in the child's importedExports that are NOT mocked
@@ -367,6 +442,36 @@ export default function generateDataStructure({
     mergedDataStructure.environmentVariables =
       isolatedDataStructure.environmentVariables || [];
 
+    // Merge collected child dependency schemas into mergedDataStructure.
+    // This ensures that when gatherDataForMocks looks up schemas for child imports,
+    // the child's schemas are available.
+    for (const schemaFilePath in childDependencySchemas) {
+      for (const schemaName in childDependencySchemas[schemaFilePath]) {
+        mergedDataStructure.dependencySchemas[schemaFilePath] ||= {};
+        const existingSchema =
+          mergedDataStructure.dependencySchemas[schemaFilePath][schemaName];
+        const childSchema = childDependencySchemas[schemaFilePath][schemaName];
+
+        if (existingSchema) {
+          // Merge schemas - child schemas add to parent schemas
+          mergedDataStructure.dependencySchemas[schemaFilePath][schemaName] = {
+            signatureSchema: {
+              ...existingSchema.signatureSchema,
+              ...childSchema.signatureSchema,
+            },
+            returnValueSchema: mergeJsonTypeDefinitions(
+              existingSchema.returnValueSchema as Record<string, unknown>,
+              childSchema.returnValueSchema as Record<string, unknown>,
+            ) as Record<string, string>,
+          };
+        } else {
+          // No existing schema - just add the child's schema
+          mergedDataStructure.dependencySchemas[schemaFilePath][schemaName] =
+            childSchema;
+        }
+      }
+    }
+
     // console.info(
     //   'CODEYAM DEBUG: end merge',
     //   JSON.stringify(
@@ -426,32 +531,15 @@ export default function generateDataStructure({
       mergedDataStructure.dependencySchemas,
     );
 
-    // DEBUG: Log nodeModuleImports with isMocked status
-    const nodeModuleImportsFlattened = Object.entries(
-      entity.metadata.nodeModuleImports ?? {},
-    ).flatMap(([moduleName, imports]) =>
-      imports.map((i) => ({ moduleName, name: i.name, isMocked: i.isMocked })),
-    );
-    console.log(
-      'CodeYam DEBUG generateDataStructure:',
-      JSON.stringify(
-        {
-          entityName: entity.name,
-          nodeModuleImportsFlattened,
-          dependencySchemasKeys: Object.keys(
-            mergedDataStructure.dependencySchemas ?? {},
-          ),
-          dependencySchemasForRemix: mergedDataStructure.dependencySchemas?.[
-            '@remix-run/react'
-          ]
-            ? Object.keys(
-                mergedDataStructure.dependencySchemas['@remix-run/react'],
-              )
-            : null,
-        },
-        null,
-        2,
-      ),
+    // Enrich mocked dependency unknown types using sourceEquivalencies
+    // When a mocked dependency returns unknown, but that data flows to a child component
+    // with a known type, propagate the type back to the mocked dependency.
+    // This prevents fillInDirectSchemaGapsAndUnknowns from guessing incorrectly
+    // (e.g., 'data' becoming 'number' because pluralize thinks it's plural)
+    enrichUnknownTypesFromSourceEquivalencies(
+      isolatedDataStructure.dependencySchemas || {},
+      mergedDataStructure.dependencySchemas,
+      allImportedExports,
     );
 
     const dataForMocks = gatherDataForMocks(
@@ -460,50 +548,6 @@ export default function generateDataStructure({
       { entityName: entity.name },
     );
 
-    // DEBUG: Log the resulting dataForMocks
-    console.log(
-      'CodeYam DEBUG generateDataStructure dataForMocks result:',
-      JSON.stringify(
-        {
-          entityName: entity.name,
-          dataForMocksKeys: Object.keys(dataForMocks),
-        },
-        null,
-        2,
-      ),
-    );
-
-    // console.info(
-    //   'CODEYAM DEBUG: dataForMocks',
-    //   JSON.stringify(
-    //     {
-    //       filePath: entity.filePath,
-    //       entityName: entity.name,
-    //       dataForMocks,
-    //     },
-    //     null,
-    //     2,
-    //   ),
-    // );
-
-    // 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/generateScenarioData.ts

@@ -23,81 +23,52 @@ export interface GenerateScenarioDataArgs {
 }
 
 /**
- * Extract the hook/function name from any mock data key format.
- * Supports:
- * - Canonical: "EntityName::hookName::index" -> "hookName"
- * - Variable-qualified: "varName <- funcName" -> "funcName"
- * - Simple with parens: "funcName()" -> "funcName"
- * - Simple: "funcName" -> "funcName"
+ * Consolidates dataForMocks from the current analysis and all dependent analyses.
+ *
+ * Keys are preserved as original call signatures (e.g., 'useFetcher<UserData>()',
+ * 'db.select(usersQuery)'). When the same call signature appears from multiple
+ * analyses, schemas are merged.
  */
-function extractHookName(key: string): string | null {
-  // Canonical: "EntityName::hookName::index"
-  const canonicalMatch = key.match(/^[^:]+::([^:]+)::\d+$/);
-  if (canonicalMatch) return canonicalMatch[1];
-
-  // Variable-qualified: "varName <- funcName"
-  const varQualMatch = key.match(/<- (\w+)$/);
-  if (varQualMatch) return varQualMatch[1];
-
-  // Simple with parens: "funcName()" -> "funcName"
-  const simpleParensMatch = key.match(/^(\w+)\(\)$/);
-  if (simpleParensMatch) return simpleParensMatch[1];
-
-  // Simple: "funcName" (alphanumeric only)
-  const simpleMatch = key.match(/^(\w+)$/);
-  if (simpleMatch) return simpleMatch[1];
-
-  return null;
-}
-
-/**
- * Check if two schemas are structurally equivalent (same shape).
- * Uses JSON.stringify for deep comparison.
- */
-function schemasMatch(a: unknown, b: unknown): boolean {
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-
 export function gatherDataForMocks(
   analysis: ReadonlyAnalysis,
   dependentAnalyses: ReadonlyAnalysisMap,
-  rootEntityName?: string,
+  _rootEntityName?: string, // Kept for API compatibility but no longer used for key transformation
 ): Analysis['metadata']['scenariosDataStructure']['dataForMocks'] {
   const dataForMocks: Analysis['metadata']['scenariosDataStructure']['dataForMocks'] =
     {};
   const analysesGathered = new Set<string>();
 
-  // Track hook indices for assigning new indices when schemas differ
-  const hookIndices: Record<string, number> = {};
-
   /**
-   * Find an existing key in dataForMocks that has the same hook name
-   * and matching schema. Returns the key if found, null otherwise.
+   * Helper to merge schemas (only works for objects, otherwise just returns new value)
    */
-  const findMatchingKey = (
-    hookName: string,
-    schema: unknown,
-  ): string | null => {
-    for (const existingKey of Object.keys(dataForMocks)) {
-      const existingHook = extractHookName(existingKey);
-      if (
-        existingHook === hookName &&
-        schemasMatch(dataForMocks[existingKey], schema)
-      ) {
-        return existingKey;
-      }
+  const mergeSchemas = (
+    existing: JsonTypeDefinition[keyof JsonTypeDefinition],
+    incoming: JsonTypeDefinition[keyof JsonTypeDefinition],
+  ): JsonTypeDefinition[keyof JsonTypeDefinition] => {
+    // Only merge if both are objects (not arrays, not primitives)
+    if (
+      typeof existing === 'object' &&
+      existing !== null &&
+      !Array.isArray(existing) &&
+      typeof incoming === 'object' &&
+      incoming !== null &&
+      !Array.isArray(incoming)
+    ) {
+      return mergeJsonTypeDefinitions(
+        existing as JsonTypeDefinition,
+        incoming as JsonTypeDefinition,
+      );
     }
-    return null;
+    // For primitives/arrays, just use the incoming value
+    return incoming;
   };
 
   /**
-   * Add mock data, consolidating by hook name and schema when rootEntityName is provided.
-   * - Same hook + same schema = merge into existing key
-   * - Same hook + different schema = new key with incremented index
-   * - All keys normalized to "RootEntity::hookName::index" format when rootEntityName provided
+   * Add mock data, preserving original call signature as key.
+   * Merges schemas when the same key appears from multiple sources.
    */
   const addMockData = (
-    originalKey: string,
+    key: string,
     schema: JsonTypeDefinition[keyof JsonTypeDefinition],
   ): void => {
     // Skip if schema is empty object
@@ -115,77 +86,11 @@ export function gatherDataForMocks(
       return;
     }
 
-    const typedSchema = schema as
-      | JsonTypeDefinition
-      | string
-      | string[]
-      | JsonTypeDefinition[];
-
-    // Helper to merge schemas (only works for objects, otherwise just returns new value)
-    const mergeSchemas = (
-      existing: JsonTypeDefinition[keyof JsonTypeDefinition],
-      incoming: typeof typedSchema,
-    ): JsonTypeDefinition[keyof JsonTypeDefinition] => {
-      // Only merge if both are objects (not arrays, not primitives)
-      if (
-        typeof existing === 'object' &&
-        existing !== null &&
-        !Array.isArray(existing) &&
-        typeof incoming === 'object' &&
-        incoming !== null &&
-        !Array.isArray(incoming)
-      ) {
-        return mergeJsonTypeDefinitions(
-          existing as JsonTypeDefinition,
-          incoming as JsonTypeDefinition,
-        );
-      }
-      // For primitives/arrays, just use the incoming value
-      return incoming;
-    };
-
-    // If no rootEntityName, use legacy behavior (preserve original key)
-    if (!rootEntityName) {
-      if (dataForMocks?.[originalKey]) {
-        dataForMocks[originalKey] = mergeSchemas(
-          dataForMocks[originalKey],
-          typedSchema,
-        );
-      } else if (dataForMocks) {
-        dataForMocks[originalKey] = typedSchema;
-      }
-      return;
-    }
-
-    // Extract hook name for consolidation
-    const hookName = extractHookName(originalKey);
-    if (!hookName) {
-      // Can't parse - preserve original key
-      if (dataForMocks?.[originalKey]) {
-        dataForMocks[originalKey] = mergeSchemas(
-          dataForMocks[originalKey],
-          typedSchema,
-        );
-      } else if (dataForMocks) {
-        dataForMocks[originalKey] = typedSchema;
-      }
-      return;
-    }
-
-    // Look for existing key with same hook and matching schema
-    const matchingKey = findMatchingKey(hookName, typedSchema);
-    if (matchingKey && dataForMocks) {
-      // Same hook + same schema - merge into existing key
-      dataForMocks[matchingKey] = mergeSchemas(
-        dataForMocks[matchingKey],
-        typedSchema,
-      );
-    } else if (dataForMocks) {
-      // Different schema or first occurrence - create new canonical key
-      const index = hookIndices[hookName] ?? 0;
-      hookIndices[hookName] = index + 1;
-      const targetKey = `${rootEntityName}::${hookName}::${index}`;
-      dataForMocks[targetKey] = typedSchema;
+    // Preserve original key (call signature), merge if exists
+    if (dataForMocks[key]) {
+      dataForMocks[key] = mergeSchemas(dataForMocks[key], schema);
+    } else {
+      dataForMocks[key] = schema;
     }
   };