@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.323686

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

@@ -2,9 +2,11 @@ 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).
@@ -21,12 +23,18 @@ function sortKeysBySize(obj: Record<string, any>): Record<string, any> {
   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;
@@ -85,10 +93,16 @@ ${JSON.stringify(defaultScenarioData.data, null, 2)}
 `
     : '';
 
-  // Sort keys by size (smallest first) so small keys appear before large keys,
-  // increasing the chance the LLM generates all keys for large schemas
+  // 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
-    ? noErrorAttributes(structure.dataForMocks)
+    ? simplifyKeysForLLM(
+        noErrorAttributes(structure.dataForMocks) as JsonTypeDefinition,
+      )
     : null;
   const sortedDataForMocks =
     cleanedDataForMocks &&
@@ -97,12 +111,15 @@ ${JSON.stringify(defaultScenarioData.data, null, 2)}
       ? sortKeysBySize(cleanedDataForMocks as Record<string, any>)
       : cleanedDataForMocks;
 
-  const mockDataSection = sortedDataForMocks
-    ? `## mockData Structure
+  // 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(sortedDataForMocks, null, 2)}
 \`\`\``
-    : '## mockData Structure\nNone—return `{}` for mockData.';
+      : '## mockData Structure\nNone—return `{}` for mockData.';
 
   const argumentsSection = structure.arguments
     ? `## argumentsData Structure