@codeyam/codeyam-cli 0.1.0-staging.b8a55ba → 0.1.0-staging.d0ad4ae

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

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-01-08T16:34:34.962Z",
-  "buildTime": 1767890074962,
-  "gitCommit": "b8a55bae42c01162f8b78a22f77b23029ff8e6fe",
+  "buildTimestamp": "2026-01-13T17:06:17.271Z",
+  "buildTime": 1768323977271,
+  "gitCommit": "d0ad4aecb8553860bc47e123117cf87438cf7ca1",
   "nodeVersion": "v20.19.6",
-  "contentHash": "15631e2833f0bf3b73a8d75736c067328a964c6150dbd4efaba4f99f1a4fa136",
-  "buildNumber": 338,
-  "semanticVersion": "0.1.338",
-  "version": "0.1.338 (2026-01-08T16:34+15631e2)"
+  "contentHash": "68dcc7fe40d189a68998635c58ffd67eb34b236b0a7390d2bd47d8bcfba3573f",
+  "buildNumber": 400,
+  "semanticVersion": "0.1.400",
+  "version": "0.1.400 (2026-01-13T17:06+68dcc7f)"
 }

package/analyzer-template/common/execAsync.ts

@@ -6,7 +6,7 @@ import * as fs from 'fs';
 import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
 
 import { loadEnv } from '~codeyam/utils/server';
