@codeyam/codeyam-cli 0.1.0-staging.596f0eb → 0.1.0-staging.76566f9

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { ConditionalUsage } from './astScopes/types';
+import { CompoundConditional, ConditionalUsage } from './astScopes/types';
 import { StructuredPath } from './astScopes/paths';
 import {
   isComparisonOperator,
@@ -28,20 +28,50 @@ export default function getConditionalUsagesFromCode(
     ts.ScriptKind.TSX,
   );
 
-  function addUsage(usage: ConditionalUsage) {
+  /**
+   * Helper to get source location from an AST node
+   */
+  function getSourceLocation(
+    node: ts.Node,
+  ): ConditionalUsage['sourceLocation'] {
+    const start = node.getStart(sourceFile);
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+    const codeSnippet = node.getText(sourceFile);
+
+    return {
+      lineNumber: line + 1, // Convert to 1-based
+      column: character,
+      codeSnippet:
+        codeSnippet.length > 100
+          ? codeSnippet.slice(0, 100) + '...'
+          : codeSnippet,
+    };
+  }
+
+  function addUsage(
+    usage: Omit<ConditionalUsage, 'sourceLocation'>,
+    node: ts.Node,
+  ) {
+    const fullUsage: ConditionalUsage = {
+      ...usage,
+      sourceLocation: getSourceLocation(node),
+    };
+
     if (!conditionalUsages[usage.path]) {
       conditionalUsages[usage.path] = [];
     }
-    // Avoid duplicates
+    // Avoid duplicates (but allow different source locations)
     const exists = conditionalUsages[usage.path].some(
       (existing) =>
-        existing.location === usage.location &&
-        existing.conditionType === usage.conditionType &&
+        existing.location === fullUsage.location &&
+        existing.conditionType === fullUsage.conditionType &&
+        existing.sourceLocation?.lineNumber ===
+          fullUsage.sourceLocation?.lineNumber &&
         JSON.stringify(existing.comparedValues) ===
-          JSON.stringify(usage.comparedValues),
+          JSON.stringify(fullUsage.comparedValues),
     );
     if (!exists) {
-      conditionalUsages[usage.path].push(usage);
+      conditionalUsages[usage.path].push(fullUsage);
     }
   }
 
@@ -91,33 +121,45 @@ export default function getConditionalUsagesFromCode(
 
       if (leftPath && isLiteralExpression(unwrapped.right)) {
         const literalValue = getLiteralValue(unwrapped.right);
-        addUsage({
-          path: leftPath,
-          conditionType: 'comparison',
-          comparedValues:
-            literalValue !== undefined ? [literalValue] : undefined,
-          location,
-        });
+        addUsage(
+          {
+            path: leftPath,
+            conditionType: 'comparison',
+            comparedValues:
+              literalValue !== undefined ? [literalValue] : undefined,
+            location,
+          },
+          unwrapped,
+        );
         return;
       }
 
       if (rightPath && isLiteralExpression(unwrapped.left)) {
         const literalValue = getLiteralValue(unwrapped.left);
-        addUsage({
-          path: rightPath,
-          conditionType: 'comparison',
-          comparedValues:
-            literalValue !== undefined ? [literalValue] : undefined,
-          location,
-        });
+        addUsage(
+          {
+            path: rightPath,
+            conditionType: 'comparison',
+            comparedValues:
+              literalValue !== undefined ? [literalValue] : undefined,
+            location,
+          },
+          unwrapped,
+        );
         return;
       }
 
       if (leftPath) {
-        addUsage({ path: leftPath, conditionType: 'comparison', location });
+        addUsage(
+          { path: leftPath, conditionType: 'comparison', location },
+          unwrapped,
+        );
       }
       if (rightPath) {
-        addUsage({ path: rightPath, conditionType: 'comparison', location });
+        addUsage(
+          { path: rightPath, conditionType: 'comparison', location },
+          unwrapped,
+        );
       }
       return;
     }
@@ -134,7 +176,7 @@ export default function getConditionalUsagesFromCode(
     // Handle simple identifiers or property accesses (truthiness checks)
     const path = getPathFromNode(unwrapped, sourceFile);
     if (path) {
-      addUsage({ path, conditionType: 'truthiness', location });
+      addUsage({ path, conditionType: 'truthiness', location }, unwrapped);
     }
   }
 
@@ -170,12 +212,15 @@ export default function getConditionalUsagesFromCode(
             }
           }
         }
