@codeyam/codeyam-cli 0.1.0-staging.8aea589 → 0.1.0-staging.bbe4da9

package/analyzer-template/packages/analyze/src/lib/files/analyze/analyzeEntities/prepareDataStructures.ts

@@ -12,7 +12,7 @@ import {
   getReturnValue,
   getSourceEquivalencies,
   getUsageEquivalencies,
-  getConditionalUsagesFromCode,
+  getConditionalUsages,
   detectWrapperRequirements,
 } from '~codeyam/ai';
 import type { AnalysisOptions } from '../analyzeEntities';
@@ -94,11 +94,6 @@ export default async function prepareEntityDataStructures(
           }
         }
 
-        // Extract conditional usages from the entity code for key attribute detection
-        const conditionalUsages = entity.code
-          ? getConditionalUsagesFromCode(entity.code)
-          : {};
-
         entity.metadata.isolatedDataStructure = {
           signatureSchema: deduplicateFunctionSchemas(
             isolatedDataStructure.signatureSchema,
@@ -110,10 +105,8 @@ export default async function prepareEntityDataStructures(
             isolatedDataStructure.equivalentSignatureVariables,
           dependencySchemas: clonedDependencySchemas,
           environmentVariables: isolatedDataStructure.environmentVariables,
-          conditionalUsages:
-            Object.keys(conditionalUsages).length > 0
-              ? conditionalUsages
-              : undefined,
+          // Use enriched conditional usages with source tracing from analysis
+          conditionalUsages: isolatedDataStructure.conditionalUsages,
         };
 
         // Detect wrapper requirements (Context providers, etc.)
@@ -290,6 +283,9 @@ async function getEntityDataStructureAndFunctionCalls({
   const clonedRawSignature = { ...rawSignature };
   const clonedRawReturnValue = { ...rawReturnValue };
 
+  // Get enriched conditional usages with source tracing
+  const conditionalUsages = getConditionalUsages(dataStructure);
+
   const isolatedDataStructure = {
     signatureSchema: deduplicateFunctionSchemas(clonedRawSignature),
     returnValueSchema: deduplicateFunctionSchemas(clonedRawReturnValue),
@@ -297,6 +293,8 @@ async function getEntityDataStructureAndFunctionCalls({
       getEquivalentSignatureVariables(dataStructure),
     dependencySchemas,
     environmentVariables: dataStructure.environmentVariables,
+    conditionalUsages:
+      Object.keys(conditionalUsages).length > 0 ? conditionalUsages : undefined,
   };
 
   const functionCalls: Record<string, string[]> = {};

package/analyzer-template/packages/analyze/src/lib/files/analyze/analyzeEntities.ts

@@ -18,7 +18,7 @@ import {
   upsertEntities,
 } from '~codeyam/supabase';
 import { getCandidatesReadyForCapture as getAnalysesReadyForCapture } from './dependencyResolver';
-import { awsLog, awsLogDebugLevel } from '~codeyam/utils';
+import { awsLog, awsLogDebugLevel, Semaphore } from '~codeyam/utils';
 
 const MAX_CONCURRENT_ANALYSES = 100; // fairly arbitrary, but more isn't necessarily better
 
@@ -133,6 +133,10 @@ export default async function analyzeEntities({
   const markedReady = new Set<string>(); // Analyses we've attempted to mark ready
   const analyses: Analysis[] = [];
 
+  // Semaphore to serialize CPU-intensive Structure phase while allowing
+  // I/O-bound KeyAttributes LLM calls to run in parallel
+  const structureSemaphore = new Semaphore(1);
+
   const analysesAlreadyCompletedAtStart =
     commit?.metadata?.currentRun?.analysesCompleted ?? 0;
 
@@ -442,6 +446,7 @@ export default async function analyzeEntities({
           analyzeAsDependency: !allRootEntities.some(
             (e) => e.filePath === entity.filePath && e.name === entity.name,
           ),
+          structureSemaphore,
           ...options,
           force,
         }),

package/analyzer-template/packages/analyze/src/lib/files/analyze/gatherEntityMap.ts

@@ -73,14 +73,16 @@ export default async function gatherEntityMap({
     );
 
     if (!importedFile) {
+      // Skip dependencies when the file is not found in project.files.
+      // This commonly happens when a universal mock intercepts the import:
+      // 1. TypeScript resolves @formbricks/types/errors to the mock file
+      // 2. The original packages/types/errors.ts is never imported
+      // 3. So it's not in getSourceFiles() and thus not in project.files
+      // 4. Since the mock handles the import, we don't need to analyze the original
       console.log(
-        `CodeYam Error: File not found while gathering entity map: ${importedExportFilePath}`,
-        entity.filePath,
-        entity.name,
-      );
-      throw new Error(
-        `File not found while gathering entity map: ${importedExportFilePath}`,
+        `CodeYam Warning: Skipping dependency - file not in project.files (likely mocked): ${importedExportFilePath}`,
       );
+      continue;
     }
 
     let importedEntity = context.getEntity(

package/analyzer-template/packages/analyze/src/lib/files/analyze/trackEntityCircularDependencies.ts

@@ -99,19 +99,11 @@ function traverseEntity(
     );
 
     if (!dependentEntity) {
-      console.log(
-        'CodeYam Error: trackEntityCircularDependencies: Dependent entity not found',
-        {
-          entityFilePath: entity.filePath,
-          entityName: entity.name,
-          dependencyFilePath,
-          dependencyName,
-          fileEntities: context.getEntityNamesForFile(dependencyFilePath),
-        },
-      );
-      throw new Error(
-        'trackEntityCircularDependencies: Dependent entity not found',
-      );
+      // Skip dependencies when the entity is not found in context.
+      // This commonly happens when a universal mock intercepts the import:
+      // - gatherEntityMap skips adding the entity because the file isn't in project.files
+      // - The mock handles the import at runtime, so we don't need to track it
+      continue;
     }
 
     // Recursively traverse (will skip if already visited)

package/analyzer-template/packages/analyze/src/lib/files/analyzeChange.ts

@@ -16,7 +16,12 @@ import { AI } from '~codeyam/ai';
 import extractDiffLines from './extractDiffLines';
 import analyzeCodeChange from './analyzeCodeChange';
 import relevantDiffPart from './relevantDiffPart';
-import { awsLog, awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';
+import {
+  awsLog,
+  awsLogDebugLevel,
+  pushAnalysisError,
+  Semaphore,
+} from '~codeyam/utils';
 
 export interface AnalyzeChangeArgs {
   previousAnalysis: Analysis;
@@ -29,6 +34,8 @@ export interface AnalyzeChangeArgs {
   steps?: string[];
   updateProgress?: (detail: string) => void;
   model: AI.Model;
+  /** Semaphore to serialize CPU-intensive Structure phase */
+  structureSemaphore?: Semaphore;
 }
 
 export default async function analyzeChange({
@@ -42,6 +49,7 @@ export default async function analyzeChange({
   steps,
   updateProgress,
   model,
+  structureSemaphore,
 }: AnalyzeChangeArgs) {
   analysis.entity = entity;
   awsLog('CodeYam: Analyzing change entity', {
@@ -79,24 +87,35 @@ export default async function analyzeChange({
       });
     }
 
+    // Structure phase: CPU-intensive, serialize via semaphore if provided
     if (!steps || steps.includes(Step.Structure)) {
-      awsLogDebugLevel(
-        1,
-        `Merging dependent data structures for ${entity.name}...`,
-      );
+      if (structureSemaphore) {
+        await structureSemaphore.acquire();
+      }
+      try {
+        awsLogDebugLevel(
+          1,
+          `Merging dependent data structures for ${entity.name}...`,
+        );
 
-      const { step: dataStructureStep } = await recordStep(
-        'generateDataStructure',
-        () =>
-          generateDataStructure({
-            entity,
-            dependentAnalyses,
-            analysis,
-          }),
-      );
-      analysis.status.steps.push(dataStructureStep);
+        const { step: dataStructureStep } = await recordStep(
+          'generateDataStructure',
+          () =>
+            generateDataStructure({
+              entity,
+              dependentAnalyses,
+              analysis,
+            }),
+        );
+        analysis.status.steps.push(dataStructureStep);
+      } finally {
+        if (structureSemaphore) {
+          structureSemaphore.release();
+        }
+      }
     }
 
+    // KeyAttributes phase: I/O-bound LLM call, can run in parallel with other entities' Structure
     if (!steps || steps.includes(Step.KeyAttributes)) {
       awsLogDebugLevel(1, `Determining key attributes for ${entity.name}...`);
 

package/analyzer-template/packages/analyze/src/lib/files/analyzeEntity.ts

@@ -31,7 +31,12 @@ import relevantDiffPart from './relevantDiffPart';
 import { Step } from './enums/steps';
 import { ImmutableAnalysisContext } from '../analysisContext';
 import generateAnalyzedTreeSha from './analyze/generateAnalyzedTreeSha';
-import { awsLog, awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';
+import {
+  awsLog,
+  awsLogDebugLevel,
+  pushAnalysisError,
+  Semaphore,
+} from '~codeyam/utils';
 
 export interface AnalyzeEntityArgs {
   project: Project;
@@ -50,6 +55,8 @@ export interface AnalyzeEntityArgs {
   forceAll?: boolean;
   updateProgress?: (detail: string) => void;
   modelString?: string;
+  /** Semaphore to serialize CPU-intensive Structure phase */
+  structureSemaphore?: Semaphore;
 }
 
 /**
@@ -77,6 +84,7 @@ export default async function analyzeEntity({
   forceAll,
   updateProgress,
   modelString,
+  structureSemaphore,
 }: AnalyzeEntityArgs): Promise<{
   analysis: Analysis;
   dependentAnalyses?: ReadonlyAnalysisMap;
@@ -476,6 +484,7 @@ export default async function analyzeEntity({
             steps,
             updateProgress,
             model,
+            structureSemaphore,
           })
         : analyzeInitial({
             analysis,
@@ -485,6 +494,7 @@ export default async function analyzeEntity({
             steps,
             updateProgress,
             model,
+            structureSemaphore,
           }),
     ]);
 
@@ -498,8 +508,12 @@ export default async function analyzeEntity({
     analysis = analysisResult.analysis;
 
     analysis.completedAt = new Date().toISOString();
-    // Don't set analyzedTreeSha when ONLY_DATA_STRUCTURE=true, so full analysis can re-analyze later
-    if (process.env.ONLY_DATA_STRUCTURE !== 'true') {
+    // Don't set analyzedTreeSha when:
+    // 1. ONLY_DATA_STRUCTURE=true - so full analysis can re-analyze later
+    // 2. analyzeAsDependency=true - dependency analyses only generate Structure+KeyAttributes,
+    //    not scenarios. Leaving analyzedTreeSha unset allows partial analysis detection to work
+    //    when the entity is later analyzed directly.
+    if (process.env.ONLY_DATA_STRUCTURE !== 'true' && !analyzeAsDependency) {
       analysis.analyzedTreeSha = generateAnalyzedTreeSha(analysis);
     }
   } catch (error) {

package/analyzer-template/packages/analyze/src/lib/files/analyzeInitial.ts

@@ -12,7 +12,12 @@ import {
   type ReadonlyAnalysisMap,
 } from '~codeyam/types';
 import { upsertAnalysesWithScenarios } from '~codeyam/supabase';
-import { awsLog, awsLogDebugLevel, pushAnalysisError } from '~codeyam/utils';
+import {
+  awsLog,
+  awsLogDebugLevel,
+  pushAnalysisError,
+  Semaphore,
+} from '~codeyam/utils';
 import generateKeyAttributes from './scenarios/generateKeyAttributes';
 
 export interface AnalyzeInitialArgs {
@@ -23,6 +28,8 @@ export interface AnalyzeInitialArgs {
   steps?: string[];
   updateProgress?: (detail: string) => void;
   model: AI.Model;
+  /** Semaphore to serialize CPU-intensive Structure phase */
+  structureSemaphore?: Semaphore;
 }
 
 export default async function analyzeInitial({
@@ -33,6 +40,7 @@ export default async function analyzeInitial({
   steps,
   updateProgress,
   model,
+  structureSemaphore,
 }: AnalyzeInitialArgs) {
   analysis.entity = entity;
   awsLog('CodeYam: Analyzing initial entity', {
@@ -47,22 +55,32 @@ export default async function analyzeInitial({
   });
 
   try {
+    // Structure phase: CPU-intensive, serialize via semaphore if provided
     if (!steps || steps.includes(Step.Structure)) {
-      awsLogDebugLevel(
-        1,
-        `Merging dependent data structures for ${entity.name}...`,
-      );
-
-      const { step: dataStructureStep } = await recordStep(
-        'generateDataStructure',
-        () =>
-          generateDataStructure({
-            entity,
-            dependentAnalyses,
-            analysis,
-          }),
-      );
-      analysis.status.steps.push(dataStructureStep);
+      if (structureSemaphore) {
+        await structureSemaphore.acquire();
+      }
+      try {
+        awsLogDebugLevel(
+          1,
+          `Merging dependent data structures for ${entity.name}...`,
+        );
+
+        const { step: dataStructureStep } = await recordStep(
+          'generateDataStructure',
+          () =>
+            generateDataStructure({
+              entity,
+              dependentAnalyses,
+              analysis,
+            }),
+        );
+        analysis.status.steps.push(dataStructureStep);
+      } finally {
+        if (structureSemaphore) {
+          structureSemaphore.release();
+        }
+      }
     }
 
     // Short-circuit for test mocking: only generate data structure, skip key attributes and scenarios
@@ -73,6 +91,7 @@ export default async function analyzeInitial({
       return { analysis };
     }
 
+    // KeyAttributes phase: I/O-bound LLM call, can run in parallel with other entities' Structure
     if (!steps || steps.includes(Step.KeyAttributes)) {
       awsLogDebugLevel(1, `Determining key attributes for ${entity.name}...`);
 

package/analyzer-template/packages/analyze/src/lib/files/analyzeRemixRoute.ts

@@ -48,29 +48,20 @@ export default function analyzeRemixRoute(
           const implicitRouteFileAnalyzer =
             projectAnalyzer.getFileAnalyzer(implicitRoute);
           const exports = implicitRouteFileAnalyzer.getAllExports();
-          const defaultExport = Object.values(exports).find(
-            (e) => e.isDefaultExport,
-          );
-
-          // Ensure entities array exists before trying to use it
-          if (!implicitRoute.entities) {
-            console.log(
-              `CodeYam Warning: implicitRoute.entities not populated for ${implicitRoute.path}, skipping implicit dependency`,
-            );
-            return;
-          }
 
-          const defaultEntity = implicitRoute.entities.find((e) =>
-            implicitRouteFileAnalyzer.isDefaultExport(e.name),
+          // Find the default export entry - the key is the entity name
+          const defaultExportEntry = Object.entries(exports).find(
+            ([, e]) => e.isDefaultExport,
           );
 
-          if (!defaultExport || !defaultEntity) return;
+          if (!defaultExportEntry) return;
 
+          const [entityName, defaultExport] = defaultExportEntry;
           const code = defaultExport.code;
           return {
             code: code,
             // sha: generateSha(implicitRoute.path, 'default', code),
-            name: defaultEntity.name,
+            name: entityName,
             filePath: implicitRoute.path,
             projectId: entity.projectId,
             entityType: 'visual' as EntityType,
@@ -108,26 +99,23 @@ export default function analyzeRemixRoute(
     try {
       const rootFileAnalyzer = projectAnalyzer.getFileAnalyzer(rootFile);
       const exports = rootFileAnalyzer.getAllExports();
-      const defaultExport = Object.values(exports).find(
-        (e) => e.isDefaultExport,
-      );
 
-      if (defaultExport && rootFile.entities) {
-        const defaultEntity = rootFile.entities.find((e) =>
-          rootFileAnalyzer.isDefaultExport(e.name),
-        );
+      // Find the default export entry - the key is the entity name
+      const defaultExportEntry = Object.entries(exports).find(
+        ([, e]) => e.isDefaultExport,
+      );
 
-        if (defaultEntity) {
-          rootDependencies.push({
-            code: defaultExport.code,
-            name: defaultEntity.name,
-            filePath: rootFile.path,
-            entityType: 'visual' as EntityType,
-            isDefault: true,
-            isImplicitDependency: true,
-            isMocked: false,
-          });
-        }
+      if (defaultExportEntry) {
+        const [entityName, defaultExport] = defaultExportEntry;
+        rootDependencies.push({
+          code: defaultExport.code,
+          name: entityName,
+          filePath: rootFile.path,
+          entityType: 'visual' as EntityType,
+          isDefault: true,
+          isImplicitDependency: true,
+          isMocked: false,
+        });
       }
     } catch (e) {
       console.log(

package/analyzer-template/packages/analyze/src/lib/files/getImportedExports.ts

@@ -63,18 +63,83 @@ export default function getImportedExports(
           imports[filePath].resolvedPath ??
           filePath;
 
-        const importedExportFile = project.files.find(
+        let importedExportFile = project.files.find(
           (f) => f.path === searchPath,
         );
 
+        // Track the actual path we found (may differ from searchPath after dist->src mapping)
+        let actualResolvedPath = imports[filePath].resolvedPath;
+
+        // Workspace packages often resolve to dist/ paths (from package.json "types" or "main"),
+        // but our project.files contains source files in src/. Try mapping dist -> src.
+        if (!importedExportFile && searchPath.includes('/dist/')) {
+          const srcPath = searchPath.replace('/dist/', '/src/');
+          // Try exact match first
+          importedExportFile = project.files.find((f) => f.path === srcPath);
+          if (importedExportFile) {
+            actualResolvedPath = srcPath;
+            console.log(
+              `CodeYam: Mapped dist->src path: ${searchPath} -> ${srcPath}`,
+            );
+          }
+
+          // If not found, the dist file might be index.d.ts but src might be index.ts
+          // or the export might be re-exported from another file
+          if (!importedExportFile) {
+            // Try removing .d.ts extension and finding any matching src file
+            const basePath = srcPath
+              .replace(/\.d\.ts$/, '')
+              .replace(/\.js$/, '');
+            importedExportFile = project.files.find(
+              (f) =>
+                f.path === basePath + '.ts' ||
+                f.path === basePath + '.tsx' ||
+                (f.path.startsWith(basePath.replace('/index', '/')) &&
+                  !f.path.includes('/dist/')),
+            );
+            if (importedExportFile) {
+              actualResolvedPath = importedExportFile.path;
+              console.log(
+                `CodeYam: Mapped dist->src path (extension): ${searchPath} -> ${importedExportFile.path}`,
+              );
+            }
+          }
+        }
+
         if (!importedExportFile) {
-          console.log(
-            'CodeYam Error: File not found for imported export',
-            file.path,
-            filePath,
-            importedExportInfo,
-            imports[filePath],
-          );
+          // Check if this is a workspace package import (scoped npm package like @scope/package)
+          // but NOT a path alias like @/path or @components/...
+          // Scoped packages have format: @scope/package where scope is alphanumeric with hyphens
+          const isScopedPackage =
+            filePath.startsWith('@') &&
+            !filePath.startsWith('@/') && // Not a path alias like @/modules/...
+            !filePath.startsWith('@types/') &&
+            /^@[a-z0-9-]+\/[a-z0-9-]/.test(filePath); // Matches @scope/package pattern
+          if (isScopedPackage) {
+            // Treat unresolved scoped packages like node modules so they get mocked
+            // instead of being silently ignored
+            const name =
+              importedExportInfo.importName ?? importedExportInfo.importAlias;
+            console.log(
+              `CodeYam: Treating unresolved scoped package as node module: ${filePath} -> ${name}`,
+            );
+            return {
+              filePath,
+              name,
+              isDefault: importedExportInfo.isImportDefault,
+              isNodeModule: true, // Mark as node module so it gets mocked
+              entityType: 'library' as const, // Default to library since we can't determine the actual type
+              // No code since we couldn't resolve the source file
+            };
+          } else {
+            console.log(
+              'CodeYam Error: File not found for imported export',
+              file.path,
+              filePath,
+              importedExportInfo,
+              imports[filePath],
+            );
+          }
           return;
         }
 
@@ -96,10 +161,10 @@ export default function getImportedExports(
 
           return {
             fileId: importedExportFile.id,
-            filePath: imports[filePath].resolvedPath,
+            filePath: actualResolvedPath,
             isDefault: importedExportInfo.isImportDefault,
             resolvedFilePath:
-              resolvedFilePath === imports[filePath].resolvedPath
+              resolvedFilePath === actualResolvedPath
                 ? undefined
                 : resolvedFilePath,
             resolvedName: resolvedName === name ? undefined : resolvedName,

package/analyzer-template/packages/analyze/src/lib/files/scenarios/gatherDataForMocks.ts

@@ -132,6 +132,32 @@ export default function gatherDataForMocks(
         preprocessedSchema = mergedSchema;
       }
 
+      // Merge generic call (e.g., "foo()") data into specific argument calls (e.g., "foo(arg1, arg2)")
+      // This handles the case where the generic schema has richer nested data than the specific call
+      if (callName.includes('(') && !callName.includes('<')) {
+        // Extract the base function name and create generic call
+        const baseFunctionName = callName.split('(')[0];
+        const genericCall = baseFunctionName + '()';
+
+        // Only merge if the callName has arguments (not just empty parens)
+        if (callName !== genericCall) {
+          const mergedSchema: Record<string, string> = {
+            ...preprocessedSchema,
+          };
+          for (const path of Object.keys(preprocessedSchema)) {
+            if (path.startsWith(genericCall)) {
+              // Create corresponding specific path
+              const specificPath = callName + path.slice(genericCall.length);
+              // Only add if the specific path doesn't already exist
+              if (!mergedSchema[specificPath]) {
+                mergedSchema[specificPath] = preprocessedSchema[path];
+              }
+            }
+          }
+          preprocessedSchema = mergedSchema;
+        }
+      }
+
       const relevantMergedDependencySchema = Object.keys(
         preprocessedSchema,
       ).reduce(

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateDataStructure.ts

@@ -54,8 +54,14 @@ export default function generateDataStructure({
     const nonMockedDependentAnalyses: ReadonlyAnalysisMap =
       allImportedExports.reduce((acc, importedExport) => {
         if (importedExport.isMocked) return acc;
+        // Use resolvedFilePath when available (for re-exports from index files)
+        // to find the actual analysis of the component
+        const lookupPath =
+          ('resolvedFilePath' in importedExport &&
+            importedExport.resolvedFilePath) ||
+          importedExport.filePath;
         const relevantDependencyAnalysis =
-          dependentAnalyses[importedExport.filePath]?.[importedExport.name];
+          dependentAnalyses[lookupPath]?.[importedExport.name];
 
         if (!relevantDependencyAnalysis) {
           // console.info(

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateKeyAttributes.ts

@@ -8,6 +8,7 @@ import measureAndReportExecutionTime from '../../utils/measureAndReportExecution
 import { AI, generateEntityKeyAttributes } from '~codeyam/ai';
 import { awsLog } from '~codeyam/utils';
 import { gatherRelevantDependentKeyAttributes } from '~codeyam/ai';
+import { gatherDataForMocks } from './generateScenarioData';
 
 export interface GenerateEntityKeyAttributesArgs {
   entity: Entity;
@@ -28,7 +29,14 @@ export default async function generateKeyAttributes({
 }: GenerateEntityKeyAttributesArgs): Promise<void> {
   if (!['visual', 'library'].includes(entity.entityType)) return;
 
-  const structure = { ...analysis.metadata.scenariosDataStructure };
+  // Merge direct dataForMocks with recursively gathered data from dependencies
+  const structure = {
+    arguments: analysis.metadata.scenariosDataStructure?.arguments ?? [],
+    dataForMocks: {
+      ...(analysis.metadata.scenariosDataStructure?.dataForMocks ?? {}),
+      ...gatherDataForMocks(analysis, dependentAnalyses),
+    },
+  };
 
   awsLog(`🔮 Generating ${error ? 'error ' : ''}scenarios for`, {
     filePath: entity.filePath,

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateScenarioData.ts

@@ -104,8 +104,13 @@ export function gatherDataForMocks(
       // regardless of whether we found a relevantKey above.
       // This ensures transitive dependencies are included.
       // For example: Activity -> CurrentActivityTab -> useLastLogLine
+      // Use resolvedFilePath when available (for re-exports from index files)
+      const lookupPath =
+        ('resolvedFilePath' in importedExport &&
+          importedExport.resolvedFilePath) ||
+        importedExport.filePath;
       const dependentAnalysis =
-        dependentAnalyses?.[importedExport.filePath]?.[importedExport.name];
+        dependentAnalyses?.[lookupPath]?.[importedExport.name];
 
       if (dependentAnalysis && !analysesGathered.has(dependentAnalysis.id)) {
         analysesGathered.add(dependentAnalysis.id);

package/analyzer-template/packages/analyze/src/lib/files/scenarios/generateScenarios.ts

@@ -7,6 +7,7 @@ import {
 import measureAndReportExecutionTime from '../../utils/measureAndReportExecutionTime';
 import { AI, generateEntityScenarios } from '~codeyam/ai';
 import { awsLog } from '~codeyam/utils';
+import { gatherDataForMocks } from './generateScenarioData';
 
 export interface GenerateScenariosArgs {
   entity: Entity;
@@ -27,7 +28,14 @@ export default async function generateScenarios({
 }: GenerateScenariosArgs): Promise<void> {
   if (!['visual', 'library'].includes(entity.entityType)) return;
 
-  const structure = { ...analysis.metadata.scenariosDataStructure };
+  // Merge direct dataForMocks with recursively gathered data from dependencies
+  const structure = {
+    arguments: analysis.metadata.scenariosDataStructure?.arguments ?? [],
+    dataForMocks: {
+      ...(analysis.metadata.scenariosDataStructure?.dataForMocks ?? {}),
+      ...gatherDataForMocks(analysis, dependentAnalyses),
+    },
+  };
 
   awsLog(`🔮 Generating ${error ? 'error ' : ''}scenarios for`, {
     filePath: entity.filePath,