@codeyam/codeyam-cli 0.1.0-staging.323686 → 0.1.0-staging.39719f5

package/analyzer-template/packages/ai/src/lib/astScopes/processExpression.ts

@@ -9,6 +9,7 @@ import { StructuredPath } from './paths';
 import { nodeToSource } from './nodeToSource';
 import { methodRegistry, ArrayPushSemantics } from './methodSemantics';
 import {
+  getComparisonOperatorString,
   isArithmeticOperator,
   isAssignmentOperator,
   isBitwiseCompoundOperator,
@@ -25,6 +26,179 @@ import {
 } from './conditionalEffectsExtractor';
 import { detectArrayDerivedPattern } from './arrayDerivationDetector';
 
+/**
+ * Recursively extracts root variable names from an expression AST node.
+ * Used to identify which variables flow into JSX expression children,
+ * so we can link them to the return value schema.
+ *
+ * Examples:
+ * - `filteredTopPaths.map(...)` → ['filteredTopPaths']
+ * - `a && b` → ['a', 'b']
+ * - `condition ? x : y` → ['condition', 'x', 'y']
+ */
+function extractRootVariableNames(node: ts.Expression): string[] {
+  const ignoredIdentifiers = new Set([
+    'undefined',
+    'null',
+    'true',
+    'false',
+    'NaN',
+    'Infinity',
+  ]);
+
+  if (ts.isIdentifier(node)) {
+    const name = node.text;
+    return ignoredIdentifiers.has(name) ? [] : [name];
+  }
+
+  if (ts.isPropertyAccessExpression(node)) {
+    return extractRootVariableNames(node.expression);
+  }
+
+  if (ts.isCallExpression(node)) {
+    return extractRootVariableNames(node.expression);
+  }
+
+  if (ts.isBinaryExpression(node)) {
+    return [
+      ...extractRootVariableNames(node.left),
+      ...extractRootVariableNames(node.right),
+    ];
+  }
+
+  if (ts.isPrefixUnaryExpression(node)) {
+    return extractRootVariableNames(node.operand);
+  }
+
+  if (ts.isConditionalExpression(node)) {
+    return [
+      ...extractRootVariableNames(node.condition),
+      ...extractRootVariableNames(node.whenTrue),
+      ...extractRootVariableNames(node.whenFalse),
+    ];
+  }
+
+  if (ts.isParenthesizedExpression(node)) {
+    return extractRootVariableNames(node.expression);
+  }
+
+  // Stop recursion at JSX elements and other terminal nodes
+  if (
+    ts.isJsxElement(node) ||
+    ts.isJsxFragment(node) ||
+    ts.isJsxSelfClosingElement(node)
+  ) {
+    return [];
+  }
+
+  return [];
+}
+
+/**
+ * Checks if a JSX element has props that reference variables from the parent scope.
+ * This is used to detect unconditionally-rendered children that should have their
+ * execution flows merged into the parent.
+ *
+ * We want to track children where the parent controls data that affects the child's
+ * conditional rendering. Static props (like title="Dashboard") don't need tracking
+ * because they don't create variable execution flows.
+ *
+ * Examples:
+ * - <WorkoutsView workouts={workouts} /> → true (workouts is a variable)
+ * - <ItemList items={items} count={count} /> → true (items, count are variables)
+ * - <Header title="Dashboard" /> → false (static string)
+ * - <Footer /> → false (no props)
+ * - <Button onClick={handleClick} /> → false (only callback, no data props)
+ *
+ * @returns true if the component has at least one prop that references a variable
+ *          (excluding callbacks which typically start with 'on' or 'handle')
+ */
+function hasDataPropsFromParent(
+  node: ts.JsxElement | ts.JsxSelfClosingElement,
+  componentName: string,
+): { hasDataProps: boolean; dataProps: string[] } {
+  const attributes = ts.isJsxElement(node)
+    ? node.openingElement.attributes.properties
+    : node.attributes.properties;
+
+  const dataProps: string[] = [];
+
+  for (const attr of attributes) {
+    // Spread attributes always reference parent data: {...props}
+    if (ts.isJsxSpreadAttribute(attr)) {
+      const spreadText = attr.expression?.getText() || '...spread';
+      dataProps.push(`{...${spreadText}}`);
+      console.log(
+        `[UnconditionalChild] ${componentName}: Found spread attribute {${spreadText}}`,
+      );
+      continue;
+    }
+
+    if (ts.isJsxAttribute(attr)) {
+      const propName = attr.name.getText();
+
+      // Skip callback props - they don't create data-driven execution flows
+      // Callbacks typically start with 'on' (onClick, onChange) or 'handle' (handleSubmit)
+      if (
+        propName.startsWith('on') ||
+        propName.startsWith('handle') ||
+        propName === 'ref'
+      ) {
+        console.log(
+          `[UnconditionalChild] ${componentName}: Skipping callback prop '${propName}'`,
+        );
+        continue;
+      }
+
+      // Check if the prop value is a JSX expression (references a variable)
+      // vs a string literal which is static
+      if (attr.initializer) {
+        if (ts.isJsxExpression(attr.initializer)) {
+          // JSX expression like prop={value} - this references a variable
+          // Could be a simple identifier, property access, or more complex expression
+          const expression = attr.initializer.expression;
+          if (expression) {
+            // Skip if it's just a function/arrow function (callback)
+            if (
+              ts.isArrowFunction(expression) ||
+              ts.isFunctionExpression(expression)
+            ) {
+              console.log(
+                `[UnconditionalChild] ${componentName}: Skipping inline callback prop '${propName}'`,
+              );
+              continue;
+            }
+            // This is a data prop that references parent state/props
+            const exprText = expression.getText();
+            dataProps.push(`${propName}={${exprText}}`);
+            console.log(
+              `[UnconditionalChild] ${componentName}: Found data prop '${propName}' = {${exprText}}`,
+            );
+          }
+        } else {
+          // String literals like prop="value" are static
+          console.log(
+            `[UnconditionalChild] ${componentName}: Skipping static prop '${propName}'`,
+          );
+        }
+      }
+    }
+  }
+
+  const hasDataProps = dataProps.length > 0;
+  if (hasDataProps) {
+    console.log(
+      `[UnconditionalChild] ${componentName}: Has ${dataProps.length} data props: [${dataProps.join(', ')}]`,
+    );
+  } else {
+    console.log(
+      `[UnconditionalChild] ${componentName}: No data props found, will NOT track`,
+    );
+  }
+
+  return { hasDataProps, dataProps };
+}
+
 /**
  * Extracts the component name from a JSX element.
  * Returns null for intrinsic elements (div, span, etc.) since we only care about
@@ -921,18 +1095,50 @@ function extractConditionalsFromJsx(
     // Recursively process nested JSX elements - Fix 32: pass parent conditions
     else if (ts.isJsxElement(child)) {
       // Check if this is a user-defined component (vs intrinsic element like div)
-      // If it's a component AND there are parent conditions, record the gating conditions
       const componentName = getComponentNameFromJsx(child);
-      if (componentName && parentConditions.length > 0) {
-        for (const condition of parentConditions) {
-          context.addChildBoundaryGatingCondition(componentName, {
-            path: condition.path,
-            conditionType: 'truthiness',
-            location: 'ternary',
-            sourceLocation: condition.sourceLocation,
-            controlsJsxRendering: true,
-            isNegated: condition.isNegated,
-          });
+      if (componentName) {
+        if (parentConditions.length > 0) {
+          // If there are parent conditions, record them as gating conditions
+          console.log(
+            `[ChildBoundary] ${componentName}: Conditionally rendered with ${parentConditions.length} gating conditions`,
+          );
+          for (const condition of parentConditions) {
+            console.log(
+              `[ChildBoundary] ${componentName}: Adding gating condition path='${condition.path}' isNegated=${condition.isNegated}`,
+            );
+            context.addChildBoundaryGatingCondition(componentName, {
+              path: condition.path,
+              conditionType: 'truthiness',
+              location: 'ternary',
+              sourceLocation: condition.sourceLocation,
+              controlsJsxRendering: true,
+              isNegated: condition.isNegated,
+            });
+          }
+        } else {
+          // No parent conditions - check if it has data props for unconditional tracking
+          console.log(
+            `[ChildBoundary] ${componentName}: Checking for unconditional rendering with data props...`,
+          );
+          const { hasDataProps, dataProps } = hasDataPropsFromParent(
+            child,
+            componentName,
+          );
+          if (hasDataProps) {
+            // Fix: Track unconditionally-rendered children that receive data props
+            // These need to be tracked for flow merging even without gating conditions
+            // Example: <WorkoutsView workouts={workouts} /> - parent controls workouts data
+            console.log(
+              `[ChildBoundary] ${componentName}: TRACKING as unconditionally-rendered with data props: [${dataProps.join(', ')}]`,
+            );
+            context.addChildBoundaryGatingCondition(componentName, {
+              path: '__unconditional__',
+              conditionType: 'truthiness',
+              location: 'unconditional',
+              controlsJsxRendering: true,
+              isNegated: false,
+            });
+          }
         }
       }
       extractConditionalsFromJsx(child, context, parentConditions);
@@ -940,18 +1146,48 @@ function extractConditionalsFromJsx(
     // Handle self-closing JSX elements (e.g., <ScenarioViewer />)
     else if (ts.isJsxSelfClosingElement(child)) {
       // Check if this is a user-defined component (vs intrinsic element like div)
-      // If it's a component AND there are parent conditions, record the gating conditions
       const componentName = getComponentNameFromJsx(child);
-      if (componentName && parentConditions.length > 0) {
-        for (const condition of parentConditions) {
-          context.addChildBoundaryGatingCondition(componentName, {
-            path: condition.path,
-            conditionType: 'truthiness',
-            location: 'ternary',
-            sourceLocation: condition.sourceLocation,
-            controlsJsxRendering: true,
-            isNegated: condition.isNegated,
-          });
+      if (componentName) {
+        if (parentConditions.length > 0) {
+          // If there are parent conditions, record them as gating conditions
+          console.log(
+            `[ChildBoundary] ${componentName}: Conditionally rendered (self-closing) with ${parentConditions.length} gating conditions`,
+          );
+          for (const condition of parentConditions) {
+            console.log(
+              `[ChildBoundary] ${componentName}: Adding gating condition path='${condition.path}' isNegated=${condition.isNegated}`,
+            );
+            context.addChildBoundaryGatingCondition(componentName, {
+              path: condition.path,
+              conditionType: 'truthiness',
+              location: 'ternary',
+              sourceLocation: condition.sourceLocation,
+              controlsJsxRendering: true,
+              isNegated: condition.isNegated,
+            });
+          }
+        } else {
+          // No parent conditions - check if it has data props for unconditional tracking
+          console.log(
+            `[ChildBoundary] ${componentName}: Checking for unconditional rendering (self-closing) with data props...`,
+          );
+          const { hasDataProps, dataProps } = hasDataPropsFromParent(
+            child,
+            componentName,
+          );
+          if (hasDataProps) {
+            // Fix: Track unconditionally-rendered children that receive data props
+            console.log(
+              `[ChildBoundary] ${componentName}: TRACKING as unconditionally-rendered (self-closing) with data props: [${dataProps.join(', ')}]`,
+            );
+            context.addChildBoundaryGatingCondition(componentName, {
+              path: '__unconditional__',
+              conditionType: 'truthiness',
+              location: 'unconditional',
+              controlsJsxRendering: true,
+              isNegated: false,
+            });
+          }
         }
       }
       // Self-closing elements have no children, so no recursion needed
@@ -1127,6 +1363,11 @@ export function extractConditionalUsage(
         return literalValue;
       };
 
+      // Get the comparison operator string for the compound condition
+      const comparisonOperator = getComparisonOperatorString(
+        unwrapped.operatorToken.kind,
+      );
+
       // Helper to add a condition
       const addCondition = (
         path: string,
@@ -1171,6 +1412,7 @@ export function extractConditionalUsage(
             comparedValues,
             isNegated,
             requiredValue,
+            ...(comparisonOperator && { comparisonOperator }),
             ...(chainInfo.currentOrGroupId && {
               orGroupId: chainInfo.currentOrGroupId,
             }),
@@ -1449,7 +1691,7 @@ export function processExpression({
       const structure = context.getStructure();
 
       // Propagate existing equivalencies for sub-properties
-      for (const [key, value] of Object.entries(equivalentVariables)) {
+      for (const [key, rawValue] of Object.entries(equivalentVariables)) {
         // Check if this equivalency is for a sub-property of the identifier
         // e.g., completeDataStructure['Function Arguments'] or completeDataStructure.foo
         if (
@@ -1460,8 +1702,14 @@ export function processExpression({
           const newTargetPath = StructuredPath.fromBase(
             targetPath.toString() + subPath,
           );
-          const valuePath = StructuredPath.fromBase(value);
-          context.addEquivalence(newTargetPath, valuePath);
+          // Handle both string and string[] values
+          const values = Array.isArray(rawValue) ? rawValue : [rawValue];
+          for (const value of values) {
+            if (typeof value === 'string') {
+              const valuePath = StructuredPath.fromBase(value);
+              context.addEquivalence(newTargetPath, valuePath);
+            }
+          }
         }
       }
 
@@ -1945,23 +2193,47 @@ export function processExpression({
           //   - items[] (from the find result)
           //   - null (from the fallback)
           if (targetPath) {
-            // Process left side recursively to capture its full equivalency chain
+            // Get paths for both sides
+            const leftPath = StructuredPath.fromNode(
+              unwrappedNode.left,
+              context.sourceFile,
+            );
+            const rightPath = StructuredPath.fromNode(
+              unwrappedNode.right,
+              context.sourceFile,
+            );
+
+            // Collect all valid paths
+            const allPaths: StructuredPath[] = [];
+            if (leftPath) allPaths.push(leftPath);
+            if (rightPath) allPaths.push(rightPath);
+
+            // Add multiple equivalencies to track both sources
+            if (allPaths.length > 0) {
+              context.addMultipleEquivalencies(targetPath, allPaths);
+            }
+
+            // Process both sides to capture their internal structures
             processExpression({
               node: unwrappedNode.left,
               context,
-              targetPath,
             });
-            // Process right side recursively for completeness
             processExpression({
               node: unwrappedNode.right,
               context,
-              targetPath,
             });
-            // Set resultPath to left side for type inference
-            resultPath = StructuredPath.fromNode(
-              unwrappedNode.left,
-              context.sourceFile,
-            );
+
+            // Register the type for the target path
+            const leftType = context.inferTypeFromNode(unwrappedNode.left);
+            const rightType = context.inferTypeFromNode(unwrappedNode.right);
+            const orResultType = isDefinedType(leftType)
+              ? leftType
+              : rightType || 'unknown';
+            context.addType(targetPath, orResultType);
+
+            // Return early - we've already handled equivalencies with addMultipleEquivalencies
+            // Don't fall through to the generic addEquivalence call below
+            return true;
           }
           // Note: When there's no targetPath, we don't recursively process
           // because || is often used in boolean contexts where the full expression matters
@@ -2071,24 +2343,56 @@ export function processExpression({
 
         // Get the source expression path (e.g., the object for obj.method())
         const sourceExpr = unwrappedNode.expression.expression;
-        const sourcePath = StructuredPath.fromNode(
-          sourceExpr,
-          context.sourceFile,
-        );
+        const unwrappedSourceExpr = unwrapExpression(sourceExpr);
+
+        // When the source is a ternary expression like (cond ? arr : arr.slice()),
+        // apply method semantics to BOTH branches directly. The ternary itself isn't
+        // a variable - it's just a choice between two paths that both flow to the result.
+        if (ts.isConditionalExpression(unwrappedSourceExpr)) {
+          const branches = [
+            unwrappedSourceExpr.whenTrue,
+            unwrappedSourceExpr.whenFalse,
+          ];
 
-        if (sourcePath) {
-          // For array-specific semantics (like push), verify the source is actually an array
-          // This prevents router.push() from being mistakenly treated as Array.push()
-          const isArraySemantics = semantics instanceof ArrayPushSemantics;
-          const shouldApply =
-            !isArraySemantics ||
-            isLikelyArrayType(sourceExpr, context.typeChecker);
+          for (const branch of branches) {
+            const branchPath = StructuredPath.fromNode(
+              branch,
+              context.sourceFile,
+            );
+            if (branchPath) {
+              const isArraySemantics = semantics instanceof ArrayPushSemantics;
+              const shouldApply =
+                !isArraySemantics ||
+                isLikelyArrayType(branch, context.typeChecker);
+
+              if (shouldApply) {
+                semantics.addEquivalences(callPath, branchPath, context);
+                returnType = semantics.getReturnType();
+                handledBySemantics = true;
+              }
+            }
+          }
+        } else {
+          // Regular (non-ternary) source expression
+          const sourcePath = StructuredPath.fromNode(
+            sourceExpr,
+            context.sourceFile,
+          );
 
-          if (shouldApply) {
-            // Apply method semantics
-            semantics.addEquivalences(callPath, sourcePath, context);
-            returnType = semantics.getReturnType();
-            handledBySemantics = true;
+          if (sourcePath) {
+            // For array-specific semantics (like push), verify the source is actually an array
+            // This prevents router.push() from being mistakenly treated as Array.push()
+            const isArraySemantics = semantics instanceof ArrayPushSemantics;
+            const shouldApply =
+              !isArraySemantics ||
+              isLikelyArrayType(sourceExpr, context.typeChecker);
+
+            if (shouldApply) {
+              // Apply method semantics
+              semantics.addEquivalences(callPath, sourcePath, context);
+              returnType = semantics.getReturnType();
+              handledBySemantics = true;
+            }
           }
         }
       }
@@ -2646,6 +2950,35 @@ export function processExpression({
 
   // Handle Arrow Functions: (p) => p.prop, (a, b) => { ... }
   if (ts.isArrowFunction(unwrappedNode)) {
+    // If this arrow function is a child boundary (e.g., a .map() callback),
+    // don't process its parameters here - they will be processed when the
+    // child scope is analyzed separately. This prevents parameter variables
+    // from leaking into the parent scope's equivalencies.
+    // Check if this arrow function is a child boundary (i.e., should be processed
+    // as a separate child scope, not here in the parent scope).
+    //
+    // We use two checks because childBoundary positions can be unreliable:
+    // 1. Position-based check (standard isChildBoundary)
+    // 2. Text-based check: if the arrow function text doesn't appear in the
+    //    statement text, it was replaced with a cyScope placeholder
+    const isChildBoundary = context.isChildBoundary(unwrappedNode);
+
+    // Text-based child scope detection for when positions are unreliable
+    const arrowFnText = unwrappedNode.getText(context.sourceFile);
+    const firstLine = arrowFnText.split('\n')[0].trim();
+    const searchText = firstLine.substring(0, Math.min(20, firstLine.length));
+    const isInStatementText = context.statementInfo.text.includes(searchText);
+    const isChildScope = !isInStatementText && arrowFnText.length > 10;
+
+    if (isChildBoundary || isChildScope) {
+      // The method semantics (e.g., ArrayMapSemantics) have already established
+      // the necessary equivalences between the child scope placeholder and array elements
+      if (targetPath) {
+        context.addType(targetPath, 'function');
+      }
+      return true;
+    }
+
     // Create a path for the function
     const functionPath = StructuredPath.empty();
 
@@ -3076,6 +3409,19 @@ export function processExpression({
       for (const child of unwrappedNode.children) {
         // Process expressions in JSX children: <div>{expr}</div>
         if (ts.isJsxExpression(child) && child.expression) {
+          // When processing return value JSX, link root variables to return value schema
+          if (targetPath && targetPath.base !== '') {
+            const varNames = [
+              ...new Set(extractRootVariableNames(child.expression)),
+            ];
+            for (const varName of varNames) {
+              context.addEquivalence(
+                targetPath.withProperty(varName),
+                StructuredPath.fromBase(varName),
+              );
+            }
+          }
+
           // Process the expression with StructuredPath.empty() as targetPath
           // to trigger type registration without imposing prefix
           processExpression({
@@ -3110,6 +3456,19 @@ export function processExpression({
     for (const child of unwrappedNode.children) {
       // Process expressions in JSX children: <>{expr}</>
       if (ts.isJsxExpression(child) && child.expression) {
+        // When processing return value JSX, link root variables to return value schema
+        if (targetPath && targetPath.base !== '') {
+          const varNames = [
+            ...new Set(extractRootVariableNames(child.expression)),
+          ];
+          for (const varName of varNames) {
+            context.addEquivalence(
+              targetPath.withProperty(varName),
+              StructuredPath.fromBase(varName),
+            );
+          }
+        }
+
         // Process the expression to extract structure
         processExpression({
           node: child.expression,

package/analyzer-template/packages/ai/src/lib/astScopes/sharedPatterns.ts

@@ -71,6 +71,34 @@ export function isComparisonOperator(kind: ts.SyntaxKind): boolean {
   );
 }
 
+/**
+ * Returns the string representation of a comparison operator token.
+ */
+export function getComparisonOperatorString(
+  kind: ts.SyntaxKind,
+): string | undefined {
+  switch (kind) {
+    case ts.SyntaxKind.EqualsEqualsToken:
+      return '==';
+    case ts.SyntaxKind.EqualsEqualsEqualsToken:
+      return '===';
+    case ts.SyntaxKind.ExclamationEqualsToken:
+      return '!=';
+    case ts.SyntaxKind.ExclamationEqualsEqualsToken:
+      return '!==';
+    case ts.SyntaxKind.LessThanToken:
+      return '<';
+    case ts.SyntaxKind.LessThanEqualsToken:
+      return '<=';
+    case ts.SyntaxKind.GreaterThanToken:
+      return '>';
+    case ts.SyntaxKind.GreaterThanEqualsToken:
+      return '>=';
+    default:
+      return undefined;
+  }
+}
+
 /**
  * Checks if an operator is an arithmetic operator
  */

package/analyzer-template/packages/ai/src/lib/astScopes/types.ts

@@ -287,8 +287,9 @@ export interface AstScopeAnalysisResult {
   // Variable structure map (variable path -> type)
   structure: Record<string, string>;
 
-  // Variable equivalence map (variable path -> equivalent variable path)
-  equivalentVariables: Record<string, string>;
+  // Variable equivalence map (variable path -> equivalent variable path(s))
+  // Supports multiple equivalencies per key for OR expressions (e.g., x = a || b)
+  equivalentVariables: Record<string, string | string[]>;
 
   // Environment variables accessed in this scope
   environmentVariables: string[];
@@ -348,8 +349,9 @@ export interface ConditionalUsage {
 
   /**
    * Where this conditional usage occurs
+   * 'unconditional' is used for children that are always rendered but receive data props
    */
-  location: 'if' | 'ternary' | 'logical-and' | 'switch';
+  location: 'if' | 'ternary' | 'logical-and' | 'switch' | 'unconditional';
 
   /**
    * Source location information for this conditional usage
@@ -431,6 +433,12 @@ export interface CompoundConditional {
     isNegated: boolean;
     /** Required value for this condition to be true */
     requiredValue?: string | boolean;
+    /**
+     * The comparison operator used (e.g., '>', '<', '>=', '<=', '===', '!==').
+     * Preserves the original operator so flow generation can distinguish
+     * `length > 0` from `length === 0`.
+     */
+    comparisonOperator?: string;
     /**
      * When conditions are part of an OR expression within an && chain,
      * they share the same orGroupId. Conditions with the same orGroupId
@@ -441,7 +449,7 @@ export interface CompoundConditional {
     orGroupId?: string;
   }[];
   /** Where this compound conditional occurs */
-  location: 'if' | 'ternary' | 'logical-and' | 'switch';
+  location: 'if' | 'ternary' | 'logical-and' | 'switch' | 'unconditional';
   /** Source location for the entire compound expression */
   sourceLocation: {
     lineNumber: number;
@@ -509,6 +517,13 @@ export interface AnalysisContext {
   // Add an equivalence relationship between two variable paths
   addEquivalence(leftSide: StructuredPath, rightSide: StructuredPath): void;
 
+  // Add multiple equivalence relationships for a single variable path.
+  // Used for OR expressions like `x = a || b` where x is equivalent to both a and b.
+  addMultipleEquivalencies(
+    leftSide: StructuredPath,
+    rightSides: StructuredPath[],
+  ): void;
+
   // Add a type for a variable path
   addType(path: StructuredPath, type: string): void;
 
@@ -555,8 +570,8 @@ export interface AnalysisContext {
   // Get the built-up structure
   getStructure(): Record<string, string>;
 
-  // Get the built-up equivalence map
-  getEquivalentVariables(): Record<string, string>;
+  // Get the built-up equivalence map (supports multiple values for OR expressions)
+  getEquivalentVariables(): Record<string, string | string[]>;
 
   // Utilties for child boundaries (need to be skipped while capturing equivalencies)
   getChildBoundary(