@codeyam/codeyam-cli 0.1.0-staging.036391e → 0.1.0-staging.03e0fb2

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

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-02-10T15:50:47.182Z",
-  "buildTime": 1770738647182,
-  "gitCommit": "036391eb81237d8a0486ab9278a421ced43f450d",
+  "buildTimestamp": "2026-02-24T22:52:44.990Z",
+  "buildTime": 1771973564990,
+  "gitCommit": "03e0fb2ed10ce844a1a5215adf9aeb200ef627bb",
   "nodeVersion": "v20.20.0",
-  "contentHash": "3686880009968bee7de4a1974c22f64d417de53b5e8d46a51d7e88a017d4f2cc",
-  "buildNumber": 599,
-  "semanticVersion": "0.1.599",
-  "version": "0.1.599 (2026-02-10T15:50+3686880)"
+  "contentHash": "4a186f37ec4532e5a53e13c6fe2b2ce95a580cd45c739dc01a9ed7688ff1f99a",
+  "buildNumber": 704,
+  "semanticVersion": "0.1.704",
+  "version": "0.1.704 (2026-02-24T22:52+4a186f3)"
 }

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[2/10/2026, 3:50:47 PM] > codeyam-combo@1.0.0 mergeDependencies
-[2/10/2026, 3:50:47 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[2/24/2026, 10:52:44 PM] > codeyam-combo@1.0.0 mergeDependencies
+[2/24/2026, 10:52:44 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[2/10/2026, 3:50:47 PM] Merged dependencies into root package.json
+[2/24/2026, 10:52:44 PM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -7,17 +7,17 @@
     "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",
+    "@aws-sdk/client-cloudwatch-logs": "^3.990.0",
+    "@aws-sdk/client-cloudfront": "^3.990.0",
+    "@aws-sdk/client-codebuild": "^3.995.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.1.0",
     "@octokit/rest": "^22.0.0",
     "@sendgrid/mail": "^8.1.4",
@@ -26,13 +26,13 @@
     "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.5",
     "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",
@@ -45,7 +45,7 @@
     "yargs": "^18.0.0",
     "json5": "^2.2.3",
     "@anthropic-ai/sdk": "^0.74.0",
-    "@aws-sdk/s3-request-presigner": "^3.940.0",
+    "@aws-sdk/s3-request-presigner": "^3.990.0",
     "better-sqlite3": "^12.4.1",
     "fetch-retry": "^6.0.0",
     "kysely": "^0.28.11",

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

@@ -11,7 +11,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.74.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.5"

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

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

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

@@ -36,7 +36,6 @@ interface CompletionCallProps {
 const queue = new PQueue({
   concurrency: 100,
   timeout: 20 * 60 * 1000, // 20 minutes
-  throwOnTimeout: true,
   autoStart: true,
 });
 
@@ -135,62 +134,57 @@ export default async function completionCall({
   };
   const params = lib.openai.chatRequestToOpenAIChatParams(chatRequest);
 
-  const chatCompletion = await queue.add(
-    () => {
-      queueEndTime = Date.now();
-      return PRetry(
-        async () => {
-          const callStartTime = Date.now();
-          const waitingMessages = [
-            'Waiting for LLM response',
-            'Still waiting for LLM response',
-            'LLM call in progress',
-            'Processing LLM request',
-            'Awaiting LLM completion',
-          ];
-
-          const logInterval = setInterval(() => {
-            const elapsedSeconds = Math.floor(
-              (Date.now() - callStartTime) / 1000,
-            );
-            const messageIndex =
-              Math.floor(elapsedSeconds / 10) % waitingMessages.length;
-            awsLogDebugLevel(
-              1,
-              `${waitingMessages[messageIndex]} [type=${type}, model=${model}, elapsed=${elapsedSeconds}s]`,
-            );
-          }, 10000);
+  const chatCompletion = await queue.add(() => {
+    queueEndTime = Date.now();
+    return PRetry(
+      async () => {
+        const callStartTime = Date.now();
+        const waitingMessages = [
+          'Waiting for LLM response',
+          'Still waiting for LLM response',
+          'LLM call in progress',
+          'Processing LLM request',
+          'Awaiting LLM completion',
+        ];
+
+        const logInterval = setInterval(() => {
+          const elapsedSeconds = Math.floor(
+            (Date.now() - callStartTime) / 1000,
+          );
+          const messageIndex =
+            Math.floor(elapsedSeconds / 10) % waitingMessages.length;
+          awsLogDebugLevel(
+            1,
+            `${waitingMessages[messageIndex]} [type=${type}, model=${model}, elapsed=${elapsedSeconds}s]`,
+          );
+        }, 10000);
 
-          try {
-            return await openai.chat.completions.create(params, {
-              timeout: 5 * 60 * 1000, // 5 minute timeout
-            });
-          } finally {
-            clearInterval(logInterval);
-          }
-        },
-        {
-          ...defaultRetryOptions,
-          onFailedAttempt: (error) => {
-            retryCount++;
-            console.log(
-              `CodeYam Error: Completion call failed [model=${model}]`,
-              {
-                error,
-                prompt,
-                systemMessage,
-                attempts,
-                retryCount,
-              },
-            );
-          },
+        try {
+          return await openai.chat.completions.create(params, {
+            timeout: 5 * 60 * 1000, // 5 minute timeout
+          });
+        } finally {
+          clearInterval(logInterval);
+        }
+      },
+      {
+        ...defaultRetryOptions,
+        onFailedAttempt: (error) => {
+          retryCount++;
+          console.log(
+            `CodeYam Error: Completion call failed [model=${model}]`,
+            {
+              error,
+              prompt,
+              systemMessage,
+              attempts,
+              retryCount,
+            },
+          );
         },
-      );
-    },
-    {
-      throwOnTimeout: true,
-    },
-  );
+      },
+    );
+  });
   const endTime = Date.now();
 
   const llmCallStats = getLLMCallStats({
@@ -310,65 +304,60 @@ ${completion}
 
 Please provide a corrected version with valid JSON only. Do not include any explanatory text, just the valid JSON object.`;
 
-        const correctionChatCompletion = await queue.add(
-          () => {
-            return PRetry(
-              async () => {
-                const correctionStartTime = Date.now();
-                const waitingMessages = [
-                  'Waiting for LLM correction response',
-                  'Still waiting for LLM correction',
-                  'LLM correction in progress',
-                  'Processing LLM correction request',
-                  'Awaiting LLM correction completion',
-                ];
-
-                const logInterval = setInterval(() => {
-                  const elapsedSeconds = Math.floor(
-                    (Date.now() - correctionStartTime) / 1000,
-                  );
-                  const messageIndex =
-                    Math.floor(elapsedSeconds / 10) % waitingMessages.length;
-                  awsLogDebugLevel(
-                    1,
-                    `${waitingMessages[messageIndex]} [type=${type}, model=${model}, elapsed=${elapsedSeconds}s]`,
-                  );
-                }, 10000);
-
-                try {
-                  return await openai.chat.completions.create(
-                    {
-                      ...params,
-                      messages: [
-                        { role: 'system', content: systemMessage },
-                        { role: 'user', content: prompt },
-                        { role: 'assistant', content: completion },
-                        { role: 'user', content: correctionPrompt },
-                      ],
-                    },
-                    {
-                      timeout: 5 * 60 * 1000,
-                    },
-                  );
-                } finally {
-                  clearInterval(logInterval);
-                }
-              },
-              {
-                ...defaultRetryOptions,
-                onFailedAttempt: (error) => {
-                  console.log('CodeYam Error: Correction call failed', {
-                    error,
-                    attempts,
-                  });
-                },
+        const correctionChatCompletion = await queue.add(() => {
+          return PRetry(
+            async () => {
+              const correctionStartTime = Date.now();
+              const waitingMessages = [
+                'Waiting for LLM correction response',
+                'Still waiting for LLM correction',
+                'LLM correction in progress',
+                'Processing LLM correction request',
+                'Awaiting LLM correction completion',
+              ];
+
+              const logInterval = setInterval(() => {
+                const elapsedSeconds = Math.floor(
+                  (Date.now() - correctionStartTime) / 1000,
+                );
+                const messageIndex =
+                  Math.floor(elapsedSeconds / 10) % waitingMessages.length;
+                awsLogDebugLevel(
+                  1,
+                  `${waitingMessages[messageIndex]} [type=${type}, model=${model}, elapsed=${elapsedSeconds}s]`,
+                );
+              }, 10000);
+
+              try {
+                return await openai.chat.completions.create(
+                  {
+                    ...params,
+                    messages: [
+                      { role: 'system', content: systemMessage },
+                      { role: 'user', content: prompt },
+                      { role: 'assistant', content: completion },
+                      { role: 'user', content: correctionPrompt },
+                    ],
+                  },
+                  {
+                    timeout: 5 * 60 * 1000,
+                  },
+                );
+              } finally {
+                clearInterval(logInterval);
+              }
+            },
+            {
+              ...defaultRetryOptions,
+              onFailedAttempt: (error) => {
+                console.log('CodeYam Error: Correction call failed', {
+                  error,
+                  attempts,
+                });
               },
-            );
-          },
-          {
-            throwOnTimeout: true,
-          },
-        );
+            },
+          );
+        });
 
         const correctedRawCompletion =
           correctionChatCompletion.choices?.[0]?.message?.content;