@codeyam/codeyam-cli 0.1.0-staging.2a88920 → 0.1.0-staging.4684848

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

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-02-03T16:02:42.155Z",
-  "buildTime": 1770134562155,
-  "gitCommit": "2a889201e1cd93b82aab6744032951d45114bbb4",
+  "buildTimestamp": "2026-02-13T12:46:15.997Z",
+  "buildTime": 1770986775997,
+  "gitCommit": "4684848f0720e8d6673ec5479d17c6a1d40ce733",
   "nodeVersion": "v20.20.0",
-  "contentHash": "7fe877ecfbb0322305ef8daccd364fe4275c2fb3c60d2436353f83025a750441",
-  "buildNumber": 559,
-  "semanticVersion": "0.1.559",
-  "version": "0.1.559 (2026-02-03T16:02+7fe877e)"
+  "contentHash": "4e94e73e9be6ff27f80a8345110fe1d31d9863861a8966e4b17887ad7c6eff67",
+  "buildNumber": 619,
+  "semanticVersion": "0.1.619",
+  "version": "0.1.619 (2026-02-13T12:46+4e94e73)"
 }

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[2/3/2026, 4:02:42 PM] > codeyam-combo@1.0.0 mergeDependencies
-[2/3/2026, 4:02:42 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[2/13/2026, 12:46:15 PM] > codeyam-combo@1.0.0 mergeDependencies
+[2/13/2026, 12:46:15 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[2/3/2026, 4:02:42 PM] Merged dependencies into root package.json
+[2/13/2026, 12:46:15 PM] 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",
@@ -30,7 +30,7 @@
     "jest": "^30.2.0",
     "jsdom": "^27.4.0",
     "jsonc-parser": "^3.2.1",
-    "lru-cache": "^11.2.4",
+    "lru-cache": "^11.2.5",
     "openai": "^6.16.0",
     "p-queue": "^8.1.0",
     "p-retry": "^7.1.1",
@@ -44,11 +44,11 @@
     "pluralize": "^8.0.0",
     "yargs": "^18.0.0",
     "json5": "^2.2.3",
-    "@anthropic-ai/sdk": "^0.71.0",
+    "@anthropic-ai/sdk": "^0.74.0",
     "@aws-sdk/s3-request-presigner": "^3.940.0",
     "better-sqlite3": "^12.4.1",
     "fetch-retry": "^6.0.0",
-    "kysely": "^0.28.5",
+    "kysely": "^0.28.11",
     "pg": "^8.16.3",
     "@octokit/request": "^10.0.3",
     "lucide-react": "^0.556.0",

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.74.0",
     "jsdom": "^27.4.0",
     "p-queue": "^8.1.0",
     "p-retry": "^7.1.1",
     "piscina": "^5.1.4",
-    "lru-cache": "^11.2.4"
+    "lru-cache": "^11.2.5"
   },
   "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/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