@codeyam/codeyam-cli 0.1.0-staging.e090cb3 → 0.1.0-staging.eb21b2f

package/analyzer-template/.build-info.json

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-02-12T23:50:24.548Z",
-  "buildTime": 1770940224548,
-  "gitCommit": "e090cb37d89776c7e2c35ef0b8abba954004f457",
+  "buildTimestamp": "2026-02-14T10:09:30.576Z",
+  "buildTime": 1771063770576,
+  "gitCommit": "eb21b2f5ac2124ce27c80ffc92fb7f8aad27e383",
   "nodeVersion": "v20.20.0",
-  "contentHash": "137e331d30c083a78ae7f8a1b9366f0cbefd882b8f0f7858cb3fb8501bf391ad",
-  "buildNumber": 618,
-  "semanticVersion": "0.1.618",
-  "version": "0.1.618 (2026-02-12T23:50+137e331)"
+  "contentHash": "7f2a19190511996b687bdd764ab6297993590ece837b6bbdec8bda87b904ab50",
+  "buildNumber": 625,
+  "semanticVersion": "0.1.625",
+  "version": "0.1.625 (2026-02-14T10:09+7f2a191)"
 }

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[2/12/2026, 11:50:24 PM] > codeyam-combo@1.0.0 mergeDependencies
-[2/12/2026, 11:50:24 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[2/14/2026, 10:09:30 AM] > codeyam-combo@1.0.0 mergeDependencies
+[2/14/2026, 10:09:30 AM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[2/12/2026, 11:50:24 PM] Merged dependencies into root package.json
+[2/14/2026, 10:09:30 AM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -8,7 +8,7 @@
   },
   "dependencies": {
     "@aws-sdk/client-cloudwatch-logs": "^3.980.0",
-    "@aws-sdk/client-cloudfront": "^3.966.0",
+    "@aws-sdk/client-cloudfront": "^3.985.0",
     "@aws-sdk/client-codebuild": "^3.948.0",
     "@aws-sdk/client-dynamodb": "^3.956.0",
     "@aws-sdk/client-ec2": "^3.899.0",

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

@@ -14,35 +14,46 @@ const isStandaloneIndex = (s?: string) => !!s && STANDALONE_INDEX_RE.test(s);
 // The regex matches any path ending with .length that has [] somewhere before it
 const DYNAMIC_LENGTH_RE = /\[\].*\.length$/;
 
-// Treat these as structural placeholders (don't commit them as concrete leaves)
-function isSkippableLeafType(t: string) {
-  // 'unknown' by itself is a placeholder (but 'boolean | unknown' is not)
-  // Also handles optional variants like 'object | undefined', 'object | null',
-  // 'array | undefined', etc. — these are still structural placeholders that
-  // should not overwrite already-populated structures.
+// Cache for type string analysis to avoid repeated split/filter operations.
+// These functions are called multiple times per path segment across thousands of paths.
+const typeAnalysisCache = new Map<
+  string,
+  { isSkippable: boolean; baseType: string; isNullable: boolean }
+>();
+
+function getTypeAnalysis(t: string) {
+  const cached = typeAnalysisCache.get(t);
+  if (cached) return cached;
   const parts = t.split('|').map((s) => s.trim());
   const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
-  return (
-    base.length === 1 &&
-    (base[0] === 'object' ||
-      base[0] === 'array' ||
-      base[0] === 'function' ||
-      base[0] === 'unknown')
-  );
+  const result = {
+    isSkippable:
+      base.length === 1 &&
+      (base[0] === 'object' ||
+        base[0] === 'array' ||
+        base[0] === 'function' ||
+        base[0] === 'unknown'),
+    baseType: base[0],
+    isNullable: parts.includes('undefined') || parts.includes('null'),
+  };
+  typeAnalysisCache.set(t, result);
+  return result;
+}
+
+// Treat these as structural placeholders (don't commit them as concrete leaves)
+function isSkippableLeafType(t: string) {
+  return getTypeAnalysis(t).isSkippable;
 }
 
 // Extract the base structural type from a potentially nullable type string.
 // e.g., 'object | undefined' → 'object', 'array | null' → 'array'
 function getBaseSkippableType(t: string): string {
-  const parts = t.split('|').map((s) => s.trim());
-  const base = parts.filter((s) => s !== 'undefined' && s !== 'null');
-  return base[0];
+  return getTypeAnalysis(t).baseType;
 }
 
 // Check if a type string has nullable annotations (| undefined or | null)
 function isNullableType(t: string): boolean {
-  const parts = t.split('|').map((s) => s.trim());
-  return parts.includes('undefined') || parts.includes('null');
+  return getTypeAnalysis(t).isNullable;
 }
 
 // Matches paths containing [][] — e.g., "items[][]" or "items[][].text"

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

@@ -4,10 +4,10 @@ import type { ExecutionFlow, ScenariosDataStructure } from '~codeyam/types';
 type RequiredValue = NonNullable<ExecutionFlow['requiredValues']>[number];
 
 const DEFAULT_MAX_CHUNK_SIZE = 10_000; // ~10K chars per chunk
+const DEFAULT_MAX_KEYS_PER_CHUNK = 20;
 
 export interface ChunkOptions {
   maxChunkSize?: number;
-  /** @deprecated Use maxChunkSize instead. Kept for backward compatibility in tests. */
   maxKeysPerChunk?: number;
 }
 
@@ -33,16 +33,19 @@ export function chunkDataStructure(
     return [dataForMocks];
   }
 
-  const { maxChunkSize = DEFAULT_MAX_CHUNK_SIZE } = options;
+  const {
+    maxChunkSize = DEFAULT_MAX_CHUNK_SIZE,
+    maxKeysPerChunk = DEFAULT_MAX_KEYS_PER_CHUNK,
+  } = options;
   const keys = Object.keys(dataForMocks);
 
   // Calculate total size to see if chunking is needed
   const totalSize = JSON.stringify(dataForMocks).length;
-  if (totalSize <= maxChunkSize) {
+  if (totalSize <= maxChunkSize && keys.length <= maxKeysPerChunk) {
     return [dataForMocks];
   }
 
-  // Greedily pack keys into chunks by cumulative size
+  // Greedily pack keys into chunks by cumulative size and key count
   const chunks: Array<ScenariosDataStructure['dataForMocks']> = [];
   let currentChunk: Record<string, unknown> = {};
   let currentSize = 0;
@@ -52,8 +55,14 @@ export function chunkDataStructure(
       (dataForMocks as Record<string, unknown>)[key],
     ).length;
 
-    // If adding this key would exceed the limit AND chunk isn't empty, start a new chunk
-    if (currentSize > 0 && currentSize + keySize > maxChunkSize) {
+    const currentKeyCount = Object.keys(currentChunk).length;
+
+    // If adding this key would exceed size or key count limit AND chunk isn't empty, start a new chunk
+    if (
+      currentSize > 0 &&
+      (currentSize + keySize > maxChunkSize ||
+        currentKeyCount >= maxKeysPerChunk)
+    ) {
       chunks.push(currentChunk as ScenariosDataStructure['dataForMocks']);
       currentChunk = {};
       currentSize = 0;

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

@@ -32,6 +32,30 @@ import resolvePathToControllable from './resolvePathToControllable';
 import { AI } from '~codeyam/ai';
 import type { JsxRenderingUsage, ConditionalUsage } from './astScopes/types';
 
+/**
+ * Patterns that indicate a child component is a modal/overlay/blocking element.
+ * Same patterns used in generateExecutionFlowsFromConditionalEffects.ts for
+ * state variable names — here applied to child component names.
+ */
+const BLOCKING_CHILD_PATTERNS = [
+  /modal/i,
+  /overlay/i,
+  /dialog/i,
+  /popup/i,
+  /drawer/i,
+  /sheet/i,
+  /lightbox/i,
+  /backdrop/i,
+];
+
+/**
+ * Check if a child component name suggests it's a blocking/modal element.
+ * Exported for testing.
+ */
+export function isBlockingChildComponent(componentName: string): boolean {
+  return BLOCKING_CHILD_PATTERNS.some((pattern) => pattern.test(componentName));
+}
+
 interface GenerateExecutionFlowsArgs {
   entity: Pick<Entity, 'sha' | 'name' | 'filePath' | 'code' | 'metadata'>;
   mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>;
@@ -273,6 +297,11 @@ export default function generateExecutionFlows({
     calculateFlowPriority(flow, gatingPathToChildren);
   }
 
+  // Assign exclusiveGroup for truthy/falsy flow pairs that control child components.
+  // When the same gating path produces both a truthy flow (show component) and a
+  // falsy flow (hide component), they are mutually exclusive and should be grouped.
+  assignExclusiveGroupsForGatingPairs(allFlows);
+
   // Sort flows by priority (highest first)
   allFlows.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
 
@@ -361,6 +390,60 @@ function buildGatingPathToChildrenMap(
   return gatingPathToChildren;
 }
 
+/**
+ * Assign exclusiveGroup for truthy/falsy flow pairs that control child components.
+ *
+ * When the same attribute path produces both a truthy and falsy flow (e.g.,
+ * {diffView && <DiffModal/>}), they are mutually exclusive — only one can be
+ * active at a time. Grouping them ensures the scenario generator treats them
+ * as alternative states rather than combining them.
+ */
+function assignExclusiveGroupsForGatingPairs(flows: ExecutionFlow[]): void {
+  // Build a map: attributePath -> flows with truthy or falsy comparison for that path
+  const pathToFlows = new Map<
+    string,
+    { truthy: ExecutionFlow[]; falsy: ExecutionFlow[] }
+  >();
+
+  for (const flow of flows) {
+    // Only consider flows that control child components
+    if (!flow.childComponentsControlled?.length) continue;
+
+    for (const rv of flow.requiredValues) {
+      if (rv.comparison === 'truthy' || rv.comparison === 'falsy') {
+        if (!pathToFlows.has(rv.attributePath)) {
+          pathToFlows.set(rv.attributePath, { truthy: [], falsy: [] });
+        }
+        pathToFlows.get(rv.attributePath)![rv.comparison].push(flow);
+      }
+    }
+  }
+
+  // Also check falsy flows that DON'T have childComponentsControlled —
+  // they still pair with truthy flows that do
+  for (const flow of flows) {
+    if (flow.childComponentsControlled?.length) continue; // Already processed
+
+    for (const rv of flow.requiredValues) {
+      if (rv.comparison === 'falsy' && pathToFlows.has(rv.attributePath)) {
+        pathToFlows.get(rv.attributePath)!.falsy.push(flow);
+      }
+    }
+  }
+
+  // Assign exclusiveGroup where both truthy and falsy flows exist
+  for (const [attributePath, { truthy, falsy }] of pathToFlows) {
+    if (truthy.length > 0 && falsy.length > 0) {
+      const groupName = `gating:${attributePath}`;
+      for (const flow of [...truthy, ...falsy]) {
+        if (!flow.exclusiveGroup) {
+          flow.exclusiveGroup = groupName;
+        }
+      }
+    }
+  }
+}
+
 /**
  * Calculate priority and childComponentsControlled for a flow.
  *
@@ -415,6 +498,19 @@ function calculateFlowPriority(
     if (flow.impact !== 'high') {
       flow.impact = 'high';
     }
+
+    // Check if any controlled child component is a modal/dialog/overlay.
+    // Only truthy flows (which SHOW the component) should be marked as blocking.
+    // Falsy flows (which HIDE the component) should not be blocking.
+    const isTruthyFlow = flow.requiredValues.some(
+      (rv) => rv.comparison === 'truthy' || rv.comparison === 'equals',
+    );
+    if (
+      isTruthyFlow &&
+      Array.from(childComponentsControlled).some(isBlockingChildComponent)
+    ) {
+      flow.blocksOtherFlows = true;
+    }
   }
 
   // Calculate priority score

package/analyzer-template/packages/analyze/src/lib/files/scenarios/gatherDataForMocks.ts

@@ -353,8 +353,6 @@ function processCall(
   // Preprocess to filter signatures and extract functionCallReturnValue
   let preprocessedSchema = preprocessSchemaForMocks(mergedSchema);
 
-  const functionNames: string[] = [];
-
   const isFunctionNameWithoutFunction = (
     path: string,
     functionName: string,
@@ -439,31 +437,58 @@ function processCall(
     }
   }
 
-  const relevantMergedDependencySchema = Object.keys(preprocessedSchema).reduce(
-    (acc, path) => {
-      if (path.endsWith(')')) {
-        const pathParts = splitOutsideParenthesesAndArrays(path);
-        const functionName = joinParenthesesAndArrays([
-          ...pathParts.slice(0, -1),
-          pathParts[pathParts.length - 1].split('(')[0],
-        ]);
-        functionNames.push(functionName);
-        for (const existingPath in acc) {
-          if (isFunctionNameWithoutFunction(existingPath, functionName)) {
-            delete acc[existingPath];
-          }
-        }
-      }
+  // Two-pass function name filtering to avoid O(k²) retroactive deletion.
+  // Pass 1: Discover all unique function names from paths ending with ')'
+  const functionNameSet = new Set<string>();
+  const schemaKeys = Object.keys(preprocessedSchema);
+  for (const path of schemaKeys) {
+    if (path.endsWith(')')) {
+      const pathParts = splitOutsideParenthesesAndArrays(path);
+      const functionName = joinParenthesesAndArrays([
+        ...pathParts.slice(0, -1),
+        pathParts[pathParts.length - 1].split('(')[0],
+      ]);
+      functionNameSet.add(functionName);
+    }
+  }
 
-      if (functionNames.some((fn) => isFunctionNameWithoutFunction(path, fn))) {
-        return acc;
-      }
+  // Index function names by first segment for O(1) bucket lookup instead of
+  // checking all function names for every path. Most paths only need to check
+  // 1-2 function names instead of all F.
+  const fnByFirstSegment = new Map<string, string[]>();
+  for (const fn of functionNameSet) {
+    const dotIdx = fn.indexOf('.');
+    const firstSeg = dotIdx >= 0 ? fn.slice(0, dotIdx) : fn;
+    let bucket = fnByFirstSegment.get(firstSeg);
+    if (!bucket) {
+      bucket = [];
+      fnByFirstSegment.set(firstSeg, bucket);
+    }
+    bucket.push(fn);
+  }
 
-      acc[path] = preprocessedSchema[path];
-      return acc;
-    },
-    {} as Record<string, string>,
-  );
+  // Pass 2: Filter paths that match any discovered function name prefix.
+  // Use indexed lookup: extract path's first segment, check only matching function names.
+  const relevantMergedDependencySchema: Record<string, string> = {};
+  for (const path of schemaKeys) {
+    // Extract first segment of path (before first '.', '(', or '<')
+    const dotIdx = path.indexOf('.');
+    const parenIdx = path.indexOf('(');
+    const angleIdx = path.indexOf('<');
+    let minIdx = path.length;
+    if (dotIdx >= 0 && dotIdx < minIdx) minIdx = dotIdx;
+    if (parenIdx >= 0 && parenIdx < minIdx) minIdx = parenIdx;
+    if (angleIdx >= 0 && angleIdx < minIdx) minIdx = angleIdx;
+    const firstSeg = path.slice(0, minIdx);
+
+    const candidates = fnByFirstSegment.get(firstSeg);
+    if (
+      !candidates ||
+      !candidates.some((fn) => isFunctionNameWithoutFunction(path, fn))
+    ) {
+      relevantMergedDependencySchema[path] = preprocessedSchema[path];
+    }
+  }
 
   const filledSchema = fillInDirectSchemaGapsAndUnknowns({
     scopeName: importedExport.name,