@codeyam/codeyam-cli 0.1.0-staging.c90f8c9 → 0.1.0-staging.c9dc00c

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

@@ -18,6 +18,7 @@ import type {
   CompoundConditional,
   DerivedVariableOperation,
   DerivedVariableInfo,
+  JsxRenderingUsage,
 } from './astScopes/types';
 import type { EnrichedConditionalUsage } from './worker/SerializableDataStructure';
 import resolvePathToControllable from './resolvePathToControllable';
@@ -32,7 +33,7 @@ export interface ChildComponentConditionalData {
   /** Child's conditional usages keyed by variable name (may include sourceDataPath from enrichment) */
   conditionalUsages: Record<string, ExtendedConditionalUsage[]>;
   /** Child's equivalent signature variables (maps internal paths to prop paths) */
-  equivalentSignatureVariables: Record<string, string>;
+  equivalentSignatureVariables: Record<string, string | string[]>;
   /** Child's compound conditionals */
   compoundConditionals: CompoundConditional[];
   /**
@@ -41,6 +42,11 @@ export interface ChildComponentConditionalData {
    * then `hasAnalysis` is a gating condition for all of ChildComponent's flows.
    */
   gatingConditions?: ConditionalUsage[];
+  /**
+   * Child's JSX rendering usages (arrays rendered via .map(), text interpolation).
+   * These generate "variation flows" for different array lengths.
+   */
+  jsxRenderingUsages?: JsxRenderingUsage[];
 }
 
 export interface GenerateFlowsFromConditionalsArgs {
@@ -51,7 +57,7 @@ export interface GenerateFlowsFromConditionalsArgs {
   /** Map of controllable paths to their types */
   attributesMap: Record<string, string>;
   /** Map from local variable names to data sources */
-  equivalentSignatureVariables: Record<string, string>;
+  equivalentSignatureVariables: Record<string, string | string[]>;
   /** Map from full paths to short paths */
   fullToShortPathMap: Record<string, string>;
   /**
@@ -73,6 +79,21 @@ export interface GenerateFlowsFromConditionalsArgs {
    * to `currentRun.entityShas` when `isInCurrentRun` isn't in conditionalUsages.
    */
   derivedVariables?: Record<string, DerivedVariableInfo>;
+  /**
+   * Optional map of child prop paths to their actual data sources.
+   * Used when child props flow through useState but ultimately come from
+   * mockable data sources (e.g., API calls, fetchers).
+   *
+   * Example:
+   * - "WorkoutsView().signature[0].workouts" → "createClient()...functionCallReturnValue.data"
+   *
+   * When a child path translates to a useState value, we check this map
+   * to find the real data source that can be mocked.
+   */
+  sourceEquivalencies?: Record<
+    string,
+    Array<{ scopeNodeName: string; schemaPath: string }>
+  >;
 }
 
 /**
@@ -117,7 +138,7 @@ function expandDerivedVariableToSources(
   path: string,
   conditionalUsages: Record<string, ConditionalUsage[]>,
   attributesMap: Record<string, string>,
-  equivalentSignatureVariables: Record<string, string>,
+  equivalentSignatureVariables: Record<string, string | string[]>,
   fullToShortPathMap: Record<string, string>,
   visited: Set<string> = new Set(),
   derivedVariables?: Record<string, DerivedVariableInfo>,
@@ -387,6 +408,20 @@ function findInAttributesMapForPath(
   return null;
 }
 
+/**
+ * Generate a slug from a path for use in flow IDs and exclusive groups.
+ */
+function pathToSlug(path: string): string {
+  return path
+    .replace(/\[\d+\]/g, '')
+    .replace(/\[\]/g, '')
+    .replace(/\(\)/g, '')
+    .replace(/\.functionCallReturnValue/g, '')
+    .replace(/[<>]/g, '')
+    .replace(/\./g, '-')
+    .toLowerCase();
+}
+
 /**
  * Generate a human-readable name from a path.
  * Extracts the last meaningful part of the path.
@@ -732,8 +767,8 @@ function normalizePathForDeduplication(
  */
 function translateChildPathToParent(
   childPath: string,
-  childEquivalentSignatureVariables: Record<string, string>,
-  parentEquivalentSignatureVariables: Record<string, string>,
+  childEquivalentSignatureVariables: Record<string, string | string[]>,
+  parentEquivalentSignatureVariables: Record<string, string | string[]>,
   childName: string,
 ): string | null {
   // Extract the root variable from the child path
@@ -760,7 +795,11 @@ function translateChildPathToParent(
 
   // Look up the child's equivalence for this root variable
   // e.g., childEquiv[selectedScenario] = "signature[0].selectedScenario"
-  const childPropPath = childEquivalentSignatureVariables[rootVar];
+  // Handle array case (OR expressions) - use first element if array
+  const rawChildPropPath = childEquivalentSignatureVariables[rootVar];
+  const childPropPath = Array.isArray(rawChildPropPath)
+    ? rawChildPropPath[0]
+    : rawChildPropPath;
 
   if (!childPropPath) {
     // No mapping found - this might be internal state, not a prop
@@ -773,7 +812,11 @@ function translateChildPathToParent(
 
   // Look up parent's equivalence to find what value was passed to this prop
   // e.g., parentEquiv["ChildName().signature[0].selectedScenario"] = "selectedScenario"
-  const parentValue = parentEquivalentSignatureVariables[fullChildPropPath];
+  // Handle array case (OR expressions) - use first element if array
+  const rawParentValue = parentEquivalentSignatureVariables[fullChildPropPath];
+  const parentValue = Array.isArray(rawParentValue)
+    ? rawParentValue[0]
+    : rawParentValue;
 
   if (!parentValue) {
     // No parent mapping found - log ALL parent keys that contain the childName
@@ -800,6 +843,7 @@ export default function generateExecutionFlowsFromConditionals(
     fullToShortPathMap,
     childComponentData,
     derivedVariables,
+    sourceEquivalencies,
   } = args;
 
   const flows: ExecutionFlow[] = [];
@@ -1771,6 +1815,69 @@ export default function generateExecutionFlowsFromConditionals(
               }
             }
 
+            // Fallback 2: Try sourceEquivalencies to find the actual data source
+            // This handles the case where props flow through useState but originate
+            // from a mockable data source (e.g., API call, fetcher).
+            //
+            // Example: WorkoutsView receives `workouts` prop which in parent is stored
+            // in useState, but ultimately comes from a Supabase query.
+            // sourceEquivalencies tells us: "WorkoutsView().signature[0].workouts" → "createClient()...data"
+            if (!resolvedPath && sourceEquivalencies) {
+              // Build the child prop path to look up in sourceEquivalencies
+              // Format: "ChildName().signature[0].propName"
+              // First, find what prop this child path maps to
+              let childPropName: string | null = null;
+              for (const [varName, varPath] of Object.entries(
+                childData.equivalentSignatureVariables,
+              )) {
+                // Check if childPath starts with this variable name
+                // e.g., childPath = "workouts.length", varName = "workouts", varPath = "signature[0].workouts"
+                if (
+                  childPath === varName ||
+                  childPath.startsWith(`${varName}.`)
+                ) {
+                  childPropName = varName;
+                  break;
+                }
+              }
+
+              if (childPropName) {
+                // Build the full sourceEquivalencies key
+                const sourceEquivKey = `${childName}().signature[0].${childPropName}`;
+
+                const sourceEquivEntry = sourceEquivalencies[sourceEquivKey];
+                if (sourceEquivEntry && sourceEquivEntry.length > 0) {
+                  const dataSourcePath = sourceEquivEntry[0].schemaPath;
+
+                  // Check if this data source path is controllable
+                  const dataSourceResolution = resolvePathToControllable(
+                    dataSourcePath,
+                    attributesMap,
+                    equivalentSignatureVariables,
+                    fullToShortPathMap,
+                  );
+
+                  if (
+                    dataSourceResolution.isControllable &&
+                    dataSourceResolution.resolvedPath
+                  ) {
+                    // Preserve any suffix from the child path
+                    // e.g., childPath = "workouts.length" → suffix = ".length"
+                    const suffix = childPath.startsWith(`${childPropName}.`)
+                      ? childPath.slice(childPropName.length)
+                      : '';
+                    resolvedPath = dataSourceResolution.resolvedPath + suffix;
+
+                    if (shouldDebugChild) {
+                      console.log(
+                        `[DEBUG CHILD ${childName}]   sourceEquivalencies fallback SUCCESS: using data source ${resolvedPath}`,
+                      );
+                    }
+                  }
+                }
+              }
+            }
+
             // If still not resolved after fallback, skip
             if (!resolvedPath) {
               if (shouldDebugChild) {
@@ -1970,6 +2077,189 @@ export default function generateExecutionFlowsFromConditionals(
           }
         }
       }
+
+      // Process child's jsxRenderingUsages (array.map flows)
+      // This generates array variation flows (empty, few, many) for arrays rendered in child
+      if (childData.jsxRenderingUsages) {
+        for (const jsxUsage of childData.jsxRenderingUsages) {
+          // Translate the child path to a parent path
+          const translatedPath = translateChildPathToParent(
+            jsxUsage.path,
+            childData.equivalentSignatureVariables,
+            equivalentSignatureVariables,
+            childName,
+          );
+
+          if (!translatedPath) {
+            continue;
+          }
+
+          // Resolve to controllable path in parent context
+          const resolution = resolvePathToControllable(
+            translatedPath,
+            attributesMap,
+            equivalentSignatureVariables,
+            fullToShortPathMap,
+          );
+
+          let resolvedPath = resolution.resolvedPath;
+
+          // Try sourceEquivalencies fallback if not controllable
+          if (!resolution.isControllable || !resolvedPath) {
+            if (sourceEquivalencies) {
+              // Build the sourceEquivalencies key
+              // The child path (e.g., "workouts") maps to a prop path (e.g., "signature[0].workouts")
+              let childPropName: string | null = null;
+              for (const [varName, varPath] of Object.entries(
+                childData.equivalentSignatureVariables,
+              )) {
+                if (
+                  jsxUsage.path === varName ||
+                  jsxUsage.path.startsWith(`${varName}.`)
+                ) {
+                  childPropName = varName;
+                  break;
+                }
+              }
+
+              if (childPropName) {
+                const sourceEquivKey = `${childName}().signature[0].${childPropName}`;
+                const sourceEquivEntry = sourceEquivalencies[sourceEquivKey];
+
+                if (sourceEquivEntry && sourceEquivEntry.length > 0) {
+                  const dataSourcePath = sourceEquivEntry[0].schemaPath;
+
+                  const dataSourceResolution = resolvePathToControllable(
+                    dataSourcePath,
+                    attributesMap,
+                    equivalentSignatureVariables,
+                    fullToShortPathMap,
+                  );
+
+                  if (
+                    dataSourceResolution.isControllable &&
+                    dataSourceResolution.resolvedPath
+                  ) {
+                    resolvedPath = dataSourceResolution.resolvedPath;
+                  }
+                }
+              }
+            }
+          }
+
+          if (!resolvedPath) {
+            continue;
+          }
+
+          // Check for duplicates
+          const normalizedPath = normalizePathForDeduplication(
+            resolvedPath,
+            fullToShortPathMap,
+          );
+          const dedupeKey = `${normalizedPath}:${jsxUsage.renderingType}`;
+          if (seenNormalizedPaths.has(dedupeKey)) {
+            continue;
+          }
+          seenNormalizedPaths.add(dedupeKey);
+
+          // Generate array variation flows for array-map rendering
+          if (jsxUsage.renderingType === 'array-map') {
+            const baseName = generateNameFromPath(resolvedPath);
+            const pathSlug = pathToSlug(resolvedPath);
+            const exclusiveGroup = `array-length-${pathSlug}`;
+
+            // Empty array flow
+            const emptyFlow: ExecutionFlow = {
+              id: `${pathSlug}-empty-array`,
+              name: `${baseName} Empty`,
+              description: `When ${baseName.toLowerCase()} array is empty`,
+              requiredValues: [
+                {
+                  attributePath: resolvedPath,
+                  value: '0',
+                  comparison: 'length<',
+                  valueType: 'array',
+                },
+                ...gatingRequiredValues,
+              ],
+              impact: 'medium',
+              exclusiveGroup,
+              sourceLocation: jsxUsage.sourceLocation
+                ? {
+                    lineNumber: jsxUsage.sourceLocation.lineNumber,
+                    column: jsxUsage.sourceLocation.column,
+                  }
+                : undefined,
+              codeSnippet: jsxUsage.sourceLocation?.codeSnippet,
+            };
+
+            if (!seenFlowIds.has(emptyFlow.id)) {
+              seenFlowIds.add(emptyFlow.id);
+              flows.push(emptyFlow);
+            }
+
+            // Few items flow (1-3)
+            const fewFlow: ExecutionFlow = {
+              id: `${pathSlug}-few-items`,
+              name: `${baseName} Few Items`,
+              description: `When ${baseName.toLowerCase()} array has 1-3 items`,
+              requiredValues: [
+                {
+                  attributePath: resolvedPath,
+                  value: '3',
+                  comparison: 'length<',
+                  valueType: 'array',
+                },
+                ...gatingRequiredValues,
+              ],
+              impact: 'low',
+              exclusiveGroup,
+              sourceLocation: jsxUsage.sourceLocation
+                ? {
+                    lineNumber: jsxUsage.sourceLocation.lineNumber,
+                    column: jsxUsage.sourceLocation.column,
+                  }
+                : undefined,
+              codeSnippet: jsxUsage.sourceLocation?.codeSnippet,
+            };
+
+            if (!seenFlowIds.has(fewFlow.id)) {
+              seenFlowIds.add(fewFlow.id);
+              flows.push(fewFlow);
+            }
+
+            // Many items flow (10+)
+            const manyFlow: ExecutionFlow = {
+              id: `${pathSlug}-many-items`,
+              name: `${baseName} Many Items`,
+              description: `When ${baseName.toLowerCase()} array has many items`,
+              requiredValues: [
+                {
+                  attributePath: resolvedPath,
+                  value: '10',
+                  comparison: 'length>',
+                  valueType: 'array',
+                },
+                ...gatingRequiredValues,
+              ],
+              impact: 'low',
+              exclusiveGroup,
+              sourceLocation: jsxUsage.sourceLocation
+                ? {
+                    lineNumber: jsxUsage.sourceLocation.lineNumber,
+                    column: jsxUsage.sourceLocation.column,
+                  }
+                : undefined,
+              codeSnippet: jsxUsage.sourceLocation?.codeSnippet,
+            };
+
+            if (!seenFlowIds.has(manyFlow.id)) {
+              seenFlowIds.add(manyFlow.id);
+              flows.push(manyFlow);
+            }
+          }
+        }
+      }
     }
   }
 

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

@@ -19,7 +19,7 @@ export interface GenerateFlowsFromJsxUsagesArgs {
   /** Map of controllable paths to their types */
   attributesMap: Record<string, string>;
   /** Map from local variable names to data sources */
-  equivalentSignatureVariables: Record<string, string>;
+  equivalentSignatureVariables: Record<string, string | string[]>;
   /** Map from full paths to short paths */
   fullToShortPathMap: Record<string, string>;
   /** Structure map for type lookup */

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

@@ -743,6 +743,48 @@ function processScope({
   };
 }
 
+/**
+ * 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.
  *
@@ -792,9 +834,15 @@ export default function isolateScopes(
   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
-  if (isolatedScopes.text.trim().length === 0) {
+  // 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];