@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.25a2014

package/analyzer-template/packages/analyze/src/lib/asts/sourceFiles/getAllEntityNodes.ts

@@ -7,6 +7,11 @@ interface GetAllEntityNodesArgs {
   entities?: { [key: string]: ts.Node };
 }
 
+const allEntityNodesCache = new WeakMap<
+  ts.SourceFile,
+  { [key: string]: ts.Node }
+>();
+
 export function getAllEntityNodes({
   sourceFile,
   possibleIdentifierNode,
@@ -14,6 +19,14 @@ export function getAllEntityNodes({
   entities = {},
 }: GetAllEntityNodesArgs) {
   try {
+    const isRootCall = !possibleIdentifierNode && !entityNode;
+    if (isRootCall) {
+      const cached = allEntityNodesCache.get(sourceFile);
+      if (cached) {
+        return cached;
+      }
+    }
+
     if (!possibleIdentifierNode) {
       possibleIdentifierNode = sourceFile;
     }
@@ -39,6 +52,9 @@ export function getAllEntityNodes({
           }),
         };
       }
+      if (isRootCall) {
+        allEntityNodesCache.set(sourceFile, entities);
+      }
       return entities;
     }
 
@@ -223,6 +239,9 @@ export function getAllEntityNodes({
       }
     });
 
