@codeyam/codeyam-cli 0.1.0-staging.28f73cf → 0.1.0-staging.323686

package/analyzer-template/packages/ai/src/lib/promptGenerators/gatherAttributesMap.ts

@@ -1,4 +1,4 @@
-import { Entity } from '~codeyam/types';
+import { DataStructure } from '~codeyam/types';
 import cleanOutBoundary from '../cleanOutBoundary';
 import {
   joinParenthesesAndArrays,
@@ -65,19 +65,80 @@ function validAttribute(attribute: string) {
   return true;
 }
 
+/**
+ * Gathers attributes from data structures for use in prompts.
+ *
+ * @param isolatedDataStructure - The entity's own data structure (determines which paths to include)
+ * @param mergedDataStructureOrEquivalentVars - Either the merged data structure (with richer types from
+ *   dependent analyses) OR equivalentSignatureVariables for backwards compatibility
+ * @param equivalentSignatureVariablesOrReverse - Either equivalentSignatureVariables OR reverse flag
+ * @param reverseArg - The reverse flag (only used when all 4 args provided)
+ */
 export function gatherAttributesMap(
-  entity: Pick<Entity, 'metadata'>,
-  reverse = false,
+  isolatedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>,
+  mergedDataStructureOrEquivalentVars?:
+    | Omit<DataStructure, 'equivalentSignatureVariables'>
+    | DataStructure['equivalentSignatureVariables'],
+  equivalentSignatureVariablesOrReverse?:
+    | DataStructure['equivalentSignatureVariables']
+    | boolean,
+  reverseArg?: boolean,
 ) {
+  // Handle backwards compatibility: detect if called with old signature
+  // Old: (mergedDataStructure, equivalentSignatureVariables?, reverse?)
+  // New: (isolatedDataStructure, mergedDataStructure, equivalentSignatureVariables?, reverse?)
+  let mergedDataStructure: Omit<
+    DataStructure,
+    'equivalentSignatureVariables'
+  > | null;
+  let equivalentSignatureVariables: DataStructure['equivalentSignatureVariables'];
+  let reverse: boolean;
+
+  if (
+    mergedDataStructureOrEquivalentVars &&
+    typeof mergedDataStructureOrEquivalentVars === 'object' &&
+    'dependencySchemas' in mergedDataStructureOrEquivalentVars
+  ) {
+    // New signature: (isolated, merged, equivalentVars?, reverse?)
+    mergedDataStructure = mergedDataStructureOrEquivalentVars as Omit<
+      DataStructure,
+      'equivalentSignatureVariables'
+    >;
+    equivalentSignatureVariables =
+      (equivalentSignatureVariablesOrReverse as DataStructure['equivalentSignatureVariables']) ??
+      {};
+    reverse = reverseArg ?? false;
+  } else {
+    // Old signature: (merged, equivalentVars?, reverse?)
+    // Use isolatedDataStructure as both isolated and merged for backwards compatibility
+    mergedDataStructure = null; // Will use isolatedDataStructure for types
+    equivalentSignatureVariables =
+      (mergedDataStructureOrEquivalentVars as DataStructure['equivalentSignatureVariables']) ??
+      {};
+    reverse =
+      (equivalentSignatureVariablesOrReverse as boolean | undefined) ?? false;
+  }
+
   const attributesMap: Record<string, string> = {};
   const associationMap: Record<string, string> = {};
   // Maps internalPath -> full data structure path (e.g., "useDiffModal().diffView")
   const dataStructurePathMap: Record<string, string> = {};
-  const { signatureSchema, equivalentSignatureVariables, dependencySchemas } =
-    entity.metadata.isolatedDataStructure;
-  for (const key in signatureSchema) {
+
+  // Use isolatedDataStructure for paths, but look up types in mergedDataStructure when available
+  const isolatedSignatureSchema = isolatedDataStructure.signatureSchema;
+  const mergedSignatureSchema =
+    mergedDataStructure?.signatureSchema ?? isolatedSignatureSchema;
+  const isolatedDependencySchemas = isolatedDataStructure.dependencySchemas;
+  const mergedDependencySchemas =
+    mergedDataStructure?.dependencySchemas ?? isolatedDependencySchemas;
+
+  // Process signature schema - use isolatedDataStructure keys, but merged types
+  for (const key in isolatedSignatureSchema) {
     const keyParts = splitOutsideParenthesesAndArrays(key);
     if (keyParts[0].startsWith('signature')) {
+      // Use merged type if available, otherwise fall back to isolated type
+      const typeValue =
+        mergedSignatureSchema[key] ?? isolatedSignatureSchema[key];
       const equivalentSignatureVariable =
         equivalentSignatureVariables[keyParts[0]];
       const equivalentSignatureVariableParts = splitOutsideParenthesesAndArrays(
@@ -92,7 +153,7 @@ export function gatherAttributesMap(
           equivalentKey,
           ...keyParts.slice(1),
         ]);
-        attributesMap[equivalentPath] = signatureSchema[key];
+        attributesMap[equivalentPath] = typeValue;
         associationMap[reverse ? equivalentPath : key] = reverse
           ? key
           : equivalentPath;
@@ -100,7 +161,7 @@ export function gatherAttributesMap(
         dataStructurePathMap[equivalentPath] = equivalentPath;
       } else {
         const relativePath = joinParenthesesAndArrays(keyParts.slice(1));
-        attributesMap[relativePath] = signatureSchema[key];
+        attributesMap[relativePath] = typeValue;
         associationMap[reverse ? relativePath : key] = reverse
           ? key
           : relativePath;
@@ -110,25 +171,41 @@ export function gatherAttributesMap(
     }
   }
 
-  for (const filePath in dependencySchemas) {
-    for (const entityName in dependencySchemas[filePath]) {
-      const returnValueDataStructure =
-        dependencySchemas[filePath][entityName].returnValueSchema ?? {};
+  // Process dependency schemas - iterate through isolatedDependencySchemas (for which paths to include)
+  // but use mergedDependencySchemas for types (richer type information)
+  for (const filePath in isolatedDependencySchemas) {
+    for (const entityName in isolatedDependencySchemas[filePath]) {
+      // Get the isolated return value schema (determines which paths exist)
+      const isolatedReturnValueSchema =
+        isolatedDependencySchemas[filePath][entityName].returnValueSchema ?? {};
+
+      // Get the merged return value schema (for richer types)
+      const mergedReturnValueSchema =
+        mergedDependencySchemas?.[filePath]?.[entityName]?.returnValueSchema ??
+        isolatedReturnValueSchema;
 
-      // First pass: collect all function paths
+      // First pass: collect all function paths from merged schema (for broader coverage)
       const functionPaths: string[] = [];
-      for (const path in returnValueDataStructure) {
-        if (returnValueDataStructure[path] === 'function') {
+      for (const path in mergedReturnValueSchema) {
+        if (mergedReturnValueSchema[path] === 'function') {
           functionPaths.push(path);
         }
       }
 
-      // Second pass: process all paths
-      for (const path in returnValueDataStructure) {
+      // Second pass: process paths from merged schema, but only include paths that
+      // are rooted in an isolated path (i.e., isolatedDataStructure knows about this dependency)
+      for (const path in mergedReturnValueSchema) {
         const pathParts = splitOutsideParenthesesAndArrays(path);
         if (pathParts.length < 2) continue;
 
-        if (returnValueDataStructure[path] === 'function') {
+        // Filter out paths that contain signature[N] anywhere
+        // These represent function input parameters, not data from data sources
+        // Key attributes must reference data sources, not function inputs
+        if (pathParts.some((part) => part.startsWith('signature['))) {
+          continue;
+        }
+
+        if (mergedReturnValueSchema[path] === 'function') {
           continue;
         }
 
@@ -176,7 +253,7 @@ export function gatherAttributesMap(
               const relativePath = path;
               if (!validAttribute(relativePath)) continue;
 
-              attributesMap[relativePath] = returnValueDataStructure[path];
+              attributesMap[relativePath] = mergedReturnValueSchema[path];
               associationMap[reverse ? relativePath : path] = reverse
                 ? path
                 : relativePath;
@@ -194,7 +271,8 @@ export function gatherAttributesMap(
         // Normalize the path for internal use (e.g., ['*'] -> '*')
         const relativePath = normalizePathForInternalUse(rawRelativePath);
 
-        attributesMap[relativePath] = returnValueDataStructure[path];
+        // Use the type from mergedReturnValueSchema
+        attributesMap[relativePath] = mergedReturnValueSchema[path];
         associationMap[reverse ? relativePath : path] = reverse
           ? path
           : relativePath;

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateChangesEntityScenarioDataGenerator.ts

@@ -66,7 +66,7 @@ ${incompleteResponse}
     {
       name: scenario.name,
       description: scenario.description,
-      keyAttributeInstructions: scenario.metadata.keyAttributeInstructions,
+      coveredFlows: scenario.metadata?.coveredFlows || [],
     },
     null,
     2,

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateChangesEntityScenariosGenerator.ts

@@ -1,17 +1,11 @@
-import {
-  Entity,
-  Scenario,
-  ReadonlyAnalysisMap,
-  Analysis,
-} from '~codeyam/types';
-import gatherRelevantDependentKeyAttributes from '../gatherRelevantDependentKeyAttributes';
+import { DataStructure, Entity, ExecutionFlow, Scenario } from '~codeyam/types';
 
 interface GenerateChangesEntityScenariosGeneratorArgs {
   entity: Pick<Entity, 'name' | 'code' | 'metadata'>;
-  keyAttributes: Analysis['metadata']['keyAttributes'];
-  addedKeyAttributes: Analysis['metadata']['keyAttributes'];
-  removedKeyAttributes: Analysis['metadata']['keyAttributes'];
-  dependentAnalyses: ReadonlyAnalysisMap;
+  mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>;
+  executionFlows?: ExecutionFlow[];
+  addedFlows?: ExecutionFlow[];
+  removedFlows?: ExecutionFlow[];
   existingScenarios: Scenario[];
   commitDiff: string;
   error: boolean;
@@ -20,54 +14,26 @@ interface GenerateChangesEntityScenariosGeneratorArgs {
 
 export default function generateChangesEntityScenariosGenerator({
   entity,
-  keyAttributes,
-  addedKeyAttributes,
-  removedKeyAttributes,
-  dependentAnalyses,
+  executionFlows,
+  addedFlows,
+  removedFlows,
   existingScenarios,
   commitDiff,
   error,
   changedDataStructureFields = [],
 }: GenerateChangesEntityScenariosGeneratorArgs) {
-  const relevantDependentKeyAttributesFlat =
-    gatherRelevantDependentKeyAttributes(entity, dependentAnalyses);
-
-  // Restructure flat array into nested format: { [filePath]: { [entityName]: KeyAttribute[] } }
-  const relevantDependentKeyAttributes: Record<
-    string,
-    Record<string, any[]>
-  > = {};
-  for (const attr of relevantDependentKeyAttributesFlat) {
-    const filePath = (attr as any).filePath;
-    const entityName = (attr as any).originalEntityName;
-
-    if (!filePath || !entityName) continue;
-
-    if (!relevantDependentKeyAttributes[filePath]) {
-      relevantDependentKeyAttributes[filePath] = {};
-    }
-    if (!relevantDependentKeyAttributes[filePath][entityName]) {
-      relevantDependentKeyAttributes[filePath][entityName] = [];
-    }
-    relevantDependentKeyAttributes[filePath][entityName].push(attr);
-  }
-
-  const formatKeyAttrs = (attrs: Analysis['metadata']['keyAttributes']) =>
-    attrs.map((ka) => ({
-      dataStructurePath: ka.dataStructurePath,
-      localVariable: ka.internalPath,
-      description: ka.description,
-      validValueOptions: ka.validValueOptions,
-    }));
-
   const addedSection =
-    addedKeyAttributes?.length > 0
-      ? JSON.stringify(formatKeyAttrs(addedKeyAttributes), null, 2)
+    addedFlows && addedFlows.length > 0
+      ? JSON.stringify(addedFlows, null, 2)
       : 'None';
 
   const removedSection =
-    removedKeyAttributes?.length > 0
-      ? JSON.stringify(removedKeyAttributes, null, 2)
+    removedFlows && removedFlows.length > 0
+      ? JSON.stringify(
+          removedFlows.map((f) => ({ id: f.id, name: f.name })),
+          null,
+          2,
+        )
       : 'None';
 
   const changedFieldsSection =
@@ -79,18 +45,18 @@ Fields that changed type, were added, or removed:
 ${JSON.stringify(changedDataStructureFields, null, 2)}
 \`\`\`
 
-**Update keyAttributeInstructions for affected scenarios** (e.g., if "stats.visualEntities" changed from array to number).
+**Update scenarios if their coveredFlows depend on these changed fields.**
 `
       : '';
 
   const existingScenariosJson = JSON.stringify(
     existingScenarios
-      .filter((s) => (error ? !!s.metadata.error : !s.metadata.error))
+      .filter((s) => (error ? !!s.metadata?.error : !s.metadata?.error))
       .map((s) => ({
         name: s.name,
         description: s.description,
-        keyAttributeInstructions: s.metadata.keyAttributeInstructions,
-        playwrightInstructions: s.metadata.playwrightInstructions,
+        coveredFlows: s.metadata?.coveredFlows || [],
+        playwrightInstructions: s.metadata?.playwrightInstructions,
       })),
     null,
     2,
@@ -104,52 +70,29 @@ ${commitDiff}
 \`\`\``
     : '';
 
-  const dependencySection =
-    !error &&
-    relevantDependentKeyAttributes &&
-    Object.keys(relevantDependentKeyAttributes).length > 0
-      ? `
-## Dependency Key Attributes
+  const executionFlowsSection =
+    executionFlows && executionFlows.length > 0
+      ? `## Current Execution Flows
+All distinct outcomes/behaviors this component can currently produce:
 \`\`\`json
-${JSON.stringify(
-  Object.keys(relevantDependentKeyAttributes).reduce((acc: any, path) => {
-    acc[path] = Object.keys(relevantDependentKeyAttributes[path]).reduce(
-      (entityAcc: any, entityName) => {
-        entityAcc[entityName] = relevantDependentKeyAttributes[path][
-          entityName
-        ].map((ka: any) => ({
-          dataStructurePath: ka.dataStructurePath,
-          localVariable: ka.path || ka.internalPath,
-          description: ka.description,
-          validValueOptions: ka.validValueOptions,
-        }));
-        return entityAcc;
-      },
-      {},
-    );
-    return acc;
-  }, {}),
-  null,
-  2,
-)}
-\`\`\``
+${JSON.stringify(executionFlows, null, 2)}
+\`\`\`
+`
       : '';
 
-  return `## Added Key Attributes
+  return `## Added Execution Flows
+New flows that need scenario coverage:
 \`\`\`json
 ${addedSection}
 \`\`\`
 
-## Removed Key Attributes
+## Removed Execution Flows
+Flows that no longer exist (remove from scenarios):
 \`\`\`json
 ${removedSection}
 \`\`\`
 ${changedFieldsSection}
-## Current Key Attributes
-\`\`\`json
-${JSON.stringify(formatKeyAttrs(keyAttributes), null, 2)}
-\`\`\`
-
+${executionFlowsSection}
 ## Existing Scenarios
 \`\`\`json
 ${existingScenariosJson}
@@ -159,5 +102,5 @@ ${diffSection}
 ## Current Code
 \`\`\`typescript
 ${entity.code}
-\`\`\`${dependencySection}`;
+\`\`\``;
 }

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateChunkPrompt.ts

@@ -0,0 +1,82 @@
+import {
+  ExecutionFlow,
+  Scenario,
+  ScenariosDataStructure,
+} from '~codeyam/types';
+import simplifyKeysForLLM from './simplifyKeysForLLM';
+import noErrorAttributes from './noErrorAttributes';
+import { JsonTypeDefinition } from '~codeyam/types';
+
+type RequiredValue = NonNullable<ExecutionFlow['requiredValues']>[number];
+
+interface GenerateChunkPromptArgs {
+  scenario: Scenario;
+  chunk: ScenariosDataStructure['dataForMocks'];
+  chunkIndex: number;
+  totalChunks: number;
+  relevantRequiredValues: RequiredValue[];
+}
+
+/**
+ * Generate a prompt for a focused LLM call to generate mock data for a single chunk.
+ *
+ * Large data structures overwhelm LLMs, causing them to make mistakes on some keys.
+ * By processing smaller chunks, each key gets more focused attention.
+ */
+export default function generateChunkPrompt({
+  scenario,
+  chunk,
+  chunkIndex,
+  totalChunks,
+  relevantRequiredValues,
+}: GenerateChunkPromptArgs): string {
+  // Clean up the schema for LLM consumption
+  const cleanedSchema = simplifyKeysForLLM(
+    noErrorAttributes(chunk) as JsonTypeDefinition,
+  );
+
+  const keysInChunk = Object.keys(chunk || {});
+
+  // Build requirements section if there are relevant requiredValues
+  const requirementsSection =
+    relevantRequiredValues.length > 0
+      ? `## Execution Flow Requirements for These Keys
+These specific values MUST be set to produce the correct scenario behavior:
+\`\`\`json
+${JSON.stringify(relevantRequiredValues, null, 2)}
+\`\`\`
+
+`
+      : '';
+
+  return `Generate mock data for chunk ${chunkIndex + 1} of ${totalChunks}.
+
+## Scenario
+\`\`\`json
+${JSON.stringify({ name: scenario.name, description: scenario.description }, null, 2)}
+\`\`\`
+
+${requirementsSection}## Keys in This Chunk (${keysInChunk.length} keys)
+Generate data for ONLY these keys:
+${keysInChunk.map((k) => `- \`${k}\``).join('\n')}
+
+## Schema for This Chunk
+\`\`\`json
+${JSON.stringify(cleanedSchema, null, 2)}
+\`\`\`
+
+## Instructions
+1. Match the EXACT structure shown in the schema
+2. Keys with special characters like \`*\` are LITERAL keys, not patterns
+3. If requiredValues are shown above, set values that satisfy them
+4. For paths like \`functionCall().functionCallReturnValue.property\`, the mock data key is just \`functionCall()\`
+
+Return ONLY a JSON object with this structure:
+\`\`\`json
+{
+  "mockData": {
+    // fill in ONLY the keys from this chunk
+  }
+}
+\`\`\``;
+}

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateCriticalKeysPrompt.ts

@@ -0,0 +1,103 @@
+import {
+  ExecutionFlow,
+  Scenario,
+  ScenariosDataStructure,
+} from '~codeyam/types';
+import simplifyKeysForLLM from './simplifyKeysForLLM';
+import noErrorAttributes from './noErrorAttributes';
+import { JsonTypeDefinition } from '~codeyam/types';
+
+interface GenerateCriticalKeysPromptArgs {
+  scenario: Scenario;
+  executionFlows: ExecutionFlow[] | undefined;
+  criticalKeys: string[];
+  fullDataForMocks: ScenariosDataStructure['dataForMocks'];
+}
+
+/**
+ * Generate a prompt for a focused LLM call to generate only the critical mock data keys.
+ *
+ * When a scenario has covered flows with requiredValues, only a subset of the full
+ * dataForMocks schema is actually needed to satisfy those requirements. This prompt
+ * focuses the LLM on JUST those critical keys, avoiding confusion from large schemas.
+ *
+ * This is called BEFORE the main data generation to ensure critical keys are correctly
+ * generated with full attention from the LLM.
+ */
+export default function generateCriticalKeysPrompt({
+  scenario,
+  executionFlows,
+  criticalKeys,
+  fullDataForMocks,
+}: GenerateCriticalKeysPromptArgs): string {
+  // Build the subset schema with only critical keys
+  const criticalSchema: Record<string, any> = {};
+  if (fullDataForMocks && typeof fullDataForMocks === 'object') {
+    for (const key of criticalKeys) {
+      if (key in fullDataForMocks) {
+        criticalSchema[key] = (fullDataForMocks as Record<string, any>)[key];
+      }
+    }
+  }
+
+  // Clean up the schema for LLM consumption
+  const cleanedSchema = simplifyKeysForLLM(
+    noErrorAttributes(criticalSchema) as JsonTypeDefinition,
+  );
+
+  // Get the covered flows and their requirements
+  const coveredFlowIds = scenario.metadata?.coveredFlows || [];
+  const coveredFlowRequirements = coveredFlowIds
+    .map((flowId) => {
+      const flow = executionFlows?.find((f) => f.id === flowId);
+      if (!flow) return null;
+      return {
+        flowId: flow.id,
+        flowName: flow.name,
+        flowDescription: flow.description,
+        requiredValues: flow.requiredValues,
+      };
+    })
+    .filter(Boolean);
+
+  return `Generate mock data for these CRITICAL keys. Pay close attention to the requiredValues.
+
+## IMPORTANT: These keys are critical for satisfying the execution flow requirements
+The keys below directly control the scenario's behavior. Generate values that EXACTLY satisfy the requiredValues.
+
+## Scenario
+\`\`\`json
+${JSON.stringify({ name: scenario.name, description: scenario.description }, null, 2)}
+\`\`\`
+
+## Execution Flow Requirements
+These are the specific values that MUST be set:
+\`\`\`json
+${JSON.stringify(coveredFlowRequirements, null, 2)}
+\`\`\`
+
+## Critical Keys Schema (generate data for ONLY these keys)
+\`\`\`json
+${JSON.stringify(cleanedSchema, null, 2)}
+\`\`\`
+
+## Instructions
+1. Match the EXACT structure shown in the schema
+2. Keys with special characters like \`*\` are LITERAL keys, not patterns
+3. Set values that satisfy ALL the requiredValues above
+4. For paths like \`functionCall().functionCallReturnValue.property\`, the mock data key is just \`functionCall()\`
+
+Return ONLY a JSON object with this structure:
+\`\`\`json
+{
+  "scenarioData": {
+    "scenarioName": "${scenario.name}",
+    "data": {
+      "mockData": {
+        // fill in ONLY the critical keys above
+      }
+    }
+  }
+}
+\`\`\``;
+}

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateEntityScenarioDataGenerator.ts

@@ -1,21 +1,84 @@
-import { ScenariosDataStructure, Scenario, ScenarioData } from '~codeyam/types';
+import {
+  ScenariosDataStructure,
+  Scenario,
+  ScenarioData,
+  JsonTypeDefinition,
+  ExecutionFlow,
+} from '~codeyam/types';
 import noErrorAttributes from './noErrorAttributes';
+import simplifyKeysForLLM from './simplifyKeysForLLM';
+
+/**
+ * Sort object keys by the size of their JSON-stringified values (smallest first).
+ * This ensures small keys appear before large keys in the LLM prompt, increasing
+ * the chance they get generated before the LLM loses focus on large schemas.
+ */
+function sortKeysBySize(obj: Record<string, any>): Record<string, any> {
+  const entries = Object.entries(obj);
+  entries.sort(([, a], [, b]) => {
+    const sizeA = JSON.stringify(a).length;
+    const sizeB = JSON.stringify(b).length;
+    return sizeA - sizeB;
+  });
+  return Object.fromEntries(entries);
+}
+
+interface GeneratePromptOptions {
+  /** When true, mockData has already been generated via chunks - skip it in main call */
+  mockDataAlreadyGenerated?: boolean;
+}
 
 export default function generateEntityScenarioDataGenerator(
   structure: ScenariosDataStructure,
   scenario: Scenario,
+  executionFlows: ExecutionFlow[] | undefined,
   defaultScenarioData?: ScenarioData,
   incompleteResponse?: string,
+  options?: GeneratePromptOptions,
 ) {
   if (incompleteResponse) {
     return incompleteResponse;
   }
 
+  // Get the covered flows for this scenario and look up their requiredValues
+  const coveredFlowIds = scenario.metadata?.coveredFlows || [];
+  const coveredFlowRequirements = coveredFlowIds
+    .map((flowId) => {
+      const flow = executionFlows?.find((f) => f.id === flowId);
+      if (!flow) return null;
+      return {
+        flowId: flow.id,
+        flowName: flow.name,
+        flowDescription: flow.description,
+        requiredValues: flow.requiredValues,
+      };
+    })
+    .filter(Boolean);
+
+  // Get blocking flows that are NOT covered by this scenario
+  // These should be explicitly avoided in the mock data
+  const blockingFlowsToAvoid = (executionFlows || [])
+    .filter(
+      (flow) =>
+        flow.blocksOtherFlows === true && !coveredFlowIds.includes(flow.id),
+    )
+    .map((flow) => ({
+      flowId: flow.id,
+      flowName: flow.name,
+      flowDescription: flow.description,
+      requiredValues: flow.requiredValues,
+    }));
+
   const scenarioJson = JSON.stringify(
     {
       name: scenario.name,
       description: scenario.description,
-      keyAttributeInstructions: scenario.metadata.keyAttributeInstructions,
+      // Include the flow requirements to guide data generation
+      coveredFlows: coveredFlowRequirements,
+      // Include blocking flows to avoid
+      ...(blockingFlowsToAvoid.length > 0 && {
+        blockingFlowsToAvoid,
+      }),
     },
     null,
     2,
@@ -30,12 +93,33 @@ ${JSON.stringify(defaultScenarioData.data, null, 2)}
 `
     : '';
 
-  const mockDataSection = structure.dataForMocks
-    ? `## mockData Structure
+  // Simplify verbose function call keys for LLM consumption, then sort by size.
+  // The static analysis generates keys like "useQuery({ id: Number(id), onSuccess: async (quote) => { ...30 lines... } })"
+  // which confuse the LLM. simplifyKeysForLLM reduces them to "useQuery({ id, onSuccess: () => <truncated> })"
+  // while the reconcileMockDataKeys function will still match the simplified response back to original keys.
+  // Then sort keys by size (smallest first) so small keys appear before large keys,
+  // increasing the chance the LLM generates all keys for large schemas.
+  const cleanedDataForMocks = structure.dataForMocks
+    ? simplifyKeysForLLM(
+        noErrorAttributes(structure.dataForMocks) as JsonTypeDefinition,
+      )
+    : null;
+  const sortedDataForMocks =
+    cleanedDataForMocks &&
+    typeof cleanedDataForMocks === 'object' &&
+    !Array.isArray(cleanedDataForMocks)
+      ? sortKeysBySize(cleanedDataForMocks as Record<string, any>)
+      : cleanedDataForMocks;
+
+  // When mockData has already been generated via chunks, skip it in the main call
+  const mockDataSection = options?.mockDataAlreadyGenerated
+    ? '## mockData Structure\nmockData has been pre-generated—return `{}` for mockData.'
+    : sortedDataForMocks
+      ? `## mockData Structure
 \`\`\`json
-${JSON.stringify(noErrorAttributes(structure.dataForMocks), null, 2)}
+${JSON.stringify(sortedDataForMocks, null, 2)}
 \`\`\``
-    : '## mockData Structure\nNone—return `{}` for mockData.';
+      : '## mockData Structure\nNone—return `{}` for mockData.';
 
   const argumentsSection = structure.arguments
     ? `## argumentsData Structure