@codeyam/codeyam-cli 0.1.0-staging.bd4126b → 0.1.0-staging.c276166

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

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2026-02-19T08:29:57.611Z",
-  "buildTime": 1771489797611,
-  "gitCommit": "bd4126bbd54a1b23f04969e37544b3c03acde084",
+  "buildTimestamp": "2026-03-13T15:02:19.275Z",
+  "buildTime": 1773414139275,
+  "gitCommit": "c27616677af6d43760242cadcf9021d31b2f9225",
   "nodeVersion": "v20.20.0",
-  "contentHash": "4dfdb43772550ef44f8cdd768e38d72a07ca14fb3f7b3110a84fe60ab2637cbd",
-  "buildNumber": 641,
-  "semanticVersion": "0.1.641",
-  "version": "0.1.641 (2026-02-19T08:29+4dfdb43)"
+  "contentHash": "68aada52a9e636008fb2f4fffc504ee4b3e09bd06eacbf40d008b536dcb9018b",
+  "buildNumber": 981,
+  "semanticVersion": "0.1.981",
+  "version": "0.1.981 (2026-03-13T15:02+68aada5)"
 }

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[2/19/2026, 8:29:57 AM] > codeyam-combo@1.0.0 mergeDependencies
-[2/19/2026, 8:29:57 AM] > node ./scripts/mergePackageJsonFiles.cjs
+[3/13/2026, 3:02:19 PM] > codeyam-combo@1.0.0 mergeDependencies
+[3/13/2026, 3:02:19 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[2/19/2026, 8:29:57 AM] Merged dependencies into root package.json
+[3/13/2026, 3:02:19 PM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -9,7 +9,7 @@
   "dependencies": {
     "@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-codebuild": "^3.1000.0",
     "@aws-sdk/client-dynamodb": "^3.990.0",
     "@aws-sdk/client-ec2": "^3.990.0",
     "@aws-sdk/client-ecr": "^3.990.0",
@@ -18,7 +18,7 @@
     "@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/auth-app": "^8.2.0",
     "@octokit/rest": "^22.0.0",
     "@sendgrid/mail": "^8.1.4",
     "@supabase/supabase-js": "2.88.0",
@@ -32,37 +32,37 @@
     "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",
     "playwright": "1.58.0",
     "sharp": "^0.34.5",
-    "simple-git": "^3.28.0",
+    "simple-git": "^3.32.2",
     "undici": "^7.18.2",
     "uuid": "^11.1.0",
     "pluralize": "^8.0.0",
     "yargs": "^18.0.0",
     "json5": "^2.2.3",
-    "@anthropic-ai/sdk": "^0.74.0",
+    "@anthropic-ai/sdk": "^0.78.0",
     "@aws-sdk/s3-request-presigner": "^3.990.0",
-    "better-sqlite3": "^12.4.1",
+    "better-sqlite3": "^12.6.2",
     "fetch-retry": "^6.0.0",
     "kysely": "^0.28.11",
-    "pg": "^8.16.3",
+    "pg": "^8.19.0",
     "@octokit/request": "^10.0.3",
-    "lucide-react": "^0.556.0",
+    "lucide-react": "^0.577.0",
     "react-resizable": "^3.0.5"
   },
   "devDependencies": {
     "typescript": "^5.9.3",
     "@jest/types": "^30.2.0",
-    "@types/node": "^25.0.2",
+    "@types/node": "^25.3.3",
     "@types/yargs": "^17.0.34",
     "@types/jsdom": "^27.0.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^30.0.0",
-    "@types/pg": "^8.15.5",
+    "@types/pg": "^8.18.0",
     "@types/ws": "^8.18.1",
     "@octokit/types": "^16.0.0",
     "@types/react": "^19.2.7",

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

@@ -9,9 +9,9 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.74.0",
+    "@anthropic-ai/sdk": "^0.78.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/astScopes/astScopeAnalyzer.ts

@@ -909,11 +909,42 @@ export class ASTScopeAnalyzer {
     if (tsType.flags & ts.TypeFlags.Union) {
       const unionType = tsType as ts.UnionType;
 
-      // Check if it's a string literal union
-      const isAllStringLiterals = unionType.types.every(
+      // Check if it's a string literal union (optionally with null/undefined).
+      // Preserve literal values so the LLM knows which values are valid when
+      // generating mock data. Without this, types like
+      // 'suggestion' | 'warning' | 'achievement' | 'tip' become just 'string'
+      // and the LLM generates invalid values (e.g. "Motivational").
+      const stringLiterals = unionType.types.filter(
         (t) => (t.flags & ts.TypeFlags.StringLiteral) !== 0,
       );
-      if (isAllStringLiterals) return 'string';
+      const nullishTypes = unionType.types.filter(
+        (t) =>
+          (t.flags & ts.TypeFlags.Undefined) !== 0 ||
+          (t.flags & ts.TypeFlags.Null) !== 0,
+      );
+
+      if (
+        stringLiterals.length > 0 &&
+        stringLiterals.length + nullishTypes.length === unionType.types.length
+      ) {
+        const literalValues = stringLiterals.map(
+          (t) => `'${(t as ts.LiteralType).value}'`,
+        );
+        const literalUnion = literalValues.join(' | ');
+
+        if (nullishTypes.length > 0) {
+          const nullishParts: string[] = [];
+          if (nullishTypes.some((t) => (t.flags & ts.TypeFlags.Null) !== 0))
+            nullishParts.push('null');
+          if (
+            nullishTypes.some((t) => (t.flags & ts.TypeFlags.Undefined) !== 0)
+          )
+            nullishParts.push('undefined');
+          return `${literalUnion} | ${nullishParts.join(' | ')}`;
+        }
+
+        return literalUnion;
+      }
 
       // Check if it's a number literal union
       const isAllNumberLiterals = unionType.types.every(

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,63 @@ 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 chatCompletionResult = 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,
-    },
-  );
+      },
+    );
+  });
+
+  if (!chatCompletionResult) {
+    throw new Error('Completion call returned no result');
+  }
+
+  const chatCompletion = chatCompletionResult;
   const endTime = Date.now();
 
   const llmCallStats = getLLMCallStats({
@@ -310,65 +310,66 @@ ${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);
-                }
+        const correctionChatCompletionResult = 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,
+                });
               },
