@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.596f0eb

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,

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 =
@@ -426,7 +428,7 @@ export class ReactFrameworkManager implements EquivalencyManager {
           const valid = pathParts
             .slice(3)
             .reverse()
-            .every((part, index) => pParts.reverse()[index] === part);
+            .every((part, index) => [...pParts].reverse()[index] === part);
 
           // if (p.includes('.title') && valid)
           //   console.info({ p, pParts, pathParts: pathParts.slice(3) });

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

@@ -0,0 +1,139 @@
+/**
+ * BatchSchemaProcessor
+ *
+ * Converts recursive addToSchema calls into iterative batch processing.
+ * This eliminates deep call stack recursion and allows for better
+ * deduplication of work.
+ *
+ * ## How It Works
+ *
+ * Instead of:
+ *   addToSchema() -> followEquivalencies() -> addToSchema() -> ...
+ *
+ * We do:
+ *   1. Add initial work to queue
+ *   2. Process queue iteratively
+ *   3. Each item may add more work to queue
+ *   4. Continue until queue is empty
+ *
+ * ## Benefits
+ *
+ * - No deep recursion (avoids stack overflow on complex codebases)
+ * - Work deduplication happens upfront via visited set
+ * - Easier to profile and debug
+ * - Could enable parallel processing in the future
+ */
+
+export interface WorkItem {
+  scopeNodeName: string;
+  path: string;
+  value: string;
+  equivalencyValueChain: unknown[];
+  traceId?: number;
+}
+
+export interface BatchProcessorStats {
+  itemsProcessed: number;
+  itemsSkipped: number;
+  maxQueueSize: number;
+  processingTimeMs: number;
+}
+
+export class BatchSchemaProcessor {
+  private workQueue: WorkItem[] = [];
+  private stats: BatchProcessorStats = {
+    itemsProcessed: 0,
+    itemsSkipped: 0, // Kept for API compatibility, always 0
+    maxQueueSize: 0,
+    processingTimeMs: 0,
+  };
+
+  /**
+   * Add a work item to the queue.
+   * Returns true if added.
+   *
+   * NOTE: We don't deduplicate here because the equivalencyValueChain matters
+   * for database population even if (scope, path, value) is the same.
+   * Different chains of the same length may have different intermediate paths.
+   * The VisitedTracker in ScopeDataStructure handles actual deduplication.
+   */
+  addWork(item: WorkItem): boolean {
+    this.workQueue.push(item);
+
+    if (this.workQueue.length > this.stats.maxQueueSize) {
+      this.stats.maxQueueSize = this.workQueue.length;
+    }
+
+    return true;
+  }
+
+  /**
+   * Check if there are more items to process.
+   */
+  hasWork(): boolean {
+    return this.workQueue.length > 0;
+  }
+
+  /**
+   * Get the next work item from the queue.
+   */
+  getNextWork(): WorkItem | undefined {
+    const item = this.workQueue.shift();
+    if (item) {
+      this.stats.itemsProcessed++;
+    }
+    return item;
+  }
+
+  /**
+   * Check if a (scope, path, value) combination was already visited.
+   * NOTE: Currently always returns false as we don't deduplicate in the batch processor.
+   */
+  isVisited(_scopeNodeName: string, _path: string, _value: string): boolean {
+    return false; // Deduplication handled by VisitedTracker in ScopeDataStructure
+  }
+
+  /**
+   * Process all items in the queue using the provided processor function.
+   * The processor function should call addWork() to queue any follow-up work.
+   */
+  processAll(
+    processor: (item: WorkItem, addWork: (item: WorkItem) => boolean) => void,
+  ): void {
+    const startTime = Date.now();
+
+    while (this.hasWork()) {
+      const item = this.getNextWork()!;
+      processor(item, (newItem) => this.addWork(newItem));
+    }
+
+    this.stats.processingTimeMs = Date.now() - startTime;
+  }
+
+  /**
+   * Get processing statistics.
+   */
+  getStats(): BatchProcessorStats {
+    return { ...this.stats };
+  }
+
+  /**
+   * Reset the processor for reuse.
+   */
+  reset(): void {
+    this.workQueue = [];
+    this.stats = {
+      itemsProcessed: 0,
+      itemsSkipped: 0,
+      maxQueueSize: 0,
+      processingTimeMs: 0,
+    };
+  }
+
+  /**
+   * Get current queue size (for debugging/monitoring).
+   */
+  getQueueSize(): number {
+    return this.workQueue.length;
+  }
+}

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

@@ -0,0 +1,224 @@
+/**
+ * DebugTracer
+ *
+ * Structured debug/trace system for ScopeDataStructure analysis.
+ * Enables selective tracing of specific paths or scopes without code changes.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * const tracer = new DebugTracer({
+ *   enabled: true,
+ *   pathPatterns: [/user\.id/, /signature\[0\]/],
+ *   scopePatterns: [/MyComponent/],
+ *   maxDepth: 10,
+ * });
+ *
+ * // In code:
+ * tracer.trace('addToSchema', { path, value, scope: scopeNode.name });
+ * tracer.traceEnter('followEquivalencies', { path, subPath });
+ * // ... do work ...
+ * tracer.traceExit('followEquivalencies', { propagated: true });
+ * ```
+ *
+ * ## Trace Output
+ *
+ * When enabled, produces structured output like:
+ * ```
+ * [TRACE] addToSchema { path: "user.id", value: "string", scope: "MyComponent" }
+ * [ENTER] followEquivalencies { path: "user.id", subPath: "user" }
+ * [EXIT]  followEquivalencies { propagated: true }
+ * ```
+ */
+
+export interface DebugTracerOptions {
+  /** Master switch - if false, all tracing is disabled */
+  enabled: boolean;
+
+  /** Regex patterns for paths to trace (empty = trace all paths) */
+  pathPatterns?: RegExp[];
+
+  /** Regex patterns for scopes to trace (empty = trace all scopes) */
+  scopePatterns?: RegExp[];
+
+  /** Maximum trace depth (prevents runaway output) */
+  maxDepth?: number;
+
+  /** Custom output function (defaults to console.info) */
+  output?: (message: string, data?: Record<string, unknown>) => void;
+
+  /** Include timestamps in output */
+  timestamps?: boolean;
+}
+
+export interface TraceContext {
+  path?: string;
+  scope?: string;
+  [key: string]: unknown;
+}
+
+export class DebugTracer {
+  private enabled: boolean;
+  private pathPatterns: RegExp[];
+  private scopePatterns: RegExp[];
+  private maxDepth: number;
+  private output: (message: string, data?: Record<string, unknown>) => void;
+  private timestamps: boolean;
+  private depth = 0;
+  private traceCount = 0;
+
+  constructor(options: DebugTracerOptions) {
+    this.enabled = options.enabled;
+    this.pathPatterns = options.pathPatterns ?? [];
+    this.scopePatterns = options.scopePatterns ?? [];
+    this.maxDepth = options.maxDepth ?? 50;
+    this.output = options.output ?? this.defaultOutput;
+    this.timestamps = options.timestamps ?? false;
+  }
+
+  /**
+   * Check if tracing should happen for this context.
+   */
+  private shouldTrace(context: TraceContext): boolean {
+    if (!this.enabled) return false;
+    if (this.depth >= this.maxDepth) return false;
+
+    // If no patterns specified, trace everything
+    if (this.pathPatterns.length === 0 && this.scopePatterns.length === 0) {
+      return true;
+    }
+
+    // Check path patterns
+    if (context.path && this.pathPatterns.length > 0) {
+      if (this.pathPatterns.some((p) => p.test(context.path!))) {
+        return true;
+      }
+    }
+
+    // Check scope patterns
+    if (context.scope && this.scopePatterns.length > 0) {
+      if (this.scopePatterns.some((p) => p.test(context.scope!))) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Default output to console with formatting.
+   */
+  private defaultOutput = (
+    message: string,
+    data?: Record<string, unknown>,
+  ): void => {
+    const indent = '  '.repeat(this.depth);
+    const timestamp = this.timestamps ? `[${Date.now()}] ` : '';
+    if (data) {
+      console.info(`${timestamp}${indent}${message}`, JSON.stringify(data));
+    } else {
+      console.info(`${timestamp}${indent}${message}`);
+    }
+  };
+
+  /**
+   * Simple trace point - logs a message with context.
+   */
+  trace(label: string, context: TraceContext = {}): void {
+    if (!this.shouldTrace(context)) return;
+    this.traceCount++;
+    this.output(`[TRACE] ${label}`, context as Record<string, unknown>);
+  }
+
+  /**
+   * Trace entering a function/block - increases depth.
+   */
+  traceEnter(label: string, context: TraceContext = {}): void {
+    if (!this.shouldTrace(context)) return;
+    this.traceCount++;
+    this.output(`[ENTER] ${label}`, context as Record<string, unknown>);
+    this.depth++;
+  }
+
+  /**
+   * Trace exiting a function/block - decreases depth.
+   */
+  traceExit(label: string, context: TraceContext = {}): void {
+    if (this.depth > 0) this.depth--;
+    if (!this.shouldTrace(context)) return;
+    this.output(`[EXIT]  ${label}`, context as Record<string, unknown>);
+  }
+
+  /**
+   * Trace a warning condition.
+   */
+  traceWarn(label: string, context: TraceContext = {}): void {
+    if (!this.shouldTrace(context)) return;
+    this.traceCount++;
+    this.output(`[WARN]  ${label}`, context as Record<string, unknown>);
+  }
+
+  /**
+   * Enable tracing dynamically.
+   */
+  enable(): void {
+    this.enabled = true;
+  }
+
+  /**
+   * Disable tracing dynamically.
+   */
+  disable(): void {
+    this.enabled = false;
+  }
+
+  /**
+   * Reset depth counter (useful after errors).
+   */
+  resetDepth(): void {
+    this.depth = 0;
+  }
+
+  /**
+   * Get trace statistics.
+   */
+  getStats(): { traceCount: number; currentDepth: number; enabled: boolean } {
+    return {
+      traceCount: this.traceCount,
+      currentDepth: this.depth,
+      enabled: this.enabled,
+    };
+  }
+
+  /**
+   * Reset all statistics.
+   */
+  reset(): void {
+    this.depth = 0;
+    this.traceCount = 0;
+  }
+}
+
+/**
+ * Default disabled tracer instance.
+ * Use this when you want tracing infrastructure but disabled by default.
+ */
+export const defaultTracer = new DebugTracer({ enabled: false });
+
+/**
+ * Create a tracer that captures output to an array (for testing).
+ */
+export function createTestTracer(options: Partial<DebugTracerOptions> = {}): {
+  tracer: DebugTracer;
+  output: string[];
+} {
+  const output: string[] = [];
+  const tracer = new DebugTracer({
+    enabled: true,
+    ...options,
+    output: (message, data) => {
+      output.push(data ? `${message} ${JSON.stringify(data)}` : message);
+    },
+  });
+  return { tracer, output };
+}