@codeyam/codeyam-cli 0.1.0-staging.15d0f46 → 0.1.0-staging.1669d45

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,19 +1,11 @@
-import {
-  DataStructure,
-  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'>;
   mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>;
-  keyAttributes: Analysis['metadata']['keyAttributes'];
-  addedKeyAttributes: Analysis['metadata']['keyAttributes'];
-  removedKeyAttributes: Analysis['metadata']['keyAttributes'];
-  dependentAnalyses: ReadonlyAnalysisMap;
+  executionFlows?: ExecutionFlow[];
+  addedFlows?: ExecutionFlow[];
+  removedFlows?: ExecutionFlow[];
   existingScenarios: Scenario[];
   commitDiff: string;
   error: boolean;
@@ -22,62 +14,26 @@ interface GenerateChangesEntityScenariosGeneratorArgs {
 
 export default function generateChangesEntityScenariosGenerator({
   entity,
-  mergedDataStructure,
-  keyAttributes,
-  addedKeyAttributes,
-  removedKeyAttributes,
-  dependentAnalyses,
+  executionFlows,
+  addedFlows,
+  removedFlows,
   existingScenarios,
   commitDiff,
   error,
   changedDataStructureFields = [],
 }: GenerateChangesEntityScenariosGeneratorArgs) {
-  const relevantDependentKeyAttributesFlat =
-    gatherRelevantDependentKeyAttributes(
-      entity,
-      mergedDataStructure,
-      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,
-      // Include new fields when present
-      ...(ka.valueType && { valueType: ka.valueType }),
-      ...(ka.dependencies && { dependencies: ka.dependencies }),
-    }));
-
   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 =
@@ -89,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,
@@ -114,55 +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,
-          // Include new fields when present
-          ...(ka.valueType && { valueType: ka.valueType }),
-          ...(ka.dependencies && { dependencies: ka.dependencies }),
-        }));
-        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}
@@ -172,5 +102,5 @@ ${diffSection}
 ## Current Code
 \`\`\`typescript
 ${entity.code}
-\`\`\`${dependencySection}`;
+\`\`\``;
 }

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

@@ -1,9 +1,30 @@
-import { ScenariosDataStructure, Scenario, ScenarioData } from '~codeyam/types';
+import {
+  ScenariosDataStructure,
+  Scenario,
+  ScenarioData,
+  ExecutionFlow,
+} from '~codeyam/types';
 import noErrorAttributes from './noErrorAttributes';
 
