@codeyam/codeyam-cli 0.1.0-staging.15d0f46 → 0.1.0-staging.1669d45

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.
+ */
+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;
+}

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

@@ -1,6 +1,7 @@
 import {
   Analysis,
   Entity,
+  JsonTypeDefinition,
   ReadonlyAnalysis,
   ReadonlyAnalysisMap,
 } from '~codeyam/types';
@@ -21,17 +22,91 @@ export interface GenerateScenarioDataArgs {
   updateProgress?: (detail: string) => void;
 }
 
+/**
+ * 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.
+ */
 export function gatherDataForMocks(
   analysis: ReadonlyAnalysis,
   dependentAnalyses: ReadonlyAnalysisMap,
+  _rootEntityName?: string, // Kept for API compatibility but no longer used for key transformation
 ): Analysis['metadata']['scenariosDataStructure']['dataForMocks'] {
-  const dataForMocks = {};
+  const dataForMocks: Analysis['metadata']['scenariosDataStructure']['dataForMocks'] =
+    {};
   const analysesGathered = new Set<string>();
 
+  /**
+   * Helper to merge schemas (only works for objects, otherwise just returns new value)
+   */
+  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,
+      );
+    }
+    // For primitives/arrays, just use the incoming value
+    return incoming;
+  };
+
+  /**
+   * Add mock data, preserving original call signature as key.
+   * Merges schemas when the same key appears from multiple sources.
+   */
+  const addMockData = (
+    key: string,
+    schema: JsonTypeDefinition[keyof JsonTypeDefinition],
+  ): void => {
+    // Skip if schema is empty object
+    if (
+      typeof schema === 'object' &&
+      schema !== null &&
+      !Array.isArray(schema) &&
+      Object.keys(schema).length === 0
+    ) {
+      return;
+    }
+
+    // Skip null/undefined
+    if (schema === null || schema === undefined) {
+      return;
+    }
+
+    // Preserve original key (call signature), merge if exists
+    if (dataForMocks[key]) {
+      dataForMocks[key] = mergeSchemas(dataForMocks[key], schema);
+    } else {
+      dataForMocks[key] = schema;
+    }
+  };
+
   // inner recursive function to gather data for mocks
   const gatherDataForMocksRecursive = (
     activeAnalysis: ReadonlyAnalysis,
   ): void => {
+    // First, process ALL keys from this analysis's dataForMocks
+    const localDataForMocks =
+      activeAnalysis.metadata?.scenariosDataStructure?.dataForMocks ?? {};
+
+    for (const [key, schema] of Object.entries(localDataForMocks)) {
+      addMockData(key, schema as JsonTypeDefinition[keyof JsonTypeDefinition]);
+    }
+
+    // Then, recurse into dependent analyses based on imports
     const allImportedExports = [
       ...(activeAnalysis.entity?.metadata.importedExports ?? []),
       ...Object.keys(
@@ -46,68 +121,7 @@ export function gatherDataForMocks(
       ),
     ];
 
-    // console.info('CODEYAM DEBUG: gatherDataForMocksRecursive START', {
-    //   filePath: activeAnalysis.filePath,
-    //   analysisEntityName: activeAnalysis.entityName,
-    //   analysisId: activeAnalysis.id,
-    //   entity: !!activeAnalysis.entity,
-    //   entityName: activeAnalysis.entity?.name,
-    //   allImportedExports: allImportedExports.map((ie) => ({
-    //     filePath: ie.filePath,
-    //     name: ie.name,
-    //   })),
-    // });
-
     for (const importedExport of allImportedExports) {
-      const localDataForMocks =
-        activeAnalysis.metadata?.scenariosDataStructure?.dataForMocks ?? {};
-      // 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,
-      //   relevantKeys,
-      //   hasLocalDataForMocks: Object.keys(localDataForMocks).length > 0,
-      //   localDataForMocksKeys: Object.keys(localDataForMocks),
-      // });
-
-      // First, if we have local data for this mock, add it
-      for (const relevantKey of relevantKeys) {
-        const localDataForMock = localDataForMocks[relevantKey];
-
-        // console.info('CODEYAM DEBUG: Found relevantKey', {
-        //   relevantKey,
-        //   localDataForMockType: typeof localDataForMock,
-        //   localDataForMockValue: localDataForMock,
-        //   isObject: typeof localDataForMock === 'object',
-        //   objectKeysLength:
-        //     typeof localDataForMock === 'object' && localDataForMock !== null
-        //       ? Object.keys(localDataForMock).length
-        //       : 'N/A',
-        // });
-
-        if (Object.keys(localDataForMock).length > 0) {
-          if ((dataForMocks as any)[relevantKey]) {
-            (dataForMocks as any)[relevantKey] = mergeJsonTypeDefinitions(
-              (dataForMocks as any)[relevantKey],
-              localDataForMock,
-            );
-          } else {
-            (dataForMocks as any)[relevantKey] = localDataForMock;
-          }
-        }
-      }
-
-      // ALWAYS check for dependent analysis to gather nested dependencies,
-      // regardless of whether we found a relevantKey above.
-      // This ensures transitive dependencies are included.
-      // For example: Activity -> CurrentActivityTab -> useLastLogLine
       // Use resolvedFilePath when available (for re-exports from index files)
       const lookupPath =
         ('resolvedFilePath' in importedExport &&
@@ -121,30 +135,10 @@ export function gatherDataForMocks(
         gatherDataForMocksRecursive(dependentAnalysis);
       }
     }
-
-    // console.info('CODEYAM DEBUG: gatherDataForMocksRecursive END', {
-    //   filePath: activeAnalysis.filePath,
-    //   entityName: activeAnalysis.entityName,
-    //   currentDataForMocksKeys: Object.keys(dataForMocks),
-    // });
   };
 
   gatherDataForMocksRecursive(analysis);
 
-  // console.info(
-  //   'CODEYAM DEBUG: gatherDataForMocks FINAL RESULT',
-  //   JSON.stringify(
-  //     {
-  //       filePath: analysis.filePath,
-  //       entityName: analysis.entityName,
-  //       dataForMocksKeys: Object.keys(dataForMocks),
-  //       dataForMocks,
-  //     },
-  //     null,
-  //     2,
-  //   ),
-  // );
-
   return dataForMocks;
 }
 
@@ -159,7 +153,7 @@ export default async function generateScenarioData({
 
   const structure: Analysis['metadata']['scenariosDataStructure'] = {
     arguments: analysis.metadata.scenariosDataStructure?.arguments ?? [],
-    dataForMocks: gatherDataForMocks(analysis, dependentAnalyses),
+    dataForMocks: gatherDataForMocks(analysis, dependentAnalyses, entity.name),
   };
 
   const scenarios = analysis.scenarios;
@@ -197,6 +191,7 @@ export default async function generateScenarioData({
         entity,
         structure,
         scenarios,
+        executionFlows: analysis.metadata.executionFlows,
         analysis,
         model,
       }),

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

@@ -28,13 +28,10 @@ export default async function generateScenarios({
 }: GenerateScenariosArgs): Promise<void> {
   if (!['visual', 'library'].includes(entity.entityType)) return;
 
-  // Merge direct dataForMocks with recursively gathered data from dependencies
+  // Gather all mock data, consolidated under the root entity name
   const structure = {
     arguments: analysis.metadata.scenariosDataStructure?.arguments ?? [],
-    dataForMocks: {
-      ...(analysis.metadata.scenariosDataStructure?.dataForMocks ?? {}),
-      ...gatherDataForMocks(analysis, dependentAnalyses),
-    },
+    dataForMocks: gatherDataForMocks(analysis, dependentAnalyses, entity.name),
   };
 
   awsLog(`🔮 Generating ${error ? 'error ' : ''}scenarios for`, {
@@ -60,7 +57,7 @@ export default async function generateScenarios({
           description: 'The only external state the component can be in.',
           metadata: {
             testName: 'it("renders correctly")',
-            keyAttributeInstructions: {},
+            coveredFlows: [],
           },
         },
       ];
@@ -75,8 +72,7 @@ export default async function generateScenarios({
     () =>
       generateEntityScenarios({
         entity,
-        keyAttributes: analysis.metadata.keyAttributes,
-        dependentAnalyses,
+        executionFlows: analysis.metadata.executionFlows,
         analysis,
         error,
         model,