-              {
-                ...defaultRetryOptions,
-                onFailedAttempt: (error) => {
-                  console.log('CodeYam Error: Correction call failed', {
-                    error,
-                    attempts,
-                  });
-                },
-              },
-            );
-          },
-          {
-            throwOnTimeout: true,
-          },
-        );
+            },
+          );
+        });
+
+        if (!correctionChatCompletionResult) {
+          throw new Error('Correction call returned no result');
+        }
+
+        const correctionChatCompletion = correctionChatCompletionResult;
 
         const correctedRawCompletion =
           correctionChatCompletion.choices?.[0]?.message?.content;

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

@@ -1108,6 +1108,33 @@ export class ScopeDataStructure {
       return;
     }
 
+    // Case 3: Circular reference through scope-suffixed names (____cyScope pattern)
+    // When a named arrow function is defined inside a scope (e.g., useEffect callback):
+    //   const identifyUser = async () => { ... };
+    //   identifyUser();
+    // This creates a variable "identifyUser" and a scope "identifyUser____cyScope9F".
+    // Mutual equivalencies between these cause infinite loops in Phase 2 because
+    // processing one triggers addToSchema → followEquivalencies → addEquivalency
+    // on the reverse, which repeats indefinitely.
+    // Only block when the REVERSE direction already exists (creating a cycle).
+    // The initial one-directional equivalency is necessary for scope resolution.
+    if (
+      path &&
+      equivalentPath &&
+      (equivalentPath.startsWith(path + '____') ||
+        path.startsWith(equivalentPath + '____'))
+    ) {
+      // Check if the reverse equivalency already exists
+      const reverseEquivalencies =
+        scopeNode.equivalencies[equivalentPath] || [];
+      const reverseExists = reverseEquivalencies.some(
+        (v) => v.schemaPath === path,
+      );
+      if (reverseExists) {
+        return;
+      }
+    }
+
     if (!equivalentScopeName) {
       console.error(
         'CodeYam Error: Missing equivalent scope name - FULL CONTEXT:',

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

@@ -0,0 +1,62 @@
+/**
+ * Coerces primitive values to empty arrays when the schema expects an array.
+ *
+ * The LLM sometimes generates a primitive (boolean, number, string) where the
+ * schema expects an array. For example:
+ *   Schema: { webapps: [{ name: "string" }] }
+ *   LLM output: { webapps: true }
+ *
+ * This causes runtime errors like `TypeError: config.webapps?.forEach is not a function`
+ * because the code expects an array but gets a boolean.
+ *
+ * Coercion rule:
+ * - primitive → array: replace with []
+ *
+ * Null and undefined values are preserved (they may be intentionally nullable).
+ *
+ * @param data The mock data object to coerce (mutated in place)
+ * @param schema The schema describing expected types
+ */
+export default function coercePrimitivesToArraysBySchema<T>(
+  data: T,
+  schema: unknown,
+): T {
+  if (data === null || data === undefined) {
+    return data;
+  }
+
+  if (typeof data !== 'object') {
+    return data;
+  }
+
+  if (Array.isArray(data)) {
+    const itemSchema = Array.isArray(schema) ? schema[0] : undefined;
+    for (let i = 0; i < data.length; i++) {
+      data[i] = coercePrimitivesToArraysBySchema(data[i], itemSchema);
+    }
+    return data;
+  }
+
+  const dataObj = data as Record<string, unknown>;
+  const schemaObj = schema as Record<string, unknown> | undefined;
+
+  for (const key of Object.keys(dataObj)) {
+    const value = dataObj[key];
+    const fieldSchema = schemaObj?.[key];
+
+    if (value === null || value === undefined) {
+      continue;
+    }
+
+    if (typeof value !== 'object' && Array.isArray(fieldSchema)) {
+      // Schema expects an array but the value is a primitive.
+      // Replace with an empty array.
+      dataObj[key] = [];
+    } else if (typeof value === 'object' && value !== null) {
+      // Both value and schema are objects — recurse
+      coercePrimitivesToArraysBySchema(value, fieldSchema);
+    }
+  }
+
+  return data;
+}

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

@@ -19,6 +19,8 @@ import convertNullToUndefinedBySchema from './dataStructure/helpers/convertNullT
 import convertTypeAnnotationsToValues from './dataStructure/helpers/convertTypeAnnotationsToValues';
 import fixNullIdsBySchema from './dataStructure/helpers/fixNullIdsBySchema';
 import coerceObjectsToPrimitivesBySchema from './dataStructure/helpers/coerceObjectsToPrimitivesBySchema';
+import coercePrimitivesToArraysBySchema from './dataStructure/helpers/coercePrimitivesToArraysBySchema';
+import stripNullableMarkers from './dataStructure/helpers/stripNullableMarkers';
 import { JsonTypeDefinition } from '~codeyam/types';
 import { deepMerge } from '~codeyam/generate';
 import {
@@ -172,6 +174,46 @@ function findKeyPath(
   return null;
 }
 
+/**
+ * Strip primitive values from `source` when the `destination` already has an
+ * array or object at the same key. Returns a cleaned copy of source (or null
+ * if nothing remains after stripping).
+ *
+ * This prevents misplaced LLM data (e.g., `{ webapps: true }`) from
+ * overwriting correct complex values (e.g., `{ webapps: [...] }`) during
+ * deep merge in relocateMisplacedNestedKeys.
+ */
+function stripPrimitivesOverwritingComplexValues(
+  destination: Record<string, unknown>,
+  source: unknown,
+): Record<string, unknown> | null {
+  if (typeof source !== 'object' || source === null || Array.isArray(source)) {
+    return null;
+  }
+
+  const result: Record<string, unknown> = {};
+  let hasKeys = false;
+
+  for (const key of Object.keys(source as Record<string, unknown>)) {
+    const srcVal = (source as Record<string, unknown>)[key];
+    const dstVal = destination[key];
+
+    // If destination has an array or object but source has a primitive, skip it
+    if (
+      typeof dstVal === 'object' &&
+      dstVal !== null &&
+      typeof srcVal !== 'object'
+    ) {
+      continue;
+    }
+
+    result[key] = srcVal;
+    hasKeys = true;
+  }
+
+  return hasKeys ? result : null;
+}
+
 /**
  * Relocate misplaced nested keys in mockData to their correct position
  * based on the dataForMocks structure.
@@ -233,12 +275,22 @@ function relocateMisplacedNestedKeys(
     }
 
     // Deep merge the value into the correct location
-    // Use deep merge to preserve existing data at that location
+    // Use deep merge to preserve existing data at that location.
+    // Before merging, strip primitives from the misplaced value that would
+    // overwrite arrays/objects at the destination. The misplaced data is lower
+    // quality — the LLM put it in the wrong place — so primitives like `true`
+    // should not overwrite correct complex values like arrays.
     if (current[key] !== undefined && typeof current[key] === 'object') {
-      current[key] = deepMerge(
+      const safeValue = stripPrimitivesOverwritingComplexValues(
         current[key] as Record<string, unknown>,
         value as Record<string, unknown>,
       );
+      if (safeValue !== null) {
+        current[key] = deepMerge(
+          current[key] as Record<string, unknown>,
+          safeValue,
+        );
+      }
     } else {
       current[key] = value;
     }
@@ -1063,6 +1115,18 @@ export async function generateDataForScenario({
     );
   }
 
+  // Strip _nullable markers from LLM-generated mock data.
+  // The _nullable marker is an internal CodeYam concept used in type definitions
+  // to indicate that a field can be null/undefined. The LLM sometimes includes
+  // these markers in its generated data, which causes runtime errors when code
+  // iterates over object keys (e.g., Object.keys(importedBy) picks up "_nullable",
+  // then Object.keys(importedBy["_nullable"]) calls Object.keys(null) and throws).
+  if (fullScenarioData.data.mockData) {
+    stripNullableMarkers(
+      fullScenarioData.data.mockData as Record<string, unknown>,
+    );
+  }
+
   // Relocate misplaced nested keys to their correct position.
   // The LLM sometimes places nested keys at root level instead of inside their
   // parent object (e.g., 'fastener' at root instead of inside 'trpc').
@@ -1098,6 +1162,18 @@ export async function generateDataForScenario({
     );
   }
 
+  // Coerce primitives to empty arrays when the schema expects an array.
+  // The LLM sometimes generates a primitive (e.g., `webapps: true`) where the
+  // schema expects an array (e.g., `webapps: [{ name: "string" }]`).
+  // This causes runtime errors like "TypeError: config.webapps?.forEach is not a function".
+  // Must run AFTER coerceObjectsToPrimitivesBySchema and BEFORE convertCommaSeparatedStringsToArrays.
+  if (structure.dataForMocks && fullScenarioData.data.mockData) {
+    coercePrimitivesToArraysBySchema(
+      fullScenarioData.data.mockData,
+      structure.dataForMocks,
+    );
+  }
+
   // Convert comma-separated strings to arrays when appropriate.
   // The LLM sometimes generates strings like "color,size" instead of arrays
   // like ["color", "size"] when the schema type is incorrectly inferred as