@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.1a2737b

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-02-19T19:31:47.143Z",
+  "buildTime": 1771529507143,
+  "gitCommit": "1a2737b0fd2af08a258172a82704b84460d1dcfc",
+  "nodeVersion": "v20.20.0",
+  "contentHash": "7aa82b02f9a5c4c0baec4d7db041ce29c43713b4208ef992dbac30fbc81f00da",
+  "buildNumber": 641,
+  "semanticVersion": "0.1.641",
+  "version": "0.1.641 (2026-02-19T19:31+7aa82b0)"
 }

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
+[2/19/2026, 7:31:47 PM] > codeyam-combo@1.0.0 mergeDependencies
+[2/19/2026, 7:31:47 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[1/21/2026, 3:32:00 PM] Merged dependencies into root package.json
+[2/19/2026, 7:31:47 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.966.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.940.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.990.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,29 +26,29 @@
     "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.5",
     "openai": "^6.16.0",
     "p-queue": "^8.1.0",
     "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",
     "json5": "^2.2.3",
-    "@anthropic-ai/sdk": "^0.71.0",
-    "@aws-sdk/s3-request-presigner": "^3.940.0",
+    "@anthropic-ai/sdk": "^0.74.0",
+    "@aws-sdk/s3-request-presigner": "^3.990.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",
@@ -64,7 +64,7 @@
     "@types/jest": "^30.0.0",
     "@types/pg": "^8.15.5",
     "@types/ws": "^8.18.1",
-    "@octokit/types": "^15.0.0",
+    "@octokit/types": "^16.0.0",
     "@types/react": "^19.2.7",
     "@types/react-dom": "^19.2.3",
     "@types/react-resizable": "^3.0.7",

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

@@ -40,7 +40,11 @@ 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,
+  skipWorkerPool,
+} from './src/lib/analyzeScope';
 export { default as logOrderedMap } from './src/lib/logOrderedMap';
 export {
   default as splitOutsideParentheses,
@@ -54,8 +58,13 @@ export {
   removeDuplicateFunctionCalls,
 } from './src/lib/dataStructure/helpers/cleanNonObjectFunctions';
 export { default as convertDotNotation } from './src/lib/dataStructure/helpers/convertDotNotation';
+export { default as convertTypeAnnotationsToValues } from './src/lib/dataStructure/helpers/convertTypeAnnotationsToValues';
 export { default as cleanOutBoundary } from './src/lib/cleanOutBoundary';
-export { fillInDirectSchemaGapsAndUnknowns } from './src/lib/dataStructure/helpers/fillInSchemaGapsAndUnknowns';
+export {
+  fillInDirectSchemaGapsAndUnknowns,
+  buildSchemaIndexes,
+  type SchemaIndexes,
+} from './src/lib/dataStructure/helpers/fillInSchemaGapsAndUnknowns';
 export { default as deduplicateFunctionSchemas } from './src/lib/dataStructure/helpers/deduplicateFunctionSchemas';
 export { default as getConditionalUsagesFromCode } from './src/lib/getConditionalUsagesFromCode';
 export type {
@@ -81,10 +90,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/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

@@ -49,6 +49,20 @@ let workerPool: Piscina<
   AnalyzeScopeWorkerInput,
   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
@@ -65,11 +79,49 @@ 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 (workerPoolSkipped) return;
   if (workerPool !== null) return;
 
   // Only initialize worker pool in Node.js environment
@@ -85,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,
@@ -121,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"
   }
@@ -182,6 +242,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 +267,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 +294,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,
@@ -337,7 +394,7 @@ export async function analyzeScopeLocal({
             }
 
             for (const mapping of [structure, equivalentVariables]) {
-              for (let [key, value] of Object.entries(mapping)) {
+              for (let [key, rawValue] of Object.entries(mapping)) {
                 for (const [childScopeId, childScope] of sortedEntries) {
                   const scopeText = fileAnalyzer.sourceFile.text.slice(
                     childScope.start,
@@ -357,27 +414,49 @@ export async function analyzeScopeLocal({
                     return text;
                   };
 
-                  if (value.includes(scopeText)) {
-                    // DEBUG: Log when replacement happens
-                    if (key.includes('Fetcher') || key.includes('fetcher')) {
-                      console.log(
-                        'CodeYam DEBUG value replacement:',
-                        JSON.stringify({
-                          key,
-                          oldValue: value,
-                          childScopeId,
-                          scopeTextPreview: scopeText.slice(0, 50),
-                        }),
-                      );
+                  // Handle both string and string[] values (for OR expressions)
+                  const processValue = (value: string): string => {
+                    if (value.includes(scopeText)) {
+                      // DEBUG: Log when replacement happens
+                      if (key.includes('Fetcher') || key.includes('fetcher')) {
+                        console.log(
+                          'CodeYam DEBUG value replacement:',
+                          JSON.stringify({
+                            key,
+                            oldValue: value,
+                            childScopeId,
+                            scopeTextPreview: scopeText.slice(0, 50),
+                          }),
+                        );
+                      }
+                      return replaceChildScopeId(value);
+                    }
+                    return value;
+                  };
+
+                  if (Array.isArray(rawValue)) {
+                    const newValues = rawValue.map(processValue);
+                    (mapping as Record<string, string | string[]>)[key] =
+                      newValues;
+                    rawValue = newValues;
+                  } else if (typeof rawValue === 'string') {
+                    const newValue = processValue(rawValue);
+                    if (newValue !== rawValue) {
+                      (mapping as Record<string, string | string[]>)[key] =
+                        newValue;
+                      rawValue = newValue;
                     }
-                    value = replaceChildScopeId(value);
-                    mapping[key] = value;
                   }
+
                   if (key.includes(scopeText)) {
                     const oldKey = key;
                     key = replaceChildScopeId(key);
-                    mapping[key] = mapping[oldKey];
-                    delete mapping[oldKey];
+                    (mapping as Record<string, string | string[]>)[key] = (
+                      mapping as Record<string, string | string[]>
+                    )[oldKey];
+                    delete (mapping as Record<string, string | string[]>)[
+                      oldKey
+                    ];
                   }
                 }
               }
@@ -561,14 +640,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 +692,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 +787,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;
+}