+    if (isRootCall) {
+      allEntityNodesCache.set(sourceFile, entities);
+    }
     return entities;
   } catch (e) {
     console.log(

package/analyzer-template/packages/analyze/src/lib/asts/sourceFiles/getAllExports.ts

@@ -10,9 +10,19 @@ export interface ExportedFunction {
   directImportName?: string;
 }
 
+const exportsCache = new WeakMap<
+  ts.SourceFile,
+  Record<string, ExportedFunction>
+>();
+
 export function getAllExports(
   sourceFile: ts.SourceFile,
 ): Record<string, ExportedFunction> {
+  const cached = exportsCache.get(sourceFile);
+  if (cached) {
+    return cached;
+  }
+
   const exportsCodeMap: Record<string, ExportedFunction> = {};
 
   function addExport(
@@ -239,5 +249,6 @@ export function getAllExports(
     }
   });
 
+  exportsCache.set(sourceFile, exportsCodeMap);
   return exportsCodeMap;
 }

package/analyzer-template/packages/analyze/src/lib/asts/sourceFiles/getImportsAnalysis.ts

@@ -6,7 +6,14 @@ type ImportsAnalysis = {
   [importedFilePath: string]: ExportInfo[];
 };
 
+const importsAnalysisCache = new WeakMap<ts.SourceFile, ImportsAnalysis>();
+
 export function getImportsAnalysis(sourceFile: ts.SourceFile): ImportsAnalysis {
+  const cached = importsAnalysisCache.get(sourceFile);
+  if (cached) {
+    return cached;
+  }
+
   const importsMapEntries: [string, ExportInfo[]][] = [];
 
   const importsVisitor = (node: ts.Node) => {
@@ -35,6 +42,7 @@ export function getImportsAnalysis(sourceFile: ts.SourceFile): ImportsAnalysis {
     {} as ImportsAnalysis,
   );
 
+  importsAnalysisCache.set(sourceFile, consolidatedImportsMapEntries);
   return consolidatedImportsMapEntries;
 }
 

package/analyzer-template/packages/analyze/src/lib/asts/sourceFiles/getResolvedModule.ts

@@ -2,21 +2,44 @@ import ts from 'typescript';
 import path from 'path';
 import fs from 'fs';
 
+/**
+ * Cache for nearest tsconfig lookups (keyed by directory).
+ * Speeds up repeated lookups during module resolution.
+ */
+const nearestTsConfigCache = new Map<string, string | undefined>();
+
 /**
  * Find the nearest tsconfig.json by walking up the directory tree from the source file
  */
 function findNearestTsConfig(sourceFileName: string): string | undefined {
   let currentDir = path.dirname(sourceFileName);
   const root = path.parse(currentDir).root;
+  const visited: string[] = [];
 
   while (currentDir !== root) {
+    const cached = nearestTsConfigCache.get(currentDir);
+    if (cached !== undefined || nearestTsConfigCache.has(currentDir)) {
+      for (const dir of visited) {
+        nearestTsConfigCache.set(dir, cached);
+      }
+      return cached;
+    }
+
+    visited.push(currentDir);
     const tsConfigPath = path.join(currentDir, 'tsconfig.json');
     if (fs.existsSync(tsConfigPath)) {
+      for (const dir of visited) {
+        nearestTsConfigCache.set(dir, tsConfigPath);
+      }
       return tsConfigPath;
     }
     currentDir = path.dirname(currentDir);
   }
 
+  for (const dir of visited) {
+    nearestTsConfigCache.set(dir, undefined);
+  }
+
   return undefined;
 }
 
@@ -25,6 +48,14 @@ function findNearestTsConfig(sourceFileName: string): string | undefined {
  */
 const tsConfigCache = new Map<string, ts.CompilerOptions>();
 
+/**
+ * Cache resolved module lookups by program for fast repeat access.
+ */
+const resolvedModuleCacheByProgram = new WeakMap<
+  ts.Program,
+  Map<string, ts.ResolvedModuleFull | null>
+>();
+
 /**
  * Get compiler options from a tsconfig file
  */
@@ -62,6 +93,19 @@ export function getResolvedModule(
   // Try to find the nearest tsconfig for this source file
   const nearestTsConfig = findNearestTsConfig(sourceFile.fileName);
 
+  const cacheForProgram =
+    resolvedModuleCacheByProgram.get(program) ??
+    new Map<string, ts.ResolvedModuleFull | null>();
+  if (!resolvedModuleCacheByProgram.has(program)) {
+    resolvedModuleCacheByProgram.set(program, cacheForProgram);
+  }
+
+  const cacheKey = `${nearestTsConfig ?? ''}|${sourceFile.fileName}|${moduleName}`;
+  if (cacheForProgram.has(cacheKey)) {
+    const cached = cacheForProgram.get(cacheKey);
+    return cached ?? undefined;
+  }
+
   // Start with the program's compiler options
   let compilerOptions = program.getCompilerOptions();
 
@@ -90,6 +134,7 @@ export function getResolvedModule(
 
   // If TypeScript's resolution succeeded, return it
   if (result.resolvedModule) {
+    cacheForProgram.set(cacheKey, result.resolvedModule);
     return result.resolvedModule;
   }
 
@@ -105,14 +150,17 @@ export function getResolvedModule(
     for (const ext of extensions) {
       const testPath = absolutePath + ext;
       if (fs.existsSync(testPath)) {
-        return {
+        const resolved = {
           resolvedFileName: testPath,
           extension: ext.includes('/') ? path.extname(ext) : ext,
           isExternalLibraryImport: false,
         } as ts.ResolvedModuleFull;
+        cacheForProgram.set(cacheKey, resolved);
+        return resolved;
       }
     }
   }
 
+  cacheForProgram.set(cacheKey, null);
   return undefined;
 }

package/analyzer-template/packages/analyze/src/lib/asts/sourceFiles/getSourceFilesForAllImports.ts

@@ -21,5 +21,6 @@ export function getSourceFilesForAllImports(
 
   visit(sourceFile); // Start visiting nodes from the root source file
 
-  return getSourceFilesForImports(moduleNames, sourceFile, program);
+  const uniqueModuleNames = Array.from(new Set(moduleNames));
+  return getSourceFilesForImports(uniqueModuleNames, sourceFile, program);
 }

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

@@ -17,6 +17,8 @@ import {
   getConditionalEffects,
   getCompoundConditionals,
   getChildBoundaryGatingConditions,
+  getJsxRenderingUsages,
+  skipWorkerPool,
 } from '~codeyam/ai';
 import type { AnalysisOptions } from '../analyzeEntities';
 
@@ -134,6 +136,8 @@ export default async function prepareEntityDataStructures(
               // Include child boundary gating conditions for child component flow merging
               childBoundaryGatingConditions:
                 isolatedDataStructure.childBoundaryGatingConditions,
+              // Include JSX rendering usages for array size and text length flow generation
+              jsxRenderingUsages: isolatedDataStructure.jsxRenderingUsages,
             };
 
             // Detect wrapper requirements (Context providers, etc.)
@@ -268,6 +272,23 @@ export default async function prepareEntityDataStructures(
   };
 
   const entities = Array.from(allEntities);
+
+  // The worker thread creates its own ProjectAnalyzer (ts.Program) on first use,
+  // which takes 50-70s. For small entity counts the overhead far exceeds the actual
+  // processing time (<2s). Skip the worker and run on the main thread instead,
+  // reusing the existing ProjectAnalyzer.
+  const entitiesNeedingGeneration = entities.filter(
+    (e) =>
+      !e.metadata?.isolatedDataStructure || options.force || options.forceAll,
+  ).length;
+  const WORKER_ENTITY_THRESHOLD = 500;
+  if (entitiesNeedingGeneration < WORKER_ENTITY_THRESHOLD) {
+    console.log(
+      `CodeYam: Skipping worker thread for DS prep (${entitiesNeedingGeneration} entities < ${WORKER_ENTITY_THRESHOLD} threshold)`,
+    );
+    skipWorkerPool();
+  }
+
   const sequential =
     DEBUG_SEQUENTIAL_EXECUTION || options.sequentialDataStructurePrep;
 
@@ -333,11 +354,23 @@ async function getEntityDataStructureAndFunctionCalls({
         functionName: importedExport.name,
       });
 
-      // If neither signature nor return value found, this function doesn't exist in the analysis.
-      // We need to check BOTH because hooks like useParams() have no signature (no arguments)
-      // but DO have a return value that needs to be mocked.
+      // If neither signature nor return value found, check if this function has matching
+      // external function calls. External functions (like useLoaderData from react-router)
+      // don't have entries in functionResults, so getReturnValue returns null for them.
+      // But their return values ARE traced in externalFunctionCalls via perVariableSchemas.
+      // We need to check for matching calls before skipping.
       if (!signatureSchema && !returnValueSchema) {
-        return acc;
+        const hasMatchingExternalCall =
+          dataStructure.externalFunctionCalls?.some(
+            (fc) =>
+              fc.name === importedExport.name ||
+              fc.name.startsWith(importedExport.name + '<'),
+          );
+
+        // Only skip if there are no matching external function calls
+        if (!hasMatchingExternalCall) {
+          return acc;
+        }
       }
 
       // Clone schemas before deduplication to avoid mutating shared references
@@ -540,6 +573,42 @@ async function getEntityDataStructureAndFunctionCalls({
     },
   );
 
+  // Add same-file child components to dependencySchemas.
+  // Same-file components (e.g., AgentCard defined in the same file as AgentTranscriptsPage)
+  // appear in externalFunctionCalls and functionResults but NOT in importedExports or
+  // nodeModuleImports. Without this, their signatures are missing from dependencySchemas
+  // and enrichArrayTypesFromChildSignatures can't find child component field accesses.
+  const allDependencyNames = new Set(allDependencies.map((d) => d.name));
+
+  for (const efc of dataStructure.externalFunctionCalls) {
+    // Skip if already covered by importedExports or nodeModuleImports
+    if (allDependencyNames.has(efc.name)) continue;
+
+    const signatureSchema = getFunctionSignature(dataStructure, {
+      functionName: efc.name,
+    });
+
+    const returnValueSchema = getReturnValue(dataStructure, {
+      functionName: efc.name,
+    });
+
+    // Only add if we have signature or return value data
+    if (!signatureSchema && !returnValueSchema) continue;
+
+    const clonedSignatureSchema = { ...(signatureSchema ?? {}) };
+    const clonedReturnValueSchema = { ...(returnValueSchema ?? {}) };
+
+    const entityFilePath = entity.filePath;
+    dependencySchemas[entityFilePath] ||= {};
+    dependencySchemas[entityFilePath][efc.name] = {
+      signatureSchema: deduplicateFunctionSchemas(clonedSignatureSchema),
+      returnValueSchema: deduplicateFunctionSchemas(clonedReturnValueSchema),
+      usageEquivalencies: getUsageEquivalencies(dataStructure, efc.name) ?? {},
+      sourceEquivalencies:
+        getSourceEquivalencies(dataStructure, efc.name) ?? {},
+    };
+  }
+
   const rawReturnValue =
     getReturnValue(dataStructure, { fillInUnknowns: false }) ?? {};
 
@@ -557,19 +626,6 @@ async function getEntityDataStructureAndFunctionCalls({
 
   // Get compound conditionals (grouped conditions that must all be true)
   const compoundConditionals = getCompoundConditionals(dataStructure);
-
-  console.log(
-    `[ConditionalEffects] prepareDataStructures for ${entity.name}:`,
-    `dataStructure.conditionalEffects=${(dataStructure as any).conditionalEffects?.length ?? 0}`,
-    `getConditionalEffects returned ${conditionalEffects.length} effects`,
-    conditionalEffects
-      .slice(0, 5)
-      .map(
-        (e: any) =>
-          `${e.effect?.setterName}(${e.effect?.value?.slice?.(0, 20) ?? e.effect?.value})`,
-      ),
-  );
-
   const rawUsageEquivalencies = getUsageEquivalencies(dataStructure);
   const rawSourceEquivalencies = getSourceEquivalencies(dataStructure);
 
@@ -577,11 +633,16 @@ async function getEntityDataStructureAndFunctionCalls({
   const childBoundaryGatingConditions =
     getChildBoundaryGatingConditions(dataStructure);
 
+  // Get JSX rendering usages for array size and text length flow generation
+  const jsxRenderingUsages = getJsxRenderingUsages(dataStructure);
+
+  const equivalentSignatureVariables =
+    getEquivalentSignatureVariables(dataStructure);
+
   const isolatedDataStructure = {
     signatureSchema: deduplicateFunctionSchemas(clonedRawSignature),
     returnValueSchema: deduplicateFunctionSchemas(clonedRawReturnValue),
-    equivalentSignatureVariables:
-      getEquivalentSignatureVariables(dataStructure),
+    equivalentSignatureVariables,
     dependencySchemas,
     environmentVariables: dataStructure.environmentVariables,
     conditionalUsages:
@@ -604,6 +665,10 @@ async function getEntityDataStructureAndFunctionCalls({
       Object.keys(childBoundaryGatingConditions).length > 0
         ? childBoundaryGatingConditions
         : undefined,
+    // Include JSX rendering usages for array size and text length flow generation
+    // These track arrays rendered via .map() and strings interpolated in JSX
+    jsxRenderingUsages:
+      jsxRenderingUsages.length > 0 ? jsxRenderingUsages : undefined,
   };
 
   const functionCalls: Record<string, string[]> = {};
@@ -859,9 +924,21 @@ export function determineMockedDependencies(entity: Entity) {
       // A schema with only "EntityName(): function" just indicates the entity is callable,
       // it doesn't mean there's actual return data to mock
       const hasReturnValue = hasActualReturnValueData(entityReturnValueSchema);
-      const complexReturnValue = Object.values(
-        entityReturnValueSchema ?? {},
-      ).some((value) => value === 'object' || value === 'array');
+      // Check for complex return types (object/array), accounting for nullable types
+      // e.g., 'object', 'object | null', 'array | undefined' should all count as complex.
+      // Also detect when functionCallReturnValue has nested child properties — this
+      // proves it's a structured type even if its declared type is still 'unknown'.
+      const returnValueKeys = Object.keys(entityReturnValueSchema ?? {});
+      const complexReturnValue =
+        Object.values(entityReturnValueSchema ?? {}).some((value) => {
+          const baseType = value?.split(' | ')[0];
+          return baseType === 'object' || baseType === 'array';
+        }) ||
+        returnValueKeys.some(
+          (key) =>
+            key.includes('functionCallReturnValue.') ||
+            key.includes('functionCallReturnValue['),
+        );
 
       // Check if this is a validation function that should always be mocked
       const isValidationFn = isValidationFunction(entityName);

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

@@ -5,6 +5,8 @@ import {
   measureAndReportExecutionTime,
   ProjectAnalyzer,
 } from '~codeyam/analyze';
+import { transformationTracer } from '../scenarios/TransformationTracer';
+import { getFileByPathSafe } from '../../utils/getFileByPath';
 import trackEntityCircularDependencies from './trackEntityCircularDependencies';
 import validateDependencyAnalyses from './validateDependencyAnalyses';
 import extractClassMethods from './analyzeEntities/extractClassMethods';
@@ -306,6 +308,18 @@ export default async function analyzeEntities({
   awsLog(
     `CodeYam: analyzeEntities: Analysis completed with ${analyses.length} analyses`,
   );
+
+  // Flush transformation trace if tracing is enabled
+  // Wrapped in try/catch because trace data can exceed V8's max string length
+  // for large projects, and we must not crash the analysis process over tracing.
+  try {
+    transformationTracer.flush();
+  } catch (e) {
+    console.warn(
+      `CodeYam Warning: Failed to flush transformation trace: ${e.message}`,
+    );
+  }
+
   return analyses;
 
   // PHASE 3: Pure graph traversal
@@ -388,10 +402,19 @@ export default async function analyzeEntities({
             // Circular dependency detected in path - skip
             continue;
           }
-          // If already visited via another traversal path, skip to avoid deadlock.
-          // Its subtree has been fully explored; any leaves are already in leafKeys.
-          // Blocking on it would just propagate the block and cause stuck analysis.
+          // If already visited via another traversal path, check if it's a leaf.
+          // If it's a leaf, we should still wait for it to complete.
+          // Only skip if we've already explored it and it's NOT a leaf (meaning it's
+          // blocked on something else - continuing to traverse would cause a deadlock).
           if (visited.has(dependentEntityKey)) {
+            // If the visited entity is a leaf, we should wait for it to complete
+            // before processing this entity. Don't skip it!
+            if (leafKeys.has(dependentEntityKey)) {
+              // It's a leaf that hasn't completed yet - wait for it
+              isLeaf = false;
+              continue;
+            }
+            // If it's not a leaf, it's blocked on something else - skip to avoid deadlock
             continue;
           }
           isLeaf = false;
@@ -426,7 +449,7 @@ export default async function analyzeEntities({
     }
 
     const file =
-      entity.file || project.files.find((f) => f.path === entity.filePath);
+      entity.file || getFileByPathSafe(projectAnalyzer, entity.filePath);
     if (!file) {
       awsLog(
         `CodeYam: analyzeEntities: File not found for entity: ${entityKey}`,

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

@@ -138,6 +138,18 @@ export default async function findOrCreateEntity({
           break;
         }
       }
+
+      // Mark previous versions as superseded
+      const entitiesToSupersede = previousEntities.filter(
+        (e) => !e.metadata?.isSuperseded,
+      );
+      if (entitiesToSupersede.length > 0) {
+        for (const prev of entitiesToSupersede) {
+          prev.metadata = prev.metadata || {};
+          prev.metadata.isSuperseded = true;
+        }
+        await upsertEntities(entitiesToSupersede);
+      }
     }
 
     entity = {

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

@@ -1,6 +1,7 @@
 import { Entity } from '~codeyam/types';
 import findOrCreateEntity from './findOrCreateEntity';
 import { ProjectAnalyzer } from '../../ProjectAnalyzer';
+import { getFileByPathSafe } from '../../utils/getFileByPath';
 import { AnalysisContext } from '../../analysisContext';
 
 // Track files we've already warned about to avoid duplicate warnings
@@ -71,8 +72,9 @@ export default async function gatherEntityMap({
     //   `  → imported export ${importedExportFilePath}:${importedExportName}`,
     // );
 
-    const importedFile = project.files.find(
-      (file) => file.path === importedExportFilePath,
+    const importedFile = getFileByPathSafe(
+      projectAnalyzer,
+      importedExportFilePath,
     );
 
     if (!importedFile) {

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

@@ -1,5 +1,6 @@
 import type {
   Analysis,
+  Entity,
   ReadonlyAnalysisMap,
   ReadonlyAnalysis,
   ReadonlyEntity,
@@ -61,13 +62,13 @@ export default function validateDependencyAnalyses({
   for (const dependency of entity.metadata?.importedExports ?? []) {
     const dependencyFilePath =
       dependency.resolvedFilePath ?? dependency.filePath;
-    const dependencyName = dependency.resolvedName ?? dependency.name;
+    // Use the entity/import name, not the export name (resolvedName).
+    // For default exports, resolvedName is 'default' but the entity is stored
+    // under its actual identifier name (e.g., 'QuoteDetailsDrawer').
+    const dependencyName = dependency.name;
 
     // if the entity has duplicate dependencies, handle gracefully
     if (dependentAnalyses[dependencyFilePath]?.[dependencyName]) {
-      // console.log(
-      //   `CodeYam: validateDependencyAnalyses: Entity ${entity.filePath}:${entity.name} has duplicate dependency ${dependencyFilePath}:${dependencyName}. Skipping...`,
-      // );
       continue;
     }
 
@@ -103,6 +104,23 @@ export default function validateDependencyAnalyses({
       continue;
     }
 
+    // Ensure the entity is attached to the analysis.
+    // The entity might not be attached if the analysis was loaded from the database
+    // without its entity being in the context's entity map.
+    // This is critical for generateDataStructure to merge child component tRPC calls.
+    let dependentEntity: ReadonlyEntity | undefined = dependentAnalysis.entity;
+    if (!dependentEntity) {
+      // Try to get the entity from the context
+      dependentEntity = context.getEntity(dependencyFilePath, dependencyName);
+      if (dependentEntity) {
+        // Attach the entity to the analysis (mutating, but necessary for downstream use)
+        // We need the double cast because ReadonlyEntity has readonly arrays that aren't
+        // assignable to Entity's mutable arrays.
+        (dependentAnalysis as unknown as Analysis).entity =
+          dependentEntity as unknown as Entity;
+      }
+    }
+
     // Store the dependent analysis
     dependentAnalyses[dependencyFilePath] ||= {};
     dependentAnalyses[dependencyFilePath][dependencyName] = dependentAnalysis;
@@ -125,12 +143,17 @@ export default function validateDependencyAnalyses({
       }
     }
 
-    validateDependencyAnalyses({
-      readonlyAnalysis: dependentAnalysis,
-      entity: dependentAnalysis.entity,
-      context: context,
-      dependentAnalyses,
-    });
+    // Only recurse if we have the entity. Without the entity, we can't process
+    // the dependency's own dependencies, but we can still use this dependency's
+    // analysis data (mergedDataStructure, etc.)
+    if (dependentEntity) {
+      validateDependencyAnalyses({
+        readonlyAnalysis: dependentAnalysis,
+        entity: dependentEntity,
+        context: context,
+        dependentAnalyses,
+      });
+    }
   }
 
   return { dependentAnalyses };

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

@@ -1,5 +1,6 @@
 import { Entity, EntityType, File, ProjectFramework } from '~codeyam/types';
 import { ProjectAnalyzer } from '../ProjectAnalyzer';
+import { getFileByPathSafe } from '../utils/getFileByPath';
 import { generateSha } from '~codeyam/database';
 import { isRemixRoute } from '~codeyam/utils';
 
@@ -88,11 +89,9 @@ export default function analyzeRemixRoute(
   // Find root.tsx for this route's webapp and add as implicit dependency
   // This ensures root.tsx dependencies (like useLoaderData in AppContent) get analyzed for mocking
   const routeAppDir = file.path.split('/routes/')[0];
-  const rootFile = projectAnalyzer.project.files.find(
-    (f) =>
-      f.path === `${routeAppDir}/root.tsx` ||
-      f.path === `${routeAppDir}/root.jsx`,
-  );
+  const rootFile =
+    getFileByPathSafe(projectAnalyzer, `${routeAppDir}/root.tsx`) ??
+    getFileByPathSafe(projectAnalyzer, `${routeAppDir}/root.jsx`);
 
   const rootDependencies: Entity['metadata']['importedExports'] = [];
   if (rootFile) {

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

@@ -1,6 +1,7 @@
 import { Entity, File, Project } from '~codeyam/types';
 import { FileAnalyzer } from '../FileAnalyzer';
 import { ProjectAnalyzer } from '../ProjectAnalyzer';
+import { getFileByPathSafe } from '../utils/getFileByPath';
 import type { FunctionDependenciesMap } from '../asts/sourceFiles/getPseudoFile';
 // import { generateSha } from '~codeyam/database';
 
@@ -63,9 +64,7 @@ export default function getImportedExports(
           imports[filePath].resolvedPath ??
           filePath;
 
-        let importedExportFile = project.files.find(
-          (f) => f.path === searchPath,
-        );
+        let importedExportFile = getFileByPathSafe(projectAnalyzer, searchPath);
 
         // Track the actual path we found (may differ from searchPath after dist->src mapping)
         let actualResolvedPath = imports[filePath].resolvedPath;
@@ -84,7 +83,7 @@ export default function getImportedExports(
             const srcPath = `${packagePath}/src/${relativePath}`
               .replace(/\.d\.ts$/, '.ts')
               .replace(/\.js$/, '.ts');
-            importedExportFile = project.files.find((f) => f.path === srcPath);
+            importedExportFile = getFileByPathSafe(projectAnalyzer, srcPath);
             if (importedExportFile) {
               actualResolvedPath = srcPath;
               console.log(
@@ -97,7 +96,7 @@ export default function getImportedExports(
           if (!importedExportFile) {
             const srcPath = searchPath.replace('/dist/', '/src/');
             // Try exact match first
-            importedExportFile = project.files.find((f) => f.path === srcPath);
+            importedExportFile = getFileByPathSafe(projectAnalyzer, srcPath);
             if (importedExportFile) {
               actualResolvedPath = srcPath;
               console.log(
@@ -114,13 +113,16 @@ export default function getImportedExports(
             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/')),
-            );
+            importedExportFile =
+              getFileByPathSafe(projectAnalyzer, basePath + '.ts') ??
+              getFileByPathSafe(projectAnalyzer, basePath + '.tsx');
+            if (!importedExportFile) {
+              importedExportFile = project.files.find(
+                (f) =>
+                  f.path.startsWith(basePath.replace('/index', '/')) &&
+                  !f.path.includes('/dist/'),
+              );
+            }
             if (importedExportFile) {
               actualResolvedPath = importedExportFile.path;
               console.log(