-        addUsage({
-          path: discriminantPath,
-          conditionType: 'switch',
-          comparedValues: caseValues.length > 0 ? caseValues : undefined,
-          location: 'switch',
-        });
+        addUsage(
+          {
+            path: discriminantPath,
+            conditionType: 'switch',
+            comparedValues: caseValues.length > 0 ? caseValues : undefined,
+            location: 'switch',
+          },
+          node,
+        );
       }
     }
 
@@ -269,9 +314,13 @@ interface EnrichedConditionalUsageInput extends ConditionalUsage {
 
 export function formatConditionalUsagesForPrompt(
   conditionalUsages: Record<string, EnrichedConditionalUsageInput[]>,
+  compoundConditionals?: CompoundConditional[],
 ): string {
   const entries = Object.entries(conditionalUsages);
-  if (entries.length === 0) {
+  if (
+    entries.length === 0 &&
+    (!compoundConditionals || compoundConditionals.length === 0)
+  ) {
     return '';
   }
 
@@ -315,9 +364,72 @@ export function formatConditionalUsagesForPrompt(
       description += 'Used in truthiness check (presence/absence matters)';
     }
 
+    // Include source locations if available (show up to 3 examples)
+    const usagesWithLocation = usages.filter((u) => u.sourceLocation);
+    if (usagesWithLocation.length > 0) {
+      description += '\n    - Locations:';
+      for (const usage of usagesWithLocation.slice(0, 3)) {
+        const loc = usage.sourceLocation!;
+        const snippet =
+          loc.codeSnippet.length > 60
+            ? loc.codeSnippet.slice(0, 60) + '...'
+            : loc.codeSnippet;
+        description += `\n      - Line ${loc.lineNumber}: \`${snippet}\``;
+      }
+      if (usagesWithLocation.length > 3) {
+        description += `\n      - ... and ${usagesWithLocation.length - 3} more`;
+      }
+    }
+
     lines.push(description);
   }
 
+  // Add compound conditionals section if present
+  if (compoundConditionals && compoundConditionals.length > 0) {
+    lines.push('');
+    lines.push(
+      '### Compound Conditionals (ALL conditions must be true together)',
+    );
+    lines.push('');
+    lines.push(
+      'These conditions are combined with && and must ALL be satisfied together for a code path to execute.',
+    );
+    lines.push(
+      'IMPORTANT: Ensure at least one scenario satisfies ALL conditions in each compound conditional simultaneously.',
+    );
+    lines.push('');
+
+    for (const compound of compoundConditionals) {
+      lines.push(`- Chain at line ${compound.sourceLocation.lineNumber}:`);
+      lines.push(`    - Expression: \`${compound.expression}\``);
+      lines.push(`    - All these conditions must be TRUE together:`);
+
+      for (const condition of compound.conditions) {
+        let conditionDesc = `      - \`${condition.path}\``;
+        if (
+          condition.conditionType === 'comparison' &&
+          condition.comparedValues?.length
+        ) {
+          const op = condition.isNegated ? '!== ' : '=== ';
+          conditionDesc += ` ${op}${condition.comparedValues.map((v) => `"${v}"`).join(' or ')}`;
+        } else if (condition.conditionType === 'truthiness') {
+          conditionDesc += condition.isNegated
+            ? ' must be falsy (false, null, undefined, 0, "")'
+            : ' must be truthy';
+        }
+        if (condition.requiredValue !== undefined) {
+          conditionDesc += ` (required: ${JSON.stringify(condition.requiredValue)})`;
+        }
+        lines.push(conditionDesc);
+      }
+    }
+
+    lines.push('');
+    lines.push(
+      'When key attributes are part of compound conditionals, list the other conditions as dependencies.',
+    );
+  }
+
   lines.push('');
   lines.push(
     'Consider these attributes as candidates for key attributes, especially those with specific comparison values.',

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

@@ -1,18 +1,22 @@
 import { saveLlmCall } from '~codeyam/aws/dynamodb';
 import { ScenariosDataStructure, Scenario } from '~codeyam/types';
-import * as lib from '.';
 import completionCall from './completionCall';
-import guessNewScenarioDataFromDescriptionGenerator from './promptGenerators/guessNewScenarioDataFromDescriptionGenerator';
+import guessNewScenarioDataFromDescriptionGenerator, {
+  KeyAttributeSelection,
+} from './promptGenerators/guessNewScenarioDataFromDescriptionGenerator';
 import guessEditScenarioDataFromDescriptionGenerator from './promptGenerators/guessEditScenarioDataFromDescriptionGenerator';
 import { AI, DEFAULT_LARGER_MODEL } from '~codeyam/ai';
 import { parseJsonSafe } from './parsers/parseJsonSafe';
 
+export type { KeyAttributeSelection };
+
 export interface GuessScenarioDataFromDescriptionArgs {
   description: string;
   editingMockName?: string;
   editingMockData?: { [key: string]: unknown };
   existingScenarios: Scenario[];
   scenariosDataStructure: ScenariosDataStructure;
+  keyAttributeSelections?: KeyAttributeSelection[];
   model?: AI.Model;
 }
 
@@ -22,6 +26,7 @@ export default async function generateEntityScenarios({
   editingMockData,
   existingScenarios,
   scenariosDataStructure,
+  keyAttributeSelections,
   model,
 }: GuessScenarioDataFromDescriptionArgs): Promise<
   Scenario['metadata']['data'] | null
@@ -38,6 +43,7 @@ export default async function generateEntityScenarios({
         description,
         existingScenarios,
         scenariosDataStructure,
+        keyAttributeSelections,
       });
 
   const response = await completionCall({

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

@@ -198,6 +198,13 @@ export function gatherAttributesMap(
         const pathParts = splitOutsideParenthesesAndArrays(path);
         if (pathParts.length < 2) continue;
 
+        // 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;
         }

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

@@ -64,10 +64,28 @@ export default function generateChangesEntityScenariosGenerator({
       dataStructurePath: ka.dataStructurePath,
       localVariable: ka.internalPath,
       description: ka.description,
-      validValueOptions: ka.validValueOptions,
+      // Include indexed validValueOptions for structured references
+      validValueOptions: ka.validValueOptions.map((value, index) => ({
+        index,
+        value,
+      })),
+      ...(ka.errorValueOptions?.length && {
+        errorValueOptions: ka.errorValueOptions.map((value, index) => ({
+          index,
+          value,
+        })),
+      }),
       // Include new fields when present
       ...(ka.valueType && { valueType: ka.valueType }),
       ...(ka.dependencies && { dependencies: ka.dependencies }),
+      // Include source locations showing where this attribute is used in conditionals
+      ...(ka.sourceLocations?.length && {
+        codeUsages: ka.sourceLocations.map((loc) => ({
+          line: loc.lineNumber,
+          code: loc.codeSnippet,
+          context: loc.description,
+        })),
+      }),
     }));
 
   const addedSection =
@@ -131,10 +149,32 @@ ${JSON.stringify(
           dataStructurePath: ka.dataStructurePath,
           localVariable: ka.path || ka.internalPath,
           description: ka.description,
-          validValueOptions: ka.validValueOptions,
+          // Include indexed validValueOptions for structured references
+          validValueOptions: (ka.validValueOptions || []).map(
+            (value: string, index: number) => ({
+              index,
+              value,
+            }),
+          ),
+          ...(ka.errorValueOptions?.length && {
+            errorValueOptions: ka.errorValueOptions.map(
+              (value: string, index: number) => ({
+                index,
+                value,
+              }),
+            ),
+          }),
           // Include new fields when present
           ...(ka.valueType && { valueType: ka.valueType }),
           ...(ka.dependencies && { dependencies: ka.dependencies }),
+          // Include source locations showing where this attribute is used in conditionals
+          ...(ka.sourceLocations?.length && {
+            codeUsages: ka.sourceLocations.map((loc: any) => ({
+              line: loc.lineNumber,
+              code: loc.codeSnippet,
+              context: loc.description,
+            })),
+          }),
         }));
         return entityAcc;
       },

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

@@ -24,10 +24,28 @@ export default function generateEntityScenariosGenerator({
       dataStructurePath: ka.dataStructurePath,
       localVariable: ka.internalPath,
       description: ka.description,
-      validValueOptions: ka.validValueOptions,
+      // Include indexed validValueOptions for structured references
+      validValueOptions: ka.validValueOptions.map((value, index) => ({
+        index,
+        value,
+      })),
+      ...(ka.errorValueOptions?.length && {
+        errorValueOptions: ka.errorValueOptions.map((value, index) => ({
+          index,
+          value,
+        })),
+      }),
       // Include new fields when present
       ...(ka.valueType && { valueType: ka.valueType }),
       ...(ka.dependencies && { dependencies: ka.dependencies }),
+      // Include source locations showing where this attribute is used in conditionals
+      ...(ka.sourceLocations?.length && {
+        codeUsages: ka.sourceLocations.map((loc) => ({
+          line: loc.lineNumber,
+          code: loc.codeSnippet,
+          context: loc.description,
+        })),
+      }),
     })),
     null,
     2,
@@ -46,10 +64,28 @@ ${JSON.stringify(
     localVariable: ka.internalPath,
     forDependency: ka.dependentEntityName,
     description: ka.description,
-    validValueOptions: ka.validValueOptions,
+    // Include indexed validValueOptions for structured references
+    validValueOptions: ka.validValueOptions.map((value, index) => ({
+      index,
+      value,
+    })),
+    ...(ka.errorValueOptions?.length && {
+      errorValueOptions: ka.errorValueOptions.map((value, index) => ({
+        index,
+        value,
+      })),
+    }),
     // Include new fields when present
     ...(ka.valueType && { valueType: ka.valueType }),
     ...(ka.dependencies && { dependencies: ka.dependencies }),
+    // Include source locations showing where this attribute is used in conditionals
+    ...(ka.sourceLocations?.length && {
+      codeUsages: ka.sourceLocations.map((loc) => ({
+        line: loc.lineNumber,
+        code: loc.codeSnippet,
+        context: loc.description,
+      })),
+    }),
   })),
   null,
   2,

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

