@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.28f73cf

package/analyzer-template/project/writeMockDataTsx.ts

@@ -244,6 +244,9 @@ const jsonToCode = (
     } else {
       const keyStrings: string[] = [];
       const jsonObj = json as Record<string, unknown>;
+      // Track normalized function names to avoid duplicate keys in output
+      // e.g., submit({ a }) and submit({ b }) should both become "submit" once
+      const seenNormalizedFuncNames = new Set<string>();
 
       for (const key of Object.keys(jsonObj)) {
         if (jsonObj[key] === undefined || jsonObj[key] === null) continue;
@@ -252,6 +255,42 @@ const jsonToCode = (
           if (key === '~~codeyam-jsx~~') {
             return `<>${(jsonObj[key] as string[]).join('')}</>`;
           }
+
+          // Check if this is a nested function signature with array value
+          // e.g., "postMessage(message, '*')": ["mockMessageString", "*"]
+          // These need to be transformed into callable arrow functions
+          // Only apply at deeper nesting levels (level > 2) - top-level mock data keys
+          // (level 2) are return values that should preserve their data
+          // Skip when array contains objects (likely return data like getAll() returning [{name, value}])
+          const argsArray = jsonObj[key] as unknown[];
+          const isReturnData = argsArray.some(
+            (item) => item && typeof item === 'object' && !Array.isArray(item),
+          );
+          if (
+            key.includes('(') &&
+            key.endsWith(')') &&
+            level > 2 &&
+            !isReturnData
+          ) {
+            const funcName = key.split('(')[0];
+            // Skip if we've already added this normalized function name
+            if (seenNormalizedFuncNames.has(funcName)) {
+              continue;
+            }
+            seenNormalizedFuncNames.add(funcName);
+            const argsArray = jsonObj[key] as unknown[];
+            const argsString = argsArray
+              .map((_, i) => `arg${i + 1}`)
+              .join(', ');
+            console.log(
+              `CodeYam: Nested func transform (array): "${key}" -> "${funcName}"`,
+            );
+            keyStrings.push(
+              `${levelSpacing}"${safeString(funcName, level)}": (${argsString}) => {}`,
+            );
+            continue;
+          }
+
           const arrayString = jsonToCode(
             jsonObj[key],
             level + 1,
@@ -269,9 +308,38 @@ const jsonToCode = (
             );
           }
         } else if (typeof jsonObj[key] === 'object') {
-          // Check if this object has a "functionCallReturnValue" key - if so, unwrap it
           const objKeys = Object.keys(jsonObj[key] as object);
+
+          // Check if this is a nested function signature (e.g., "postMessage(message, targetOrigin)": { signature: [...] })
+          // These need to be transformed into callable arrow functions
+          // Only apply at deeper nesting levels (level > 2) - top-level mock data keys
+          // (level 2) are return values that should preserve their data
           if (
+            key.includes('(') &&
+            key.endsWith(')') &&
+            level > 2 &&
+            objKeys.includes('signature') &&
+            Array.isArray((jsonObj[key] as Record<string, unknown>).signature)
+          ) {
+            const funcName = key.split('(')[0];
+            // Skip if we've already added this normalized function name
+            if (seenNormalizedFuncNames.has(funcName)) {
+              continue;
+            }
+            seenNormalizedFuncNames.add(funcName);
+            const signature = (jsonObj[key] as Record<string, unknown>)
+              .signature as string[];
+            const argsString = signature
+              .map((_, i) => `arg${i + 1}`)
+              .join(', ');
+            console.log(
+              `CodeYam: Nested func transform (signature): "${key}" -> "${funcName}"`,
+            );
+            keyStrings.push(
+              `${levelSpacing}"${safeString(funcName, level)}": (${argsString}) => {}`,
+            );
+          } else if (
+            // Check if this object has a "functionCallReturnValue" key - if so, unwrap it
             objKeys.length === 1 &&
             objKeys[0] === 'functionCallReturnValue'
           ) {
@@ -341,9 +409,60 @@ const jsonToCode = (
           }
           return keyValue;
         } else if (typeof jsonObj[key] === 'string') {
-          keyStrings.push(
-            `${levelSpacing}"${safeString(key, level)}": "${safeString(jsonObj[key] as string, level)}"`,
-          );
+          const stringValue = jsonObj[key] as string;
+
+          // Check if this is a nested function signature with string value
+          // e.g., "postMessage(message, '*')": "() => { console.log('postMessage called'); }"
+          // These need to have the key normalized to just the function name
+          // Only apply at deeper nesting levels (level > 2)
+          if (key.includes('(') && key.endsWith(')') && level > 2) {
+            const funcName = key.split('(')[0];
+
+            // Skip if we've already added this normalized function name
+            if (seenNormalizedFuncNames.has(funcName)) {
+              continue;
+            }
+            seenNormalizedFuncNames.add(funcName);
+
+            // Check if the string value looks like a function expression
+            const looksLikeFunction =
+              stringValue.includes('=>') ||
+              stringValue.startsWith('function') ||
+              stringValue.startsWith('async');
+
+            // Handle special type indicators that need transformation
+            let outputValue: string;
+            if (stringValue === 'promise') {
+              outputValue = 'Promise.resolve()';
+              console.log(
+                `CodeYam: Nested func transform (string->Promise): "${key}" -> "${funcName}": Promise.resolve()`,
+              );
+            } else if (stringValue === 'function') {
+              outputValue = '() => {}';
+              console.log(
+                `CodeYam: Nested func transform (string->function): "${key}" -> "${funcName}": () => {}`,
+              );
+            } else if (looksLikeFunction) {
+              outputValue = stringValue;
+              console.log(
+                `CodeYam: Nested func transform (string): "${key}" -> "${funcName}": ${stringValue.substring(0, 30)}...`,
+              );
+            } else {
+              // Plain string value - must be quoted
+              outputValue = `"${safeString(stringValue, level)}"`;
+              console.log(
+                `CodeYam: Nested func transform (string->quoted): "${key}" -> "${funcName}": "${stringValue}"`,
+              );
+            }
+
+            keyStrings.push(
+              `${levelSpacing}"${safeString(funcName, level)}": ${outputValue}`,
+            );
+          } else {
+            keyStrings.push(
+              `${levelSpacing}"${safeString(key, level)}": "${safeString(stringValue, level)}"`,
+            );
+          }
         } else {
           keyStrings.push(
             `${levelSpacing}"${safeString(key, level)}": ${safeString(String(jsonObj[key]), level)}`,
@@ -437,6 +556,7 @@ import React from 'react';
     const rawScenarioMockData = {
       ...(mockScenario.metadata.data?.mockData ?? {}),
     };
+
     // Reconcile scenario-specific mock data keys as well
     const scenarioMockData = reconcileMockDataKeys(
       rawScenarioMockData,
@@ -448,6 +568,7 @@ import React from 'react';
     });
 
     const mergedMockData = deepMerge(defaultMockData, scenarioMockData);
+
     // Normalize mock data to merge entries with same normalized function name
     const normalizedMockData = normalizeMockData(
       mergedMockData as Record<string, unknown>,

package/analyzer-template/project/writeScenarioComponents.ts

@@ -43,6 +43,12 @@ interface WriteScenarioComponentsArgs {
   })[];
   writtenScenarioComponents?: { [key: string]: string[] };
   fileStore?: LazyFileStore;
+  /**
+   * When a default export needs to be accessible as a named export (e.g., when
+   * the parent imports it as `{ Name }` via an index re-export), pass the name here.
+   * A re-export statement `export { default as Name };` will be added to the output.
+   */
+  exportAsNamed?: string;
 }
 
 type EnhancedImportedExport = Omit<
@@ -83,54 +89,62 @@ function isIndexPath(filePath: string) {
 }
 
 /**
- * Rewrite asset imports (CSS, images, fonts, etc.) to correct relative paths.
- * These imports aren't tracked as importedExports, so we need to handle them separately.
+ * Rewrite relative asset paths to correct locations when a file is moved.
  *
- * Handles patterns like:
+ * This function generically handles ANY string literal containing a relative path
+ * to an asset file, not just import statements. This catches patterns like:
  * - import "./globals.css"
  * - import styles from "./file.module.css"
- * - import logo from "./logo.png"
+ * - localFont({ src: "../fonts/font.woff2" })
+ * - Image src="../images/logo.png"
+ * - Any other string literal with a relative asset path
  */
 function rewriteAssetImports(
   fileContent: string,
   originalFilePath: string,
   newFilePath: string,
 ): string {
-  // Match imports with non-JS/TS extensions
+  // Asset file extensions that should have their paths rewritten
   const assetExtensions =
     'css|scss|sass|less|styl|png|jpg|jpeg|gif|svg|webp|ico|woff|woff2|ttf|eot|otf|mp4|webm|json';
-  const assetImportRegex = new RegExp(
-    `import\\s+(?:[\\w$]+\\s+from\\s+)?(['"])(\\.{1,2}/[^'"]+\\.(?:${assetExtensions}))\\1`,
+
+  // Match ANY string literal containing a relative path to an asset file
+  // This captures both single and double quoted strings that start with ./ or ../
+  const relativeAssetPathRegex = new RegExp(
+    `(['"])(\\.{1,2}/[^'"]*\\.(?:${assetExtensions}))\\1`,
     'g',
   );
 
   // Get the directory part of the original file path (relative to project root)
   const originalDirParts = originalFilePath.split('/').slice(0, -1);
 
-  return fileContent.replace(assetImportRegex, (match, quote, importPath) => {
-    // Resolve the asset path relative to the original file's directory
-    // We need to manually resolve the relative path without using path.resolve
-    // which would resolve against the actual filesystem
-    const importParts = importPath.split('/');
-    const resolvedParts = [...originalDirParts];
-
-    for (const part of importParts) {
-      if (part === '..') {
-        resolvedParts.pop();
-      } else if (part !== '.') {
-        resolvedParts.push(part);
+  return fileContent.replace(
+    relativeAssetPathRegex,
+    (match, quote, assetPath) => {
+      // Resolve the asset path relative to the original file's directory
+      // We need to manually resolve the relative path without using path.resolve
+      // which would resolve against the actual filesystem
+      const pathParts = assetPath.split('/');
+      const resolvedParts = [...originalDirParts];
+
+      for (const part of pathParts) {
+        if (part === '..') {
+          resolvedParts.pop();
+        } else if (part !== '.') {
+          resolvedParts.push(part);
+        }
       }
-    }
 
-    // Build the project-relative path to the asset
-    const absoluteAssetPath = resolvedParts.join('/');
+      // Build the project-relative path to the asset
+      const absoluteAssetPath = resolvedParts.join('/');
 
-    // Calculate the new relative path from new file location
-    const newRelativePath = getRelativePath(newFilePath, absoluteAssetPath);
+      // Calculate the new relative path from new file location
+      const newRelativePath = getRelativePath(newFilePath, absoluteAssetPath);
 
-    // Reconstruct the import statement
-    return match.replace(importPath, newRelativePath);
-  });
+      // Replace the path in the original match, preserving the quote style
+      return `${quote}${newRelativePath}${quote}`;
+    },
+  );
 }
 
 function addMockToContent(
@@ -409,6 +423,7 @@ export default async function writeScenarioComponents({
   namespaceMocks,
   writtenScenarioComponents = {},
   fileStore,
+  exportAsNamed,
 }: WriteScenarioComponentsArgs): Promise<{
   scenarioComponentPaths: string[];
   writtenScenarioComponents: { [key: string]: string[] };
@@ -643,10 +658,12 @@ export default async function writeScenarioComponents({
     (importedExportEntity as Entity).localFilePath = importedExport.filePath;
 
     if (!importedExport.isMocked) {
+      // Use resolvedFilePath (actual entity location) for scenario component writing.
+      // This is critical for re-exports: when importing from index.tsx which re-exports
+      // from a nested file, we need to write scenario components for the actual file
+      // where the entity code lives, not the re-export file.
       const importedExportFilePath =
-        importedExportEntity.localFilePath === file.path
-          ? (importedExport.resolvedFilePath ?? importedExport.filePath)
-          : importedExport.filePath;
+        importedExport.resolvedFilePath ?? importedExport.filePath;
 
       if (importedExportFilePath !== file.path) {
         if (
@@ -668,17 +685,41 @@ export default async function writeScenarioComponents({
             ? fileStore.getByPath(importedExportFilePath)
             : project.files.find((f) => f.path === importedExportFilePath);
 
+          // Fallback: if file at resolvedFilePath doesn't exist, try filePath
+          // This handles cases where the actual entity file isn't in project.files
+          // (e.g., type re-exports where only the index file is tracked)
+          if (
+            !fileNotMocked &&
+            importedExport.resolvedFilePath &&
+            importedExport.filePath !== importedExport.resolvedFilePath
+          ) {
+            const fallbackPath = importedExport.filePath;
+            fileNotMocked = fileStore
+              ? fileStore.getByPath(fallbackPath)
+              : project.files.find((f) => f.path === fallbackPath);
+          }
+
+          // Skip if file still not found - can't write scenario component without the file
+          if (!fileNotMocked) {
+            continue;
+          }
+
           // Ensure content is loaded for the file
           if (
             fileNotMocked &&
             fileStore &&
-            !fileStore.isContentLoaded(importedExportFilePath)
+            !fileStore.isContentLoaded(fileNotMocked.path)
           ) {
-            fileNotMocked = await fileStore.ensureContent(
-              importedExportFilePath,
-            );
+            fileNotMocked = await fileStore.ensureContent(fileNotMocked.path);
           }
 
+          // When a default export is imported as named (via index re-export), we need
+          // to add a named re-export to the scenario component so the import works.
+          // e.g., if file has `export default X` but parent does `import { X } from '...'`
+          const needsNamedReExport =
+            importedExport.resolvedIsDefault === true &&
+            importedExport.isDefault === false;
+
           const {
             scenarioComponentPaths: newScenarioComponentPaths,
             writtenScenarioComponents: updatedWrittenScenarioComponents,
@@ -696,6 +737,8 @@ export default async function writeScenarioComponents({
             namespaceMocks,
             writtenScenarioComponents,
             fileStore,
+            // Pass the import name so we can add `export { default as Name };`
+            exportAsNamed: needsNamedReExport ? importedExport.name : undefined,
           });
           writtenScenarioComponents = updatedWrittenScenarioComponents;
           scenarioComponentPaths.push(...newScenarioComponentPaths);
@@ -729,18 +772,38 @@ export default async function writeScenarioComponents({
             relativeMocksDir,
             scenario.name,
           );
+        } else if (importedExport.isMocked) {
+          // No mock structure available, but isMocked is true.
+          // Generate a simple stub mock that returns scenario data.
+          // This prevents ReferenceError at runtime when the stripped
+          // function is called (e.g., local helper functions like getInitialProps).
+          const functionName = importedExport.name;
+
+          // Add scenarios import if not present
+          if (fileContent.indexOf('import { scenarios } from') === -1) {
+            const mockDataPath = `${relativeMocksDir}/MockData_${safeFileName(scenario.name)}`;
+            const importStatement = `import { scenarios } from "${mockDataPath}";`;
+            fileContent = `${fileContent}\n\n\n${importStatement}`;
+          }
+
+          // Generate a simple stub that returns the scenario data for this function
+          const stubMock = `\n\n// Stub mock for local function without mock structure\nfunction ${functionName}(...args) {\n  return scenarios().data()?.["${functionName}()"];\n}`;
+          fileContent += stubMock;
         }
       }
     }
 
     // Try to find the import mapping using different key formats
     // The import mapping may use either absolute or relative paths as keys
-    // IMPORTANT: Use filePath (where it's imported FROM), not resolvedFilePath (where entity lives)
-    // For re-exports like ~codeyam/types, filePath="packages/types/index.ts",
-    // resolvedFilePath="packages/types/src/types/Commit.ts"
-    // We need to generate files at the import location (index.ts), not the entity location
+    // Use filePath (import source) for looking up the import mapping
+    // because that's how imports are written in source code
     const mockFilePathRelative = importedExport.filePath;
 
+    // For scenario component paths, prefer resolvedFilePath (where entity actually lives)
+    // because that's where scenario component files are written
+    const scenarioFilePathRelative =
+      importedExport.resolvedFilePath ?? importedExport.filePath;
+
     // Try looking up with different key formats (absolute, relative, resolved absolute)
     // Filter out undefined keys to avoid misleading undefined lookups
     const lookupKeys = [
@@ -794,10 +857,28 @@ export default async function writeScenarioComponents({
     } else {
       // For non-mocked imports, rewrite the import path to point to the generated scenario file
       // Use fileStore for O(1) lookup when available
-      const fileNotMocked = fileStore
-        ? fileStore.getByPath(mockFilePathRelative)
-        : project.files.find((f) => f.path === mockFilePathRelative);
-      const fileName = mockFilePathRelative.split('/').pop();
+      // First try resolvedFilePath (where entity lives), fallback to filePath (import source)
+      let fileNotMocked = fileStore
+        ? fileStore.getByPath(scenarioFilePathRelative)
+        : project.files.find((f) => f.path === scenarioFilePathRelative);
+
+      // Track which path we're actually using for the scenario component
+      let actualScenarioFilePathRelative = scenarioFilePathRelative;
+      if (
+        !fileNotMocked &&
+        importedExport.resolvedFilePath &&
+        importedExport.filePath !== importedExport.resolvedFilePath
+      ) {
+        // Fallback to filePath if file at resolvedFilePath doesn't exist
+        actualScenarioFilePathRelative = importedExport.filePath;
+        fileNotMocked = fileStore
+          ? fileStore.getByPath(actualScenarioFilePathRelative)
+          : project.files.find(
+              (f) => f.path === actualScenarioFilePathRelative,
+            );
+      }
+
+      const fileName = actualScenarioFilePathRelative.split('/').pop();
       const fileNotMockedIsIndex = isIndexPath(fileNotMocked?.path);
       const mockFilePath = isFrameworkRoute(
         fileNotMocked,
@@ -810,7 +891,7 @@ export default async function writeScenarioComponents({
             rootFile,
             entity: importedExportEntity,
             rootAnalysis,
-            scenarioComponentPath: mockFilePathRelative,
+            scenarioComponentPath: actualScenarioFilePathRelative,
             project,
             framework,
             scenario,
@@ -818,7 +899,7 @@ export default async function writeScenarioComponents({
             .split('.')
             .slice(0, -1)
             .join('.')
-        : mockFilePathRelative.replace(
+        : actualScenarioFilePathRelative.replace(
             `${fileName}`,
             `${importedExportEntity.sha}_${fileNotMockedIsIndex ? 'index_' : ''}${safeFileName(importedExportEntity.name)}_${safeFileName(scenario.name)}`,
           );
@@ -833,7 +914,39 @@ export default async function writeScenarioComponents({
           'g',
         );
 
-        fileContent = fileContent.replace(importRegExp, `${path}$1`);
+        // Check if the original import path still exists in the file
+        // If it was already rewritten by another entity from the same module,
+        // we need to add a separate import statement for this entity
+        if (fileContent.match(importRegExp)) {
+          fileContent = fileContent.replace(importRegExp, `${path}$1`);
+        } else {
+          // The import path was already rewritten - add a new import for this entity
+          // This handles cases where multiple entities are imported from the same index file
+          // (e.g., import { A, B, C } from '@pkg') and each has its own scenario file
+          const entityImportName = importedExport.name;
+          const newImport = `import { ${entityImportName} } from '${path}';`;
+
+          // First, try to remove this entity from the already-rewritten grouped import
+          // This prevents duplicate/conflicting imports
+          // Match patterns like "EntityName," or ", EntityName" or "EntityName" (if only one)
+          const removeFromGroupedImportPatterns = [
+            new RegExp(`\\b${entityImportName}\\s*,\\s*`, 'g'), // "EntityName, "
+            new RegExp(`\\s*,\\s*${entityImportName}\\b`, 'g'), // ", EntityName"
+          ];
+          for (const pattern of removeFromGroupedImportPatterns) {
+            fileContent = fileContent.replace(pattern, '');
+          }
+
+          // Add the new import at the beginning of fileContent
+          // Note: The header comment (// Scenario:) doesn't exist yet - it's prepended at writeFile time
+          // So prepending here puts the import right after the header in the final output
+          //
+          // IMPORTANT: We cannot use indexOf('// Scenario:') + '\n\n' here because:
+          // 1. The header doesn't exist during processing
+          // 2. indexOf would return -1, and indexOf('\n\n', -1) starts from 0
+          // 3. This could find a \n\n inside a function body, inserting the import there!
+          fileContent = newImport + '\n' + fileContent;
+        }
       }
     }
   }
@@ -852,6 +965,36 @@ export default async function writeScenarioComponents({
     );
   }
 
+  // Rewrite node_module imports that have universal mocks
+  // Universal mocks create mock files at __codeyamMocks__/{safeFileName}.tsx
+  // We need to rewrite imports like `import { logger } from "@formbricks/logger"`
+  // to `import { logger } from "../__codeyamMocks__/_formbricks_logger"`
+  const universalMocks = project.metadata?.universalMocks ?? [];
+  const nodeModuleUniversalMocks = universalMocks.filter(
+    (mock) => mock.nodeModule && mock.content,
+  );
+
+  for (const universalMock of nodeModuleUniversalMocks) {
+    const originalPath = universalMock.filePath;
+    // Create the mock file name using the same pattern as applyUniversalMocks
+    const safeFileName = originalPath.replace(/[^a-zA-Z0-9_\-./]/g, '_');
+    const mockFileRelativePath = `${relativeMocksDir}/${safeFileName}`;
+
+    // Match both single and double quotes, and handle both named and default imports
+    // Pattern 1: import { x, y } from "module"
+    // Pattern 2: import x from "module"
+    // Pattern 3: import * as x from "module"
+    const importRegex = new RegExp(
+      `(import\\s+(?:\\{[^}]*\\}|\\*\\s+as\\s+\\w+|\\w+)\\s+from\\s+)['"]${originalPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]`,
+      'g',
+    );
+
+    fileContent = fileContent.replace(
+      importRegex,
+      `$1'${mockFileRelativePath}'`,
+    );
+  }
+
   if (
     rootAnalysis.entitySha === entity.sha &&
     entity.metadata?.notExported &&
@@ -864,6 +1007,17 @@ export default async function writeScenarioComponents({
     }
   }
 
+  // When a default export is imported as named via re-export (e.g., index.tsx re-exports
+  // a default export as named), we need to add a named export so the parent's
+  // import statement works: `import { Name } from './path'`
+  // The local variable name is the same as exportAsNamed (e.g., ScenarioEditor)
+  if (exportAsNamed) {
+    const namedExport = `export { ${exportAsNamed} };`;
+    if (!fileContent.includes(namedExport)) {
+      fileContent = `${fileContent}\n\n${namedExport}`;
+    }
+  }
+
   const basePath = safeFolder(file.path.split('/').slice(0, -1).join('/'));
   const extension = file.name.split('.').pop();
   // Include scenario name in path to allow multiple scenarios to coexist

package/analyzer-template/project/writeUniversalMocks.ts

@@ -28,7 +28,26 @@ export default async function writeUniversalMocks({
 }: WriteUniversalMocksArgs) {
   const { project } = projectAnalyzer;
 
-  for (const universalMock of project.metadata?.universalMocks ?? []) {
+  // Group node_module mocks by filePath to merge multiple exports into one file
+  // This prevents later mocks from overwriting earlier ones for the same package
+  const nodeModuleMocksByPath = new Map<
+    string,
+    Array<(typeof universalMocks)[number]>
+  >();
+  const universalMocks = project.metadata?.universalMocks ?? [];
+
+  for (const mock of universalMocks) {
+    if (mock.nodeModule) {
+      const existing = nodeModuleMocksByPath.get(mock.filePath) ?? [];
+      existing.push(mock);
+      nodeModuleMocksByPath.set(mock.filePath, existing);
+    }
+  }
+
+  // Track which filePaths we've already processed (for node_modules)
+  const processedNodeModulePaths = new Set<string>();
+
+  for (const universalMock of universalMocks) {
     console.log(
       'CodeYam: Initializing universal mock',
       universalMock.filePath,
@@ -60,13 +79,27 @@ export default async function writeUniversalMocks({
           universalMock.filePath,
         );
         const fileAnalyzer = projectAnalyzer.getFileAnalyzer(file);
-        if (fileAnalyzer.getAllEntityNodes()[universalMock.entityName]) {
-          const entityCode = fileAnalyzer.getEntityCode(
+
+        // Use getAllDeclaredEntityNodes to avoid incorrectly matching identifier references
+        if (
+          fileAnalyzer.getAllDeclaredEntityNodes()[universalMock.entityName]
+        ) {
+          const entityCode = fileAnalyzer.getDeclaredEntityCode(
             universalMock.entityName,
           );
           mockContent = file.content.replace(entityCode, universalMock.content);
         }
       } else {
+        // For node_modules, check if we've already processed this path
+        // (multiple mocks for the same package should be merged)
+        if (universalMock.nodeModule) {
+          if (processedNodeModulePaths.has(universalMock.filePath)) {
+            // Already processed as part of a merged mock, skip
+            continue;
+          }
+          processedNodeModulePaths.add(universalMock.filePath);
+        }
+
         const appPath = getAppPath(
           project,
           framework,
@@ -83,14 +116,37 @@ export default async function writeUniversalMocks({
           CODEYAM_MOCKS_DIRNAME,
           safeFileName(filePathForMockFile) + '.tsx',
         );
-        const exportName =
-          universalMock.entityName === 'default'
-            ? 'default'
-            : `{ ${universalMock.entityName} }`;
-        if (exportName === 'default') {
-          mockContent = `export default ${universalMock.content}`;
+
+        // For node_modules, merge all mocks for this filePath
+        const mocksToProcess = universalMock.nodeModule
+          ? (nodeModuleMocksByPath.get(universalMock.filePath) ?? [
+              universalMock,
+            ])
+          : [universalMock];
+
+        const contentParts: string[] = [];
+        const namedExports: string[] = [];
+        let hasDefaultExport = false;
+
+        for (const mock of mocksToProcess) {
+          if (mock.entityName === 'default') {
+            hasDefaultExport = true;
+            contentParts.push(`export default ${mock.content}`);
+          } else {
+            contentParts.push(mock.content);
+            namedExports.push(mock.entityName);
+          }
+        }
+
+        // Build the final mock content
+        if (namedExports.length > 0) {
+          mockContent = contentParts.join('\n\n');
+          // Only add export statement for non-default exports if not already in content
+          if (!hasDefaultExport || namedExports.length > 0) {
+            mockContent += `\n\nexport { ${namedExports.join(', ')} };`;
+          }
         } else {
-          mockContent = `${universalMock.content}\n\nexport { ${universalMock.entityName} };`;
+          mockContent = contentParts.join('\n\n');
         }
       }
 
@@ -132,6 +188,12 @@ export default async function writeUniversalMocks({
         );
         const allSourceFiles = projectAnalyzer.getAllSourceFiles();
         for (const sourceFile of allSourceFiles) {
+          // Skip JSON files - they should not have imports rewritten
+          // This can happen when resolveJsonModule is enabled in tsconfig
+          // and package.json is included in the TypeScript program
+          if (sourceFile.path.endsWith('.json')) {
+            continue;
+          }
           if (importRegEx.test(sourceFile.content)) {
             const relativeMockPath = getRelativePath(sourceFile.path, mockPath);
             const newContent = sourceFile.content.replace(