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

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, {
+  ExecutionFlowSelection,
+} from './promptGenerators/guessNewScenarioDataFromDescriptionGenerator';
 import guessEditScenarioDataFromDescriptionGenerator from './promptGenerators/guessEditScenarioDataFromDescriptionGenerator';
 import { AI, DEFAULT_LARGER_MODEL } from '~codeyam/ai';
 import { parseJsonSafe } from './parsers/parseJsonSafe';
 
+export type { ExecutionFlowSelection };
+
 export interface GuessScenarioDataFromDescriptionArgs {
   description: string;
   editingMockName?: string;
   editingMockData?: { [key: string]: unknown };
   existingScenarios: Scenario[];
   scenariosDataStructure: ScenariosDataStructure;
+  flowSelections?: ExecutionFlowSelection[];
   model?: AI.Model;
 }
 
@@ -22,6 +26,7 @@ export default async function generateEntityScenarios({
   editingMockData,
   existingScenarios,
   scenariosDataStructure,
+  flowSelections,
   model,
 }: GuessScenarioDataFromDescriptionArgs): Promise<
   Scenario['metadata']['data'] | null
@@ -38,6 +43,7 @@ export default async function generateEntityScenarios({
         description,
         existingScenarios,
         scenariosDataStructure,
+        flowSelections,
       });
 
   const response = await completionCall({

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

@@ -119,6 +119,16 @@ function processScope({
   }
   const childScopesRanges: ChildRange[] = [];
 
+  // Extract gating conditions BEFORE any JSX is extracted into child scopes
+  // This ensures we capture conditions like {cond && <ChildComponent />}
+  // before the JSX is replaced with placeholders.
+  // Only extract when maxJSXLimit > 0 (i.e., when JSX will actually be extracted).
+  const extractedGatingConditions: ScopeInfo['extractedGatingConditions'] = {};
+
+  if (maxJSXLimit > 0) {
+    extractGatingConditionsFromJsx(node, sourceFile, extractedGatingConditions);
+  }
+
   const addChildScopesRange = ({
     start,
     end,
@@ -726,6 +736,10 @@ function processScope({
     text: modifiedText,
     variables: Array.from(variables),
     childScopes,
+    // Include gating conditions if any were found
+    ...(Object.keys(extractedGatingConditions).length > 0 && {
+      extractedGatingConditions,
+    }),
   };
 }
 
@@ -772,7 +786,11 @@ export default function isolateScopes(
   // }
   // logChildIds(isolatedScopes);
 
-  processJSXForScope(isolatedScopes, generateSyntheticName);
+  // Process JSX for the root scope only (not child scopes)
+  // Child scopes contain callback functions that should preserve their JSX
+  // for analysis - gating conditions are now detected in processScope BEFORE extraction
+  const jsxLimit = options?.jsxLimit ?? 10;
+  processJSXForScope(isolatedScopes, generateSyntheticName, jsxLimit);
 
   // If the root scope text is empty and there's only one child scope,
   // return that child scope as the root scope
@@ -800,9 +818,224 @@ export default function isolateScopes(
  * Any errors during parsing are caught and logged, ensuring robust handling
  * of invalid or unexpected input.
  */
+/**
+ * Helper to get the component name from a JSX element (returns null for intrinsic elements like 'div')
+ */
+function getJsxComponentName(
+  node: ts.JsxElement | ts.JsxSelfClosingElement,
+  sourceFile: ts.SourceFile,
+): string | null {
+  let tagName: string;
+  if (ts.isJsxElement(node)) {
+    tagName = node.openingElement.tagName.getText(sourceFile);
+  } else {
+    tagName = node.tagName.getText(sourceFile);
+  }
+  // Intrinsic elements start with lowercase
+  if (tagName[0] === tagName[0].toLowerCase()) {
+    return null;
+  }
+  return tagName;
+}
+
+/**
+ * Helper to extract a simple path string from an expression (for gating conditions)
+ */
+function getSimplePathFromExpression(
+  expr: ts.Expression,
+  sourceFile: ts.SourceFile,
+): string | null {
+  // Unwrap parentheses
+  while (ts.isParenthesizedExpression(expr)) {
+    expr = expr.expression;
+  }
+
+  if (ts.isIdentifier(expr)) {
+    return expr.text;
+  }
+  if (ts.isPropertyAccessExpression(expr)) {
+    const base = getSimplePathFromExpression(expr.expression, sourceFile);
+    if (base) {
+      return `${base}.${expr.name.text}`;
+    }
+  }
+  if (ts.isBinaryExpression(expr)) {
+    // For comparisons like `x === 'value'`, return the left side path
+    if (
+      expr.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+      expr.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken
+    ) {
+      return getSimplePathFromExpression(expr.left, sourceFile);
+    }
+    // For && chains, try to get a path from either side
+    if (expr.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+      return (
+        getSimplePathFromExpression(expr.left, sourceFile) ||
+        getSimplePathFromExpression(expr.right, sourceFile)
+      );
+    }
+  }
+  return null;
+}
+
+/**
+ * Extracts gating conditions from JSX before it's extracted into child scopes.
+ * This detects patterns like:
+ * - {condition && <Component />}
+ * - {condition ? <ComponentA /> : <ComponentB />}
+ * - {a ? <A/> : b ? <B/> : <C/>} (chained ternaries)
+ */
+function extractGatingConditionsFromJsx(
+  node: ts.Node,
+  sourceFile: ts.SourceFile,
+  gatingConditions: ScopeInfo['extractedGatingConditions'],
+): void {
+  // Process JSX expression children like {condition && <Component />}
+  const processJsxExpression = (expr: ts.Expression): void => {
+    // Unwrap parentheses
+    while (ts.isParenthesizedExpression(expr)) {
+      expr = expr.expression;
+    }
+
+    // Handle && chains: {condition && <Component />}
+    if (
+      ts.isBinaryExpression(expr) &&
+      expr.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+    ) {
+      // The right side might be JSX or another && expression
+      let rightExpr = expr.right;
+      while (ts.isParenthesizedExpression(rightExpr)) {
+        rightExpr = rightExpr.expression;
+      }
+
+      if (ts.isJsxElement(rightExpr) || ts.isJsxSelfClosingElement(rightExpr)) {
+        const componentName = getJsxComponentName(rightExpr, sourceFile);
+        if (componentName) {
+          // Extract all conditions from the && chain
+          const extractConditions = (e: ts.Expression): string[] => {
+            while (ts.isParenthesizedExpression(e)) {
+              e = e.expression;
+            }
+            if (
+              ts.isBinaryExpression(e) &&
+              e.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+            ) {
+              // Check if right side is JSX (terminal) or more conditions
+              let right = e.right;
+              while (ts.isParenthesizedExpression(right)) {
+                right = right.expression;
+              }
+              if (ts.isJsxElement(right) || ts.isJsxSelfClosingElement(right)) {
+                // Right is JSX, so left contains all conditions
+                return extractConditions(e.left);
+              }
+              // Both sides are conditions
+              return [
+                ...extractConditions(e.left),
+                ...extractConditions(e.right),
+              ];
+            }
+            const path = getSimplePathFromExpression(e, sourceFile);
+            return path ? [path] : [];
+          };
+
+          const conditions = extractConditions(expr.left);
+          if (!gatingConditions![componentName]) {
+            gatingConditions![componentName] = [];
+          }
+          for (const path of conditions) {
+            gatingConditions![componentName].push({
+              path,
+              conditionType: 'truthiness',
+              location: 'logical-and',
+            });
+          }
+        }
+      }
+    }
+
+    // Handle ternaries: {condition ? <A /> : <B />}
+    if (ts.isConditionalExpression(expr)) {
+      processConditionalExpression(expr, sourceFile, gatingConditions, false);
+    }
+  };
+
+  // Recursive function to handle chained ternaries
+  const processConditionalExpression = (
+    expr: ts.ConditionalExpression,
+    sf: ts.SourceFile,
+    gc: ScopeInfo['extractedGatingConditions'],
+    parentConditionNegated: boolean,
+  ): void => {
+    const conditionPath = getSimplePathFromExpression(expr.condition, sf);
+
+    // Process whenTrue branch
+    let whenTrue = expr.whenTrue;
+    while (ts.isParenthesizedExpression(whenTrue)) {
+      whenTrue = whenTrue.expression;
+    }
+    if (ts.isJsxElement(whenTrue) || ts.isJsxSelfClosingElement(whenTrue)) {
+      const componentName = getJsxComponentName(whenTrue, sf);
+      if (componentName && conditionPath) {
+        if (!gc![componentName]) {
+          gc![componentName] = [];
+        }
+        gc![componentName].push({
+          path: conditionPath,
+          conditionType: 'truthiness',
+          location: 'ternary',
+          isNegated: false,
+        });
+      }
+    }
+
+    // Process whenFalse branch
+    let whenFalse = expr.whenFalse;
+    while (ts.isParenthesizedExpression(whenFalse)) {
+      whenFalse = whenFalse.expression;
+    }
+
+    if (ts.isJsxElement(whenFalse) || ts.isJsxSelfClosingElement(whenFalse)) {
+      const componentName = getJsxComponentName(whenFalse, sf);
+      if (componentName && conditionPath) {
+        if (!gc![componentName]) {
+          gc![componentName] = [];
+        }
+        gc![componentName].push({
+          path: conditionPath,
+          conditionType: 'truthiness',
+          location: 'ternary',
+          isNegated: true, // else branch = negated condition
+        });
+      }
+    } else if (ts.isConditionalExpression(whenFalse)) {
+      // Chained ternary: a ? <A/> : b ? <B/> : <C/>
+      // Recursively process the nested ternary
+      processConditionalExpression(whenFalse, sf, gc, true);
+    }
+  };
+
+  // Traverse JSX children to find expressions
+  let jsxExpressionCount = 0;
+  let ternaryCount = 0;
+  const traverseJsx = (n: ts.Node): void => {
+    if (ts.isJsxExpression(n) && n.expression) {
+      jsxExpressionCount++;
+      if (ts.isConditionalExpression(n.expression)) {
+        ternaryCount++;
+      }
+      processJsxExpression(n.expression);
+    }
+    ts.forEachChild(n, traverseJsx);
+  };
+
+  traverseJsx(node);
+}
+
 function processJSXForScope(
   scope: ScopeInfo,
   generateSyntheticName: () => string,
+  jsxLimit: number = 10,
 ) {
   // Parse the scope text as a TypeScript AST to find JSX elements
   const scopeText = scope.text;
@@ -818,6 +1051,34 @@ function processJSXForScope(
       ts.ScriptKind.TSX,
     );
 
+    // Extract gating conditions BEFORE extraction (while JSX is still complete)
+    const gatingConditions: ScopeInfo['extractedGatingConditions'] = {};
+
+    extractGatingConditionsFromJsx(
+      tempSourceFile,
+      tempSourceFile,
+      gatingConditions,
+    );
+
+    // Merge with any existing gating conditions from processScope
+    // (processScope extracts from original text, this extracts from modified text)
+    if (Object.keys(gatingConditions).length > 0) {
+      if (scope.extractedGatingConditions) {
+        for (const [componentName, conditions] of Object.entries(
+          gatingConditions,
+        )) {
+          if (scope.extractedGatingConditions[componentName]) {
+            // Merge conditions, avoiding duplicates
+            scope.extractedGatingConditions[componentName].push(...conditions);
+          } else {
+            scope.extractedGatingConditions[componentName] = conditions;
+          }
+        }
+      } else {
+        scope.extractedGatingConditions = gatingConditions;
+      }
+    }
+
     const nodeMap = new Map<ts.Node, string>();
 
     // Find all JSX elements in this scope without recursing into child scopes
@@ -841,6 +1102,7 @@ function processJSXForScope(
       end: number;
       id: string;
       code: string;
+      jsxTagName?: string;
     }> = [];
 
     for (const [node, id] of nodeMap.entries()) {
@@ -848,13 +1110,23 @@ function processJSXForScope(
       const nodeEnd = node.getEnd();
       const code = node.getText(tempSourceFile);
 
-      // Only process reasonably sized JSX elements
-      if (code.length > 10) {
+      // Extract the JSX tag name
+      let jsxTagName: string | undefined;
+      if (ts.isJsxElement(node)) {
+        const tagNameNode = node.openingElement.tagName;
+        jsxTagName = tagNameNode.getText(tempSourceFile);
+      } else if (ts.isJsxSelfClosingElement(node)) {
+        jsxTagName = node.tagName.getText(tempSourceFile);
+      }
+
+      // Only process JSX elements larger than the limit
+      if (code.length > jsxLimit) {
         replacements.push({
           start: scopeStart + nodeStart,
           end: scopeStart + nodeEnd,
           id,
           code,
+          jsxTagName,
         });
       }
     }
@@ -876,6 +1148,7 @@ function processJSXForScope(
         end: replacement.end,
         variables: [],
         childScopes: {},
+        jsxTagName: replacement.jsxTagName,
       };
 
       // Replace in text

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

@@ -166,6 +166,12 @@ export default function mergeStatements(statements: Statement[]) {
     return acc;
   }, {});
 
+  // Track variable reassignments: when a variable is reassigned (creating ::cyDuplicateKey::),
+  // subsequent references to that variable in VALUES should use the duplicate key.
+  // This ensures configData → fetcher.data.data uses the FIRST fetcher, while
+  // settingsData → fetcher.data.data uses fetcher::cyDuplicateKey1::.data.data
+  const activeRemappings: Record<string, string> = {};
+
   const equivalentVariables = statements.reduce((acc: any, result) => {
     for (const [key, value] of Object.entries(
       result.equivalentVariables ?? {},
@@ -196,16 +202,40 @@ export default function mergeStatements(statements: Statement[]) {
     for (const [key, value] of Object.entries(
       result.equivalentVariables ?? {},
     )) {
+      // 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);
+        }
+      }
+
       if (acc[key]) {
-        if (acc[key] === value) continue;
+        if (acc[key] === remappedValue) continue;
 
         let duplicateId = 1;
         while (acc[`${key}::cyDuplicateKey${duplicateId}::`]) {
           duplicateId++;
         }
-        acc[`${key}::cyDuplicateKey${duplicateId}::`] = value;
+        const duplicateKey = `${key}::cyDuplicateKey${duplicateId}::`;
+        acc[duplicateKey] = remappedValue;
+
+        // Track this remapping for subsequent statements
+        // Any future references to 'key' in VALUES should use duplicateKey instead
+        activeRemappings[key] = duplicateKey;
       } else {
-        acc[key] = value;
+        acc[key] = remappedValue;
       }
     }
     return acc;

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;
         }