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

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

@@ -191,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,