@@ -1,24 +1,50 @@
 import { ScenariosDataStructure, Scenario } from '~codeyam/types';
 
+export interface KeyAttributeSelection {
+  path: string;
+  value: string;
+  valueOptionIndex?: number;
+  isCustom: boolean;
+}
+
 interface GenerateEntityScenariosGeneratorArgs {
   description: string;
   existingScenarios: Scenario[];
   scenariosDataStructure: ScenariosDataStructure;
+  keyAttributeSelections?: KeyAttributeSelection[];
 }
 
 export default function guessNewScenarioDataFromDescriptionGenerator({
   description,
   existingScenarios,
   scenariosDataStructure,
+  keyAttributeSelections,
 }: GenerateEntityScenariosGeneratorArgs) {
+  let keyAttributesSection = '';
+  if (keyAttributeSelections && keyAttributeSelections.length > 0) {
+    keyAttributesSection = `
+  User-selected Key Attributes and Values:
+  The user has specifically requested these key attributes and values be used in the scenario:
+  ${keyAttributeSelections
+    .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}"
+${keyAttributesSection}
+  New Scenario user-created prompt: "${description || '(No additional description - generate based on selected key attributes)'}"
   `;
 }

package/analyzer-template/packages/ai/src/lib/worker/SerializableDataStructure.ts

@@ -28,6 +28,11 @@ export interface SerializableFunctionCallInfo {
   receivingVariableNames?: string[];
   /** Maps each call signature to the variable that receives its return value */
   callSignatureToVariable?: Record<string, string>;
+  /**
+   * Stores individual return value schemas per receiving variable, BEFORE merging.
+   * Key is the receiving variable name (e.g., "userFetcher", "reportFetcher").
+   */
+  perVariableSchemas?: Record<string, Record<string, string>>;
 }
 
 export interface SerializableFunctionResult {

package/analyzer-template/packages/ai/src/lib/worker/analyzeScopeWorker.ts

@@ -8,7 +8,10 @@
 import { Entity } from '~codeyam/types';
 import { FileAnalyzer, ProjectAnalyzer } from '~codeyam/analyze';
 import { analyzeScopeLocal } from '../analyzeScope';
-import { ScopeInfo } from '../dataStructure/ScopeDataStructure';
+import {
+  ScopeInfo,
+  resetScopeDataStructureMetrics,
+} from '../dataStructure/ScopeDataStructure';
 import { SerializableDataStructure } from './SerializableDataStructure';
 import { AI } from '~codeyam/ai';
 import { setThreadContext } from '~codeyam/utils';
@@ -48,6 +51,10 @@ let fileAnalyzerPath: string | null = null;
 export default async function runAnalyzeScope(
   input: AnalyzeScopeWorkerInput,
 ): Promise<AnalyzeScopeWorkerOutput> {
+  // Reset metrics counters at the start of each entity analysis to prevent
+  // false "infinite loop" detection when processing multiple entities
+  resetScopeDataStructureMetrics();
+
   try {
     const { entity, project, dirPath, filePath, file, scope, model } = input;