@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.596f0eb

package/analyzer-template/project/writeSimpleRoot.ts

@@ -221,6 +221,7 @@ export default async function writeSimpleRoot(
 
           // Find node module dependencies used by root.tsx that need mocking
           // These are typically Remix hooks like useLoaderData, useActionData, etc.
+          // IMPORTANT: Only mock dependencies that have isMocked: true in the entity's nodeModuleImports
           const nodeModulesToMock = [
             '@remix-run/react',
             '@remix-run/node',
@@ -228,11 +229,25 @@ export default async function writeSimpleRoot(
             'react-router-dom',
           ];
 
+          // Get nodeModuleImports from the entity to check isMocked flags
+          const entityNodeModuleImports =
+            options.entity?.metadata?.nodeModuleImports || {};
+
           for (const modulePath of nodeModulesToMock) {
             const moduleSchemas = dependencySchemas[modulePath];
             if (!moduleSchemas) continue;
 
+            // Get the imports for this module that have isMocked: true
+            const mockedImports = (entityNodeModuleImports[modulePath] || [])
+              .filter((imp: { isMocked?: boolean }) => imp.isMocked === true)
+              .map((imp: { name: string }) => imp.name);
+
             for (const entityName in moduleSchemas) {
+              // Only mock if this entity is marked as isMocked: true in nodeModuleImports
+              if (!mockedImports.includes(entityName)) {
+                continue;
+              }
+
               // Check if this entity is actually used in root.tsx
               const importRegex = new RegExp(
                 `import\\s+(?:{[^}]*\\b${entityName}\\b[^}]*}|\\b${entityName}\\b)\\s+from\\s+['"]${modulePath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}['"]`,
@@ -240,8 +255,108 @@ export default async function writeSimpleRoot(
 
               if (!newContent.match(importRegex)) continue;
 
-              // Generate mock code for this dependency
-              const mockCode = constructMockCode(entityName, dependencySchemas);
+              // Find the correct variable-qualified mock key for ROOT's usage
+              // The mock data is stored under keys like "variableName <- functionName"
+              // For root.tsx, we need to find the key that corresponds to ROOT's usage,
+              // NOT the route's (Settings') usage.
+              const dataForMocks =
+                options.routeAnalysis?.metadata?.scenariosDataStructure
+                  ?.dataForMocks;
+
+              // Find all keys that end with this entity name
+              const matchingKeys = dataForMocks
+                ? Object.keys(dataForMocks).filter((key) =>
+                    key.endsWith(` <- ${entityName}`),
+                  )
+                : [];
+
+              // If there are multiple keys (e.g., one for root.tsx and one for Settings),
+              // we need to find the one for ROOT, not the route being simulated.
+              // Strategy: Find which property names are used in root.tsx for this hook,
+              // then match to a key that uses one of those property names.
+              let mockKey: string | undefined;
+
+              if (matchingKeys.length > 1) {
+                // Parse root.tsx to find how this hook is used
+                // Look for patterns like: const { prop1, prop2 } = useLoaderData()
+                // or: const result = useLoaderData()
+                const hookUsageRegex = new RegExp(
+                  `(?:const|let|var)\\s+(?:\\{([^}]+)\\}|([a-zA-Z_][a-zA-Z0-9_]*))\\s*=\\s*${entityName}(?:<[^>]*>)?\\s*\\(`,
+                  'g',
+                );
+
+                const matches = [...newContent.matchAll(hookUsageRegex)];
+                const rootPropertyNames: string[] = [];
+
+                for (const match of matches) {
+                  if (match[1]) {
+                    // Destructured: { prop1, prop2, prop3: alias }
+                    const props = match[1]
+                      .split(',')
+                      .map((p) => p.trim().split(':')[0].trim())
+                      .filter(Boolean);
+                    rootPropertyNames.push(...props);
+                  } else if (match[2]) {
+                    // Simple assignment: const result = ...
+                    rootPropertyNames.push(match[2]);
+                  }
+                }
+
+                // Find a key that uses one of root's property names
+                mockKey = matchingKeys.find((key) => {
+                  const varName = key.split(' <- ')[0];
+                  return rootPropertyNames.includes(varName);
+                });
+
+                // Fallback: if no match found but there are multiple keys,
+                // exclude the route's key (which we can identify from mockedImports variable names)
+                if (!mockKey) {
+                  // The route's variable names would be in its own analysis
+                  // For simplicity, just use the first key that's different from the most common pattern
+                  mockKey = matchingKeys[0];
+                }
+              } else if (matchingKeys.length === 1) {
+                mockKey = matchingKeys[0];
+              }
+
+              // Generate simple mock code that uses the ORIGINAL function name
+              // (not a variable-qualified name like useLoaderData_loadError)
+              // This is important because root.tsx's code calls useLoaderData(),
+              // so our mock must also be named useLoaderData.
+              let mockCode: string | undefined;
+              if (mockKey) {
+                // Generate simple mock code with the original function name
+                // For useLoaderData in root.tsx, we need to provide safe defaults
+                // because the mock data is for the route being analyzed, not root.tsx.
+                // Root.tsx may access properties like .length on arrays that don't exist
+                // in the route's loader data.
+                if (entityName === 'useLoaderData') {
+                  // Provide safe defaults for common root.tsx loader properties
+                  // These are merged with the actual mock data, with mock data taking priority
+                  mockCode = `const ${entityName}ReturnValue = {
+  // Safe defaults for common root.tsx loader properties
+  availableAPIKeys: [],
+  queueJobs: [],
+  queuedJobCount: 0,
+  currentEntities: [],
+  historicalRuns: [],
+  currentRun: undefined,
+  projectSlug: null,
+  currentlyExecuting: null,
+  // Merge with actual mock data (route data takes priority)
+  ...scenarios().data()?.["${mockKey}"]
+};
+
+function ${entityName}() {
+  return ${entityName}ReturnValue;
+}`;
+                } else {
+                  mockCode = `const ${entityName}ReturnValue = scenarios().data()?.["${mockKey}"];\n\nfunction ${entityName}() {\n  return ${entityName}ReturnValue;\n}`;
+                }
+              } else {
+                // Fallback to constructMockCode for simple cases
+                mockCode = constructMockCode(entityName, dependencySchemas);
+              }
 
               if (mockCode) {
                 console.log(

package/analyzer-template/project/writeUniversalMocks.ts

@@ -28,7 +28,38 @@ export default async function writeUniversalMocks({
 }: WriteUniversalMocksArgs) {
   const { project } = projectAnalyzer;
 
-  for (const universalMock of project.metadata?.universalMocks ?? []) {
+  // Deduplicate universal mocks by (filePath, entityName) before processing.
+  // This handles cases where the same mock might appear multiple times in the array.
+  const allMocks = project.metadata?.universalMocks ?? [];
+  const seenMocks = new Set<string>();
+  const universalMocks = allMocks.filter((mock) => {
+    const key = `${mock.filePath}:${mock.entityName}`;
+    if (seenMocks.has(key)) {
+      return false;
+    }
+    seenMocks.add(key);
+    return true;
+  });
+
+  // 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]>
+  >();
+
+  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 +91,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 +128,46 @@ 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}`;
-        } else {
-          mockContent = `${universalMock.content}\n\nexport { ${universalMock.entityName} };`;
+
+        // For node_modules, merge all mocks for this filePath
+        const mocksToProcess = universalMock.nodeModule
+          ? (nodeModuleMocksByPath.get(universalMock.filePath) ?? [
+              universalMock,
+            ])
+          : [universalMock];
+
+        const contentParts: string[] = [];
+        const exportsToAdd: 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);
+
+            // Check if the content already exports this entity
+            // to avoid duplicate exports like "export const X... export { X };"
+            const content = mock.content ?? '';
+            const alreadyExports =
+              content.includes(`export const ${mock.entityName}`) ||
+              content.includes(`export function ${mock.entityName}`) ||
+              content.includes(`export class ${mock.entityName}`) ||
+              content.includes(`export { ${mock.entityName}`);
+
+            if (!alreadyExports) {
+              exportsToAdd.push(mock.entityName);
+            }
+          }
+        }
+
+        // Build the final mock content
+        mockContent = contentParts.join('\n\n');
+
+        // Only add export statement for entities that don't already export themselves
+        if (exportsToAdd.length > 0) {
+          mockContent += `\n\nexport { ${exportsToAdd.join(', ')} };`;
         }
       }
 
@@ -132,6 +209,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(

package/analyzer-template/scripts/postbuild.cjs

@@ -32,6 +32,17 @@ function updateImportStatements(directory, level = 0) {
         result = result.replace(
           /from\s+['"](\.+\/)(.*?)['"]/g,
           (match, relativePath, moduleName) => {
+            // Skip template literals with variables (e.g., '../${importPath}')
+            // These are dynamic imports that shouldn't be processed at build time
+            if (moduleName.includes('${')) {
+              return match;
+            }
+
+            // Skip if the module already has a file extension
+            if (/\.(js|ts|tsx|jsx|mjs|cjs|json)$/.test(moduleName)) {
+              return match;
+            }
+
             const fullPath = path.resolve(
               path.dirname(filePath),
               relativePath + moduleName,
@@ -78,7 +89,7 @@ function updateImportStatements(directory, level = 0) {
             return `'${relativeLevel}/packages/${importPath}/index.js'`;
           },
         );
-        result = result.replace(/.js.js/g, '.js');
+        result = result.replace(/\.js\.js/g, '.js');
         result = result.replace(/index\/index\.js/g, 'index.js');
         result = result.replace(/(index\.js\/)+/g, '');
 

package/background/src/lib/virtualized/common/execAsync.js

@@ -1,4 +1,4 @@
-import { loadBackgroundJob, updateBackgroundJobProgress, } from "../../../../../packages/supabase/index.js";
+import { loadBackgroundJob, updateBackgroundJobProgress, } from "../../../../../packages/database/index.js";
 import * as fs from 'fs';
 import { spawn } from 'child_process';
 import { loadEnv } from "../../../../../packages/utils/server.js";

package/background/src/lib/virtualized/project/LazyFileStore.js

@@ -1,4 +1,4 @@
-import { loadFiles, loadEntities, saveFiles, generateSha, } from "../../../../../packages/supabase/index.js";
+import { loadFiles, loadEntities, saveFiles, generateSha, } from "../../../../../packages/database/index.js";
 /**
  * LazyFileStore provides O(1) file lookups with on-demand content/entity loading.
  *

package/background/src/lib/virtualized/project/analyzeBaselineCommit.js

@@ -1,5 +1,5 @@
 import analyzeBranchCommit from "./analyzeBranchCommit.js";
-import { loadAnalysisBranches, upsertAnalysisBranches, updateCommitMetadata, updateProjectMetadata, } from "../../../../../packages/supabase/index.js";
+import { loadAnalysisBranches, upsertAnalysisBranches, updateCommitMetadata, updateProjectMetadata, } from "../../../../../packages/database/index.js";
 import { awsLog } from "../../../../../packages/utils/index.js";
 export default async function analyzeBaselineCommit({ project, projectAnalyzer, branchCommit, analysisIds, scenarioIds, context, steps, desiredAnalyses = [], force = false, fileStore, }) {
     awsLog('CodeYam: Analyze - branchCommit (baseline) path', {

package/background/src/lib/virtualized/project/analyzeBranchCommit.js

@@ -1,6 +1,6 @@
 import createEntitiesAndSortFiles from "./createEntitiesAndSortFiles.js";
 import { analyzeEntities, } from "../../../../../packages/analyze/index.js";
-import { loadAnalyses, loadFile, updateCommitMetadata, updateProjectMetadata, } from "../../../../../packages/supabase/index.js";
+import { loadAnalyses, loadFile, updateCommitMetadata, updateProjectMetadata, } from "../../../../../packages/database/index.js";
 import checkApprovedPath from "./checkApprovedPath.js";
 export default async function analyzeBranchCommit({ project, projectAnalyzer, branchCommit, analysisIds, context, steps, fileStore, }) {
     console.log('CodeYam: Starting Branch Commit Analysis', branchCommit.sha, {

package/background/src/lib/virtualized/project/analyzeFileEntities.js

@@ -1,6 +1,6 @@
 import { analyzeEntities, findOrCreateEntity, gatherEntityMap, setImportedExports, } from "../../../../../packages/analyze/index.js";
 import checkApprovedPath from "./checkApprovedPath.js";
-import { loadEntity, updateCommitMetadata, upsertCommits, } from "../../../../../packages/supabase/index.js";
+import { loadEntity, updateCommitMetadata, upsertCommits, } from "../../../../../packages/database/index.js";
 import { analyzeFileMocks } from "./mocks/analyzeFileMock.js";
 export default async function analyzeFileEntities({ project, projectAnalyzer, commit, branchId, entityShas, scenarioIds, analyzeMockName, steps, context, fileStore, }) {
     var _a;

package/background/src/lib/virtualized/project/analyzeRegularCommit.js

@@ -1,6 +1,6 @@
 import analyzeFileEntities from "./analyzeFileEntities.js";
 import analyzeAndGatherIndirectEntities from "./analyzeAndGatherIndirectEntities.js";
-import { loadAnalyses, loadAnalysisBranches, updateBackgroundJobProgress, updateCommitMetadata, upsertAnalysesWithScenarios, upsertAnalysisBranches, } from "../../../../../packages/supabase/index.js";
+import { loadAnalyses, loadAnalysisBranches, updateBackgroundJobProgress, updateCommitMetadata, upsertAnalysesWithScenarios, upsertAnalysisBranches, } from "../../../../../packages/database/index.js";
 import { awsLog, awsLogDebugLevel } from "../../../../../packages/utils/index.js";
 async function entitiesReadyToBeCaptured(entities, entityShas, context, analysisIds) {
     const readyToBeCaptured = [];

package/background/src/lib/virtualized/project/captureLibraryFunctionDirect.js

@@ -1,5 +1,5 @@
 import { awsLog } from "../../../../../packages/utils/index.js";
-import { updateFreshAnalysisStatus, updateFreshAnalysisStatusWithScenarios, loadAnalysis, } from "../../../../../packages/supabase/index.js";
+import { updateFreshAnalysisStatus, updateFreshAnalysisStatusWithScenarios, loadAnalysis, } from "../../../../../packages/database/index.js";
 import executeLibraryFunctionDirect from "./executeLibraryFunctionDirect.js";
 /**
  * Capture a library function by executing it directly (no browser, no screenshots).