@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.e38f7bd

package/analyzer-template/packages/ai/src/lib/dataStructure/ScopeDataStructure.ts

@@ -210,6 +210,17 @@ export interface FunctionCallInfo {
    * are encountered, they get merged into one FunctionCallInfo but we track all signatures.
    */
   allCallSignatures?: string[];
+  /**
+   * Variable names that receive the return value of each call.
+   * For example, in `const result1 = db.select(query1)`, the receiving variable is 'result1'.
+   * This enables generating separate mock data for each call site.
+   */
+  receivingVariableNames?: string[];
+  /**
+   * Maps each call signature to the variable that receives its return value.
+   * For example: { "db.select(query1)": "result1", "db.select(query2)": "result2" }
+   */
+  callSignatureToVariable?: Record<string, string>;
 }
 
 /**
@@ -307,6 +318,7 @@ const ALLOWED_EQUIVALENCY_REASONS = new Set([
   'Array.from() equivalency',
   'propagated sub-property equivalency',
   'propagated function call return sub-property equivalency',
+  'propagated parent-variable equivalency', // Added: propagate child scope equivalencies to parent scope when variable is defined in parent
   'where was this function called from', // Added: tracks which scope called an external function
 ]);
 
@@ -919,6 +931,39 @@ export class ScopeDataStructure {
       }
     }
 
+    // Skip self-referential equivalencies that would create infinite loops.
+    // Case 1: Direct self-reference (path === equivalentPath)
+    // FunctionCallManager adds equivalency(subPath, subPath, externalFunctionName, ...)
+    // For simple calls like buildBranchFileMap(), this is fine.
+    // But for chained calls like query.where().where().where(), each method call adds
+    // a .functionCallReturnValue segment, and the equivalency processing creates an infinite loop.
+    // We detect chained calls by counting .functionCallReturnValue occurrences in the path.
+    if (
+      path === equivalentPath &&
+      equivalencyReason === 'equivalency to external function call'
+    ) {
+      // Count how many .functionCallReturnValue segments are in the path
+      const functionCallReturnValueCount = (
+        path.match(/\.functionCallReturnValue/g) || []
+      ).length;
+      // Skip if there are multiple chained calls (2+ .functionCallReturnValue segments)
+      if (functionCallReturnValueCount >= 2) {
+        return;
+      }
+    }
+
+    // Case 2: Circular reference where equivalentPath contains path as a prefix
+    // e.g., path="query" and equivalentPath="query.where(...).functionCallReturnValue"
+    // This happens with method chaining patterns where a variable is reassigned to
+    // the result of a method call on itself: query = query.where(...)
+    // Resolving this equivalency would require resolving query first, creating infinite recursion.
+    if (
+      equivalentPath.startsWith(path + '.') ||
+      equivalentPath.startsWith(path + '(')
+    ) {
+      return;
+    }
+
     if (!equivalentScopeName) {
       console.warn('Debug Propagation: missing equivalent scope name', {
         path,
@@ -1295,6 +1340,23 @@ export class ScopeDataStructure {
     return this.pathManager.joinPathParts(pathParts);
   }
 
+  /**
+   * Extracts the root variable name from a path.
+   * E.g., "collected[]" -> "collected", "foo.bar" -> "foo", "collected[0]" -> "collected"
+   */
+  extractRootVariable(path: string): string | null {
+    const parts = this.splitPath(path);
+    if (parts.length === 0) return null;
+
+    const firstPart = parts[0];
+    // Strip array notation: "collected[]" -> "collected", "collected[0]" -> "collected"
+    const bracketIndex = firstPart.indexOf('[');
+    if (bracketIndex > 0) {
+      return firstPart.substring(0, bracketIndex);
+    }
+    return firstPart;
+  }
+
   // PRIVATE METHODS //
 
   private uniqueId(params: {
@@ -1390,6 +1452,41 @@ export class ScopeDataStructure {
     const { isolatedStructure, isolatedEquivalentVariables } =
       scopeNode.analysis;
 
+    // DEBUG: Log all equivalencies related to useFetcher
+    if (
+      Object.keys(isolatedEquivalentVariables || {}).some(
+        (k) => k.includes('Fetcher') || k.includes('fetcher'),
+      )
+    ) {
+      console.log(
+        'CodeYam DEBUG determineEquivalenciesAndBuildSchema:',
+        JSON.stringify(
+          {
+            scopeNodeName: scopeNode.name,
+            fetcherEquivalencies: Object.entries(
+              isolatedEquivalentVariables || {},
+            )
+              .filter(
+                ([k, v]) =>
+                  k.includes('Fetcher') ||
+                  k.includes('fetcher') ||
+                  String(v).includes('Fetcher') ||
+                  String(v).includes('fetcher'),
+              )
+              .reduce(
+                (acc, [k, v]) => {
+                  acc[k] = v;
+                  return acc;
+                },
+                {} as Record<string, string>,
+              ),
+          },
+          null,
+          2,
+        ),
+      );
+    }
+
     const allPaths = Array.from(
       new Set([
         ...Object.keys(isolatedStructure || {}),
@@ -1416,6 +1513,47 @@ export class ScopeDataStructure {
           'original equivalency',
         );
 
+        // Propagate equivalencies involving parent-scope variables to those parent scopes.
+        // This handles patterns like: collected.push({...entity}) where 'collected' is defined
+        // in a parent scope. The equivalency collected[] -> push().signature[0] needs to be
+        // visible when tracing from the parent scope.
+        const rootVariable = this.extractRootVariable(path);
+        const equivalentRootVariable =
+          this.extractRootVariable(equivalentValue);
+
+        // Skip propagation for self-referential reassignment patterns like:
+        //   x = x.method().functionCallReturnValue
+        // where the path IS the variable itself (not a sub-path like x[] or x.prop).
+        // These create circular references since both sides reference the same variable.
+        //
+        // But DO propagate for patterns like collected[] -> collected.push(...).signature[0]
+        // where the path has additional segments beyond the root variable.
+        const pathIsJustRootVariable = path === rootVariable;
+        const isSelfReferentialReassignment =
+          pathIsJustRootVariable && rootVariable === equivalentRootVariable;
+
+        if (
+          rootVariable &&
+          !isSelfReferentialReassignment &&
+          scopeNode.parentInstantiatedVariables?.includes(rootVariable)
+        ) {
+          // Find the parent scope where this variable is defined
+          for (const parentScopeName of scopeNode.tree || []) {
+            const parentScope = this.scopeNodes[parentScopeName];
+            if (parentScope?.instantiatedVariables?.includes(rootVariable)) {
+              // Add the equivalency to the parent scope as well
+              this.addEquivalency(
+                path,
+                equivalentValue,
+                scopeNode.name, // The equivalent path's scope remains the child scope
+                parentScope, // But store it in the parent scope's equivalencies
+                'propagated parent-variable equivalency',
+              );
+              break;
+            }
+          }
+        }
+
         // Propagate sub-property equivalencies when the equivalentValue is a simple variable
         // that has sub-properties defined in the isolatedEquivalentVariables.
         // This handles cases like: dataItem={{ structure: completeDataStructure }}
@@ -1492,6 +1630,16 @@ export class ScopeDataStructure {
             scopeNode,
             allPaths,
           );
+
+          // Track which variable receives the return value of each function call
+          // This enables generating separate mock data for each call site
+          this.trackReceivingVariable(path, equivalentValue);
+        }
+
+        // Also track variables that receive destructured properties from function call return values
+        // e.g., "userData" -> "db.query('users').functionCallReturnValue.data"
+        if (equivalentValue.includes('.functionCallReturnValue.')) {
+          this.trackReceivingVariable(path, equivalentValue);
         }
       }
     }
@@ -1562,6 +1710,86 @@ export class ScopeDataStructure {
     }
   }
 
+  /**
+   * Tracks which variable receives the return value of a function call.
+   *
+   * When we encounter an equivalency like:
+   *   result1 -> db.select(query1).functionCallReturnValue
+   *
+   * This method extracts the call signature (db.select(query1)) and maps it
+   * to the receiving variable (result1) on the corresponding FunctionCallInfo.
+   *
+   * This enables generating separate mock data for each call site when the same
+   * function is called multiple times with different arguments.
+   */
+  private trackReceivingVariable(
+    receivingVariable: string,
+    equivalentValue: string,
+  ): void {
+    // Extract the call signature by finding the .functionCallReturnValue part
+    // and taking everything before it
+    // Handles both:
+    //   "db.select(query1).functionCallReturnValue" -> "db.select(query1)"
+    //   "db.query('users').functionCallReturnValue.data" -> "db.query('users')"
+    const funcReturnIdx = equivalentValue.indexOf('.functionCallReturnValue');
+    if (funcReturnIdx === -1) {
+      return;
+    }
+    const callSignature = equivalentValue.substring(0, funcReturnIdx);
+
+    // Skip if the receiving variable is not a simple identifier
+    // (e.g., skip if it's a path like "obj.property" or contains array access)
+    if (receivingVariable.includes('.') || receivingVariable.includes('[')) {
+      return;
+    }
+
+    // Find the FunctionCallInfo that matches this call signature
+    const searchKey = getFunctionCallRoot(callSignature);
+    const functionCallInfo =
+      this.getExternalFunctionCallsIndex().get(searchKey);
+
+    // DEBUG: Track useFetcher calls
+    if (searchKey === 'useFetcher' || callSignature.includes('useFetcher')) {
+      console.log(
+        'CodeYam DEBUG trackReceivingVariable:',
+        JSON.stringify(
+          {
+            receivingVariable,
+            equivalentValue,
+            callSignature,
+            searchKey,
+            foundFunctionCallInfo: !!functionCallInfo,
+            existingRecvVars: functionCallInfo?.receivingVariableNames,
+            existingCallSigToVar: functionCallInfo?.callSignatureToVariable,
+          },
+          null,
+          2,
+        ),
+      );
+    }
+
+    if (!functionCallInfo) {
+      return;
+    }
+
+    // Initialize arrays if needed
+    if (!functionCallInfo.receivingVariableNames) {
+      functionCallInfo.receivingVariableNames = [];
+    }
+    if (!functionCallInfo.callSignatureToVariable) {
+      functionCallInfo.callSignatureToVariable = {};
+    }
+
+    // Add the receiving variable to the list (if not already present)
+    if (!functionCallInfo.receivingVariableNames.includes(receivingVariable)) {
+      functionCallInfo.receivingVariableNames.push(receivingVariable);
+    }
+
+    // Map the call signature to its receiving variable
+    // Use the full call signature (not the search key) for precise mapping
+    functionCallInfo.callSignatureToVariable[callSignature] = receivingVariable;
+  }
+
   /**
    * Propagates returnValue.* sub-properties from a callback scope to the usage path.
    *
@@ -3458,6 +3686,9 @@ export class ScopeDataStructure {
               {} as Record<string, SerializableScopeVariable[]>,
             )
           : undefined,
+        allCallSignatures: efc.allCallSignatures,
+        receivingVariableNames: efc.receivingVariableNames,
+        callSignatureToVariable: efc.callSignatureToVariable,
       }));
 
     // Get root function result

package/analyzer-template/packages/ai/src/lib/dataStructure/equivalencyManagers/FunctionCallManager.ts

@@ -439,6 +439,27 @@ export default class FunctionCallManager implements EquivalencyManager {
             scopeNode,
             externalFunctionCallInfo,
           );
+        } else {
+          // Even if an entry exists, we need to register this call signature
+          // so it gets merged into allCallSignatures. This handles multiple
+          // calls to the same function (e.g., multiple useFetcher() calls).
+          const newFunctionCallInfo = {
+            name: functionCallRoot,
+            callSignature: functionCallSignature,
+            callScope: equivalencyValueChain[0].currentPath.scopeNodeName,
+            schema: {},
+            equivalencies: {},
+          };
+          if (traceId && debugLevel > 0) {
+            console.info(
+              'Debug Propagation: addFunctionCall external (merge)',
+              {
+                existingCallSignature: externalFunctionCallInfo.callSignature,
+                newCallSignature: functionCallSignature,
+              },
+            );
+          }
+          scopeDataStructure.addFunctionCall(scopeNode, newFunctionCallInfo);
         }
 
         if (traceId && debugLevel > 0) {
@@ -456,13 +477,22 @@ export default class FunctionCallManager implements EquivalencyManager {
 
         propagated = true;
 
-        scopeDataStructure.addEquivalency(
-          subPath,
-          subPath,
-          externalFunctionCallInfo.name,
-          scopeNode,
-          'equivalency to external function call',
-        );
+        // Skip self-referential equivalencies for chained external function calls.
+        // For chained calls like query.where().where(), each method call adds a
+        // .functionCallReturnValue segment. Processing these creates infinite loops.
+        // We only add the equivalency for simple calls (0-1 .functionCallReturnValue segments).
+        const functionCallReturnValueCount = (
+          subPath.match(/\.functionCallReturnValue/g) || []
+        ).length;
+        if (functionCallReturnValueCount < 2) {
+          scopeDataStructure.addEquivalency(
+            subPath,
+            subPath,
+            externalFunctionCallInfo.name,
+            scopeNode,
+            'equivalency to external function call',
+          );
+        }
 
         if (subPathParts[subPathParts.length - 1].startsWith('signature[')) {
           externalFunctionCallInfo.equivalencies[subPath] ||= [];

package/analyzer-template/packages/ai/src/lib/dataStructure/equivalencyManagers/frameworks/ReactFrameworkManager.ts

@@ -251,9 +251,9 @@ export class ReactFrameworkManager implements EquivalencyManager {
               equivalentPathParts[0].replace(existingFunctionName, ''),
             ...equivalentPathParts.slice(1),
           ]);
-          for (const equivalentValue of scopeNode.equivalencies[
-            equivalentPath
-          ]) {
+          const equivalenciesToReroute =
+            scopeNode.equivalencies[equivalentPath] ?? [];
+          for (const equivalentValue of equivalenciesToReroute) {
             scopeDataStructure.removeEquivalency(
               equivalentPath,
               equivalentValue,
@@ -273,7 +273,9 @@ export class ReactFrameworkManager implements EquivalencyManager {
           equivalentPath = newEquivalentPath;
         }
 
-        for (const equivalentValue of scopeNode.equivalencies[equivalentPath]) {
+        const equivalenciesToModify =
+          scopeNode.equivalencies[equivalentPath] ?? [];
+        for (const equivalentValue of equivalenciesToModify) {
           if (equivalentValue.scopeNodeName === useCallbackScopeInfoName) {
             modifiedEquivalencies = true;
             equivalentValue.scopeNodeName =

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/cleanNonObjectFunctions.ts

@@ -702,13 +702,16 @@ function handleFunctionMapping(
     }
 
     // Don't add [] element for ambiguous methods without other array evidence
+    // Also don't add [] if the path was already identified as a string type
     const methodName = getMethodName(lastPart);
     const isAmbiguousMethod = ambiguousArrayMethodsSet.has(methodName);
+    const isStringType = keyMapping[previousPath] === 'string';
     if (
       !isValidFunctionCall(previousPart) &&
       arrayMethodsSet.has(methodName) &&
       !keyMapping[previousPath + '[]'] &&
-      !isAmbiguousMethod
+      !isAmbiguousMethod &&
+      !isStringType
     ) {
       keyMapping[previousPath + '[]'] = 'unknown';
     }

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/convertDotNotation.ts

@@ -26,7 +26,6 @@ export default function convertDotNotation(
     const parts = splitOutsideParenthesesAndArrays(rawPath);
     if (!parts || parts.length === 0) continue;
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let cursor: any = result;
 
     for (let i = 0; i < parts.length; i++) {
@@ -181,8 +180,9 @@ export default function convertDotNotation(
           if (!isSkippableLeafType(typ)) {
             cursor[key] = [typ];
           } else {
-            // structural/placeholder subtype — ensure array exists but don't clobber
-            if (!Array.isArray(cursor[key])) cursor[key] = [];
+            // structural/placeholder subtype — ensure array exists but don't clobber existing values
+            // Only create an array if nothing exists yet; preserve concrete types like 'string'
+            if (cursor[key] === undefined) cursor[key] = [];
           }
           i++; // consume '[]'
         } else {

package/analyzer-template/packages/ai/src/lib/dataStructure/helpers/getFunctionCallRoot.ts

@@ -1,11 +1,41 @@
 import { splitOutsideParenthesesAndArrays } from '../../splitOutsideParentheses';
 
+/**
+ * Find the position of the first '(' that is NOT inside angle brackets.
+ * Returns -1 if not found.
+ */
+function findFirstParenOutsideTypeParams(signature: string): number {
+  let angleDepth = 0;
+
+  for (let i = 0; i < signature.length; i++) {
+    const char = signature[i];
+
+    if (char === '<') {
+      angleDepth++;
+    } else if (char === '>') {
+      angleDepth--;
+    } else if (char === '(' && angleDepth === 0) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
 export default function getFunctionCallRoot(functionCallSignature: string) {
   const functionCallSignatureParts = splitOutsideParenthesesAndArrays(
     functionCallSignature,
   );
 
-  return functionCallSignatureParts[0]
-    .replace(/(cyScope\d+)F/, '$1')
-    .split('(')[0];
+  const firstPart = functionCallSignatureParts[0];
+
+  // Find the first '(' that's not inside type parameters (angle brackets)
+  // This handles cases like "useFetcher<{ data: UserData | null }>()"
+  // which should return "useFetcher<{ data: UserData | null }>"
+  // (preserving type params for scope node matching)
+  const parenPos = findFirstParenOutsideTypeParams(firstPart);
+
+  const result = parenPos >= 0 ? firstPart.substring(0, parenPos) : firstPart;
+
+  return result.replace(/(cyScope\d+)F/, '$1');
 }

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

@@ -1,4 +1,9 @@
-import { Entity, ReadonlyAnalysis, ReadonlyAnalysisMap } from '~codeyam/types';
+import {
+  DataStructure,
+  Entity,
+  ReadonlyAnalysis,
+  ReadonlyAnalysisMap,
+} from '~codeyam/types';
 import {
   joinParenthesesAndArrays,
   splitOutsideParenthesesAndArrays,
@@ -7,6 +12,7 @@ import { gatherAttributesMap } from './promptGenerators/gatherAttributesMap';
 
 export default function gatherRelevantDependentKeyAttributes(
   entity: Pick<Entity, 'name' | 'metadata'>,
+  mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>,
   dependentAnalyses: ReadonlyAnalysisMap,
 ) {
   // console.info(
@@ -52,10 +58,16 @@ export default function gatherRelevantDependentKeyAttributes(
   //   ),
   // );
 
-  const { associationMap } = gatherAttributesMap(entity);
+  const isolatedDataStructure = entity.metadata?.isolatedDataStructure;
+  const equivalentSignatureVariables =
+    isolatedDataStructure?.equivalentSignatureVariables ?? {};
+  const { associationMap } = gatherAttributesMap(
+    isolatedDataStructure ?? mergedDataStructure,
+    mergedDataStructure,
+    equivalentSignatureVariables,
+  );
 
-  const dependencySchemas =
-    entity.metadata?.isolatedDataStructure?.dependencySchemas;
+  const dependencySchemas = mergedDataStructure?.dependencySchemas;
   const relevantDependentKeyAttributes: ReadonlyAnalysis['metadata']['keyAttributes'][0][] =
     [];
   Object.keys(dependentAnalyses).forEach((path) => {

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

@@ -29,8 +29,17 @@ export default async function generateChangesEntityKeyAttributes({
     existingKeyAttributes: existingKeyAttributes?.map((a) => a.externalPath),
   });
 
+  const isolatedDataStructure = entity.metadata?.isolatedDataStructure;
+  const mergedDataStructure = analysis.metadata.mergedDataStructure;
+  const equivalentSignatureVariables =
+    isolatedDataStructure?.equivalentSignatureVariables ?? {};
   const { attributesMap, associationMap, dataStructurePathMap } =
-    gatherAttributesMap(entity, true);
+    gatherAttributesMap(
+      isolatedDataStructure ?? mergedDataStructure,
+      mergedDataStructure,
+      equivalentSignatureVariables,
+      true,
+    );
 
   const prompt = generateEntityKeyAttributesGenerator({
     code: entity.code,
@@ -102,6 +111,9 @@ export default async function generateChangesEntityKeyAttributes({
       description: addedKeyAttribute.description,
       validValueOptions: addedKeyAttribute.validValueOptions,
       errorValueOptions: addedKeyAttribute.errorValueOptions,
+      // Preserve new fields from LLM response
+      valueType: addedKeyAttribute.valueType,
+      dependencies: addedKeyAttribute.dependencies,
     };
     if (index !== -1) {
       keyAttributes.splice(index, 1, fullKeyAttribute);
@@ -167,6 +179,14 @@ Note: A conditional that shows a different UI state (e.g., loading screen, redir
 
 Only return attributes from the "Attributes and Value Types" list—these are the only values we can control. Use the exact path provided. Use \`functionCallReturnValue\` for function return values. Use \`[]\` for array items (e.g., \`items[]\`).
 
+## Dependencies
+
+If this key attribute is only used if one or more other attributes have specific values, include those dependencies in a \`dependencies\` array.
+
+## Value Type
+
+Should reiterate the type of the attribute (e.g., "string", "object", "array", "boolean", etc.) based on the "Attributes and Value Types" list.
+
 ## Response Format
 
 For \`validValueOptions\`, include boundary/extreme values that trigger different behavior—but NOT values that would cause errors.
@@ -177,6 +197,10 @@ For \`validValueOptions\`, include boundary/extreme values that trigger differen
     {
       "path": "user",
       "description": "Controls whether the main form or redirect screen displays",
+      "dependencies": [
+        { "projectId": "must be a valid project ID for 'user' to have effect" }
+      ],
+      "valueType": "object",
       "validValueOptions": ["truthy user object", "null/undefined"]
     }
   ],
@@ -214,6 +238,14 @@ NOT key attributes:
 
 Only return attributes from the "Attributes and Value Types" list—these are the only values we can control. Use the exact path provided. Use \`functionCallReturnValue\` for function return values. Use \`[]\` for array items (e.g., \`items[]\`).
 
+## Dependencies
+
+If this key attribute is only used if one or more other attributes have specific values, include those dependencies in a \`dependencies\` array.
+
+## Value Type
+
+Should reiterate the type of the attribute (e.g., "string", "object", "array", "boolean", etc.) based on the "Attributes and Value Types" list.
+
 ## Response Format
 
 For \`validValueOptions\`, include boundary/extreme values that trigger different behavior—but NOT values that would cause errors.
@@ -224,6 +256,10 @@ For \`validValueOptions\`, include boundary/extreme values that trigger differen
     {
       "path": "config.enabled",
       "description": "Controls whether the main processing logic runs",
+      "dependencies": [
+        { "analysisMode": "must be 'full' for 'enabled' to have effect" }
+      ],
+      "valueType": "boolean",
       "validValueOptions": ["true", "false"]
     }
   ],

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

@@ -328,7 +328,7 @@ const generateChangesSystemMessage = (
 Preserve existing data and only modify what's necessary for the new structure.
 - If structure unchanged and data sufficient, return empty data: \`{ "data": {} }\`
 - If new fields added, fill them with realistic values
-- Fill ALL fields with realistic values (except error attributes)
+- Fill ALL fields with realistic values (except error attributes and key attributes set to null or undefined)
 - NEVER include "error" fields—omit entirely`
     : `## Non-Default Scenario (Incremental Update)
 Preserve existing data and only modify what changed.
@@ -365,8 +365,11 @@ Use simple elements only (\`<div>\`, \`<span>\`). No custom components.
 { "onClick": { "~~codeyam-code~~": "() => console.log('clicked')" } }
 \`\`\`
 
-## Function Keys
-Preserve function call syntax exactly as written in the structure.
+## Mock Data Keys
+Preserve keys exactly as written in the structure. There are two formats:
+- Standard function calls: \`"useUser()"\`, \`"from().select()"\`
+- Variable-qualified calls (for multiple calls to the same function): \`"entityDiffFetcher <- useFetcher"\`
+  This reads as "entityDiffFetcher receives from useFetcher". Each variable gets distinct mock data.
 
 ## Response Format
 \`\`\`json

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

@@ -46,6 +46,7 @@ export default async function generateChangesEntityScenarios({
 }: GenerateChangesEntityScenariosArgs) {
   const relevantDependentKeyAttributes = gatherRelevantDependentKeyAttributes(
     entity,
+    analysis.metadata.mergedDataStructure,
     dependentAnalyses,
   );
   if (
@@ -71,6 +72,7 @@ export default async function generateChangesEntityScenarios({
 
   const prompt = generateChangesEntityScenariosGenerator({
     entity,
+    mergedDataStructure: analysis.metadata.mergedDataStructure,
     keyAttributes,
     addedKeyAttributes,
     removedKeyAttributes,

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

@@ -23,9 +23,13 @@ export default async function generateEntityDataStructure({
   //   // code: entity.code.length,
   // });
 
-  const fileScope = isolateScopes(fileAnalyzer.sourceFile.getText(), {
+  // Use getFullText() to include leading trivia (comments/whitespace) so that
+  // positions from isolateScopes match AST node positions which include trivia
+  const fileText = fileAnalyzer.sourceFile.getFullText();
+  const fileScope = isolateScopes(fileText, {
     entityNames: [entity.name],
   });
+
   let entityScope =
     fileScope.name === entity.name
       ? fileScope
@@ -39,12 +43,10 @@ export default async function generateEntityDataStructure({
   }
 
   if (!entityScope) {
-    if (entity.code === fileAnalyzer.sourceFile.getText()) {
+    if (entity.code === fileText) {
       entityScope = fileScope;
     } else {
-      const entityStartIndex = fileAnalyzer.sourceFile
-        .getText()
-        .indexOf(entity.code);
+      const entityStartIndex = fileText.indexOf(entity.code);
       const entityIndex = entityStartIndex + entity.code.length / 2;
       entityScope = Object.values(fileScope.childScopes).find(
         (s) => entityIndex > s.start && entityIndex < s.end,