-import { getGlobalProcessManager, ProcessType } from '../process';
+import { getGlobalProcessManager, ProcessType } from '~codeyam/process';
 
 loadEnv();
 

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[1/8/2026, 4:34:34 PM] > codeyam-combo@1.0.0 mergeDependencies
-[1/8/2026, 4:34:34 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[1/13/2026, 5:06:17 PM] > codeyam-combo@1.0.0 mergeDependencies
+[1/13/2026, 5:06:17 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[1/8/2026, 4:34:34 PM] Merged dependencies into root package.json
+[1/13/2026, 5:06:17 PM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -7,8 +7,8 @@
     "build": "tsc && node ./scripts/postbuild.cjs"
   },
   "dependencies": {
-    "@aws-sdk/client-cloudwatch-logs": "^3.962.0",
-    "@aws-sdk/client-cloudfront": "^3.899.0",
+    "@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",
@@ -31,9 +31,9 @@
     "jsdom": "^27.4.0",
     "jsonc-parser": "^3.2.1",
     "lru-cache": "^11.2.4",
-    "openai": "^6.9.0",
+    "openai": "^6.16.0",
     "p-queue": "^8.1.0",
-    "p-retry": "^6.2.1",
+    "p-retry": "^7.1.1",
     "piscina": "^5.1.4",
     "pixelmatch": "^5.3.0",
     "playwright": "^1.56.1",
@@ -42,6 +42,8 @@
     "undici": "^7.16.0",
     "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",
@@ -56,6 +58,7 @@
     "typescript": "^5.9.3",
     "@jest/types": "^30.2.0",
     "@types/node": "^25.0.2",
+    "@types/yargs": "^17.0.34",
     "@types/jsdom": "^27.0.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^30.0.0",

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

@@ -12,7 +12,7 @@
     "@anthropic-ai/sdk": "^0.71.0",
     "jsdom": "^27.4.0",
     "p-queue": "^8.1.0",
-    "p-retry": "^6.2.1",
+    "p-retry": "^7.1.1",
     "piscina": "^5.1.4",
     "lru-cache": "^11.2.4"
   },

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

@@ -20,6 +20,18 @@ import {
 } from './sharedPatterns';
 import { processBindingPattern } from './processBindings';
 
+/**
+ * Detects if a property access looks like an environment variable store access.
+ * Matches patterns like `env.DATABASE_URL`, `env.IS_FORMBRICKS_CLOUD`, etc.
+ * where the object is named "env" and the property looks like an env var name.
+ */
+function isEnvStoreAccess(fullText: string): boolean {
+  // Match: env.SOME_VAR or env.someVar (but object must be exactly "env")
+  // This catches patterns from @t3-oss/env-nextjs and similar packages
+  const envStorePattern = /^env\.[A-Z_][A-Z0-9_]*$/;
+  return envStorePattern.test(fullText);
+}
+
 /**
  * Converts a call expression argument to a StructuredPath.
  *
@@ -802,7 +814,8 @@ export function processExpression({
     // Check if this is an environment variable access
     const fullText = unwrappedNode.getText(context.sourceFile);
     if (
-      fullText.includes('.env.') // simple heuristic for env var access but not great
+      fullText.includes('.env.') || // process.env.X, window.env.X
+      isEnvStoreAccess(fullText) // env.X where env is likely an env config object
     ) {
       context.addEnvironmentVariable(fullText);
     }

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

@@ -1,25 +1,44 @@
-export default function checkAllAttributes(data: { [key: string]: unknown }) {
-  for (const key of Object.keys(data || {})) {
+export default function checkAllAttributes(
+  data: { [key: string]: unknown } | unknown,
+): unknown {
+  // Handle non-object values (strings, numbers, etc.) - return them as-is
+  if (data === null || data === undefined) {
+    return data;
+  }
+  if (typeof data !== 'object') {
+    return data;
+  }
+  // Handle arrays - recurse into each element
+  if (Array.isArray(data)) {
+    return data.map((item) => checkAllAttributes(item));
+  }
+
+  const obj = data as { [key: string]: unknown };
+  for (const key of Object.keys(obj)) {
     try {
-      if (data[key] === undefined) {
-        delete data[key];
+      if (obj[key] === undefined) {
+        delete obj[key];
         continue;
       }
 
-      if (typeof data[key] === 'object') {
-        checkAllAttributes(data[key] as { [key: string]: unknown });
-      } else if (typeof data[key] === 'string') {
-        data[key] = (data[key] as string).replace(/\n/g, '\\n');
+      if (Array.isArray(obj[key])) {
+        obj[key] = (obj[key] as unknown[]).map((item) =>
+          checkAllAttributes(item),
+        );
+      } else if (typeof obj[key] === 'object' && obj[key] !== null) {
+        checkAllAttributes(obj[key]);
+      } else if (typeof obj[key] === 'string') {
+        obj[key] = (obj[key] as string).replace(/\n/g, '\\n');
       }
     } catch (e) {
       console.error('Error checking all attributes', {
         key,
-        data,
+        data: obj,
         error: e,
       });
       throw e;
     }
   }
 
-  return data;
+  return obj;
 }

package/analyzer-template/packages/ai/src/lib/dataStructure/ScopeDataStructure.ts

@@ -1395,6 +1395,18 @@ export class ScopeDataStructure {
         const equivalentSchemaPath = equivalentSchemaPathMap.get(remainingKey);
 
         if (equivalentSchemaPath) {
+          // Skip propagation when there's a structural mismatch:
+          // - schemaPath ends with [] (array element, represents an object)
+          // - equivalentSchemaPath doesn't end with [] (non-array prop, usually a scalar)
+          // This prevents incorrectly typing array elements as strings when they're
+          // equivalent to scalar props like JSX keys (e.g., workouts[] ↔ Card().key)
+          const schemaPathEndsWithArray = schemaPath.endsWith('[]');
+          const equivalentEndsWithArray = equivalentSchemaPath.endsWith('[]');
+          if (schemaPathEndsWithArray !== equivalentEndsWithArray) {
+            // Don't propagate between array element paths and non-array paths
+            continue;
+          }
+
           const value1 = scopeNode.schema[schemaPath];
           const value2 = equivalentScopeNode.schema[equivalentSchemaPath];
 
@@ -3409,12 +3421,14 @@ export class ScopeDataStructure {
       );
 
     const equivalencies = this.getEquivalencies(functionName);
+    const scopeName = functionName ?? this.scopeTreeManager.getRootName();
+
     for (const equivalenceKey in equivalencies ?? {}) {
       for (const equivalenceValue of equivalencies[equivalenceKey]) {
         const schemaPath = equivalenceValue.schemaPath;
         if (
           schemaPath.startsWith('signature[') &&
-          equivalenceValue.scopeNodeName === functionName &&
+          equivalenceValue.scopeNodeName === scopeName &&
           !signatureInSchema[schemaPath]
         ) {
           signatureInSchema[schemaPath] = 'unknown';
@@ -3428,14 +3442,60 @@ export class ScopeDataStructure {
       equivalencies,
     );
 
-    // CRITICAL: Set onlyEquivalencies to true to prevent database modifications
-    // during this "getter" method. validateSchema triggers manager.finalize which
-    // can call addToSchema -> addToEquivalencyDatabase -> mergeEquivalencyDatabaseEntries,
-    // which would incorrectly remove entries from the database.
-    const wasOnlyEquivalencies = this.onlyEquivalencies;
-    this.onlyEquivalencies = true;
     this.validateSchema(tempScopeNode, true, fillInUnknowns);
-    this.onlyEquivalencies = wasOnlyEquivalencies;
+
+    // After validateSchema has filled in types, propagate nested paths from
+    // variables to their signature equivalents.
+    // e.g., workouts[].activity_type -> signature[0].workouts[].activity_type
+    //
+    // Build a map of variable names that are equivalent to signature paths
+    // e.g., { 'workouts': 'signature[0].workouts' }
+    const variableToSignatureMap: Record<string, string> = {};
+
+    for (const equivalenceKey in equivalencies ?? {}) {
+      for (const equivalenceValue of equivalencies[equivalenceKey]) {
+        const schemaPath = equivalenceValue.schemaPath;
+        // Track which variables map to signature paths
+        // equivalenceKey is the variable name (e.g., 'workouts')
+        // schemaPath is where it comes from (e.g., 'signature[0].workouts')
+        if (
+          schemaPath.startsWith('signature[') &&
+          equivalenceValue.scopeNodeName === scopeName
+        ) {
+          variableToSignatureMap[equivalenceKey] = schemaPath;
+        }
+      }
+    }
+
+    // Propagate nested paths from variables to their signature equivalents
+    // e.g., if workouts = signature[0].workouts, then workouts[].title becomes
+    // signature[0].workouts[].title
+    for (const schemaKey in schema) {
+      // Skip keys that already start with signature[
+      if (schemaKey.startsWith('signature[')) continue;
+
+      // Check if this key starts with a variable that maps to a signature path
+      for (const [variableName, signaturePath] of Object.entries(
+        variableToSignatureMap,
+      )) {
+        // Check if schemaKey starts with variableName followed by a property accessor
+        // e.g., 'workouts[]' starts with 'workouts'
+        if (
+          schemaKey === variableName ||
+          schemaKey.startsWith(variableName + '.') ||
+          schemaKey.startsWith(variableName + '[')
+        ) {
+          // Transform the path: replace the variable prefix with the signature path
+          const suffix = schemaKey.slice(variableName.length);
+          const signatureKey = signaturePath + suffix;
+
+          // Add to schema if not already present
+          if (!tempScopeNode.schema[signatureKey]) {
+            tempScopeNode.schema[signatureKey] = schema[schemaKey];
+          }
+        }
+      }
+    }
 
     return tempScopeNode.schema;
   }
@@ -4049,6 +4109,16 @@ export class ScopeDataStructure {
           if (Object.keys(perVariableSchemas).length < numReceivingVars) {
             // Not all variables have schemas - fall back to rootSchema extraction
             perVariableSchemas = undefined;
+          } else {
+            // Also check that at least one schema is non-empty
+            // Bug fix: perCallSignatureSchemas may have entries but with empty schemas {}
+            // In this case, we should fall through to Fallback which uses rootSchema
+            const hasNonEmptySchema = Object.values(perVariableSchemas).some(
+              (schema) => Object.keys(schema).length > 0,
+            );
+            if (!hasNonEmptySchema) {
+              perVariableSchemas = undefined;
+            }
           }
         }
 
@@ -4068,7 +4138,11 @@ export class ScopeDataStructure {
           }
         }
 
-        // CASE 3: Parameterized calls that create SEPARATE efc entries (no perCallSignatureSchemas)
+        // CASE 3: Extract from efc.schema when perCallSignatureSchemas is missing or empty
+        // This handles two scenarios:
+        // 1. Parameterized calls that create SEPARATE efc entries (no perCallSignatureSchemas)
+        // 2. Destructuring where perCallSignatureSchemas exists but has EMPTY schemas
+        //
         // When useFetcher<ConfigData>() and useFetcher<SettingsData>() are called, they create separate
         // efc entries because getFunctionCallRoot preserves type parameters. Each entry has its own
         // `schema` field, but due to variable reassignment, the schema may be contaminated with paths
@@ -4084,14 +4158,39 @@ export class ScopeDataStructure {
         //
         // We filter to only keep paths that should belong to THIS call by checking if the
         // receiving variable's equivalency points to this call's return value.
+        //
+        // BUG FIX: The old condition `!efc.perCallSignatureSchemas` was FALSE when the object
+        // existed (even with empty schemas), causing this case to be skipped. We now also check
+        // if all schemas in perCallSignatureSchemas are empty.
+        const hasNonEmptyPerCallSignatureSchemas =
+          efc.perCallSignatureSchemas &&
+          Object.values(efc.perCallSignatureSchemas).some(
+            (schema) => Object.keys(schema).length > 0,
+          );
+
+        // Build the call signature prefix that paths should start with
+        const callSigPrefix = `${efc.callSignature}.functionCallReturnValue`;
+
+        // Check if efc.schema has variable-specific paths (indicating destructuring).
+        // Destructuring: const { entities, gitStatus } = useLoaderData()
+        // - efc.schema has paths like: useLoaderData().functionCallReturnValue.entities...
+        // Multiple calls: const x = useFetcher(); const y = useFetcher();
+        // - efc.schema has paths like: useFetcher().functionCallReturnValue.data...
+        // CASE 3 should only run for destructuring (variable-specific paths exist).
+        const hasVariableSpecificPaths = (
+          efc.receivingVariableNames ?? []
+        ).some((varName) =>
+          Object.keys(efc.schema).some((path) =>
+            path.startsWith(`${callSigPrefix}.${varName}`),
+          ),
+        );
+
         if (
           !perVariableSchemas &&
-          !efc.perCallSignatureSchemas &&
-          numReceivingVars >= 1
+          !hasNonEmptyPerCallSignatureSchemas &&
+          numReceivingVars >= 1 &&
+          hasVariableSpecificPaths
         ) {
-          // Build the call signature prefix that paths should start with
-          const callSigPrefix = `${efc.callSignature}.functionCallReturnValue`;
-
           // Filter efc.schema to only include paths matching this call signature
           const filteredSchema: Record<string, string> = {};
           for (const [path, type] of Object.entries(efc.schema)) {
@@ -4101,16 +4200,18 @@ export class ScopeDataStructure {
           }
 
           // Build perVariableSchemas from the filtered schema
+          // For destructuring, filter paths by variable name
           if (Object.keys(filteredSchema).length > 0) {
             perVariableSchemas = {};
             for (const varName of efc.receivingVariableNames ?? []) {
-              // For each variable, extract paths and transform to functionCallReturnValue format
+              // For destructuring, extract only paths specific to this variable
+              const varSpecificPrefix = `${callSigPrefix}.${varName}`;
               const varSchema: Record<string, string> = {};
+
               for (const [path, type] of Object.entries(filteredSchema)) {
-                if (path.startsWith(callSigPrefix)) {
-                  // Transform to generic functionCallReturnValue path
-                  // e.g., "useFetcher<ConfigData>().functionCallReturnValue.data.data.theme"
-                  //     -> "functionCallReturnValue.data.data.theme"
+                if (path.startsWith(varSpecificPrefix)) {
+                  // Transform: useLoaderData().functionCallReturnValue.entities.sha
+                  //         -> functionCallReturnValue.entities.sha (keep the variable name)
                   const suffix = path.slice(callSigPrefix.length);
                   const returnValuePath = `functionCallReturnValue${suffix}`;
                   varSchema[returnValuePath] = type;

package/analyzer-template/packages/ai/src/lib/dataStructure/equivalencyManagers/frameworks/JavascriptFrameworkManager.ts

@@ -518,8 +518,9 @@ export class JavascriptFrameworkManager implements EquivalencyManager {
 
     for (const [arrayPath, arrayInfo] of Object.entries(arrays)) {
       if (arrayInfo.paths.size > 1 && arrayInfo.values.size === 1) {
+        const elementType = Array.from(arrayInfo.values)[0];
         arrayInfo.paths.forEach((path) => delete scopeNode.schema[path]);
-        scopeNode.schema[`${arrayPath}[]`] = Array.from(arrayInfo.values)[0];
+        scopeNode.schema[`${arrayPath}[]`] = elementType;
       }
     }
   }

package/analyzer-template/packages/ai/src/lib/dataStructure/equivalencyManagers/frameworks/MuiManager.ts

@@ -49,50 +49,107 @@ export class MuiManager implements EquivalencyManager {
     for (const [path, equivalencies] of Object.entries(
       scopeNode.equivalencies,
     )) {
-      // Look for DataGrid().signature[0].columns equivalency (DataGrid, DataGridPro, DataGridPremium)
+      // Case 1: Look for DataGrid().signature[0].columns equivalency pointing to a columns variable
       const dataGridMatch = path.match(
         /^(DataGrid(?:Pro|Premium)?\(\))\.signature\[0\]\.columns$/,
       );
-      if (!dataGridMatch) continue;
-
-      const dataGridCall = dataGridMatch[1];
+      if (dataGridMatch) {
+        const dataGridCall = dataGridMatch[1];
 
-      // Find what columns is equivalent to (e.g., "columns" variable)
-      for (const equiv of equivalencies) {
-        const columnsVar = equiv.schemaPath;
+        // Find what columns is equivalent to (e.g., "columns" variable)
+        for (const equiv of equivalencies) {
+          const columnsVar = equiv.schemaPath;
 
-        // Find renderCell callbacks, following equivalency chains if needed
-        const callbackScopes = this.findRenderCellCallbacks(
-          columnsVar,
-          scopeNode,
-          new Set(),
-          scopeDataStructure,
-        );
+          // Find renderCell callbacks, following equivalency chains if needed
+          const callbackScopes = this.findRenderCellCallbacks(
+            columnsVar,
+            scopeNode,
+            new Set(),
+            scopeDataStructure,
+          );
 
-        for (const callbackScopeName of callbackScopes) {
-          // Get the callback scope node
-          const callbackScopeNode =
-            scopeDataStructure.getScopeOrFunctionCallInfo(callbackScopeName);
-          if (!callbackScopeNode) {
-            continue;
+          for (const callbackScopeName of callbackScopes) {
+            this.addRowEquivalencyToCallback(
+              callbackScopeName,
+              dataGridCall,
+              scopeNode,
+              scopeDataStructure,
+            );
           }
+        }
+        continue;
+      }
 
-          // Add equivalency: signature[0].row ≡ DataGrid().signature[0].rows[]
-          const callbackParamRowPath = 'signature[0].row';
-          const rowsArrayElementPath = `${dataGridCall}.signature[0].rows[]`;
+      // Case 2: Look for inline array props where DataGrid().signature[0].columns[N].renderCell
+      // directly points to a callback scope (e.g., DataGrid().signature[0].columns[0].renderCell → cyScope1())
+      // Also handles columns[].renderCell for normalized paths
+      const inlineRenderCellMatch = path.match(
+        /^(DataGrid(?:Pro|Premium)?\(\))\.signature\[0\]\.columns\[(?:\d+|)\]\.renderCell$/,
+      );
 
-          scopeDataStructure.addEquivalency(
-            callbackParamRowPath,
-            rowsArrayElementPath,
-            scopeNode.name,
-            callbackScopeNode as ScopeNode,
-            'MUI DataGrid renderCell params.row equivalency',
+      if (inlineRenderCellMatch) {
+        const dataGridCall = inlineRenderCellMatch[1];
+
+        for (const equiv of equivalencies) {
+          // Check if the equivalency points to a callback scope (cyScope*)
+          // Could be cyScope1() or cyScope1().functionCallReturnValue
+          const callbackMatch = equiv.schemaPath.match(
+            /^(cyScope[0-9A-Fa-f]+)\(\)(?:\.functionCallReturnValue)?$/,
           );
+          if (callbackMatch) {
+            // Try both naming conventions:
+            // 1. Just the cyScope name (e.g., "cyScope1")
+            // 2. Parent____cyScope name (e.g., "CustomersPage____cyScope1")
+            const callbackScopeName = callbackMatch[1];
+            const prefixedCallbackScopeName = `${scopeNode.name}____${callbackMatch[1]}`;
+            // Try unprefixed name first, then prefixed
+            this.addRowEquivalencyToCallback(
+              callbackScopeName,
+              dataGridCall,
+              scopeNode,
+              scopeDataStructure,
+            );
+            // Also try prefixed version in case it exists
+            this.addRowEquivalencyToCallback(
+              prefixedCallbackScopeName,
+              dataGridCall,
+              scopeNode,
+              scopeDataStructure,
+            );
+          }
         }
       }
     }
   }
 
+  /**
+   * Helper to add the signature[0].row → DataGrid().signature[0].rows[] equivalency
+   */
+  private addRowEquivalencyToCallback(
+    callbackScopeName: string,
+    dataGridCall: string,
+    scopeNode: ScopeNode,
+    scopeDataStructure: ScopeDataStructure,
+  ) {
+    const callbackScopeNode =
+      scopeDataStructure.getScopeOrFunctionCallInfo(callbackScopeName);
+    if (!callbackScopeNode) {
+      return;
+    }
+
+    // Add equivalency: signature[0].row ≡ DataGrid().signature[0].rows[]
+    const callbackParamRowPath = 'signature[0].row';
+    const rowsArrayElementPath = `${dataGridCall}.signature[0].rows[]`;
+
+    scopeDataStructure.addEquivalency(
+      callbackParamRowPath,
+      rowsArrayElementPath,
+      scopeNode.name,
+      callbackScopeNode as ScopeNode,
+      'MUI DataGrid renderCell params.row equivalency',
+    );
+  }
+
   /**
    * Process Autocomplete callbacks to link option parameters to options array.
    *
@@ -702,12 +759,11 @@ export class MuiManager implements EquivalencyManager {
     }
   }
 
-  internalFunctions: Set<string> = new Set([
-    'DataGrid',
-    'DataGridPro',
-    'DataGridPremium',
-    'Autocomplete',
-  ]);
+  // NOTE: We intentionally do NOT include DataGrid/Autocomplete in internalFunctions.
+  // While they're MUI components (not external data sources), we need them to remain
+  // in externalFunctionCalls so that data flow tracing works correctly.
+  // For example: DataGrid().signature[0].rows → data.items[] tracing
+  internalFunctions: Set<string> = new Set([]);
 
   toString() {
     return 'MuiManager';