@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.323686

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

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-01-21T15:32:00.721Z",
-  "buildTime": 1769009520721,
-  "gitCommit": "1669d4579d4212b661c5b5f872516c46dc39c48c",
-  "nodeVersion": "v20.19.6",
-  "contentHash": "d47ce71ca17d37da11228a938a9ab3a41c22d9db644db0104a74089f8fd3e173",
-  "buildNumber": 471,
-  "semanticVersion": "0.1.471",
-  "version": "0.1.471 (2026-01-21T15:32+d47ce71)"
+  "buildTimestamp": "2026-01-30T00:55:52.181Z",
+  "buildTime": 1769734552181,
+  "gitCommit": "03236865a7602ab6d30df31e0ad3bee876906fb9",
+  "nodeVersion": "v20.20.0",
+  "contentHash": "05d53efd18fbc545b72ac5e31193346a32efa60861ecfb3bf24454bef6533f43",
+  "buildNumber": 549,
+  "semanticVersion": "0.1.549",
+  "version": "0.1.549 (2026-01-30T00:55+05d53ef)"
 }

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[1/21/2026, 3:32:00 PM] > codeyam-combo@1.0.0 mergeDependencies
-[1/21/2026, 3:32:00 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[1/30/2026, 12:55:52 AM] > codeyam-combo@1.0.0 mergeDependencies
+[1/30/2026, 12:55:52 AM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[1/21/2026, 3:32:00 PM] Merged dependencies into root package.json
+[1/30/2026, 12:55:52 AM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -16,7 +16,7 @@
     "@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.940.0",
+    "@aws-sdk/lib-storage": "^3.975.0",
     "@aws-sdk/util-dynamodb": "^3.971.0",
     "@octokit/auth-app": "^8.1.0",
     "@octokit/rest": "^22.0.0",
@@ -36,10 +36,10 @@
     "p-retry": "^7.1.1",
     "piscina": "^5.1.4",
     "pixelmatch": "^5.3.0",
-    "playwright": "^1.56.1",
+    "playwright": "1.58.0",
     "sharp": "^0.34.5",
     "simple-git": "^3.28.0",
-    "undici": "^7.16.0",
+    "undici": "^7.18.2",
     "uuid": "^11.1.0",
     "pluralize": "^8.0.0",
     "yargs": "^18.0.0",

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

@@ -40,7 +40,10 @@ export { default as describeCodeChange } from './src/lib/describeCodeChange';
 export { default as validateTypeStructure } from './src/lib/validateTypeStructure';
 export { default as validateDataStructure } from './src/lib/validateDataStructure';
 export { default as isolateScopes } from './src/lib/isolateScopes';
-export { default as analyzeScope } from './src/lib/analyzeScope';
+export {
+  default as analyzeScope,
+  destroyWorkerPool,
+} from './src/lib/analyzeScope';
 export { default as logOrderedMap } from './src/lib/logOrderedMap';
 export {
   default as splitOutsideParentheses,
@@ -81,10 +84,15 @@ export {
   getConditionalEffects,
   getCompoundConditionals,
   getChildBoundaryGatingConditions,
+  getJsxRenderingUsages,
 } from './src/lib/worker/SerializableDataStructure';
 export { parseJsonSafe } from './src/lib/parsers/parseJsonSafe';
 export { default as completionCall } from './src/lib/completionCall';
 
+// NOTE: E2E data tracking utilities (e2eDataTracking.ts) are NOT exported here
+// because they use Node.js 'crypto' module which breaks browser builds.
+// Import directly from '~codeyam/ai/src/lib/e2eDataTracking' when needed in Node.js tests.
+
 // Wrapper detection
 export { default as detectWrapperRequirements } from './src/lib/wrapperDetection/detectWrapperRequirements';
 export { KNOWN_LIBRARY_HOOKS } from './src/lib/wrapperDetection/knownLibraryHooks';

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

@@ -49,6 +49,7 @@ let workerPool: Piscina<
   AnalyzeScopeWorkerInput,
   AnalyzeScopeWorkerOutput
 > | null = null;
+let workerPoolDestroyed = false;
 
 /**
  * Check if we're in Node.js main thread
@@ -65,11 +66,48 @@ function getIsMainThread(): boolean {
   return isMainThread;
 }
 
+/**
+ * Destroy the worker pool, freeing its ~2GB heap.
+ * Called after data structure preparation completes (the producing phase transition).
+ * The worker is not needed after this point — subsequent calls to ensureWorkerPool() will throw.
+ */
+export async function destroyWorkerPool() {
+  if (workerPool) {
+    const memBefore = process.memoryUsage();
+    console.log('CodeYam: Destroying worker pool...', {
+      rssBefore: `${Math.round(memBefore.rss / 1024 / 1024)}MB`,
+      heapBefore: `${Math.round(memBefore.heapUsed / 1024 / 1024)}MB`,
+    });
+
+    await workerPool.destroy();
+    workerPool = null;
+
+    // Force GC if available to reclaim worker memory faster
+    if (global.gc) {
+      global.gc();
+    }
+
+    const memAfter = process.memoryUsage();
+    console.log('CodeYam: Worker pool destroyed', {
+      rssAfter: `${Math.round(memAfter.rss / 1024 / 1024)}MB`,
+      heapAfter: `${Math.round(memAfter.heapUsed / 1024 / 1024)}MB`,
+      rssDelta: `${Math.round((memAfter.rss - memBefore.rss) / 1024 / 1024)}MB`,
+    });
+  }
+  workerPoolDestroyed = true;
+}
+
 /**
  * Lazy initialization of worker pool.
  * Called on first use to ensure environment variables are set.
  */
 function ensureWorkerPool() {
+  if (workerPoolDestroyed) {
+    throw new Error(
+      'CodeYam: Worker pool was destroyed (post-producing phase). ' +
+        'analyzeScope should not be called after data structure preparation completes.',
+    );
+  }
   if (workerPool !== null) return;
 
   // Only initialize worker pool in Node.js environment
@@ -182,6 +220,9 @@ export async function analyzeScopeLocal({
       string,
       import('./astScopes/types').ConditionalUsage[]
     > = {};
+    // Collect JSX rendering usages (arrays via .map(), strings via interpolation)
+    const allJsxRenderingUsages: import('./astScopes/types').JsxRenderingUsage[] =
+      [];
 
     const astAnalysisResultWithStatements = statementScopes.map(
       (statementScope) => {
@@ -204,16 +245,6 @@ export async function analyzeScopeLocal({
         }
         // Collect conditional effects from AST analysis
         if (astAnalysisResult.conditionalEffects?.length > 0) {
-          console.log(
-            `[ConditionalEffects] analyzeScope collecting from statement "${statementScope.name}":`,
-            astAnalysisResult.conditionalEffects.map((e) => ({
-              setter: e.effect.setterName,
-              value: e.effect.value,
-              condition:
-                e.condition?.path ||
-                e.conditions?.map((c) => c.path).join(' && '),
-            })),
-          );
           allConditionalEffects.push(...astAnalysisResult.conditionalEffects);
         }
         // Collect compound conditionals from AST analysis
@@ -241,6 +272,10 @@ export async function analyzeScopeLocal({
             allChildBoundaryGatingConditions[childName].push(...usages);
           }
         }
+        // Collect JSX rendering usages from AST analysis
+        if (astAnalysisResult.jsxRenderingUsages?.length) {
+          allJsxRenderingUsages.push(...astAnalysisResult.jsxRenderingUsages);
+        }
         return {
           statementScope,
           astAnalysisResult,
@@ -561,14 +596,7 @@ export async function analyzeScopeLocal({
 
     // Add conditional effects from this scope's analysis
     if (allConditionalEffects.length > 0) {
-      console.log(
-        `[ConditionalEffects] analyzeScope adding ${allConditionalEffects.length} effects to scopeDataStructure for scope "${scope.name}"`,
-      );
       scopeDataStructure.addConditionalEffects(allConditionalEffects);
-    } else {
-      console.log(
-        `[ConditionalEffects] analyzeScope: no conditional effects found for scope "${scope.name}"`,
-      );
     }
 
     // Add compound conditionals from this scope's analysis
@@ -620,13 +648,9 @@ export async function analyzeScopeLocal({
       );
     }
 
-    // Log child scopes that will be processed
-    const childScopeNames = Object.keys(scope.childScopes);
-    if (childScopeNames.length > 0) {
-      console.log(
-        `[ConditionalEffects] analyzeScope will process ${childScopeNames.length} child scopes:`,
-        childScopeNames,
-      );
+    // Add JSX rendering usages from this scope's analysis
+    if (allJsxRenderingUsages.length > 0) {
+      scopeDataStructure.addJsxRenderingUsages(allJsxRenderingUsages);
     }
 
     await Promise.all(
@@ -719,16 +743,6 @@ export default async function analyzeScope(
     try {
       const result = await workerPool.run(workerInput);
 
-      // Log the conditional effects from the worker result
-      const workerConditionalEffects =
-        result.dataStructure?.conditionalEffects || [];
-      console.log(
-        `[ConditionalEffects] Worker returned ${workerConditionalEffects.length} conditional effects for ${entity.name}:`,
-        workerConditionalEffects.map(
-          (e: any) => `${e.effect?.setterName}(${e.effect?.value})`,
-        ),
-      );
-
       // Store the serializable data structure in the scope
       scope.dataStructure = result.dataStructure as any;
       return;

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

@@ -0,0 +1,199 @@
+/**
+ * Shared utilities for detecting array-derived expressions in conditionals.
+ *
+ * These utilities detect patterns like:
+ * - arr.some(fn) → { sourcePath: 'arr', operation: 'arraySome' }
+ * - arr.every(fn) → { sourcePath: 'arr', operation: 'arrayEvery' }
+ * - arr.includes(x) → { sourcePath: 'arr', operation: 'arrayIncludes' }
+ * - arr.length → { sourcePath: 'arr', operation: 'arrayLength' }
+ *
+ * Used by both:
+ * - variableDeclarationHandler.ts (for variable assignments)
+ * - processExpression.ts (for inline conditionals)
+ */
+
+import ts from 'typescript';
+
+/** Array predicate method operations */
+export type ArrayPredicateOperation =
+  | 'arrayIncludes'
+  | 'arraySome'
+  | 'arrayEvery';
+
+/** Array length operation */
+export type ArrayLengthOperation = 'arrayLength';
+
+/** All array-derived operations */
+export type ArrayDerivedOperation =
+  | ArrayPredicateOperation
+  | ArrayLengthOperation;
+
+/** Result of detecting an array derivation pattern */
+export interface ArrayDerivationResult {
+  sourcePath: string;
+  operation: ArrayDerivedOperation;
+}
+
+/**
+ * Extracts a simple path string from an expression.
+ * Returns the path for identifiers and property access chains.
+ */
+export function getSimplePath(node: ts.Expression): string | null {
+  if (ts.isIdentifier(node)) {
+    return node.text;
+  }
+  if (ts.isPropertyAccessExpression(node)) {
+    const objectPath = getSimplePath(node.expression);
+    if (objectPath) {
+      return `${objectPath}.${node.name.text}`;
+    }
+  }
+  // Handle optional chaining: a?.b
+  if (ts.isNonNullExpression(node)) {
+    return getSimplePath(node.expression);
+  }
+  return null;
+}
+
+/**
+ * Maps array method names to derivation operation names
+ */
+function getArrayPredicateOperation(
+  methodName: string,
+): ArrayPredicateOperation | null {
+  switch (methodName) {
+    case 'includes':
+      return 'arrayIncludes';
+    case 'some':
+      return 'arraySome';
+    case 'every':
+      return 'arrayEvery';
+    default:
+      return null;
+  }
+}
+
+/**
+ * Detects if an expression is an array predicate call and extracts the array path.
+ * Patterns detected:
+ * - arr.includes(x) → { sourcePath: 'arr', operation: 'arrayIncludes' }
+ * - arr?.includes(x) → { sourcePath: 'arr', operation: 'arrayIncludes' }
+ * - arr.some(fn) → { sourcePath: 'arr', operation: 'arraySome' }
+ * - arr.every(fn) → { sourcePath: 'arr', operation: 'arrayEvery' }
+ * - Boolean(x && arr?.includes(y)) → { sourcePath: 'arr', operation: 'arrayIncludes' }
+ */
+export function detectArrayPredicatePattern(
+  expr: ts.Expression,
+): ArrayDerivationResult | null {
+  // Unwrap Boolean() calls: Boolean(x) → x
+  if (
+    ts.isCallExpression(expr) &&
+    ts.isIdentifier(expr.expression) &&
+    expr.expression.text === 'Boolean' &&
+    expr.arguments.length === 1
+  ) {
+    return detectArrayPredicatePattern(expr.arguments[0]);
+  }
+
+  // Handle logical AND: a && b - check both sides for array predicates
+  if (
+    ts.isBinaryExpression(expr) &&
+    expr.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
+  ) {
+    // Try the right side first (more likely to have the predicate)
+    const rightResult = detectArrayPredicatePattern(expr.right);
+    if (rightResult) return rightResult;
+    // Try the left side
+    const leftResult = detectArrayPredicatePattern(expr.left);
+    if (leftResult) return leftResult;
+    return null;
+  }
+
+  // Handle parenthesized expressions
+  if (ts.isParenthesizedExpression(expr)) {
+    return detectArrayPredicatePattern(expr.expression);
+  }
+
+  if (!ts.isCallExpression(expr)) {
+    return null;
+  }
+
+  const callExpr = expr.expression;
+
+  // Handle both regular property access (arr.includes) and optional chaining (arr?.includes)
+  let objectExpr: ts.Expression | null = null;
+  let methodName: string | null = null;
+
+  if (ts.isPropertyAccessExpression(callExpr)) {
+    objectExpr = callExpr.expression;
+    methodName = callExpr.name.text;
+  } else if (
+    ts.isElementAccessExpression(callExpr) &&
+    ts.isStringLiteral(callExpr.argumentExpression)
+  ) {
+    // Handle arr["includes"]() syntax (rare but possible)
+    objectExpr = callExpr.expression;
+    methodName = callExpr.argumentExpression.text;
+  }
+
+  if (!objectExpr || !methodName) {
+    return null;
+  }
+
+  const operation = getArrayPredicateOperation(methodName);
+  if (!operation) {
+    return null;
+  }
+
+  // Get the source path for the array
+  const sourcePath = getSimplePath(objectExpr);
+  if (!sourcePath) {
+    return null;
+  }
+
+  return { sourcePath, operation };
+}
+
+/**
+ * Detects if an expression is an array.length access.
+ * Patterns detected:
+ * - arr.length → { sourcePath: 'arr', operation: 'arrayLength' }
+ * - arr?.length → { sourcePath: 'arr', operation: 'arrayLength' }
+ */
+export function detectArrayLengthPattern(
+  expr: ts.Expression,
+): ArrayDerivationResult | null {
+  // Handle property access: arr.length
+  if (ts.isPropertyAccessExpression(expr)) {
+    if (expr.name.text === 'length') {
+      const sourcePath = getSimplePath(expr.expression);
+      if (sourcePath) {
+        return { sourcePath, operation: 'arrayLength' };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Detects any array-derived pattern (predicate methods or .length).
+ * This is the main entry point for inline conditional detection.
+ */
+export function detectArrayDerivedPattern(
+  expr: ts.Expression,
+): ArrayDerivationResult | null {
+  // Check for array predicate methods first (.some, .every, .includes)
+  const predicateResult = detectArrayPredicatePattern(expr);
+  if (predicateResult) {
+    return predicateResult;
+  }
+
+  // Check for .length access
+  const lengthResult = detectArrayLengthPattern(expr);
+  if (lengthResult) {
+    return lengthResult;
+  }
+
+  return null;
+}

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

@@ -109,6 +109,7 @@ export class ASTScopeAnalyzer {
   private conditionalEffects: import('./types').ConditionalEffect[] = [];
   private childBoundaryGatingConditions: Record<string, ConditionalUsage[]> =
     {};
+  private jsxRenderingUsages: import('./types').JsxRenderingUsage[] = [];
   /**
    * Tracks derived boolean variables and their source expressions.
    * Maps variable name to derivation info.
@@ -219,6 +220,7 @@ export class ASTScopeAnalyzer {
       conditionalEffects: this.conditionalEffects,
       derivedVariables: this.derivedVariables,
       childBoundaryGatingConditions: this.childBoundaryGatingConditions,
+      jsxRenderingUsages: this.jsxRenderingUsages,
       isComplete:
         completeness.equivalences === 'full' &&
         completeness.structures === 'full',
@@ -273,6 +275,8 @@ export class ASTScopeAnalyzer {
       updateSchemaType: (path, newType) => this.updateSchemaType(path, newType),
       addConditionalEffect: (effect) => this.addConditionalEffect(effect),
       getConditionalEffects: () => this.conditionalEffects,
+      addJsxRenderingUsage: (usage) => this.addJsxRenderingUsage(usage),
+      getJsxRenderingUsages: () => this.jsxRenderingUsages,
     };
     return context;
   }
@@ -603,6 +607,17 @@ export class ASTScopeAnalyzer {
     const rightSideStr = rightSide?.toRightHandSideString();
 
     if (leftSideStr && rightSideStr && leftSideStr !== rightSideStr) {
+      const existingValue = this.equivalentVariables[leftSideStr];
+      // Don't overwrite a meaningful value with 'undefined' or 'null'.
+      // This is critical for ternary conditionals like `const x = cond ? func() : undefined`
+      // or `const x = items.find(...) || null` where we want to preserve
+      // the equivalency to the more meaningful value (func()'s return value, items[]).
+      if (
+        existingValue &&
+        (rightSideStr === 'undefined' || rightSideStr === 'null')
+      ) {
+        return;
+      }
       this.equivalentVariables[leftSideStr] = rightSideStr;
     }
   }
@@ -734,6 +749,22 @@ export class ASTScopeAnalyzer {
     this.conditionalEffects.push(effect);
   }
 
+  /**
+   * Add a JSX rendering usage (array.map() or text interpolation)
+   * Deduplicates by path and rendering type
+   */
+  private addJsxRenderingUsage(
+    usage: import('./types').JsxRenderingUsage,
+  ): void {
+    // Deduplicate: don't add if we already have the same path + renderingType
+    const exists = this.jsxRenderingUsages.some(
+      (u) => u.path === usage.path && u.renderingType === usage.renderingType,
+    );
+    if (!exists) {
+      this.jsxRenderingUsages.push(usage);
+    }
+  }
+
   /**
    * Updates the schema type for a path, typically used when switch statements
    * reveal the valid values for a parameter (creating a union type like "'a' | 'b' | 'c'")