@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.2a88920

package/analyzer-template/packages/ai/src/lib/generateExecutionFlowsFromJsxUsages.ts

@@ -0,0 +1,239 @@
+/**
+ * Generates execution flows from JSX rendering usages.
+ *
+ * This module creates variation flows for arrays and strings that are rendered
+ * directly in JSX, even without explicit conditionals:
+ * - Arrays rendered via .map() → empty, few, many flows
+ * - Strings rendered via interpolation → normal, long flows
+ *
+ * Only controllable paths (from props, hooks, or external data) produce flows.
+ */
+
+import type { ExecutionFlow } from '~codeyam/types';
+import type { JsxRenderingUsage } from './astScopes/types';
+import resolvePathToControllable from './resolvePathToControllable';
+
+export interface GenerateFlowsFromJsxUsagesArgs {
+  /** JSX rendering usages extracted from AST analysis */
+  jsxRenderingUsages: JsxRenderingUsage[];
+  /** Map of controllable paths to their types */
+  attributesMap: Record<string, string>;
+  /** Map from local variable names to data sources */
+  equivalentSignatureVariables: Record<string, string | string[]>;
+  /** Map from full paths to short paths */
+  fullToShortPathMap: Record<string, string>;
+  /** Structure map for type lookup */
+  structure: Record<string, string>;
+}
+
+/**
+ * Generate a slug from a path for use in exclusive groups
+ */
+function pathToSlug(path: string): string {
+  return path
+    .replace(/\[\d+\]/g, '')
+    .replace(/\[\]/g, '')
+    .replace(/\(\)/g, '')
+    .replace(/\.functionCallReturnValue/g, '')
+    .replace(/[<>]/g, '')
+    .replace(/\./g, '-')
+    .toLowerCase();
+}
+
+/**
+ * Generate a human-readable name from a path.
+ */
+function generateNameFromPath(path: string): string {
+  const cleanPath = path
+    .replace(/\(\)/g, '')
+    .replace(/\.functionCallReturnValue/g, '');
+  const parts = cleanPath.split('.');
+  const lastPart = parts[parts.length - 1];
+
+  // Convert camelCase to Title Case
+  return lastPart
+    .replace(/([A-Z])/g, ' $1')
+    .replace(/^./, (str) => str.toUpperCase())
+    .trim();
+}
+
+/**
+ * Generate execution flows from JSX rendering usages.
+ *
+ * For arrays: generates empty (0), few (1-3), many (10+) flows
+ * For strings: generates normal and long text flows
+ */
+export default function generateExecutionFlowsFromJsxUsages(
+  args: GenerateFlowsFromJsxUsagesArgs,
+): ExecutionFlow[] {
+  const {
+    jsxRenderingUsages,
+    attributesMap,
+    equivalentSignatureVariables,
+    fullToShortPathMap,
+  } = args;
+
+  const flows: ExecutionFlow[] = [];
+  const seenPaths = new Set<string>();
+
+  for (const usage of jsxRenderingUsages) {
+    // Resolve the path to a controllable data source
+    const resolution = resolvePathToControllable(
+      usage.path,
+      attributesMap,
+      equivalentSignatureVariables,
+      fullToShortPathMap,
+    );
+
+    if (!resolution.isControllable || !resolution.resolvedPath) {
+      // Path is not controllable - skip
+      continue;
+    }
+
+    const resolvedPath = resolution.resolvedPath;
+
+    // Deduplicate by resolved path + rendering type
+    const dedupeKey = `${resolvedPath}:${usage.renderingType}`;
+    if (seenPaths.has(dedupeKey)) {
+      continue;
+    }
+    seenPaths.add(dedupeKey);
+
+    const baseName = generateNameFromPath(resolvedPath);
+    const pathSlug = pathToSlug(resolvedPath);
+
+    if (usage.renderingType === 'array-map') {
+      // Generate 3 mutually exclusive flows for array sizes
+      const exclusiveGroup = `array-length-${pathSlug}`;
+
+      // Empty array flow
+      flows.push({
+        id: `${pathSlug}-empty-array`,
+        name: `${baseName} Empty`,
+        description: `When ${baseName.toLowerCase()} array is empty`,
+        requiredValues: [
+          {
+            attributePath: resolvedPath,
+            value: '0',
+            comparison: 'length<',
+            valueType: 'array',
+          },
+        ],
+        impact: 'medium',
+        exclusiveGroup,
+        sourceLocation: usage.sourceLocation
+          ? {
+              lineNumber: usage.sourceLocation.lineNumber,
+              column: usage.sourceLocation.column,
+            }
+          : undefined,
+        codeSnippet: usage.sourceLocation?.codeSnippet,
+      });
+
+      // Few items flow (1-3)
+      flows.push({
+        id: `${pathSlug}-few-items`,
+        name: `${baseName} Few Items`,
+        description: `When ${baseName.toLowerCase()} array has 1-3 items`,
+        requiredValues: [
+          {
+            attributePath: resolvedPath,
+            value: '3',
+            comparison: 'length<',
+            valueType: 'array',
+          },
+        ],
+        impact: 'low', // Baseline case
+        exclusiveGroup,
+        sourceLocation: usage.sourceLocation
+          ? {
+              lineNumber: usage.sourceLocation.lineNumber,
+              column: usage.sourceLocation.column,
+            }
+          : undefined,
+        codeSnippet: usage.sourceLocation?.codeSnippet,
+      });
+
+      // Many items flow (10+)
+      flows.push({
+        id: `${pathSlug}-many-items`,
+        name: `${baseName} Many Items`,
+        description: `When ${baseName.toLowerCase()} array has 10+ items`,
+        requiredValues: [
+          {
+            attributePath: resolvedPath,
+            value: '10',
+            comparison: 'length>',
+            valueType: 'array',
+          },
+        ],
+        impact: 'medium',
+        exclusiveGroup,
+        sourceLocation: usage.sourceLocation
+          ? {
+              lineNumber: usage.sourceLocation.lineNumber,
+              column: usage.sourceLocation.column,
+            }
+          : undefined,
+        codeSnippet: usage.sourceLocation?.codeSnippet,
+      });
+    } else if (
+      usage.renderingType === 'text-interpolation' &&
+      usage.valueType === 'string'
+    ) {
+      // Only generate text flows for strings (not numbers or other types)
+      // Generate 2 mutually exclusive flows for text lengths
+      const exclusiveGroup = `text-length-${pathSlug}`;
+
+      // Normal text flow
+      flows.push({
+        id: `${pathSlug}-normal-text`,
+        name: `${baseName} Normal`,
+        description: `When ${baseName.toLowerCase()} has normal length text`,
+        requiredValues: [
+          {
+            attributePath: resolvedPath,
+            value: 'normal',
+            comparison: 'equals',
+            valueType: 'string',
+          },
+        ],
+        impact: 'low',
+        exclusiveGroup,
+        sourceLocation: usage.sourceLocation
+          ? {
+              lineNumber: usage.sourceLocation.lineNumber,
+              column: usage.sourceLocation.column,
+            }
+          : undefined,
+        codeSnippet: usage.sourceLocation?.codeSnippet,
+      });
+
+      // Long text flow
+      flows.push({
+        id: `${pathSlug}-long-text`,
+        name: `${baseName} Long Text`,
+        description: `When ${baseName.toLowerCase()} has long text that might overflow`,
+        requiredValues: [
+          {
+            attributePath: resolvedPath,
+            value: 'long',
+            comparison: 'equals',
+            valueType: 'string',
+          },
+        ],
+        impact: 'low',
+        exclusiveGroup,
+        sourceLocation: usage.sourceLocation
+          ? {
+              lineNumber: usage.sourceLocation.lineNumber,
+              column: usage.sourceLocation.column,
+            }
+          : undefined,
+        codeSnippet: usage.sourceLocation?.codeSnippet,
+      });
+    }
+  }
+
+  return flows;
+}

