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

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

@@ -5,6 +5,140 @@ import { ScopeDataStructure, ScopeNode } from '../ScopeDataStructure';
 import { AddEquivalenciesInfo, EquivalencyManager } from './EquivalencyManager';
 import getFunctionCallRoot from '../helpers/getFunctionCallRoot';
 
+// JSX intrinsic elements (HTML/SVG) that should not be treated as function calls
+const HTML_INTRINSIC_ELEMENTS = new Set([
+  'a',
+  'abbr',
+  'address',
+  'area',
+  'article',
+  'aside',
+  'audio',
+  'b',
+  'base',
+  'bdi',
+  'bdo',
+  'blockquote',
+  'body',
+  'br',
+  'button',
+  'canvas',
+  'caption',
+  'cite',
+  'code',
+  'col',
+  'colgroup',
+  'data',
+  'datalist',
+  'dd',
+  'del',
+  'details',
+  'dfn',
+  'dialog',
+  'div',
+  'dl',
+  'dt',
+  'em',
+  'embed',
+  'fieldset',
+  'figcaption',
+  'figure',
+  'footer',
+  'form',
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'head',
+  'header',
+  'hr',
+  'html',
+  'i',
+  'iframe',
+  'img',
+  'input',
+  'ins',
+  'kbd',
+  'label',
+  'legend',
+  'li',
+  'link',
+  'main',
+  'map',
+  'mark',
+  'meta',
+  'meter',
+  'nav',
+  'noscript',
+  'object',
+  'ol',
+  'optgroup',
+  'option',
+  'output',
+  'p',
+  'param',
+  'picture',
+  'pre',
+  'progress',
+  'q',
+  'rp',
+  'rt',
+  'ruby',
+  's',
+  'samp',
+  'script',
+  'section',
+  'select',
+  'small',
+  'source',
+  'span',
+  'strong',
+  'style',
+  'sub',
+  'summary',
+  'sup',
+  'svg',
+  'table',
+  'tbody',
+  'td',
+  'template',
+  'textarea',
+  'tfoot',
+  'th',
+  'thead',
+  'time',
+  'title',
+  'tr',
+  'track',
+  'u',
+  'ul',
+  'var',
+  'video',
+  'wbr',
+  // Common SVG elements
+  'circle',
+  'clipPath',
+  'defs',
+  'ellipse',
+  'g',
+  'image',
+  'line',
+  'linearGradient',
+  'mask',
+  'path',
+  'pattern',
+  'polygon',
+  'polyline',
+  'radialGradient',
+  'rect',
+  'stop',
+  'text',
+  'tspan',
+  'use',
+]);
+
 export default class FunctionCallManager implements EquivalencyManager {
   private signaturePathEstablished: Record<string, Set<string>> = {};
 
@@ -272,7 +406,11 @@ export default class FunctionCallManager implements EquivalencyManager {
         functionCallScopeInfoName &&
         scopeDataStructure.scopeNodes[functionCallScopeInfoName];
 
+      // Skip JSX intrinsic elements - they're not real function calls
+      const isJsxIntrinsic = HTML_INTRINSIC_ELEMENTS.has(functionCallRoot);
+
       const isExternal =
+        !isJsxIntrinsic &&
         !scopeNode.instantiatedVariables?.includes(functionCallRoot) &&
         !scopeNode.parentInstantiatedVariables?.includes(functionCallRoot) &&
         !functionCallRoot.startsWith('signature[') &&
@@ -301,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) {
@@ -318,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/JavascriptFrameworkManager.ts

@@ -288,6 +288,18 @@ export class JavascriptFrameworkManager implements EquivalencyManager {
     let propagated = false;
     const mapFunction = mapCall.slice(4, -1); // remove 'map(' and ')'
 
+    // Extract the scope name from the map callback
+    // For named scopes like "cyScope12(...)", split('(')[0] gives "cyScope12"
+    // For inline arrow functions like "(item) => item.operation", split('(')[0] gives ""
+    const mapFunctionScopeName = mapFunction.split('(')[0];
+
+    // Skip if the map callback is an inline arrow function (no named scope)
+    // Inline arrow functions like "(item) => item.operation" aren't isolated as separate scopes
+    // so we can't create equivalencies referencing their scope name
+    if (!mapFunctionScopeName) {
+      return false;
+    }
+
     for (const [equivalentPath, equivalentValues] of Object.entries(
       scopeNode.equivalencies,
     )) {
@@ -317,7 +329,7 @@ export class JavascriptFrameworkManager implements EquivalencyManager {
             scopeDataStructure.addEquivalency(
               scopeDataStructure.joinPathParts(equivalentPathParts.slice(1)),
               'returnValue',
-              mapFunction.split('(')[0],
+              mapFunctionScopeName,
               scopeDataStructure.scopeNodes[equivalentPathParts[0]],
               '.map() function deconstruction',
               equivalencyValueChain,
@@ -327,7 +339,7 @@ export class JavascriptFrameworkManager implements EquivalencyManager {
             scopeDataStructure.addEquivalency(
               arrayEquivalent ? equivalentPath : `${equivalentPath}[]`,
               'returnValue',
-              mapFunction.split('(')[0],
+              mapFunctionScopeName,
               scopeNode,
               '.map() function deconstruction',
               equivalencyValueChain,
@@ -506,8 +518,9 @@ export class JavascriptFrameworkManager implements EquivalencyManager {
 
     for (const [arrayPath, arrayInfo] of Object.entries(arrays)) {
       if (arrayInfo.paths.size > 1 && arrayInfo.values.size === 1) {
+        const elementType = Array.from(arrayInfo.values)[0];
         arrayInfo.paths.forEach((path) => delete scopeNode.schema[path]);
-        scopeNode.schema[`${arrayPath}[]`] = Array.from(arrayInfo.values)[0];
+        scopeNode.schema[`${arrayPath}[]`] = elementType;
       }
     }
   }