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

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,9 +736,55 @@ function processScope({
     text: modifiedText,
     variables: Array.from(variables),
     childScopes,
+    // Include gating conditions if any were found
+    ...(Object.keys(extractedGatingConditions).length > 0 && {
+      extractedGatingConditions,
+    }),
   };
 }
 
+/**
+ * Check if a code string contains only type declarations (type aliases, interfaces, etc.)
+ * that don't contribute to runtime behavior. This is used to determine if the root scope
+ * should be considered "empty" for scope extraction purposes.
+ */
+function containsOnlyTypeDeclarations(code: string): boolean {
+  try {
+    const sourceFile = ts.createSourceFile(
+      'temp.ts',
+      code,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TS,
+    );
+
+    // Check each statement - if any is NOT a type-only declaration, return false
+    for (const statement of sourceFile.statements) {
+      if (
+        ts.isTypeAliasDeclaration(statement) ||
+        ts.isInterfaceDeclaration(statement) ||
+        ts.isEnumDeclaration(statement) ||
+        // Import declarations that are type-only
+        (ts.isImportDeclaration(statement) &&
+          statement.importClause?.isTypeOnly) ||
+        // Export declarations that are type-only
+        (ts.isExportDeclaration(statement) && statement.isTypeOnly)
+      ) {
+        // This is a type-only declaration, continue checking
+        continue;
+      }
+      // Found a non-type statement
+      return false;
+    }
+
+    // All statements are type-only (or there are no statements)
+    return sourceFile.statements.length > 0;
+  } catch {
+    // If parsing fails, assume it's not type-only
+    return false;
+  }
+}
+
 /**
  * Main entry point.
  *
@@ -772,11 +828,21 @@ export default function isolateScopes(
   // }
   // logChildIds(isolatedScopes);
 
-  processJSXForScope(isolatedScopes, generateSyntheticName);
-
-  // If the root scope text is empty and there's only one child scope,
-  // return that child scope as the root scope
-  if (isolatedScopes.text.trim().length === 0) {
+  // 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 (or only contains type declarations) and there's
+  // only one child scope, return that child scope as the root scope.
+  // Type declarations (type aliases, interfaces) don't contribute to runtime behavior,
+  // so we treat them as "empty" for scope extraction purposes.
+  const rootTextIsEffectivelyEmpty =
+    isolatedScopes.text.trim().length === 0 ||
+    containsOnlyTypeDeclarations(isolatedScopes.text);
+
+  if (rootTextIsEffectivelyEmpty) {
     const childScopeArray = Object.values(isolatedScopes.childScopes);
     if (childScopeArray.length === 1) {
       return childScopeArray[0];
@@ -800,9 +866,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 +1099,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 +1150,7 @@ function processJSXForScope(
       end: number;
       id: string;
       code: string;
+      jsxTagName?: string;
     }> = [];
 
     for (const [node, id] of nodeMap.entries()) {
@@ -848,13 +1158,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 +1196,7 @@ function processJSXForScope(
         end: replacement.end,
         variables: [],
         childScopes: {},
+        jsxTagName: replacement.jsxTagName,
       };
 
       // Replace in text

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

@@ -11,6 +11,11 @@ export default function mergeJsonTypeDefinitions(
     if (!typeDef) continue;
     if (typeof typeDef === 'string') continue;
     for (const [key, value] of Object.entries(typeDef)) {
+      // Preserve _nullable boolean markers set by convertDotNotation
+      if (key === '_nullable' && typeof value === 'boolean') {
+        mergedDef[key] = value;
+        continue;
+      }
       if (typeof value === 'string') {
         if (!mergedDef[key]) {
           mergedDef[key] = value;

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

@@ -7,58 +7,12 @@ import {
 
 export interface Statement {
   structure: { [key: string]: string };
-  equivalentVariables: { [key: string]: string };
+  // Supports multiple equivalencies per key for OR expressions (e.g., x = a || b)
+  equivalentVariables: { [key: string]: string | string[] };
   llmCall?: LlmCall;
 }
 
 export default function mergeStatements(statements: Statement[]) {
-  // Debug: Log input statements to understand what we're merging
-  const hasStateStructure = statements.some((s) =>
-    Object.keys(s.structure || {}).some(
-      (k) => k === 'state' || k.includes('state'),
-    ),
-  );
-  const hasStateEquiv = statements.some((s) =>
-    Object.keys(s.equivalentVariables || {}).some(
-      (k) => k === 'state' || k.includes('state'),
-    ),
-  );
-  if (hasStateStructure || hasStateEquiv) {
-    console.log(
-      `[UNION-TYPE] mergeStatements INPUT: ${statements.length} statements`,
-    );
-    statements.forEach((s, i) => {
-      const stateInStructure = Object.entries(s.structure || {}).filter(
-        ([k]) => k === 'state' || k.includes('state'),
-      );
-      const stateInEquiv = Object.entries(s.equivalentVariables || {}).filter(
-        ([k]) => k === 'state' || k.includes('state'),
-      );
-      const sigInEquiv = Object.entries(s.equivalentVariables || {}).filter(
-        ([k, v]) => k === 'state' || v === 'signature[0]',
-      );
-      if (
-        stateInStructure.length > 0 ||
-        stateInEquiv.length > 0 ||
-        sigInEquiv.length > 0
-      ) {
-        console.log(`[UNION-TYPE]   Statement ${i}:`);
-        if (stateInStructure.length > 0)
-          console.log(
-            `[UNION-TYPE]     structure: ${JSON.stringify(Object.fromEntries(stateInStructure))}`,
-          );
-        if (stateInEquiv.length > 0)
-          console.log(
-            `[UNION-TYPE]     equivalentVariables (state): ${JSON.stringify(Object.fromEntries(stateInEquiv))}`,
-          );
-        if (sigInEquiv.length > 0)
-          console.log(
-            `[UNION-TYPE]     equivalentVariables (sig): ${JSON.stringify(Object.fromEntries(sigInEquiv))}`,
-          );
-      }
-    });
-  }
-
   // This should be handled by the AST Analyzer but it currently has a bug
   const ensureFunctionCallReturnValue = (path: string, value: string) => {
     if (path.endsWith(')') && value !== 'function') {
@@ -166,12 +120,60 @@ 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> = {};
+
+  // Helper to normalize value to array and process
+  const normalizeValue = (value: string | string[]): string[] =>
+    Array.isArray(value) ? value : [value];
+
   const equivalentVariables = statements.reduce((acc: any, result) => {
-    for (const [key, value] of Object.entries(
+    for (const [key, rawValue] of Object.entries(
       result.equivalentVariables ?? {},
     )) {
+      // Handle arrays from AST analyzer (OR expressions like x = a || b)
+      // These should be preserved as arrays to track all sources
+      if (Array.isArray(rawValue)) {
+        const keyOptions = deBinaryPath(key);
+        const validValues = rawValue.filter(
+          (v): v is string => typeof v === 'string' && v.length > 0,
+        );
+        if (validValues.length === 0) continue;
+
+        // Process each array value through deBinaryPath
+        const allValueOptions: string[] = [];
+        for (const value of validValues) {
+          const valueOptions = deBinaryPath(value);
+          allValueOptions.push(...valueOptions);
+        }
+
+        // Remove duplicates while preserving order
+        const uniqueValueOptions = [...new Set(allValueOptions)];
+        const finalValue =
+          uniqueValueOptions.length === 1
+            ? uniqueValueOptions[0]
+            : uniqueValueOptions;
+
+        delete result.equivalentVariables[key];
+        if (keyOptions.length >= 2) {
+          for (const keyOption of keyOptions) {
+            result.equivalentVariables[keyOption] = finalValue;
+          }
+        } else {
+          result.equivalentVariables[keyOptions[0]] = finalValue;
+        }
+        continue;
+      }
+
+      // Original logic for string values with potential binary expressions in the string
+      const firstValue = rawValue;
+      if (!firstValue) continue;
+
       const keyOptions = deBinaryPath(key);
-      const valueOptions = deBinaryPath(value);
+      const valueOptions = deBinaryPath(firstValue);
       delete result.equivalentVariables[key];
       if (keyOptions.length === 2) {
         if (valueOptions.length === 2) {
@@ -193,19 +195,54 @@ export default function mergeStatements(statements: Statement[]) {
       }
     }
 
-    for (const [key, value] of Object.entries(
+    for (const [key, rawValue] of Object.entries(
       result.equivalentVariables ?? {},
     )) {
+      // Normalize to array for consistent handling
+      const values = normalizeValue(rawValue);
+
+      // 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.
+      const remappedValues = values.map((value) => {
+        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);
+          }
+        }
+        return remappedValue;
+      });
+
+      // Use array if multiple values, string if single
+      const remappedValue =
+        remappedValues.length === 1 ? remappedValues[0] : remappedValues;
+      const firstRemappedValue = remappedValues[0];
+
       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;
@@ -217,45 +254,32 @@ export default function mergeStatements(statements: Statement[]) {
   // If we have equivalentVariables[A] = B, and structure[A] is more specific than structure[B],
   // then update structure[B] to match structure[A]
   // This handles cases like: "state" -> "signature[0]" where "state" has a union type
-
-  // Debug: Log union types in merged structure
-  const unionTypesInStructure = Object.entries(structure).filter(
-    ([_, v]) => typeof v === 'string' && v.includes("'") && v.includes(' | '),
-  );
-  if (unionTypesInStructure.length > 0) {
-    console.log(
-      `[UNION-TYPE] mergeStatements: Found ${unionTypesInStructure.length} union types in merged structure`,
-    );
-    unionTypesInStructure.forEach(([k, v]) =>
-      console.log(`[UNION-TYPE]   structure["${k}"] = ${v}`),
-    );
-    console.log(
-      `[UNION-TYPE] mergeStatements: equivalentVariables = ${JSON.stringify(equivalentVariables)}`,
-    );
-  }
-
-  for (const [source, target] of Object.entries(equivalentVariables) as [
-    string,
+  for (const [source, rawTarget] of Object.entries(equivalentVariables) as [
     string,
+    string | string[],
   ][]) {
+    // Normalize to array for consistent handling
+    const targets = Array.isArray(rawTarget) ? rawTarget : [rawTarget];
     const sourceType = structure[source];
-    const targetType = structure[target];
 
-    // Check if source has a more specific type (union type vs generic type)
-    if (sourceType) {
-      const sourceIsUnion =
-        sourceType.includes("'") && sourceType.includes(' | ');
+    for (const target of targets) {
+      if (typeof target !== 'string') continue;
 
-      if (sourceIsUnion) {
-        // Target doesn't exist or is generic - propagate the union type
-        const targetIsGeneric =
-          !targetType || targetType === 'string' || targetType === 'unknown';
+      const targetType = structure[target];
 
-        if (targetIsGeneric) {
-          console.log(
-            `[UNION-TYPE] mergeStatements: Propagating "${source}" (${sourceType}) -> "${target}"`,
-          );
-          structure[target] = sourceType;
+      // Check if source has a more specific type (union type vs generic type)
+      if (sourceType) {
+        const sourceIsUnion =
+          sourceType.includes("'") && sourceType.includes(' | ');
+
+        if (sourceIsUnion) {
+          // Target doesn't exist or is generic - propagate the union type
+          const targetIsGeneric =
+            !targetType || targetType === 'string' || targetType === 'unknown';
+
+          if (targetIsGeneric) {
+            structure[target] = sourceType;
+          }
         }
       }
     }