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

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

@@ -0,0 +1,264 @@
+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) {
+    console.log(
+      `[GenerateExecutionFlows] Starting for ${entity.name} (${entity.filePath})`,
+    );
+
+    // Build childEntityMetadata from dependentAnalyses for child flow merging
+    // This maps child component names to their metadata (specifically isolatedDataStructure)
+    const childEntityMetadata = buildChildEntityMetadata(
+      entity,
+      dependentAnalyses,
+    );
+
+    const childCount = Object.keys(childEntityMetadata).length;
+    console.log(
+      `[GenerateExecutionFlows] Built childEntityMetadata with ${childCount} children`,
+    );
+    if (childCount > 0) {
+      console.log(
+        `[GenerateExecutionFlows] Will merge flows from children: [${Object.keys(childEntityMetadata).join(', ')}]`,
+      );
+    }
+
+    const {
+      result: { executionFlows, llmCall: executionFlowsLLMCall },
+    } = await measureAndReportExecutionTime(
+      () =>
+        generateExecutionFlowsLLM({
+          entity,
+          mergedDataStructure: analysis.metadata.mergedDataStructure,
+          model,
+          childEntityMetadata: childCount > 0 ? childEntityMetadata : undefined,
+        }),
+      `Generating execution flows`,
+      updateProgress,
+    );
+
+    console.log(
+      `[GenerateExecutionFlows] Generated ${executionFlows.length} execution flows for ${entity.name}`,
+    );
+    for (const flow of executionFlows) {
+      const reqValues = flow.requiredValues
+        .map((rv) => `${rv.attributePath}=${rv.value}`)
+        .join(', ');
+      console.log(
+        `[GenerateExecutionFlows]   - Flow '${flow.id}': ${flow.name} [${reqValues}]`,
+      );
+    }
+
+    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']> = {};
+
+  console.log(
+    `[BuildChildMetadata] Starting for entity: ${entity.name} (${entity.filePath})`,
+  );
+
+  if (!dependentAnalyses) {
+    console.log(
+      `[BuildChildMetadata] No dependentAnalyses provided, returning empty`,
+    );
+    return childEntityMetadata;
+  }
+
+  const childBoundaryGatingConditions =
+    entity.metadata?.isolatedDataStructure?.childBoundaryGatingConditions;
+
+  if (!childBoundaryGatingConditions) {
+    console.log(
+      `[BuildChildMetadata] No childBoundaryGatingConditions found in isolatedDataStructure`,
+    );
+    console.log(
+      `[BuildChildMetadata] isolatedDataStructure keys: ${Object.keys(entity.metadata?.isolatedDataStructure ?? {}).join(', ') || 'none'}`,
+    );
+    return childEntityMetadata;
+  }
+
+  const childNames = Object.keys(childBoundaryGatingConditions);
+  console.log(
+    `[BuildChildMetadata] Found ${childNames.length} children in childBoundaryGatingConditions: [${childNames.join(', ')}]`,
+  );
+
+  // Log gating conditions for each child
+  for (const [childName, conditions] of Object.entries(
+    childBoundaryGatingConditions,
+  )) {
+    const isUnconditional = conditions.some(
+      (c) => c.location === 'unconditional',
+    );
+    console.log(
+      `[BuildChildMetadata] Child '${childName}': ${conditions.length} gating conditions, unconditional=${isUnconditional}`,
+    );
+    for (const condition of conditions) {
+      console.log(
+        `[BuildChildMetadata]   - path='${condition.path}' location='${condition.location}' isNegated=${condition.isNegated ?? false}`,
+      );
+    }
+  }
+
+  const importedExports = entity.metadata?.importedExports ?? [];
+  console.log(
+    `[BuildChildMetadata] Entity has ${importedExports.length} importedExports`,
+  );
+
+  for (const childName of childNames) {
+    console.log(`[BuildChildMetadata] Looking up child '${childName}'...`);
+
+    // Find the child in importedExports to get its file path
+    const importedExport = importedExports.find(
+      (ie) => ie.name === childName || ie.resolvedName === childName,
+    );
+
+    if (!importedExport) {
+      console.log(
+        `[BuildChildMetadata] Child '${childName}' NOT FOUND in importedExports`,
+      );
+      continue;
+    }
+
+    // Use resolved paths when available (for re-exports from index files)
+    const lookupPath =
+      importedExport.resolvedFilePath ?? importedExport.filePath;
+    const lookupName = importedExport.resolvedName ?? importedExport.name;
+
+    console.log(
+      `[BuildChildMetadata] Child '${childName}' found in importedExports: lookupPath='${lookupPath}' lookupName='${lookupName}'`,
+    );
+
+    // Look up the child's analysis in dependentAnalyses
+    const childAnalysis = dependentAnalyses[lookupPath]?.[lookupName];
+
+    if (!childAnalysis) {
+      console.log(
+        `[BuildChildMetadata] Child '${childName}' analysis NOT FOUND in dependentAnalyses[${lookupPath}][${lookupName}]`,
+      );
+      console.log(
+        `[BuildChildMetadata] Available paths in dependentAnalyses: [${Object.keys(dependentAnalyses).slice(0, 10).join(', ')}...]`,
+      );
+      continue;
+    }
+
+    if (!childAnalysis.entity?.metadata) {
+      console.log(
+        `[BuildChildMetadata] Child '${childName}' analysis found but entity.metadata is missing`,
+      );
+      continue;
+    }
+
+    // Log what we found in the child's metadata
+    const childIsolated = childAnalysis.entity.metadata.isolatedDataStructure;
+    const childConditionalUsages = childIsolated?.conditionalUsages ?? {};
+    const childConditionalCount = Object.keys(childConditionalUsages).length;
+
+    console.log(
+      `[BuildChildMetadata] Child '${childName}' FOUND with metadata:`,
+    );
+    console.log(
+      `[BuildChildMetadata]   - conditionalUsages: ${childConditionalCount} paths`,
+    );
+    if (childConditionalCount > 0) {
+      for (const [path, usages] of Object.entries(childConditionalUsages)) {
+        console.log(
+          `[BuildChildMetadata]     - '${path}': ${(usages as any[]).length} usages`,
+        );
+      }
+    }
+
+    // Cast to mutable type - the metadata is only read, not modified
+    childEntityMetadata[childName] = childAnalysis.entity
+      .metadata as Entity['metadata'];
+  }
+
+  console.log(
+    `[BuildChildMetadata] RESULT: Found metadata for ${Object.keys(childEntityMetadata).length} children: [${Object.keys(childEntityMetadata).join(', ')}]`,
+  );
+
+  return childEntityMetadata;
+}

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;
     }
   };
 
@@ -286,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

@@ -57,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: [],
           },
         },
       ];
@@ -72,8 +72,7 @@ export default async function generateScenarios({
     () =>
       generateEntityScenarios({
         entity,
-        keyAttributes: analysis.metadata.keyAttributes,
-        dependentAnalyses,
+        executionFlows: analysis.metadata.executionFlows,
         analysis,
         error,
         model,