+/**
+ * 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);
+}
+
 export default function generateEntityScenarioDataGenerator(
   structure: ScenariosDataStructure,
   scenario: Scenario,
+  executionFlows: ExecutionFlow[] | undefined,
   defaultScenarioData?: ScenarioData,
   incompleteResponse?: string,
 ) {
@@ -11,11 +32,45 @@ export default function generateEntityScenarioDataGenerator(
     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,10 +85,22 @@ ${JSON.stringify(defaultScenarioData.data, null, 2)}
 `
     : '';
 
-  const mockDataSection = structure.dataForMocks
+  // 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)
+    : null;
+  const sortedDataForMocks =
+    cleanedDataForMocks &&
+    typeof cleanedDataForMocks === 'object' &&
+    !Array.isArray(cleanedDataForMocks)
+      ? sortKeysBySize(cleanedDataForMocks as Record<string, any>)
+      : cleanedDataForMocks;
+
+  const mockDataSection = sortedDataForMocks
     ? `## mockData Structure
 \`\`\`json
-${JSON.stringify(noErrorAttributes(structure.dataForMocks), null, 2)}
+${JSON.stringify(sortedDataForMocks, null, 2)}
 \`\`\``
     : '## mockData Structure\nNone—return `{}` for mockData.';
 

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

@@ -1,69 +1,30 @@
-import { Analysis, Entity } from '~codeyam/types';
+import { Entity, ExecutionFlow } from '~codeyam/types';
 
 interface GenerateEntityScenariosGeneratorArgs {
   entity: Pick<Entity, 'code' | 'metadata' | 'filePath' | 'name'>;
-  keyAttributes: Analysis['metadata']['keyAttributes'];
+  executionFlows?: ExecutionFlow[];
   error: boolean;
 }
 
 export default function generateEntityScenariosGenerator({
   entity,
-  keyAttributes,
+  executionFlows,
   error,
 }: GenerateEntityScenariosGeneratorArgs) {
-  const thisEntityKeyAttributes = keyAttributes?.filter(
-    (ka) => !ka.dependentEntityName,
-  );
-
-  const relevantDependentKeyAttributes = keyAttributes?.filter(
-    (ka) => ka.dependentEntityName,
-  );
-
-  const keyAttrsJson = JSON.stringify(
-    thisEntityKeyAttributes.map((ka) => ({
-      dataStructurePath: ka.dataStructurePath,
-      localVariable: ka.internalPath,
-      description: ka.description,
-      validValueOptions: ka.validValueOptions,
-      // Include new fields when present
-      ...(ka.valueType && { valueType: ka.valueType }),
-      ...(ka.dependencies && { dependencies: ka.dependencies }),
-    })),
-    null,
-    2,
-  );
-
-  const dependencySection =
-    !error &&
-    relevantDependentKeyAttributes &&
-    relevantDependentKeyAttributes.length > 0
-      ? `
-## Dependency Key Attributes
-\`\`\`json
-${JSON.stringify(
-  relevantDependentKeyAttributes.map((ka) => ({
-    dataStructurePath: ka.dataStructurePath,
-    localVariable: ka.internalPath,
-    forDependency: ka.dependentEntityName,
-    description: ka.description,
-    validValueOptions: ka.validValueOptions,
-    // Include new fields when present
-    ...(ka.valueType && { valueType: ka.valueType }),
-    ...(ka.dependencies && { dependencies: ka.dependencies }),
-  })),
-  null,
-  2,
-)}
-\`\`\``
-      : '';
-
-  return `## Key Attributes
+  // Build execution flows section
+  const executionFlowsSection =
+    !error && executionFlows && executionFlows.length > 0
+      ? `## Execution Flows
+These are all the distinct outcomes/behaviors this component can produce. Create scenarios that maximize coverage of these flows.
 \`\`\`json
-${keyAttrsJson}
+${JSON.stringify(executionFlows, null, 2)}
 \`\`\`
 
-## Code
+`
+      : '';
+
+  return `${executionFlowsSection}## Code
 \`\`\`typescript
 ${entity.code}
-\`\`\`${dependencySection}`;
+\`\`\``;
 }

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

@@ -0,0 +1,58 @@
+import { ExecutionFlow, Scenario } from '~codeyam/types';
+
+interface GenerateMissingKeysPromptArgs {
+  scenario: Scenario;
+  executionFlows: ExecutionFlow[] | undefined;
+  generatedMockData: Record<string, any>;
+  missingSchema: Record<string, any>;
+}
+
+/**
+ * Generate a prompt for the follow-up LLM call to fill in missing mockData keys.
+ * This is used when the initial Default Scenario response is missing some keys.
+ */
+export default function generateMissingKeysPrompt({
+  scenario,
+  executionFlows,
+  generatedMockData,
+  missingSchema,
+}: GenerateMissingKeysPromptArgs): string {
+  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,
+        requiredValues: flow.requiredValues,
+      };
+    })
+    .filter(Boolean);
+
+  return `The initial response was missing some keys. Generate mock data for ONLY the missing keys listed below.
+
+## Scenario Context
+\`\`\`json
+${JSON.stringify({ name: scenario.name, description: scenario.description, coveredFlows: coveredFlowRequirements }, null, 2)}
+\`\`\`
+
+## Already Generated Data
+\`\`\`json
+${JSON.stringify(generatedMockData, null, 2)}
+\`\`\`
+
+## Missing Keys to Generate
+\`\`\`json
+${JSON.stringify(missingSchema, null, 2)}
+\`\`\`
+
+Return ONLY a JSON object with this structure:
+\`\`\`json
+{
+  "mockData": {
+    // fill in ONLY the missing keys above
+  }
+}
+\`\`\``;
+}

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

@@ -1,24 +1,50 @@
 import { ScenariosDataStructure, Scenario } from '~codeyam/types';
 
+export interface ExecutionFlowSelection {
+  path: string;
+  value: string;
+  valueOptionIndex?: number;
+  isCustom: boolean;
+}
+
 interface GenerateEntityScenariosGeneratorArgs {
   description: string;
   existingScenarios: Scenario[];
   scenariosDataStructure: ScenariosDataStructure;
+  flowSelections?: ExecutionFlowSelection[];
 }
 
 export default function guessNewScenarioDataFromDescriptionGenerator({
   description,
   existingScenarios,
   scenariosDataStructure,
+  flowSelections,
 }: GenerateEntityScenariosGeneratorArgs) {
+  let flowSelectionsSection = '';
+  if (flowSelections && flowSelections.length > 0) {
+    flowSelectionsSection = `
+  User-selected Execution Flow Values:
+  The user has specifically requested these values be used in the scenario:
+  ${flowSelections
+    .map(
+      (sel) =>
+        `  - ${sel.path}: ${sel.value}${sel.isCustom ? ' (custom value)' : ''}`,
+    )
+    .join('\n')}
+
+  IMPORTANT: The mockData MUST include these specific values for the specified paths. Generate a scenario name and description that reflects these choices.
+  `;
+  }
+
   return `Mock Scenario Data Structure:
   \`\`\`
   ${JSON.stringify(scenariosDataStructure, null, 2)}
-  \`\`\
+  \`\`\`
   Existing Mock Scenario Data:
   \`\`\`
   ${JSON.stringify(existingScenarios, null, 2)}
   \`\`\`
-  New Scenario user-created prompt: "${description}"
+${flowSelectionsSection}
+  New Scenario user-created prompt: "${description || '(No additional description - generate based on selected execution flow values)'}"
   `;
 }