@codeyam/codeyam-cli 0.1.0-staging.323686 → 0.1.0-staging.4813bf3

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

@@ -105,6 +105,19 @@ export default function generateExecutionFlows({
     fullToShortPathMap[fullPath] = shortPath;
   }
 
+  console.log(
+    `[generateExecutionFlows] ${entity.name}: attributesMap has ${Object.keys(resolvedAttributesMap).length} keys, fullToShortPathMap has ${Object.keys(fullToShortPathMap).length} entries`,
+  );
+  console.log(
+    `[generateExecutionFlows] ${entity.name}: attributesMap keys: [${Object.keys(resolvedAttributesMap).join(', ')}]`,
+  );
+  console.log(
+    `[generateExecutionFlows] ${entity.name}: fullToShortPathMap: ${JSON.stringify(fullToShortPathMap)}`,
+  );
+  console.log(
+    `[generateExecutionFlows] ${entity.name}: equivalentSignatureVariables: ${JSON.stringify(equivalentSignatureVariables)}`,
+  );
+
   // Get pre-computed conditional data from metadata
   const conditionalUsages: Record<string, ConditionalUsage[]> =
     entity.metadata?.isolatedDataStructure?.conditionalUsages ?? {};
@@ -143,11 +156,32 @@ export default function generateExecutionFlows({
             childIsolated.equivalentSignatureVariables ?? {},
           compoundConditionals: childIsolated.compoundConditionals ?? [],
           gatingConditions,
+          jsxRenderingUsages: childIsolated.jsxRenderingUsages ?? [],
         };
       }
     }
   }
 
+  console.log(
+    `[generateExecutionFlows] ${entity.name}: conditionalUsages keys: [${Object.keys(conditionalUsages).join(', ')}]`,
+  );
+  console.log(
+    `[generateExecutionFlows] ${entity.name}: conditionalUsages sourceDataPaths: ${JSON.stringify(
+      Object.fromEntries(
+        Object.entries(conditionalUsages).map(([k, v]) => [
+          k,
+          (v as any[]).map((u: any) => u.sourceDataPath ?? '(none)'),
+        ]),
+      ),
+    )}`,
+  );
+  console.log(
+    `[generateExecutionFlows] ${entity.name}: compoundConditionals count: ${compoundConditionals.length}`,
+  );
+  console.log(
+    `[generateExecutionFlows] ${entity.name}: sourceEquivalencies keys count: ${Object.keys(mergedDataStructure.sourceEquivalencies ?? {}).length}`,
+  );
+
   const conditionalsBasedFlows = generateExecutionFlowsFromConditionals({
     conditionalUsages,
     compoundConditionals,
@@ -159,6 +193,7 @@ export default function generateExecutionFlows({
         ? childComponentData
         : undefined,
     derivedVariables,
+    sourceEquivalencies: mergedDataStructure.sourceEquivalencies,
   });
 
   console.log(
@@ -253,7 +288,7 @@ export default function generateExecutionFlows({
  */
 function buildGatingPathToChildrenMap(
   childBoundaryGatingConditions: Record<string, ConditionalUsage[]>,
-  equivalentSignatureVariables: Record<string, string>,
+  equivalentSignatureVariables: Record<string, string | string[]>,
   attributesMap: Record<string, string>,
   fullToShortPathMap: Record<string, string>,
 ): Map<string, string[]> {
@@ -279,10 +314,13 @@ function buildGatingPathToChildrenMap(
         fullToShortPathMap,
       );
 
+      // Get the equivalent, handling array case (use first element if array)
+      const equiv = equivalentSignatureVariables[gatingPath];
+      const equivPath = Array.isArray(equiv) ? equiv[0] : equiv;
       const finalPath =
         resolution.isControllable && resolution.resolvedPath
           ? resolution.resolvedPath
-          : (equivalentSignatureVariables[gatingPath] ?? gatingPath);
+          : (equivPath ?? gatingPath);
 
       // Add this child to the list of children gated by this path
       const existing = gatingPathToChildren.get(finalPath) ?? [];
@@ -303,10 +341,13 @@ function buildGatingPathToChildrenMap(
           equivalentSignatureVariables,
           fullToShortPathMap,
         );
+        // Get the equivalent, handling array case (use first element if array)
+        const varEquiv = equivalentSignatureVariables[varName];
+        const varEquivPath = Array.isArray(varEquiv) ? varEquiv[0] : varEquiv;
         const resolvedVarPath =
           varResolution.isControllable && varResolution.resolvedPath
             ? varResolution.resolvedPath
-            : (equivalentSignatureVariables[varName] ?? varName);
+            : (varEquivPath ?? varName);
 
         const varExisting = gatingPathToChildren.get(resolvedVarPath) ?? [];
         if (!varExisting.includes(childName)) {
@@ -495,8 +536,11 @@ function buildValueGroupMap(flows: ExecutionFlow[]): Map<string, string[]> {
   for (const [, flowValues] of pathToValues) {
     // Only create groups if there are multiple different values for the same path
     const uniqueValues = new Set(flowValues.map((fv) => fv.value));
-    if (uniqueValues.size > 1) {
-      // This attribute has multiple values, so all flows are siblings
+    if (uniqueValues.size > 1 && flowValues.length <= 10) {
+      // This attribute has multiple values, so all flows are siblings.
+      // Skip large groups (>10 flows) — these are typically shared gating conditions
+      // (like route params) that would dominate the selection by pulling in too many
+      // siblings and displacing higher-priority flows.
       const siblingIds = flowValues.map((fv) => fv.flowId);
       for (const fv of flowValues) {
         valueGroupMap.set(

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

@@ -18,7 +18,7 @@ export interface GenerateExecutionFlowsOptions {
   /** Map of controllable paths to their types (for path resolution) */
   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>;
   /**