package/analyzer-template/packages/ai/src/lib/mergeStatements.ts

@@ -7,58 +7,12 @@ import {
 
 export interface Statement {
   structure: { [key: string]: string };
-  equivalentVariables: { [key: string]: string };
+  // Supports multiple equivalencies per key for OR expressions (e.g., x = a || b)
+  equivalentVariables: { [key: string]: string | string[] };
   llmCall?: LlmCall;
 }
 
 export default function mergeStatements(statements: Statement[]) {
-  // Debug: Log input statements to understand what we're merging
-  const hasStateStructure = statements.some((s) =>
-    Object.keys(s.structure || {}).some(
-      (k) => k === 'state' || k.includes('state'),
-    ),
-  );
-  const hasStateEquiv = statements.some((s) =>
-    Object.keys(s.equivalentVariables || {}).some(
-      (k) => k === 'state' || k.includes('state'),
-    ),
-  );
-  if (hasStateStructure || hasStateEquiv) {
-    console.log(
-      `[UNION-TYPE] mergeStatements INPUT: ${statements.length} statements`,
-    );
-    statements.forEach((s, i) => {
-      const stateInStructure = Object.entries(s.structure || {}).filter(
-        ([k]) => k === 'state' || k.includes('state'),
-      );
-      const stateInEquiv = Object.entries(s.equivalentVariables || {}).filter(
-        ([k]) => k === 'state' || k.includes('state'),
-      );
-      const sigInEquiv = Object.entries(s.equivalentVariables || {}).filter(
-        ([k, v]) => k === 'state' || v === 'signature[0]',
-      );
-      if (
-        stateInStructure.length > 0 ||
-        stateInEquiv.length > 0 ||
-        sigInEquiv.length > 0
-      ) {
-        console.log(`[UNION-TYPE]   Statement ${i}:`);
-        if (stateInStructure.length > 0)
-          console.log(
-            `[UNION-TYPE]     structure: ${JSON.stringify(Object.fromEntries(stateInStructure))}`,
-          );
-        if (stateInEquiv.length > 0)
-          console.log(
-            `[UNION-TYPE]     equivalentVariables (state): ${JSON.stringify(Object.fromEntries(stateInEquiv))}`,
-          );
-        if (sigInEquiv.length > 0)
-          console.log(
-            `[UNION-TYPE]     equivalentVariables (sig): ${JSON.stringify(Object.fromEntries(sigInEquiv))}`,
-          );
-      }
-    });
-  }
-
   // This should be handled by the AST Analyzer but it currently has a bug
   const ensureFunctionCallReturnValue = (path: string, value: string) => {
     if (path.endsWith(')') && value !== 'function') {
@@ -172,12 +126,54 @@ export default function mergeStatements(statements: Statement[]) {
   // settingsData → fetcher.data.data uses fetcher::cyDuplicateKey1::.data.data
   const activeRemappings: Record<string, string> = {};
 
+  // Helper to normalize value to array and process
+  const normalizeValue = (value: string | string[]): string[] =>
+    Array.isArray(value) ? value : [value];
+
   const equivalentVariables = statements.reduce((acc: any, result) => {
-    for (const [key, value] of Object.entries(
+    for (const [key, rawValue] of Object.entries(
       result.equivalentVariables ?? {},
     )) {
+      // Handle arrays from AST analyzer (OR expressions like x = a || b)
+      // These should be preserved as arrays to track all sources
+      if (Array.isArray(rawValue)) {
+        const keyOptions = deBinaryPath(key);
+        const validValues = rawValue.filter(
+          (v): v is string => typeof v === 'string' && v.length > 0,
+        );
+        if (validValues.length === 0) continue;
+
+        // Process each array value through deBinaryPath
+        const allValueOptions: string[] = [];
+        for (const value of validValues) {
+          const valueOptions = deBinaryPath(value);
+          allValueOptions.push(...valueOptions);
+        }
+
+        // Remove duplicates while preserving order
+        const uniqueValueOptions = [...new Set(allValueOptions)];
+        const finalValue =
+          uniqueValueOptions.length === 1
+            ? uniqueValueOptions[0]
+            : uniqueValueOptions;
+
+        delete result.equivalentVariables[key];
+        if (keyOptions.length >= 2) {
+          for (const keyOption of keyOptions) {
+            result.equivalentVariables[keyOption] = finalValue;
+          }
+        } else {
+          result.equivalentVariables[keyOptions[0]] = finalValue;
+        }
+        continue;
+      }
+
+      // Original logic for string values with potential binary expressions in the string
+      const firstValue = rawValue;
+      if (!firstValue) continue;
+
       const keyOptions = deBinaryPath(key);
-      const valueOptions = deBinaryPath(value);
+      const valueOptions = deBinaryPath(firstValue);
       delete result.equivalentVariables[key];
       if (keyOptions.length === 2) {
         if (valueOptions.length === 2) {
@@ -199,27 +195,38 @@ export default function mergeStatements(statements: Statement[]) {
       }
     }
 
-    for (const [key, value] of Object.entries(
+    for (const [key, rawValue] of Object.entries(
       result.equivalentVariables ?? {},
     )) {
+      // Normalize to array for consistent handling
+      const values = normalizeValue(rawValue);
+
       // Apply any active remappings to the VALUE, but ONLY for property paths
       // e.g., if fetcher was remapped to fetcher::cyDuplicateKey1::,
       // then "fetcher.data.data" should become "fetcher::cyDuplicateKey1::.data.data"
       // However, we should NOT remap standalone variable references like "description"
       // because that would lose type information from the original variable.
-      let remappedValue = value;
-      for (const [originalKey, remappedKey] of Object.entries(
-        activeRemappings,
-      )) {
-        // Only remap if the value is a property path (contains a dot after the key)
-        // This preserves type information for simple variable references
-        const keyRegex = new RegExp(
-          `^${originalKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=\\.)`,
-        );
-        if (keyRegex.test(remappedValue)) {
-          remappedValue = remappedValue.replace(keyRegex, remappedKey);
+      const remappedValues = values.map((value) => {
+        let remappedValue = value;
+        for (const [originalKey, remappedKey] of Object.entries(
+          activeRemappings,
+        )) {
+          // Only remap if the value is a property path (contains a dot after the key)
+          // This preserves type information for simple variable references
+          const keyRegex = new RegExp(
+            `^${originalKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=\\.)`,
+          );
+          if (keyRegex.test(remappedValue)) {
+            remappedValue = remappedValue.replace(keyRegex, remappedKey);
+          }
         }
-      }
+        return remappedValue;
+      });
+
+      // Use array if multiple values, string if single
+      const remappedValue =
+        remappedValues.length === 1 ? remappedValues[0] : remappedValues;
+      const firstRemappedValue = remappedValues[0];
 
       if (acc[key]) {
         if (acc[key] === remappedValue) continue;
@@ -247,45 +254,32 @@ export default function mergeStatements(statements: Statement[]) {
   // If we have equivalentVariables[A] = B, and structure[A] is more specific than structure[B],
   // then update structure[B] to match structure[A]
   // This handles cases like: "state" -> "signature[0]" where "state" has a union type
-
-  // Debug: Log union types in merged structure
-  const unionTypesInStructure = Object.entries(structure).filter(
-    ([_, v]) => typeof v === 'string' && v.includes("'") && v.includes(' | '),
-  );
-  if (unionTypesInStructure.length > 0) {
-    console.log(
-      `[UNION-TYPE] mergeStatements: Found ${unionTypesInStructure.length} union types in merged structure`,
-    );
-    unionTypesInStructure.forEach(([k, v]) =>
-      console.log(`[UNION-TYPE]   structure["${k}"] = ${v}`),
-    );
-    console.log(
-      `[UNION-TYPE] mergeStatements: equivalentVariables = ${JSON.stringify(equivalentVariables)}`,
-    );
-  }
-
-  for (const [source, target] of Object.entries(equivalentVariables) as [
-    string,
+  for (const [source, rawTarget] of Object.entries(equivalentVariables) as [
     string,
+    string | string[],
   ][]) {
+    // Normalize to array for consistent handling
+    const targets = Array.isArray(rawTarget) ? rawTarget : [rawTarget];
     const sourceType = structure[source];
-    const targetType = structure[target];
 
-    // Check if source has a more specific type (union type vs generic type)
-    if (sourceType) {
-      const sourceIsUnion =
-        sourceType.includes("'") && sourceType.includes(' | ');
+    for (const target of targets) {
+      if (typeof target !== 'string') continue;
 
-      if (sourceIsUnion) {
-        // Target doesn't exist or is generic - propagate the union type
-        const targetIsGeneric =
-          !targetType || targetType === 'string' || targetType === 'unknown';
+      const targetType = structure[target];
 
-        if (targetIsGeneric) {
-          console.log(
-            `[UNION-TYPE] mergeStatements: Propagating "${source}" (${sourceType}) -> "${target}"`,
-          );
-          structure[target] = sourceType;
+      // Check if source has a more specific type (union type vs generic type)
+      if (sourceType) {
+        const sourceIsUnion =
+          sourceType.includes("'") && sourceType.includes(' | ');
+
+        if (sourceIsUnion) {
+          // Target doesn't exist or is generic - propagate the union type
+          const targetIsGeneric =
+            !targetType || targetType === 'string' || targetType === 'unknown';
+
+          if (targetIsGeneric) {
+            structure[target] = sourceType;
+          }
         }
       }
     }

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

@@ -139,16 +139,19 @@ export function gatherAttributesMap(
       // 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(
-        equivalentSignatureVariable,
-      );
+      // Handle array case (OR expressions) - use first element if array
+      const rawEquivalent = equivalentSignatureVariables[keyParts[0]];
+      const equivalentSignatureVariable = Array.isArray(rawEquivalent)
+        ? rawEquivalent[0]
+        : rawEquivalent;
+      const equivalentSignatureVariableParts = equivalentSignatureVariable
+        ? splitOutsideParenthesesAndArrays(equivalentSignatureVariable)
+        : [];
       if (
         equivalentSignatureVariable &&
-        !equivalentSignatureVariableParts[0].includes('(')
+        !equivalentSignatureVariableParts[0]?.includes('(')
       ) {
-        const equivalentKey = equivalentSignatureVariables[keyParts[0]];
+        const equivalentKey = equivalentSignatureVariable;
         const equivalentPath = joinParenthesesAndArrays([
           equivalentKey,
           ...keyParts.slice(1),

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
+      }
+    }
+  }
+}
+\`\`\``;
+}