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

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

@@ -31,12 +31,6 @@ export default function generateDataStructure({
     awsLog('CodeYam: Generating data structure for', {
       filePath: entity.filePath,
       entityName: entity.name,
-      // dependentAnalyses: Object.keys(dependentAnalyses).flatMap((path) =>
-      //   Object.keys(dependentAnalyses[path]).flatMap((entityName) => ({
-      //     path,
-      //     entityName,
-      //   })),
-      // ),
     });
 
     const allImportedExports = [
@@ -51,11 +45,118 @@ export default function generateDataStructure({
           ),
       ),
     ];
+
+    // For implicit dependencies (like root.tsx layouts), include their mocked nodeModuleImports
+    // This ensures layout file dependencies (like useLoaderData in root.tsx) are included in dataForMocks
+    // when simulating routes that are wrapped by those layout files
+    for (const importedExport of entity.metadata.importedExports ?? []) {
+      if (
+        !('isImplicitDependency' in importedExport) ||
+        !importedExport.isImplicitDependency
+      ) {
+        continue;
+      }
+
+      // Look up the implicit dependency's analysis
+      const implicitDepAnalysis =
+        dependentAnalyses[importedExport.filePath]?.[importedExport.name];
+
+      // Access nodeModuleImports from the entity attached to the analysis
+      const nodeModuleImports =
+        implicitDepAnalysis?.entity?.metadata?.nodeModuleImports;
+      if (!nodeModuleImports) {
+        continue;
+      }
+
+      // Add the implicit dependency's mocked nodeModuleImports to allImportedExports
+      for (const moduleName of Object.keys(nodeModuleImports)) {
+        const moduleImports = nodeModuleImports[moduleName] || [];
+        for (const imported of moduleImports) {
+          if (!imported.isMocked) continue;
+
+          // Only add if not already present (avoid duplicates)
+          const alreadyExists = allImportedExports.some(
+            (existing) =>
+              existing.filePath === moduleName &&
+              existing.name === imported.name,
+          );
+
+          if (!alreadyExists) {
+            allImportedExports.push({
+              filePath: moduleName,
+              name: imported.name,
+              isDefault: imported.isDefault,
+              isMocked: imported.isMocked,
+              calls: imported.calls ? [...imported.calls] : undefined,
+              callVariableNames: imported.callVariableNames
+                ? [...imported.callVariableNames]
+                : undefined,
+            });
+          }
+        }
+      }
+    }
+
     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];
+
+        // DEBUG: Track buildBranchFileMap and fileComparisons
+        if (
+          importedExport.name === 'buildBranchFileMap' ||
+          entity.name === 'GitView'
+        ) {
+          console.log('🔍 DEBUG generateDataStructure:', {
+            entityName: entity.name,
+            importedExportName: importedExport.name,
+            lookupPath,
+            hasAnalysis: !!relevantDependencyAnalysis,
+            signatureSchema:
+              relevantDependencyAnalysis?.metadata?.mergedDataStructure
+                ?.signatureSchema,
+            dependencySchemas: relevantDependencyAnalysis?.metadata
+              ?.mergedDataStructure?.dependencySchemas
+              ? Object.keys(
+                  relevantDependencyAnalysis.metadata.mergedDataStructure
+                    .dependencySchemas,
+                )
+              : null,
+          });
+          if (
+            relevantDependencyAnalysis?.metadata?.mergedDataStructure
+              ?.signatureSchema
+          ) {
+            const sig =
+              relevantDependencyAnalysis.metadata.mergedDataStructure
+                .signatureSchema;
+            console.log(
+              '🔍 DEBUG buildBranchFileMap signature keys:',
+              Object.keys(sig),
+            );
+            // Look for fileComparisons in the signature
+            for (const key of Object.keys(sig)) {
+              if (
+                key.includes('fileComparisons') ||
+                key.includes('entityDiff')
+              ) {
+                console.log(
+                  '🔍 DEBUG Found relevant key:',
+                  key,
+                  '=',
+                  JSON.stringify(sig[key], null, 2),
+                );
+              }
+            }
+          }
+        }
 
         if (!relevantDependencyAnalysis) {
           // console.info(
@@ -123,6 +224,7 @@ export default function generateDataStructure({
     // );
 
     const { isolatedDataStructure } = entity.metadata;
+
     const mergedDataStructure = mergeInDependentDataStructure({
       importedExports: allImportedExports,
       dependentAnalyses: nonMockedDependentAnalyses,
@@ -137,6 +239,39 @@ export default function generateDataStructure({
       dependencySchemas: isolatedDataStructure?.dependencySchemas || {},
     });
 
+    // DEBUG: Check merged result for GitView
+    if (entity.name === 'GitView') {
+      console.log(
+        '🔍 DEBUG GitView mergedDataStructure dependency schemas:',
+        Object.keys(mergedDataStructure.dependencySchemas || {}),
+      );
+      for (const filePath of Object.keys(
+        mergedDataStructure.dependencySchemas || {},
+      )) {
+        for (const depName of Object.keys(
+          mergedDataStructure.dependencySchemas[filePath] || {},
+        )) {
+          const depSchema =
+            mergedDataStructure.dependencySchemas[filePath][depName];
+          console.log(
+            `🔍 DEBUG Merged dep ${filePath}/${depName} signature keys:`,
+            Object.keys(depSchema.signatureSchema || {}),
+          );
+          // Look for fileComparisons
+          for (const key of Object.keys(depSchema.signatureSchema || {})) {
+            if (key.includes('fileComparisons') || key.includes('entityDiff')) {
+              console.log(
+                '🔍 DEBUG MERGED Found relevant key:',
+                key,
+                '=',
+                JSON.stringify(depSchema.signatureSchema[key], null, 2),
+              );
+            }
+          }
+        }
+      }
+    }
+
     mergedDataStructure.environmentVariables =
       isolatedDataStructure.environmentVariables || [];
 
@@ -196,6 +331,28 @@ export default function generateDataStructure({
       mergedDataStructure.dependencySchemas,
     );
 
+    // DEBUG: Check dataForMocks for GitView
+    if (entity.name === 'GitView') {
+      console.log(
+        '🔍 DEBUG GitView dataForMocks keys:',
+        Object.keys(dataForMocks),
+      );
+      for (const key of Object.keys(dataForMocks)) {
+        if (
+          key.includes('buildBranchFileMap') ||
+          key.includes('fileComparisons') ||
+          key.includes('entityDiff')
+        ) {
+          console.log(
+            '🔍 DEBUG dataForMocks relevant key:',
+            key,
+            '=',
+            JSON.stringify(dataForMocks[key], null, 2),
+          );
+        }
+      }
+    }
+
     // console.info(
     //   'CODEYAM DEBUG: dataForMocks',
     //   JSON.stringify(
@@ -209,6 +366,24 @@ export default function generateDataStructure({
     //   ),
     // );
 
+    // Log union types in signatureSchema before processing
+    const unionTypeEntries = Object.entries(
+      mergedDataStructure.signatureSchema,
+    ).filter(
+      ([_, value]) =>
+        typeof value === 'string' &&
+        value.includes("'") &&
+        value.includes(' | '),
+    );
+    if (unionTypeEntries.length > 0) {
+      console.log(
+        `[UNION-TYPE] generateDataStructure for ${entity.name}: Found union types in signatureSchema:`,
+      );
+      unionTypeEntries.forEach(([key, value]) => {
+        console.log(`[UNION-TYPE]   "${key}": ${value}`);
+      });
+    }
+
     const finalizedArgumentsSchema = fillInDirectSchemaGapsAndUnknowns({
       schema: { ...mergedDataStructure.signatureSchema },
     });

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,
@@ -66,6 +74,7 @@ export default async function generateKeyAttributes({
       () =>
         generateEntityKeyAttributes({
           entity,
+          mergedDataStructure: analysis.metadata.mergedDataStructure,
           model,
         }),
       `Generating entity key attributes`,
@@ -74,6 +83,7 @@ export default async function generateKeyAttributes({
 
     const relevantDependentKeyAttributes = gatherRelevantDependentKeyAttributes(
       entity,
+      analysis.metadata.mergedDataStructure,
       dependentAnalyses,
     );
 
@@ -84,6 +94,10 @@ export default async function generateKeyAttributes({
         // Spread to convert readonly arrays to mutable arrays (with fallback for undefined)
         validValueOptions: [...(ka.validValueOptions ?? [])],
         errorValueOptions: [...(ka.errorValueOptions ?? [])],
+        // Convert readonly dependencies array to mutable if present
+        ...(ka.dependencies && {
+          dependencies: ka.dependencies.map((dep) => ({ ...dep })),
+        }),
       })),
     ].filter(
       (ka, index, self) =>

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

@@ -61,20 +61,24 @@ export function gatherDataForMocks(
     for (const importedExport of allImportedExports) {
       const localDataForMocks =
         activeAnalysis.metadata?.scenariosDataStructure?.dataForMocks ?? {};
-      const relevantKey = Object.keys(localDataForMocks).find((key) =>
-        key.startsWith(importedExport.name),
+      // Find relevant keys - handle both old format (starts with name)
+      // and new variable-qualified format ("varName <- functionName")
+      const relevantKeys = Object.keys(localDataForMocks).filter(
+        (key) =>
+          key.startsWith(importedExport.name) ||
+          key.endsWith(` <- ${importedExport.name}`),
       );
 
       // console.info('CODEYAM DEBUG: Processing import', {
       //   importedExportName: importedExport.name,
       //   importedExportFilePath: importedExport.filePath,
-      //   relevantKey,
+      //   relevantKeys,
       //   hasLocalDataForMocks: Object.keys(localDataForMocks).length > 0,
       //   localDataForMocksKeys: Object.keys(localDataForMocks),
       // });
 
       // First, if we have local data for this mock, add it
-      if (relevantKey) {
+      for (const relevantKey of relevantKeys) {
         const localDataForMock = localDataForMocks[relevantKey];
 
         // console.info('CODEYAM DEBUG: Found relevantKey', {
@@ -104,8 +108,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,

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

@@ -398,6 +398,7 @@ export default function mergeInDependentDataStructure({
                   const postfix = joinParenthesesAndArrays(
                     schemaPathParts.slice(matchedUpToIndex),
                   );
+
                   entry.equivalentPostfixes[postfix] = entry
                     .equivalentPostfixes[postfix]
                     ? bestValueFromOptions([
@@ -673,6 +674,7 @@ export default function mergeInDependentDataStructure({
           equivalentRoot.schemaRootPath,
           relevantPostfix,
         ]);
+
         schema[newSchemaPath] = postfixValue;
       }
 
@@ -680,6 +682,77 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  // Propagate equivalency-derived attributes to generic function call variants.
+  // When attributes are traced via equivalencies (e.g., fileComparisons from buildDataMap.signature[2]),
+  // they get written to non-generic paths (returnValue.data.x or funcName().functionCallReturnValue.data.x).
+  // If the ORIGINAL input schema has generic variants (funcName<T>().functionCallReturnValue.data),
+  // we need to copy the attributes to those paths too.
+  for (const filePath in mergedDataStructure.dependencySchemas) {
+    for (const depName in mergedDataStructure.dependencySchemas[filePath]) {
+      const depSchema =
+        mergedDataStructure.dependencySchemas[filePath][depName];
+      const returnValueSchema = depSchema.returnValueSchema;
+
+      // Look at the ORIGINAL input dependencySchemas for generic variants,
+      // since the merged schema may have lost them during equivalency processing
+      const originalSchema = dependencySchemas?.[filePath]?.[depName];
+      const schemaToSearchForGenericVariants =
+        originalSchema?.returnValueSchema || returnValueSchema;
+
+      // Find all unique generic variants of this function
+      // e.g., useFetcher<BranchEntityDiffResult>() from useFetcher<BranchEntityDiffResult>().functionCallReturnValue.data
+      const genericVariants = new Set<string>();
+      const genericRegex = new RegExp(
+        `^${depName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}<[^>]+>\\(\\)`,
+      );
+
+      for (const path in schemaToSearchForGenericVariants) {
+        const match = path.match(genericRegex);
+        if (match) {
+          genericVariants.add(match[0]);
+        }
+      }
+
+      if (genericVariants.size === 0) continue;
+
+      // For each returnValue. path or non-generic function call path,
+      // create corresponding paths for each generic variant
+      const pathsToAdd: [string, string][] = [];
+
+      for (const path in returnValueSchema) {
+        const value = returnValueSchema[path];
+
+        // Handle returnValue. paths
+        if (path.startsWith('returnValue.')) {
+          const suffix = path.slice('returnValue.'.length);
+          for (const genericVariant of genericVariants) {
+            const genericPath = `${genericVariant}.functionCallReturnValue.${suffix}`;
+            if (!(genericPath in returnValueSchema)) {
+              pathsToAdd.push([genericPath, value]);
+            }
+          }
+        }
+        // Handle non-generic function call paths like depName().functionCallReturnValue.x
+        else if (path.startsWith(`${depName}().functionCallReturnValue.`)) {
+          const suffix = path.slice(
+            `${depName}().functionCallReturnValue.`.length,
+          );
+          for (const genericVariant of genericVariants) {
+            const genericPath = `${genericVariant}.functionCallReturnValue.${suffix}`;
+            if (!(genericPath in returnValueSchema)) {
+              pathsToAdd.push([genericPath, value]);
+            }
+          }
+        }
+      }
+
+      // Add the new generic variant paths
+      for (const [path, value] of pathsToAdd) {
+        returnValueSchema[path] = value;
+      }
+    }
+  }
+
   // For mocked dependencies: copy paths from dependencySchemas (usage info) and normalize
   // returnValue. paths that were created by equivalency processing.
   // This ensures all paths use the consistent functionName().functionCallReturnValue. format.
@@ -695,23 +768,38 @@ export default function mergeInDependentDataStructure({
       name: dependency.name,
     });
 
-    // First, normalize any returnValue. paths that were written by equivalency processing
-    // to the standard functionName().functionCallReturnValue. format
+    // First, normalize any returnValue paths that were written by equivalency processing
+    // to the standard functionName().functionCallReturnValue format.
+    // This includes both returnValue. (dot) and returnValue[ (array) paths.
     const pathsToNormalize: [string, string][] = [];
     for (const path in depSchema.returnValueSchema) {
-      if (path === 'returnValue' || path.startsWith('returnValue.')) {
+      if (
+        path === 'returnValue' ||
+        path.startsWith('returnValue.') ||
+        path.startsWith('returnValue[')
+      ) {
         pathsToNormalize.push([path, depSchema.returnValueSchema[path]]);
       }
     }
     for (const [path, value] of pathsToNormalize) {
       delete depSchema.returnValueSchema[path];
-      const normalizedPath =
-        path === 'returnValue'
-          ? `${dependency.name}().functionCallReturnValue`
-          : path.replace(
-              /^returnValue\./,
-              `${dependency.name}().functionCallReturnValue.`,
-            );
+      let normalizedPath: string;
+      if (path === 'returnValue') {
+        normalizedPath = `${dependency.name}().functionCallReturnValue`;
+      } else if (path.startsWith('returnValue.')) {
+        normalizedPath = path.replace(
+          /^returnValue\./,
+          `${dependency.name}().functionCallReturnValue.`,
+        );
+      } else {
+        // path.startsWith('returnValue[')
+        // e.g., returnValue[] -> getOptions().functionCallReturnValue[]
+        // e.g., returnValue[].label -> getOptions().functionCallReturnValue[].label
+        normalizedPath = path.replace(
+          /^returnValue/,
+          `${dependency.name}().functionCallReturnValue`,
+        );
+      }
       depSchema.returnValueSchema[normalizedPath] = value;
     }
 
@@ -734,9 +822,8 @@ export default function mergeInDependentDataStructure({
                 `${dependency.name}().functionCallReturnValue.`,
               );
 
-        if (!(normalizedPath in depSchema.returnValueSchema)) {
-          depSchema.returnValueSchema[normalizedPath] = value;
-        }
+        // Always write srcSchema values - they take precedence over equivalency-derived values
+        depSchema.returnValueSchema[normalizedPath] = value;
         continue;
       }
 
@@ -744,9 +831,8 @@ export default function mergeInDependentDataStructure({
       // These are needed for constructMockCode to build the proper mock data hierarchy
       // Example: supabase.auth.getSession().functionCallReturnValue.data.session
       if (path.includes('.functionCallReturnValue')) {
-        if (!(path in depSchema.returnValueSchema)) {
-          depSchema.returnValueSchema[path] = value;
-        }
+        // Always write srcSchema values - they take precedence over equivalency-derived values
+        depSchema.returnValueSchema[path] = value;
         continue;
       }
 
@@ -765,6 +851,37 @@ export default function mergeInDependentDataStructure({
           depSchema.returnValueSchema[path] = value;
         }
       }
+
+      // Copy object-typed paths for chained API access patterns (like trpc.customer.getCustomersByOrg)
+      // These intermediate paths are needed for constructMockCode to build the nested mock structure.
+      // Example: for trpc.customer.getCustomersByOrg.useQuery().functionCallReturnValue.data,
+      // we need 'trpc', 'trpc.customer', 'trpc.customer.getCustomersByOrg' all typed as 'object'.
+      // Skip paths starting with 'returnValue' - they were already handled above
+      //
+      // EXCEPTION: For function-style dependencies like getSupabase(), skip intermediate object
+      // paths like 'getSupabase().auth' that are just property access after a function call.
+      // These aren't needed because constructMockCode can infer the structure from the actual
+      // function call paths like 'getSupabase().auth.getUser()'. We only need object paths
+      // for object-style dependencies like 'supabase.auth' where the dependency itself is an object.
+      if (value === 'object' && !path.startsWith('returnValue')) {
+        // Check if this is a function-style dependency (path starts with name() or name<T>())
+        const isFunctionStyleDependency =
+          path.startsWith(`${dependency.name}()`) ||
+          path.match(new RegExp(`^${dependency.name}<[^>]+>\\(\\)`));
+
+        // For function-style dependencies, skip intermediate object paths
+        // Only keep object paths that are within functionCallReturnValue
+        if (
+          isFunctionStyleDependency &&
+          !path.includes('.functionCallReturnValue')
+        ) {
+          continue;
+        }
+
+        if (!(path in depSchema.returnValueSchema)) {
+          depSchema.returnValueSchema[path] = value;
+        }
+      }
     }
 
     cleanSchema(depSchema.returnValueSchema);
@@ -845,6 +962,40 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  // Ensure ALL dependencies from the input dependencySchemas are preserved.
+  // Some dependencies (like .d.ts type declaration files) may not have:
+  // - Equivalencies with the root scope
+  // - A dependent analysis (they're just type declarations)
+  // - Be marked as mocked
+  // Without this, their schemas would be lost entirely.
+  //
+  // IMPORTANT: Only add schemas for dependencies that weren't already processed.
+  // If a dependency has an existing schema (even an empty one), it means the
+  // existing processing (mocked dependencies, equivalencies, dependentAnalyses)
+  // has already handled it and may have intentionally filtered out certain paths.
+  for (const filePath in dependencySchemas) {
+    for (const name in dependencySchemas[filePath]) {
+      const srcSchema = dependencySchemas[filePath][name];
+      if (!srcSchema) continue;
+
+      // Check if this dependency was already processed by any other mechanism
+      const existingSchema =
+        mergedDataStructure.dependencySchemas[filePath]?.[name];
+
+      // Only add if no existing schema at all - this means the dependency
+      // wasn't processed through equivalencies, mocked dependencies, or dependentAnalyses
+      if (!existingSchema) {
+        const depSchema = findOrCreateDependentSchemas({ filePath, name });
+        for (const path in srcSchema.returnValueSchema) {
+          depSchema.returnValueSchema[path] = srcSchema.returnValueSchema[path];
+        }
+        for (const path in srcSchema.signatureSchema) {
+          depSchema.signatureSchema[path] = srcSchema.signatureSchema[path];
+        }
+      }
+    }
+  }
+
   // writeFile(
   //   'mergeInDependentDataStructure-debug-result.json',
   //   // rootScopeName,

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

@@ -176,9 +176,19 @@ export default function mergeValidatedDataStructures({
       }
     }
 
-    for (const mockName in dependentAnalysis?.metadata?.scenariosDataStructure
-      ?.dataForMocks ?? {}) {
+    const dependencyDataForMocks =
+      dependentAnalysis?.metadata?.scenariosDataStructure?.dataForMocks ?? {};
+    for (const mockName in dependencyDataForMocks) {
       addMockDataForEntity(mockName);
+
+      // If addMockDataForEntity didn't find matching entries in validatedVariables,
+      // copy the dependency's value directly. This handles cases like usePathname()
+      // which returns a simple "string" type but isn't in the root's validatedVariables.
+      if (dataForMocks[mockName] === undefined) {
+        dataForMocks[mockName] = dependencyDataForMocks[
+          mockName
+        ] as JsonTypeDefinition;
+      }
     }
   }
 

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

@@ -3,7 +3,7 @@ import { ProjectAnalyzer } from '../ProjectAnalyzer';
 import getImportedExports from './getImportedExports';
 import { getFrameworkForFile, isFrameworkRoute } from '~codeyam/utils';
 import findOrCreateEntity from './analyze/findOrCreateEntity';
-import { generateSha, loadEntities, upsertEntities } from '~codeyam/supabase';
+import { generateSha, loadEntities, upsertEntities } from '~codeyam/database';
 import { AnalysisContext } from '../analysisContext';
 import analyzeFrameworkRoute from './analyzeFrameworkRoute';
 

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.d.ts

@@ -0,0 +1,23 @@
+interface GetPresignedUploadUrlArgs {
+    bucketName: string;
+    key: string;
+    contentType?: string;
+    expiresInSeconds?: number;
+}
+interface GetPresignedDownloadUrlArgs {
+    bucketName: string;
+    key: string;
+    expiresInSeconds?: number;
+}
+/**
+ * Generate a presigned URL for uploading a file to S3.
+ * The client can PUT directly to this URL without AWS credentials.
+ */
+export declare function getPresignedUploadUrl({ bucketName, key, contentType, expiresInSeconds, }: GetPresignedUploadUrlArgs): Promise<string>;
+/**
+ * Generate a presigned URL for downloading a file from S3.
+ * Anyone with this URL can GET the file without AWS credentials.
+ */
+export declare function getPresignedDownloadUrl({ bucketName, key, expiresInSeconds, }: GetPresignedDownloadUrlArgs): Promise<string>;
+export {};
+//# sourceMappingURL=getPresignedUrl.d.ts.map

package/analyzer-template/packages/aws/dist/src/lib/s3/getPresignedUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPresignedUrl.d.ts","sourceRoot":"","sources":["../../../../src/lib/s3/getPresignedUrl.ts"],"names":[],"mappings":"AAOA,UAAU,yBAAyB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,UAAU,2BAA2B;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAKD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,UAAU,EACV,GAAG,EACH,WAAgC,EAChC,gBAAwC,GACzC,EAAE,yBAAyB,GAAG,OAAO,CAAC,MAAM,CAAC,CAU7C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,UAAU,EACV,GAAG,EACH,gBAA0C,GAC3C,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAS/C"}