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

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

@@ -5,15 +5,11 @@ import {
   Entity,
   DEFAULT_SCENARIO_NAME,
 } from '~codeyam/types';
-import deepEqual from '../../utils/deepEqual';
 import measureAndReportExecutionTime from '../../utils/measureAndReportExecutionTime';
-import {
-  AI,
-  generateChangesEntityScenarios,
-  generateChangesEntityKeyAttributes,
-} from '~codeyam/ai';
+import { AI, generateChangesEntityScenarios } from '~codeyam/ai';
 import { awsLog } from '~codeyam/utils';
 import detectChangedDataStructureFields from './detectChangedDataStructureFields';
+import generateExecutionFlows from './generateExecutionFlows';
 
 export interface GenerateChangesScenariosArgs {
   previousAnalysis: Analysis;
@@ -40,8 +36,8 @@ export default async function generateChangesScenarios({
 
   const existingScenarios = (previousAnalysis.scenarios ?? []).filter(
     (s) =>
-      (error ? s.metadata.error : !s.metadata.error) &&
-      !s.metadata.sameAsDefault,
+      (error ? s.metadata?.error : !s.metadata?.error) &&
+      !s.metadata?.sameAsDefault,
   );
   const commitDiff = commit.files.find(
     (f) => f.fileName === entity.filePath,
@@ -87,8 +83,7 @@ export default async function generateChangesScenarios({
           name: DEFAULT_SCENARIO_NAME,
           description: 'The only external state the component can be in.',
           metadata: {
-            dataMapping: {},
-            keyAttributeInstructions: {},
+            coveredFlows: [],
           },
         },
       ];
@@ -96,53 +91,20 @@ export default async function generateChangesScenarios({
     return;
   }
 
-  // if (!analysis.metadata.keyAttributes) {
-  const existingKeyAttributes = (
-    previousAnalysis.metadata?.keyAttributes ?? []
-  ).filter(
-    (keyAttribute, index, self) =>
-      self.findIndex((ka) => ka.internalPath === keyAttribute.internalPath) ===
-      index,
-  );
-
-  const {
-    result: { keyAttributes, llmCall: keyAttributesLLMCall },
-  } = await measureAndReportExecutionTime(
-    () =>
-      generateChangesEntityKeyAttributes({
-        entity,
-        existingKeyAttributes,
-        analysis,
-        commitDiff,
-        model,
-      }),
-    `Generating changes entity key attributes`,
-    updateProgress,
-  );
-
-  analysis.metadata.keyAttributes = keyAttributes;
-
-  if (keyAttributesLLMCall) {
-    analysis.metadata.llmCalls ||= [];
-    analysis.metadata.llmCalls.push({
-      name: `generateChangesEntityKeyAttributes`,
-      id: keyAttributesLLMCall.id,
+  // Generate execution flows if not already present
+  if (!analysis.metadata.executionFlows) {
+    await generateExecutionFlows({
+      entity,
+      analysis,
+      model,
+      updateProgress,
+      dependentAnalyses,
     });
   }
-  // }
 
-  const addedKeyAttributes = analysis.metadata.keyAttributes?.filter(
-    (ka) =>
-      !previousAnalysis.metadata.keyAttributes?.find(
-        (ka2) => ka.internalPath === ka2.internalPath,
-      ),
-  );
-  const removedKeyAttributes = previousAnalysis.metadata.keyAttributes?.filter(
-    (ka) =>
-      !analysis.metadata.keyAttributes.find(
-        (ka2) => ka.internalPath === ka2.internalPath,
-      ),
-  );
+  // Get previous execution flows for comparison
+  const previousExecutionFlows =
+    previousAnalysis.metadata?.executionFlows ?? [];
 
   // Detect which specific data structure fields changed
   const changedDataStructureFields = detectChangedDataStructureFields(
@@ -156,10 +118,8 @@ export default async function generateChangesScenarios({
     () =>
       generateChangesEntityScenarios({
         entity,
-        keyAttributes: analysis.metadata.keyAttributes,
-        addedKeyAttributes,
-        removedKeyAttributes,
-        dependentAnalyses,
+        executionFlows: analysis.metadata.executionFlows,
+        previousExecutionFlows,
         existingScenarios,
         commitDiff,
         analysis,
@@ -175,10 +135,13 @@ export default async function generateChangesScenarios({
   for (const scenario of scenarios) {
     if (
       scenario.previousVersionId &&
-      !scenario.metadata.revisedFromPreviousVersion
+      !scenario.metadata?.revisedFromPreviousVersion
     ) {
       if (dataStructureChanged) {
-        scenario.metadata.revisedFromPreviousVersion = true;
+        scenario.metadata = {
+          ...scenario.metadata,
+          revisedFromPreviousVersion: true,
+        };
         continue;
       }
 
@@ -186,7 +149,10 @@ export default async function generateChangesScenarios({
         (s) => s.name === scenario.name,
       );
       if (!existingScenarioStatus || existingScenarioStatus.error) {
-        scenario.metadata.revisedFromPreviousVersion = true;
+        scenario.metadata = {
+          ...scenario.metadata,
+          revisedFromPreviousVersion: true,
+        };
       }
     }
   }
@@ -210,7 +176,7 @@ export default async function generateChangesScenarios({
 
     if (analysis.scenarios) {
       for (const existingScenario of analysis.scenarios.filter((s) =>
-        error ? !!s.metadata.error : !s.metadata.error,
+        error ? !!s.metadata?.error : !s.metadata?.error,
       )) {
         const scenarioIndex = scenarios.findIndex(
           (s) => s.name === existingScenario.name,

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

@@ -9,12 +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;
   dependentAnalyses: ReadonlyAnalysisMap;
@@ -27,7 +28,9 @@ export default function generateDataStructure({
   analysis,
 }: GenerateDataStructureArgs) {
   try {
-    if (!['visual', 'library'].includes(entity.entityType)) return analysis;
+    if (!['visual', 'library'].includes(entity.entityType)) {
+      return analysis;
+    }
 
     awsLog('CodeYam: Generating data structure for', {
       filePath: entity.filePath,
@@ -174,6 +177,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;
@@ -244,8 +255,10 @@ export default function generateDataStructure({
           );
 
           if (existingImport) {
-            // Merge callVariableNames if the same dependency exists with different patterns
-            if (imported.callVariableNames && imported.calls) {
+            // Merge calls from child into existing import
+            // Note: Check length > 0 because empty array [] is truthy but has no variable names
+            if (imported.callVariableNames?.length && imported.calls) {
+              // Case 1: Both calls and callVariableNames are set - merge as pairs
               existingImport.calls = existingImport.calls || [];
               existingImport.callVariableNames =
                 existingImport.callVariableNames || [];
@@ -262,6 +275,18 @@ export default function generateDataStructure({
                   existingImport.callVariableNames.push(varName);
                 }
               }
+            } else if (imported.calls) {
+              // Case 2: Only calls are set (no callVariableNames) - common with tRPC
+              // where destructuring like `const { data, isLoading } = trpc.xxx.useQuery()`
+              // doesn't create a variable name for the hook call itself
+              existingImport.calls = existingImport.calls || [];
+
+              // Add each call that doesn't already exist
+              for (const call of imported.calls) {
+                if (!existingImport.calls.includes(call)) {
+                  existingImport.calls.push(call);
+                }
+              }
             }
           } else {
             // Add new import
@@ -299,6 +324,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 +457,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(
@@ -420,88 +540,51 @@ export default function generateDataStructure({
 
     // Enrich mocked dependency array types with fields from child component signatures
     // This ensures that when getSurveysAction returns { data: array }, and SurveyCard
-    // expects survey.updatedAt, the array element type includes updatedAt
+    // expects survey.updatedAt, the array element type includes updatedAt.
+    // Uses usageEquivalencies to trace data flow and only enrich arrays with fields
+    // from children that actually receive elements from that specific array.
     enrichArrayTypesFromChildSignatures(
       allImportedExports,
       mergedDataStructure.dependencySchemas,
+      mergedDataStructure.usageEquivalencies,
     );
 
-    // 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(
+    let dataForMocks = gatherDataForMocks(
       allImportedExports,
       mergedDataStructure.dependencySchemas,
       { 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}`);
-      });
+    // Merge dataForMocks from non-mocked child analyses to include transitive dependency data.
+    // This handles cases where grandchild trpc calls aren't in allImportedExports because
+    // the grandchild's analysis wasn't in dependentAnalyses.
+    //
+    // Issue 19 fix: The child's dataForMocks already contains merged data from its
+    // dependencies (including grandchildren). By merging the child's dataForMocks,
+    // we transitively include all nested dependency data.
+    for (const filePath in nonMockedDependentAnalyses) {
+      for (const name in nonMockedDependentAnalyses[filePath]) {
+        const childAnalysis = nonMockedDependentAnalyses[filePath][name];
+        const childDataForMocks =
+          childAnalysis?.metadata?.scenariosDataStructure?.dataForMocks;
+        if (childDataForMocks && Object.keys(childDataForMocks).length > 0) {
+          dataForMocks = mergeJsonTypeDefinitions(
+            dataForMocks as Record<string, unknown>,
+            childDataForMocks as Record<string, unknown>,
+          ) as { [importAlias: string]: JsonTypeDefinition };
+        }
+      }
     }
 
     const finalizedArgumentsSchema = fillInDirectSchemaGapsAndUnknowns({

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

@@ -0,0 +1,156 @@
+import {
+  Analysis,
+  Entity,
+  DEFAULT_SCENARIO_NAME,
+  ReadonlyAnalysisMap,
+} from '~codeyam/types';
+import measureAndReportExecutionTime from '../../utils/measureAndReportExecutionTime';
+import {
+  AI,
+  generateExecutionFlows as generateExecutionFlowsLLM,
+} from '~codeyam/ai';
+import { awsLog } from '~codeyam/utils';
+import { gatherDataForMocks } from './generateScenarioData';
+
+export interface GenerateExecutionFlowsArgs {
+  entity: Entity;
+  analysis: Analysis;
+  model: AI.Model;
+  updateProgress?: (detail: string) => void;
+  /** Map of dependent analyses for looking up child entity metadata */
+  dependentAnalyses?: ReadonlyAnalysisMap;
+}
+
+export default async function generateExecutionFlows({
+  entity,
+  analysis,
+  model,
+  updateProgress,
+  dependentAnalyses,
+}: GenerateExecutionFlowsArgs): Promise<void> {
+  if (!['visual', 'library'].includes(entity.entityType)) return;
+
+  // Gather all mock data to check if we have any data structure to work with
+  const structure = {
+    arguments: analysis.metadata.scenariosDataStructure?.arguments ?? [],
+    dataForMocks: gatherDataForMocks(analysis, {}, entity.name),
+  };
+
+  awsLog(`🔮 Generating execution flows for`, {
+    filePath: entity.filePath,
+    entityName: entity.name,
+  });
+
+  if (
+    !structure ||
+    (Object.keys(structure.dataForMocks ?? {}).length === 0 &&
+      (structure.arguments ?? []).length === 0)
+  ) {
+    // No data structure means no execution flows to generate
+    // The default scenario will be created in generateScenarios
+    analysis.scenarios = [
+      {
+        projectId: analysis.projectId,
+        analysisId: analysis.id,
+        name: DEFAULT_SCENARIO_NAME,
+        description: 'The only external state the component can be in.',
+        metadata: {
+          testName: 'it("renders correctly")',
+          coveredFlows: [],
+        },
+      },
+    ];
+
+    return;
+  }
+
+  if (!analysis.metadata.executionFlows) {
+    // Build childEntityMetadata from dependentAnalyses for child flow merging
+    // This maps child component names to their metadata (specifically isolatedDataStructure)
+    const childEntityMetadata = buildChildEntityMetadata(
+      entity,
+      dependentAnalyses,
+    );
+
+    const {
+      result: { executionFlows, llmCall: executionFlowsLLMCall },
+    } = await measureAndReportExecutionTime(
+      () =>
+        generateExecutionFlowsLLM({
+          entity,
+          mergedDataStructure: analysis.metadata.mergedDataStructure,
+          model,
+          childEntityMetadata:
+            Object.keys(childEntityMetadata).length > 0
+              ? childEntityMetadata
+              : undefined,
+        }),
+      `Generating execution flows`,
+      updateProgress,
+    );
+
+    analysis.metadata.executionFlows = executionFlows;
+
+    if (executionFlowsLLMCall) {
+      analysis.metadata.llmCalls ||= [];
+      analysis.metadata.llmCalls.push({
+        name: `generateExecutionFlows`,
+        id: executionFlowsLLMCall.id,
+      });
+    }
+  }
+}
+
+/**
+ * Build a map of child component names to their metadata for flow merging.
+ *
+ * Uses childBoundaryGatingConditions to find which children need metadata,
+ * then looks them up in importedExports to get their file paths,
+ * then retrieves their metadata from dependentAnalyses.
+ */
+export function buildChildEntityMetadata(
+  entity: Entity,
+  dependentAnalyses?: ReadonlyAnalysisMap,
+): Record<string, Entity['metadata']> {
+  const childEntityMetadata: Record<string, Entity['metadata']> = {};
+
+  if (!dependentAnalyses) {
+    return childEntityMetadata;
+  }
+
+  const childBoundaryGatingConditions =
+    entity.metadata?.isolatedDataStructure?.childBoundaryGatingConditions;
+
+  if (!childBoundaryGatingConditions) {
+    return childEntityMetadata;
+  }
+
+  const importedExports = entity.metadata?.importedExports ?? [];
+
+  for (const childName of Object.keys(childBoundaryGatingConditions)) {
+    // Find the child in importedExports to get its file path
+    const importedExport = importedExports.find(
+      (ie) => ie.name === childName || ie.resolvedName === childName,
+    );
+
+    if (!importedExport) {
+      continue;
+    }
+
+    // Use resolved paths when available (for re-exports from index files)
+    const lookupPath =
+      importedExport.resolvedFilePath ?? importedExport.filePath;
+    const lookupName = importedExport.resolvedName ?? importedExport.name;
+
+    // Look up the child's analysis in dependentAnalyses
+    const childAnalysis = dependentAnalyses[lookupPath]?.[lookupName];
+
+    if (childAnalysis?.entity?.metadata) {
+      // Cast to mutable type - the metadata is only read, not modified
+      childEntityMetadata[childName] = childAnalysis.entity
+        .metadata as Entity['metadata'];
+    }
+  }
+
+  return childEntityMetadata;
+}