@codeyam/codeyam-cli 0.1.0-staging.c5503ac → 0.1.0-staging.c85943e

package/analyzer-template/project/reconcileMockDataKeys.ts

@@ -26,22 +26,21 @@ export function reconcileMockDataKeys(
         ? reconcileMockDataKeys(value as Record<string, unknown>, expectedKeys)
         : value;
 
-    // Check if key matches an expected key exactly
-    if (expectedKeys.includes(key)) {
-      result[key] = reconciledValue;
-      continue;
-    }
-
-    // Check if this is a flat dotted key that should be converted to nested structure
-    // e.g., "trpc.fastener.getAttributeValues.useQuery({ ... })"
+    // Check if this is a flat dotted key (method chain) that should be nested.
+    // e.g., "ZId.safeParse(params.surveyId)" → { ZId: { "safeParse(params.surveyId)": ... } }
+    // e.g., "trpc.fastener.getAttributeValues.useQuery({ ... })" → nested structure
+    // constructMockCode generates nested lookups like data["ZId"]["safeParse(...)"]
+    // for method chains, so the data must be nested to match.
     const flatKeyParts = parseFlatDottedKey(key);
     if (flatKeyParts && flatKeyParts.length > 1) {
-      // Check if the parts match expected keys (indicating this should be nested)
-      const partsMatchExpected = flatKeyParts.some((part) =>
-        expectedKeys.includes(part),
-      );
-      if (partsMatchExpected) {
-        // Convert flat key to nested structure and merge
+      // Nest when:
+      // 1. The full key matches an expected key exactly (e.g., "ZId.safeParse(params.surveyId)")
+      // 2. OR individual parts match expected keys (e.g., "trpc" is an expected key)
+      //    This handles LLM-generated flat keys that should be nested (Issue 8)
+      const shouldNest =
+        expectedKeys.includes(key) ||
+        flatKeyParts.some((part) => expectedKeys.includes(part));
+      if (shouldNest) {
         deepMergeIntoResult(
           result,
           flatKeyParts,
@@ -52,6 +51,12 @@ export function reconcileMockDataKeys(
       }
     }
 
+    // Check if key matches an expected key exactly (for non-dotted keys)
+    if (expectedKeys.includes(key)) {
+      result[key] = reconciledValue;
+      continue;
+    }
+
     // Try to find closest match using existing logic
     const closestKey = findClosestKey(key, expectedKeys);
     if (closestKey) {

package/analyzer-template/project/start.ts

@@ -313,6 +313,9 @@ async function main({
               : envConfig.entityShas,
           full: orchestrateCapture === 'local-sequential',
           taskRunner,
+          // Poll faster in local mode - no DB load concerns like in cloud
+          pollingInterval:
+            orchestrateCapture === 'local-sequential' ? 5 * 1000 : undefined,
           // Always track capture progress on the commit, even when not filtering by it.
           metadataCommit: sharedContext.commit ?? sharedContext.branchCommit,
         });

package/analyzer-template/project/startScenarioCapture.ts

@@ -6,6 +6,7 @@ import writeUniversalMocks from './writeUniversalMocks';
 import writeScenario from './writeScenario';
 import writeSimpleRoot from './writeSimpleRoot';
 import writeCodeYamPage from './writeCodeYamPage';
+import writeClientLogRoute from './writeClientLogRoute';
 import {
   runMultiScenarioServer,
   ScenarioToCapture,
@@ -497,6 +498,14 @@ export async function startScenarioCapture({
       );
       allGeneratedFiles.push(codeyamPagePath);
 
+      // Write client-log API route so client-side errors appear in the server log
+      const clientLogPath = await writeClientLogRoute(
+        project,
+        framework,
+        analysis.filePath,
+      );
+      if (clientLogPath) allGeneratedFiles.push(clientLogPath);
+
       // Persist file tracking for crash/debug recovery
       writeTrackingFile(allGeneratedFiles, backupFiles);
     }

package/analyzer-template/project/writeClientLogRoute.ts

@@ -0,0 +1,125 @@
+import { Project, ProjectFramework } from '~codeyam/types';
+import { findWebAppForFile, PROJECT_RELATIVE_PATH } from '~codeyam/utils';
+import writeFile from '../common/writeFile';
+import * as path from 'path';
+
+/**
+ * Writes a client-log API route to the project so that client-side errors
+ * (window.onerror, unhandledrejection, console.error) are reported back to
+ * the server log where they can be read from the terminal.
+ *
+ * The route receives JSON POST requests and console.log's them, which sends
+ * the output to the dev server's stdout (captured in the server log file).
+ */
+export default async function writeClientLogRoute(
+  project: Project,
+  framework: ProjectFramework,
+  analysisFilePath?: string,
+) {
+  const relativePath = PROJECT_RELATIVE_PATH;
+  const fullAppPath = getFullAppPath(project, analysisFilePath);
+
+  let routePath: string;
+  let content: string;
+
+  switch (framework) {
+    case ProjectFramework.Remix:
+    case ProjectFramework.CRA:
+    case ProjectFramework.CodeYam:
+      routePath = `${relativePath}/${fullAppPath}/routes/api.client-log.ts`;
+      content = getRemixRoute();
+      break;
+    case ProjectFramework.Next:
+      routePath = `${relativePath}/${fullAppPath}/api/client-log/route.ts`;
+      content = getNextAppRoute();
+      break;
+    case ProjectFramework.NextPages:
+      routePath = `${relativePath}/pages/api/client-log.ts`;
+      content = getNextPagesRoute();
+      break;
+    default:
+      return;
+  }
+
+  await writeFile(routePath, content);
+  return routePath;
+}
+
+function getFullAppPath(project: Project, analysisFilePath?: string): string {
+  if (analysisFilePath) {
+    const webapp = findWebAppForFile(
+      analysisFilePath,
+      project.metadata?.webapps ?? [],
+    );
+    if (webapp) {
+      const webappPath = webapp.path === '.' ? '' : webapp.path;
+      const appDirectory = webapp.appDirectory ?? 'app';
+      return webappPath ? path.join(webappPath, appDirectory) : appDirectory;
+    }
+  }
+  const firstWebapp = project.metadata?.webapps?.[0];
+  if (firstWebapp) {
+    const webappPath = firstWebapp.path === '.' ? '' : firstWebapp.path;
+    const appDirectory = firstWebapp.appDirectory ?? 'app';
+    return webappPath ? path.join(webappPath, appDirectory) : appDirectory;
+  }
+  return 'app';
+}
+
+function formatLogEntry(): string {
+  return `
+function formatEntry(body) {
+  const ts = new Date().toLocaleString();
+  const scenario = body.scenario ? ' [' + body.scenario + ']' : '';
+  const type = (body.type || 'error').toUpperCase();
+  const lines = ['[' + ts + '] [CLIENT ' + type + ']' + scenario + ' ' + (body.message || 'Unknown error')];
+  if (body.stack) lines.push(body.stack);
+  if (body.url) lines.push('  at ' + body.url);
+  return lines.join('\\n');
+}`;
+}
+
+function getRemixRoute(): string {
+  return `// Auto-generated by CodeYam — client error reporting endpoint
+${formatLogEntry()}
+
+export async function action({ request }) {
+  try {
+    const body = await request.json();
+    console.log(formatEntry(body));
+  } catch (e) {}
+  return new Response('ok', { status: 200 });
+}
+`;
+}
+
+function getNextAppRoute(): string {
+  return `// Auto-generated by CodeYam — client error reporting endpoint
+import { NextResponse } from 'next/server';
+${formatLogEntry()}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json();
+    console.log(formatEntry(body));
+  } catch (e) {}
+  return NextResponse.json({ ok: true });
+}
+`;
+}
+
+function getNextPagesRoute(): string {
+  return `// Auto-generated by CodeYam — client error reporting endpoint
+import type { NextApiRequest, NextApiResponse } from 'next';
+${formatLogEntry()}
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse) {
+  if (req.method !== 'POST') return res.status(405).end();
+  try {
+    const body = typeof req.body === 'string' ? JSON.parse(req.body) : req.body;
+    console.log(formatEntry(body));
+  } catch (e) {}
+  res.status(200).json({ ok: true });
+}
+`;
+}

package/analyzer-template/project/writeMockDataTsx.ts

@@ -8,6 +8,7 @@ import type { AnyNode } from 'domhandler';
 import { safeFileName } from '~codeyam/utils';
 import { cleanOutBoundary } from '~codeyam/ai';
 import { reconcileMockDataKeys } from './reconcileMockDataKeys';
+import coerceObjectsToPrimitivesBySchema from '~codeyam/ai/src/lib/dataStructure/helpers/coerceObjectsToPrimitivesBySchema';
 
 /**
  * Normalize useParams mock data by fixing the React Router splat param (*).
@@ -1029,6 +1030,14 @@ export default async function writeMockDataTsx(
     expectedKeys,
   );
 
+  // Coerce objects/arrays to primitives when the schema expects a primitive type.
+  // Defense-in-depth: the generation pipeline already runs this coercion, but
+  // data in the DB may have wrong types from older code versions or edge cases.
+  // This prevents runtime errors like "TypeError: body.match is not a function".
+  if (dataForMocks) {
+    coerceObjectsToPrimitivesBySchema(reconciledMockData, dataForMocks);
+  }
+
   // Convert comma-separated strings to arrays for fields that should be arrays
   // This handles cases where LLM generates "color,size" instead of ["color", "size"]
   const defaultMockData =
@@ -1076,6 +1085,14 @@ import React from 'react';
       expectedKeys,
     );
 
+    // Coerce objects/arrays to primitives for non-default scenario data too
+    if (dataForMocks) {
+      coerceObjectsToPrimitivesBySchema(
+        reconciledScenarioMockData,
+        dataForMocks,
+      );
+    }
+
     // Convert comma-separated strings to arrays for scenario data
     const scenarioMockData = convertCommaSeparatedStringsToArrays(
       reconciledScenarioMockData,

package/analyzer-template/project/writeScenarioComponents.ts

@@ -1055,11 +1055,17 @@ function addMockToContent(
       // use the base name (e.g., "trpc") when calling constructMockCode. This ensures
       // constructMockCode generates a complete nested mock from the schema without
       // referencing __cyOriginal variables.
+      // NOTE: Only check for dots BEFORE the first open paren. Function calls with
+      // dotted arguments like "getSurveyWithMetadata(params.surveyId)" have dots
+      // INSIDE parens — these are NOT method chains and should keep the full signature.
       const dataKeyBaseName = dataKey.split(/[.<(]/)[0];
+      const firstParenIndex = dataKey.indexOf('(');
+      const partBeforeFirstParen =
+        firstParenIndex >= 0 ? dataKey.substring(0, firstParenIndex) : dataKey;
       const isMethodChainDataKey =
         dataKeyBaseName === importedExport.name &&
         dataKey !== importedExport.name &&
-        dataKey.includes('.');
+        partBeforeFirstParen.includes('.');
       const mockNameToUse = isMethodChainDataKey
         ? importedExport.name
         : dataKey;
@@ -1145,12 +1151,20 @@ function ${importedExport.name}(...args) {
       // referencing __cyOriginal variables. The __cyOriginal pattern is only needed
       // for partial mocking where we preserve some original methods, not for complete
       // method-chain mocks where we provide all implementations.
+      // NOTE: Only check for dots BEFORE the first open paren. Function calls with
+      // dotted arguments like "getSurveyWithMetadata(params.surveyId)" have dots
+      // INSIDE parens — these are NOT method chains and should keep the full signature.
       const dataKeyBaseName = dataKey?.split(/[.<(]/)[0];
+      const elseFirstParenIndex = dataKey?.indexOf('(') ?? -1;
+      const elsePartBeforeFirstParen =
+        dataKey && elseFirstParenIndex >= 0
+          ? dataKey.substring(0, elseFirstParenIndex)
+          : dataKey;
       const isMethodChainDataKey =
         dataKey &&
         dataKeyBaseName === importedExport.name &&
         dataKey !== importedExport.name &&
-        dataKey.includes('.');
+        (elsePartBeforeFirstParen?.includes('.') ?? false);
       const mockNameToUse = isMethodChainDataKey
         ? importedExport.name
         : (dataKey ?? importedExport.calls?.[0] ?? `${importedExport.name}()`);
@@ -1920,6 +1934,17 @@ export default async function writeScenarioComponents({
               dataFileContent = stripServerOnlyImport(dataFileContent);
               dataFileContent = applyServerOnlyMocks(dataFileContent);
 
+              // Process transitive imports: if the data entity file imports from files
+              // that have `import "server-only"`, rewrite those imports to transitive
+              // copies with server-only stripped. Without this, data entity files that
+              // end up in a client bundle (e.g., via a stripped "use server" boundary)
+              // would pull in server-only code and cause build failures.
+              dataFileContent = await processTransitiveImportsRecursively(
+                dataFileContent,
+                fileNotMocked.path,
+                dataScenarioPath,
+              );
+
               // Write the transformed data entity file
               await writeFile(dataScenarioPath, dataFileContent);
               scenarioComponentPaths.push(dataScenarioPath);
@@ -1945,9 +1970,9 @@ export default async function writeScenarioComponents({
               importedExport.name,
             );
 
-            // Don't recurse - data entities don't need their dependencies processed
-            // The import rewriting will happen later in this same loop iteration
-            // (at lines ~1590-1702) to point imports to this transformed file
+            // Don't recurse into full writeScenarioComponents - data entities don't
+            // need mock generation for their dependencies. Transitive server-only
+            // import processing is already handled above via processTransitiveImportsRecursively.
           } else {
             // For visual/library entities, recurse to process their dependencies
 
@@ -2020,20 +2045,25 @@ export default async function writeScenarioComponents({
       // that stubbing would break (e.g., Zod schemas with .superRefine())
       const isDataEntity = entityType === 'data' || entityType === 'type';
 
-      // Heuristic: Zod schemas are often misclassified as 'library' but should be preserved
-      // Detect by: name starts with Z + uppercase letter, AND has Zod method calls
-      const looksLikeZodSchema =
-        entityType === 'library' &&
-        /^Z[A-Z]/.test(importedExport.name) &&
-        importedExport.calls?.some((call: string) =>
-          /\.(superRefine|refine|transform|default|optional|nullable|array|object|string|number|boolean|parse|safeParse)\s*\(/.test(
-            call,
-          ),
-        );
+      // If calls data shows the entity is only accessed via properties/methods
+      // (e.g., formValidator.validate(), schema.superRefine()) and never directly
+      // invoked (e.g., getInitialProps()), it's used as an object and should be
+      // preserved rather than replaced with a Proxy stub.
+      const onlyPropertyAccessed =
+        importedExport.calls?.length > 0 &&
+        !importedExport.calls.some((call: string) => {
+          const afterName = call.slice(importedExport.name.length);
+          return afterName.startsWith('(') || afterName.startsWith('<');
+        });
 
-      // Callable entities can be safely stubbed (but not Zod schemas)
+      // Callable entities can be safely stubbed. Entities that are only
+      // property-accessed should be preserved (their methods need to work).
+      // 'other' entities are unknown types — safer to preserve than stub.
       const isCallable =
-        !isDataEntity && !looksLikeZodSchema && entityType !== undefined;
+        !isDataEntity &&
+        !onlyPropertyAccessed &&
+        entityType !== undefined &&
+        entityType !== 'other';
 
       // Determine what action to take
       const shouldStripAndReplace = hasMock;
@@ -2733,6 +2763,20 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     debugLog(
       `[REMAINING LOOP] import ${remainingImportIndex}/${remainingImportPaths.length}: ${importPath}`,
     );
+
+    // Skip imports that point to generated CodeYam files (same skip logic as
+    // rewriteRelativeModuleImports). Without this, MockData files from earlier
+    // captures that get discovered by the TypeScript compiler would be treated as
+    // regular imports, creating transitive copies with stale content.
+    const scenarioFilePattern = /[a-f0-9]{64}_\w+_[A-Z]\w*$/;
+    const mockDataPattern = /__codeyamMocks__\//;
+    if (
+      scenarioFilePattern.test(importPath) ||
+      mockDataPattern.test(importPath)
+    ) {
+      continue;
+    }
+
     // Resolve the import path to a project file path
     const resolvedFilePath = resolveImportPath(importPath, file.path, project);
 
@@ -3007,6 +3051,55 @@ ${exportKeyword}const ${functionName} = new Proxy(() => scenarios().data()?.["${
     }
   }
 
+  // For route components (page.tsx, layout.tsx), the component IS the Next.js page.
+  // There's no wrapper page to inject argumentsData as props (unlike non-route components
+  // which get a scenarioComponent wrapper). We need to wrap the default export so that
+  // the scenario's argumentsData is passed as props to the component.
+  if (
+    isFrameworkRoute(file, entity, framework, file === rootFile) &&
+    rootAnalysis.metadata?.scenariosDataStructure?.arguments?.length > 0
+  ) {
+    const positionalArguments =
+      rootAnalysis.metadata.scenariosDataStructure.arguments;
+    const hasNamedArgs =
+      positionalArguments.length === 1 &&
+      typeof positionalArguments[0] === 'object';
+
+    if (hasNamedArgs) {
+      // Match: export default function Name(
+      // Also: export default async function Name(
+      const defaultExportMatch = fileContent.match(
+        /export\s+default\s+(async\s+)?function\s+(\w+)\s*\(/,
+      );
+
+      if (defaultExportMatch) {
+        const funcName = defaultExportMatch[2];
+
+        // Remove "export default" from the original function declaration
+        fileContent = fileContent.replace(
+          /export\s+default\s+(async\s+)?function\s+(\w+)\s*\(/,
+          '$1function $2(',
+        );
+
+        // Ensure scenarios import is present
+        const mockDataPath = `${relativeMocksDir}/MockData_${safeFileName(scenario.name)}`;
+        if (fileContent.indexOf('import { scenarios } from') === -1) {
+          fileContent = `import { scenarios } from "${mockDataPath}";\n\n${fileContent}`;
+        }
+
+        // Add wrapper default export that injects argumentsData as props.
+        // Filter null values: the LLM uses null to mean "don't pass this prop"
+        // but spreading { prop: null } explicitly passes null, which differs from
+        // undefined (absent) and crashes components that check `prop !== undefined`.
+        fileContent += `\n\nexport default function _CYRouteWrapper(props: any) {
+  const _cyArgs = scenarios().data()?.['arguments']?.[0] ?? {};
+  const _cyCleanArgs = Object.fromEntries(Object.entries(_cyArgs).filter(([_, v]) => v !== null));
+  return <${funcName} {...props} {..._cyCleanArgs} />;
+}\n`;
+      }
+    }
+  }
+
   // Use the directive that was extracted at the beginning of processing
   // This ensures it stays at the very top even after imports are prepended
   // NOTE: We only preserve "use client" directives, NOT "use server" directives.

package/analyzer-template/tsconfig.json

@@ -15,6 +15,18 @@
       "~codeyam/*": ["./packages/*"]
     },
     "sourceMap": true,
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "types": [
+      "node",
+      "jest",
+      "jsdom",
+      "better-sqlite3",
+      "yargs",
+      "pg",
+      "ws",
+      "react",
+      "react-dom",
+      "react-resizable"
+    ]
   }
 }