@codeyam/codeyam-cli 0.1.0-staging.483fdc2 → 0.1.0-staging.50df560

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

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-02-04T17:33:57.768Z",
-  "buildTime": 1770226437768,
-  "gitCommit": "483fdc20d9d24e266e9bca6a25b473ccb58957fd",
-  "nodeVersion": "v20.20.0",
-  "contentHash": "21dbd7d480c0c50901df9ce172ec9316ac759c210f7ad6216cdfbd7d9f65446e",
-  "buildNumber": 563,
-  "semanticVersion": "0.1.563",
-  "version": "0.1.563 (2026-02-04T17:33+21dbd7d)"
+  "buildTimestamp": "2026-03-22T10:24:34.143Z",
+  "buildTime": 1774175074143,
+  "gitCommit": "50df560e6d0a0ee94acd11d575e2fddc31889a6f",
+  "nodeVersion": "v20.20.1",
+  "contentHash": "faebee669133648dadbd8892432f1e62fa8bbf062c5cc67690819cb8f39cfa86",
+  "buildNumber": 1148,
+  "semanticVersion": "0.1.1148",
+  "version": "0.1.1148 (2026-03-22T10:24+faebee6)"
 }

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[2/4/2026, 5:33:57 PM] > codeyam-combo@1.0.0 mergeDependencies
-[2/4/2026, 5:33:57 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[3/22/2026, 10:24:34 AM] > codeyam-combo@1.0.0 mergeDependencies
+[3/22/2026, 10:24:34 AM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[2/4/2026, 5:33:57 PM] Merged dependencies into root package.json
+[3/22/2026, 10:24:34 AM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -7,18 +7,18 @@
     "build": "tsc && node ./scripts/postbuild.cjs"
   },
   "dependencies": {
-    "@aws-sdk/client-cloudwatch-logs": "^3.980.0",
-    "@aws-sdk/client-cloudfront": "^3.966.0",
-    "@aws-sdk/client-codebuild": "^3.948.0",
-    "@aws-sdk/client-dynamodb": "^3.956.0",
-    "@aws-sdk/client-ec2": "^3.899.0",
-    "@aws-sdk/client-ecr": "^3.948.0",
-    "@aws-sdk/client-ecs": "^3.956.0",
-    "@aws-sdk/client-s3": "^3.940.0",
-    "@aws-sdk/client-sqs": "^3.956.0",
-    "@aws-sdk/lib-storage": "^3.975.0",
-    "@aws-sdk/util-dynamodb": "^3.971.0",
-    "@octokit/auth-app": "^8.1.0",
+    "@aws-sdk/client-cloudwatch-logs": "^3.990.0",
+    "@aws-sdk/client-cloudfront": "^3.990.0",
+    "@aws-sdk/client-codebuild": "^3.1000.0",
+    "@aws-sdk/client-dynamodb": "^3.990.0",
+    "@aws-sdk/client-ec2": "^3.990.0",
+    "@aws-sdk/client-ecr": "^3.990.0",
+    "@aws-sdk/client-ecs": "^3.990.0",
+    "@aws-sdk/client-s3": "^3.990.0",
+    "@aws-sdk/client-sqs": "^3.990.0",
+    "@aws-sdk/lib-storage": "^3.990.0",
+    "@aws-sdk/util-dynamodb": "^3.990.0",
+    "@octokit/auth-app": "^8.2.0",
     "@octokit/rest": "^22.0.0",
     "@sendgrid/mail": "^8.1.4",
     "@supabase/supabase-js": "2.88.0",
@@ -26,43 +26,43 @@
     "dotenv": "^17.2.3",
     "express": "^5.2.1",
     "get-port": "^7.1.0",
-    "htmlparser2": "^10.0.0",
+    "htmlparser2": "^10.1.0",
     "jest": "^30.2.0",
     "jsdom": "^27.4.0",
     "jsonc-parser": "^3.2.1",
-    "lru-cache": "^11.2.4",
+    "lru-cache": "^11.2.7",
     "openai": "^6.16.0",
-    "p-queue": "^8.1.0",
+    "p-queue": "^9.1.0",
     "p-retry": "^7.1.1",
     "piscina": "^5.1.4",
     "pixelmatch": "^5.3.0",
     "playwright": "1.58.0",
     "sharp": "^0.34.5",
-    "simple-git": "^3.28.0",
+    "simple-git": "^3.32.2",
     "undici": "^7.18.2",
     "uuid": "^11.1.0",
     "pluralize": "^8.0.0",
     "yargs": "^18.0.0",
     "json5": "^2.2.3",
-    "@anthropic-ai/sdk": "^0.71.0",
-    "@aws-sdk/s3-request-presigner": "^3.940.0",
-    "better-sqlite3": "^12.4.1",
+    "@anthropic-ai/sdk": "^0.78.0",
+    "@aws-sdk/s3-request-presigner": "^3.990.0",
+    "better-sqlite3": "^12.6.2",
     "fetch-retry": "^6.0.0",
-    "kysely": "^0.28.5",
-    "pg": "^8.16.3",
+    "kysely": "^0.28.14",
+    "pg": "^8.20.0",
     "@octokit/request": "^10.0.3",
-    "lucide-react": "^0.556.0",
+    "lucide-react": "^0.577.0",
     "react-resizable": "^3.0.5"
   },
   "devDependencies": {
     "typescript": "^5.9.3",
     "@jest/types": "^30.2.0",
-    "@types/node": "^25.0.2",
+    "@types/node": "^25.3.3",
     "@types/yargs": "^17.0.34",
     "@types/jsdom": "^27.0.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^30.0.0",
-    "@types/pg": "^8.15.5",
+    "@types/pg": "^8.18.0",
     "@types/ws": "^8.18.1",
     "@octokit/types": "^16.0.0",
     "@types/react": "^19.2.7",

package/analyzer-template/packages/ai/index.ts

@@ -43,6 +43,7 @@ export { default as isolateScopes } from './src/lib/isolateScopes';
 export {
   default as analyzeScope,
   destroyWorkerPool,
+  skipWorkerPool,
 } from './src/lib/analyzeScope';
 export { default as logOrderedMap } from './src/lib/logOrderedMap';
 export {

package/analyzer-template/packages/ai/package.json

@@ -9,12 +9,12 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.71.0",
+    "@anthropic-ai/sdk": "^0.78.0",
     "jsdom": "^27.4.0",
-    "p-queue": "^8.1.0",
+    "p-queue": "^9.1.0",
     "p-retry": "^7.1.1",
     "piscina": "^5.1.4",
-    "lru-cache": "^11.2.4"
+    "lru-cache": "^11.2.7"
   },
   "devDependencies": {
     "@types/jsdom": "^27.0.0"

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

@@ -50,6 +50,19 @@ let workerPool: Piscina<
   AnalyzeScopeWorkerOutput
 > | null = null;
 let workerPoolDestroyed = false;
+let workerPoolSkipped = false;
+
+/**
+ * Skip worker pool initialization for the current session.
+ *
+ * The worker thread creates its own ProjectAnalyzer (ts.Program), which takes
+ * 50-70s — far longer than the actual entity processing (<2s for typical batches).
+ * When the entity count is small, running analyzeScopeLocal on the main thread
+ * reuses the existing ProjectAnalyzer and avoids this overhead entirely.
+ */
+export function skipWorkerPool() {
+  workerPoolSkipped = true;
+}
 
 /**
  * Check if we're in Node.js main thread
@@ -108,6 +121,7 @@ function ensureWorkerPool() {
         'analyzeScope should not be called after data structure preparation completes.',
     );
   }
+  if (workerPoolSkipped) return;
   if (workerPool !== null) return;
 
   // Only initialize worker pool in Node.js environment
@@ -123,10 +137,17 @@ function ensureWorkerPool() {
   // Note: WORKER_PATH is null when __mocks__/analyzeScope.ts is active
   const { WORKER_PATH } = analyzeScopeWorkerPaths();
 
+  // Disable workers when tracing is enabled - we need access to ScopeDataStructure
+  // instance in the main thread to capture pre-serialization state
+  const tracingEnabled =
+    process.env.CODEYAM_TRACE_TRANSFORMS === '1' ||
+    process.env.CODEYAM_TRACE_TRANSFORMS === 'true';
+
   if (
     process.env.USE_WORKER_THREADS &&
     WORKER_PATH &&
-    fs.existsSync(WORKER_PATH)
+    fs.existsSync(WORKER_PATH) &&
+    !tracingEnabled
   ) {
     console.log('CodeYam: Using worker threads for analyzeScope', {
       WORKER_PATH,
@@ -159,6 +180,7 @@ function ensureWorkerPool() {
       WORKER_PATH,
       workerExists: WORKER_PATH ? fs.existsSync(WORKER_PATH) : false,
       USE_WORKER_THREADS: process.env.USE_WORKER_THREADS,
+      tracingEnabled,
     });
     workerPool = null; // Explicitly set to indicate "no workers"
   }

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

@@ -909,11 +909,42 @@ export class ASTScopeAnalyzer {
     if (tsType.flags & ts.TypeFlags.Union) {
       const unionType = tsType as ts.UnionType;
 
-      // Check if it's a string literal union
-      const isAllStringLiterals = unionType.types.every(
+      // Check if it's a string literal union (optionally with null/undefined).
+      // Preserve literal values so the LLM knows which values are valid when
+      // generating mock data. Without this, types like
+      // 'suggestion' | 'warning' | 'achievement' | 'tip' become just 'string'
+      // and the LLM generates invalid values (e.g. "Motivational").
+      const stringLiterals = unionType.types.filter(
         (t) => (t.flags & ts.TypeFlags.StringLiteral) !== 0,
       );
-      if (isAllStringLiterals) return 'string';
+      const nullishTypes = unionType.types.filter(
+        (t) =>
+          (t.flags & ts.TypeFlags.Undefined) !== 0 ||
+          (t.flags & ts.TypeFlags.Null) !== 0,
+      );
+
+      if (
+        stringLiterals.length > 0 &&
+        stringLiterals.length + nullishTypes.length === unionType.types.length
+      ) {
+        const literalValues = stringLiterals.map(
+          (t) => `'${(t as ts.LiteralType).value}'`,
+        );
+        const literalUnion = literalValues.join(' | ');
+
+        if (nullishTypes.length > 0) {
+          const nullishParts: string[] = [];
+          if (nullishTypes.some((t) => (t.flags & ts.TypeFlags.Null) !== 0))
+            nullishParts.push('null');
+          if (
+            nullishTypes.some((t) => (t.flags & ts.TypeFlags.Undefined) !== 0)
+          )
+            nullishParts.push('undefined');
+          return `${literalUnion} | ${nullishParts.join(' | ')}`;
+        }
+
+        return literalUnion;
+      }
 
       // Check if it's a number literal union
       const isAllNumberLiterals = unionType.types.every(

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

@@ -22,11 +22,8 @@ export class ForInStatementHandler implements PatternHandler {
     // Process the expression being iterated over first (e.g., object)
     context.processExpression(node.expression);
 
-    // Get the path of the object being iterated
-    const expressionPath = context.getStructuralPath(node.expression);
-
-    // If the initializer is a variable declaration with an identifier, establish equivalence
-    // to indicate it's iterating over the keys of the expression
+    // If the initializer is a variable declaration with an identifier,
+    // type it as 'string' since for-in keys are always strings
     if (ts.isVariableDeclarationList(node.initializer)) {
       const declarations = node.initializer.declarations;
       if (
@@ -36,25 +33,21 @@ export class ForInStatementHandler implements PatternHandler {
       ) {
         const variableName = StructuredPath.fromBase(declarations[0].name.text);
 
-        // Add type for the key variable (string for object keys)
+        // Type the key variable as 'string' — for-in keys are always strings.
+        // Note: We intentionally do NOT equivalence the key variable to
+        // expressionPath[*key*]. The key variable is the KEY (a string),
+        // while [*key*] in the schema represents the VALUE at a dynamic key.
+        // Creating that equivalence would cause the 'string' type to propagate
+        // to the value path. The value access (e.g., obj[key]) is handled
+        // correctly by the element access handler in processExpression.
         context.addType(variableName, 'string');
-
-        if (expressionPath) {
-          // For for...in loops, the variable is equivalent to the keys of the object
-          // We represent this with a *key* suffix to indicate it's a key, not a value
-          context.addEquivalence(variableName, expressionPath.withKey('key'));
-        }
       }
     } else if (ts.isIdentifier(node.initializer)) {
       // If the initializer is directly an identifier (rare but possible)
       const variableName = StructuredPath.fromBase(node.initializer.text);
 
-      // Add type for the key variable
+      // See comment above — type as string but don't equivalence to value path
       context.addType(variableName, 'string');
-
-      if (expressionPath) {
-        context.addEquivalence(variableName, expressionPath.withKey('key'));
-      }
     } else {
       context.processExpression(node.initializer);
     }

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,74 @@ 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
@@ -1294,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,
@@ -1338,6 +1412,7 @@ export function extractConditionalUsage(
             comparedValues,
             isNegated,
             requiredValue,
+            ...(comparisonOperator && { comparisonOperator }),
             ...(chainInfo.currentOrGroupId && {
               orGroupId: chainInfo.currentOrGroupId,
             }),
@@ -3334,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({
@@ -3368,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

@@ -433,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