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

package/analyzer-template/packages/analyze/src/lib/FileAnalyzer.ts

@@ -9,6 +9,7 @@ import {
 import { FunctionNode } from './types';
 import getEntityType from './files/getEntityType';
 import getEntityCode from './files/getEntityCode';
+import { getFileByPathSafe } from './utils/getFileByPath';
 
 export class FileAnalyzer {
   public projectAnalyzer: lib.ProjectAnalyzer;
@@ -19,6 +20,7 @@ export class FileAnalyzer {
   // Current per-file caching helps when multiple entities in the same file call getResolvedImportsRelevantToFunctionName,
   // but a project-level cache would also benefit the recursive import chain traversals that cross file boundaries.
   private resolvedImportsCache: Map<string, FunctionDependenciesMap>;
+  private allEntityNodesOnlyAliasesCache?: Record<string, ts.Node>;
 
   constructor({
     projectAnalyzer,
@@ -62,18 +64,23 @@ export class FileAnalyzer {
 
   getAllEntityNodesOnlyAliases() {
     if (!this.sourceFile) return {};
+    if (this.allEntityNodesOnlyAliasesCache) {
+      return this.allEntityNodesOnlyAliasesCache;
+    }
     try {
       const allEntityNodes = lib.asts.sourceFiles.getAllEntityNodes({
         sourceFile: this.sourceFile,
       });
-      if (allEntityNodes.default) {
-        const namedDefault = Object.entries(allEntityNodes).find(
+      const aliasesOnly = { ...allEntityNodes };
+      if (aliasesOnly.default) {
+        const namedDefault = Object.entries(aliasesOnly).find(
           ([otherEntityName, node]) =>
-            otherEntityName !== 'default' && node === allEntityNodes.default,
+            otherEntityName !== 'default' && node === aliasesOnly.default,
         );
-        if (namedDefault) delete allEntityNodes.default;
+        if (namedDefault) delete aliasesOnly.default;
       }
-      return allEntityNodes;
+      this.allEntityNodesOnlyAliasesCache = aliasesOnly;
+      return aliasesOnly;
     } catch (error) {
       console.log('CodeYam ERROR: getAllEntityNodesOnlyAliases failed:', {
         filePath: this.file?.path,
@@ -223,15 +230,11 @@ export class FileAnalyzer {
 
       // Handle dist -> src mapping for workspace packages
       let targetPath = resolvedPath;
-      let targetFile = this.projectAnalyzer.project.files.find(
-        (f) => f.path === targetPath,
-      );
+      let targetFile = getFileByPathSafe(this.projectAnalyzer, targetPath);
 
       if (!targetFile && targetPath.includes('/dist/')) {
         const srcPath = targetPath.replace('/dist/', '/src/');
-        targetFile = this.projectAnalyzer.project.files.find(
-          (f) => f.path === srcPath,
-        );
+        targetFile = getFileByPathSafe(this.projectAnalyzer, srcPath);
         if (targetFile) {
           targetPath = srcPath;
         }
@@ -239,9 +242,9 @@ export class FileAnalyzer {
         // Try with different extensions if still not found
         if (!targetFile) {
           const basePath = srcPath.replace(/\.d\.ts$/, '').replace(/\.js$/, '');
-          targetFile = this.projectAnalyzer.project.files.find(
-            (f) => f.path === basePath + '.ts' || f.path === basePath + '.tsx',
-          );
+          targetFile =
+            getFileByPathSafe(this.projectAnalyzer, basePath + '.ts') ??
+            getFileByPathSafe(this.projectAnalyzer, basePath + '.tsx');
           if (targetFile) {
             targetPath = targetFile.path;
           }
@@ -301,24 +304,25 @@ export class FileAnalyzer {
 
   getLocalEntitiesUsedInFunction(functionName: string) {
     if (!this.sourceFile) return [];
-    const entityNodes = lib.asts.sourceFiles.getAllEntityNodes({
-      sourceFile: this.sourceFile,
-    });
+    const entityNodes = this.getAllEntityNodes();
 
     // Defensive check: ensure the function exists in entityNodes
-    if (!entityNodes[functionName]) {
+    const functionNode = entityNodes[functionName];
+    if (!functionNode) {
       return [];
     }
 
     try {
-      const identifiers = this.getIdentifiersInNode(entityNodes[functionName]);
+      const identifiers = this.getIdentifiersInNode(functionNode);
       return identifiers
-        .filter(
-          (identifier, index, self) =>
-            entityNodes[identifier] !== entityNodes[functionName] &&
-            Object.keys(entityNodes).includes(identifier) &&
-            self.indexOf(identifier) === index,
-        )
+        .filter((identifier) => {
+          const node = entityNodes[identifier];
+          return (
+            !!node &&
+            node !== functionNode &&
+            typeof (node as ts.Node).kind === 'number'
+          );
+        })
         .map((identifier) => ({
           name: identifier,
           node: entityNodes[identifier],
@@ -348,14 +352,13 @@ export class FileAnalyzer {
       sourceFile: this.sourceFile,
     });
     const identifiersInRelevantNode = this.getIdentifiersInNode(relevantNode);
+    const identifiersSet = new Set(identifiersInRelevantNode);
 
     const entries = Object.entries(importsAnalysis)
       .map(([importedFilePath, importedExpressions]) => {
         const relevantExpressions = importedExpressions.filter(
           (importedExpression) => {
-            return identifiersInRelevantNode.includes(
-              importedExpression.importAlias,
-            );
+            return identifiersSet.has(importedExpression.importAlias);
           },
         );
 
@@ -439,8 +442,9 @@ export class FileAnalyzer {
             resolvedImport.resolvedFileName,
           );
 
-          let importedFile = this.projectAnalyzer.project.files.find(
-            (f) => f.path === projectPath,
+          let importedFile = getFileByPathSafe(
+            this.projectAnalyzer,
+            projectPath,
           );
 
           // Workspace packages often resolve to dist/ paths (from package.json "types" or "main"),
@@ -448,9 +452,7 @@ export class FileAnalyzer {
           if (!importedFile && projectPath.includes('/dist/')) {
             const srcPath = projectPath.replace('/dist/', '/src/');
             // Try exact match first (e.g., dist/index.d.ts -> src/index.ts)
-            importedFile = this.projectAnalyzer.project.files.find(
-              (f) => f.path === srcPath,
-            );
+            importedFile = getFileByPathSafe(this.projectAnalyzer, srcPath);
             if (importedFile) {
               projectPath = srcPath;
             }
@@ -460,10 +462,9 @@ export class FileAnalyzer {
               const basePath = srcPath
                 .replace(/\.d\.ts$/, '')
                 .replace(/\.js$/, '');
-              importedFile = this.projectAnalyzer.project.files.find(
-                (f) =>
-                  f.path === basePath + '.ts' || f.path === basePath + '.tsx',
-              );
+              importedFile =
+                getFileByPathSafe(this.projectAnalyzer, basePath + '.ts') ??
+                getFileByPathSafe(this.projectAnalyzer, basePath + '.tsx');
               if (importedFile) {
                 projectPath = importedFile.path;
               }
@@ -591,24 +592,35 @@ export class FileAnalyzer {
 
   getNamespaceIdentifiersInNode(node: ts.Node, namespaceIdentifier: string) {
     const identifiers: string[] = [];
+    const seen = new Set<string>();
 
     const identifierVisitor = (child: ts.Node) => {
       if (ts.isPropertyAccessExpression(child)) {
         if (child.expression.getText() === namespaceIdentifier) {
-          identifiers.push(child.name.getText());
+          const name = child.name.getText();
+          if (!seen.has(name)) {
+            seen.add(name);
+            identifiers.push(name);
+          }
         }
       }
       ts.forEachChild(child, identifierVisitor);
     };
 
     ts.forEachChild(node, identifierVisitor);
-    return identifiers.filter(
-      (identifier, index, self) => self.indexOf(identifier) === index,
-    );
+    return identifiers;
   }
 
   getIdentifiersInNode(node: ts.Node): string[] {
     const identifiers: string[] = [];
+    const seen = new Set<string>();
+
+    const addIdentifier = (text: string, allowDefault = false) => {
+      if (!allowDefault && text === 'default') return;
+      if (seen.has(text)) return;
+      seen.add(text);
+      identifiers.push(text);
+    };
 
     // Helper to safely get text from an identifier or string literal
     const getNodeText = (node: ts.Identifier | ts.StringLiteral): string => {
@@ -637,63 +649,57 @@ export class FileAnalyzer {
     };
 
     if (ts.isIdentifier(node)) {
-      identifiers.push(getNodeText(node));
+      addIdentifier(getNodeText(node));
     }
 
     const identifierVisitor = (child: ts.Node) => {
       if (ts.isIdentifier(child)) {
-        const text = getNodeText(child);
-        if (text === 'default') return;
-        identifiers.push(text);
+        addIdentifier(getNodeText(child));
       } else if (ts.isExportDeclaration(child)) {
         if (child.exportClause && ts.isNamedExports(child.exportClause)) {
           child.exportClause.elements.forEach((element) => {
-            identifiers.push(getNodeText(element.name));
+            addIdentifier(getNodeText(element.name), true);
           });
         } else if (
           child.exportClause &&
           ts.isNamespaceExport(child.exportClause)
         ) {
-          identifiers.push(getNodeText(child.exportClause.name));
+          addIdentifier(getNodeText(child.exportClause.name));
         }
       } else if (ts.isExportAssignment(child)) {
         if (ts.isIdentifier(child.expression)) {
-          identifiers.push(getNodeText(child.expression));
+          addIdentifier(getNodeText(child.expression));
         }
       } else if (ts.isExportSpecifier(child)) {
-        identifiers.push(getNodeText(child.name));
+        addIdentifier(getNodeText(child.name), true);
         return;
       } else if (ts.isFunctionDeclaration(child) && child.name) {
-        identifiers.push(getNodeText(child.name));
+        addIdentifier(getNodeText(child.name));
       } else if (ts.isVariableStatement(child)) {
         child.declarationList.declarations.forEach((declaration) => {
           if (ts.isIdentifier(declaration.name)) {
-            identifiers.push(getNodeText(declaration.name));
+            addIdentifier(getNodeText(declaration.name));
           }
         });
       } else if (ts.isImportDeclaration(child)) {
         if (child.importClause && child.importClause.namedBindings) {
           if (ts.isNamespaceImport(child.importClause.namedBindings)) {
-            identifiers.push(
-              getNodeText(child.importClause.namedBindings.name),
-            );
+            addIdentifier(getNodeText(child.importClause.namedBindings.name));
           } else if (ts.isNamedImports(child.importClause.namedBindings)) {
             child.importClause.namedBindings.elements.forEach((element) => {
-              identifiers.push(getNodeText(element.name));
+              addIdentifier(getNodeText(element.name));
             });
           }
         }
       } else if (ts.isImportSpecifier(child)) {
-        identifiers.push(getNodeText(child.name));
+        addIdentifier(getNodeText(child.name), true);
         return;
       }
       ts.forEachChild(child, identifierVisitor);
     };
 
     ts.forEachChild(node, identifierVisitor);
-    return identifiers.filter(
-      (identifier, index, self) => self.indexOf(identifier) === index,
-    );
+    return identifiers;
   }
 
   resolveNamespaceImport(

package/analyzer-template/packages/analyze/src/lib/ProjectAnalyzer.ts

@@ -13,6 +13,8 @@ export class ProjectAnalyzer {
   programs: ts.Program[]; // All programs from all tsconfigs
   typeChecker: ts.TypeChecker;
   private filesByPath: Map<string, File>; // O(1) lookup cache for files
+  private sourceFileByPath: Map<string, ts.SourceFile>; // O(1) lookup cache for source files
+  private typeCheckerByPath: Map<string, ts.TypeChecker>; // O(1) lookup cache for type checkers by file
 
   private constructor({
     project,
@@ -44,9 +46,20 @@ export class ProjectAnalyzer {
       lib.asts.createProgramFromTsConfigPath(configPath, excludePatterns),
     );
 
+    if (this.programs.length === 0) {
+      throw new Error(
+        'No TypeScript programs could be created — no tsconfig.json found',
+      );
+    }
+
     // Primary program is the first one (usually root) for backward compatibility
     this.program = this.programs[0];
     this.typeChecker = this.program.getTypeChecker();
+
+    // Build source file and type checker indexes for fast lookups
+    this.sourceFileByPath = new Map();
+    this.typeCheckerByPath = new Map();
+    this.buildSourceFileIndex();
   }
 
   static from({
@@ -73,32 +86,7 @@ export class ProjectAnalyzer {
   }
 
   getFileAnalyzerByPath(filePath: string) {
-    if (this.project.files?.length !== this.filesByPath.size) {
-      // Rebuild the cache if project.files has changed
-      this.filesByPath.clear();
-      for (const file of this.project.files) {
-        this.filesByPath.set(file.path, file);
-      }
-    }
-
-    // Convert absolute path to relative if needed
-    let relativePath = filePath;
-    if (filePath.startsWith(this.dirPath + '/')) {
-      relativePath = this.getRelativePath(filePath);
-    } else if (filePath.startsWith('/')) {
-      // Might be an absolute path with a different prefix (e.g., symlink)
-      // Try to normalize it to match our dirPath
-      try {
-        const normalizedPath = realpathSync(filePath);
-        if (normalizedPath.startsWith(this.dirPath + '/')) {
-          relativePath = normalizedPath.replace(this.dirPath + '/', '');
-        }
-      } catch (error) {
-        // If normalization fails, keep the original path
-      }
-    }
-
-    const file = this.filesByPath.get(relativePath);
+    const file = this.getFileByPath(filePath);
     if (!file) {
       // Technically FileAnalyzer was built to accept null file, but most of
       // the code we've written since assumes fileAnalyzer.sourceFile exists,
@@ -109,6 +97,33 @@ export class ProjectAnalyzer {
     return new lib.FileAnalyzer({ projectAnalyzer: this, file });
   }
 
+  getFileByPath(filePath: string): File | undefined {
+    this.ensureFileCache();
+
+    const candidates = new Set<string>();
+    if (filePath) {
+      candidates.add(filePath);
+    }
+
+    if (!filePath.startsWith('/')) {
+      candidates.add(filePath);
+    } else if (filePath.startsWith(this.dirPath + '/')) {
+      candidates.add(filePath.slice(this.dirPath.length + 1));
+    }
+
+    const relativePath = this.toProjectRelativePath(filePath);
+    if (relativePath) {
+      candidates.add(relativePath);
+    }
+
+    for (const candidate of candidates) {
+      const file = this.filesByPath.get(candidate);
+      if (file) return file;
+    }
+
+    return undefined;
+  }
+
   getFileAnalyzer(file: File) {
     this.filesByPath.set(file.path, file);
     return new lib.FileAnalyzer({ projectAnalyzer: this, file });
@@ -142,6 +157,16 @@ export class ProjectAnalyzer {
 
   getSourceFile(filePath: string): ts.SourceFile | undefined {
     const absolutePath = this.getAbsolutePath(filePath);
+    const relativePath = filePath.startsWith('/')
+      ? this.toProjectRelativePath(filePath)
+      : filePath;
+
+    if (relativePath) {
+      const cached = this.sourceFileByPath.get(relativePath);
+      if (cached) {
+        return cached;
+      }
+    }
 
     // Search across all programs
     for (const program of this.programs) {
@@ -241,6 +266,16 @@ export class ProjectAnalyzer {
    */
   getTypeCheckerForFile(filePath: string): ts.TypeChecker {
     const absolutePath = this.getAbsolutePath(filePath);
+    const relativePath = filePath.startsWith('/')
+      ? this.toProjectRelativePath(filePath)
+      : filePath;
+
+    if (relativePath) {
+      const cachedChecker = this.typeCheckerByPath.get(relativePath);
+      if (cachedChecker) {
+        return cachedChecker;
+      }
+    }
 
     // Search for the file in each program and return that program's typeChecker
     for (const program of this.programs) {
@@ -305,20 +340,84 @@ export class ProjectAnalyzer {
    * Refresh the TypeScript program to pick up file changes
    */
   refreshProgram(): void {
-    // Memory logging: Capture state before refresh
-    const memBefore = process.memoryUsage();
-
     // Apply the same unapprovedPaths filtering when refreshing
     const excludePatterns =
       this.project.metadata?.unapprovedPaths?.filter(Boolean) || [];
 
-    // Refresh all programs
-    this.programs = this.tsConfigPaths.map((configPath) =>
-      lib.asts.createProgramFromTsConfigPath(configPath, excludePatterns),
-    );
+    // Release old programs and caches BEFORE creating new ones to reduce peak memory.
+    // Without this, both old (~1.7GB) and new (~1.7GB) programs coexist during creation,
+    // causing OOM on monorepos with multiple tsconfigs.
+    this.programs = [];
+    this.sourceFileByPath.clear();
+    this.typeCheckerByPath.clear();
+
+    // Create programs one at a time so each old program can be GC'd before the next
+    for (const configPath of this.tsConfigPaths) {
+      this.programs.push(
+        lib.asts.createProgramFromTsConfigPath(configPath, excludePatterns),
+      );
+    }
 
     // Update primary program for backward compatibility
     this.program = this.programs[0];
     this.typeChecker = this.program.getTypeChecker();
+
+    this.buildSourceFileIndex();
+  }
+
+  private ensureFileCache(): void {
+    if (this.project.files?.length !== this.filesByPath.size) {
+      // Rebuild the cache if project.files has changed
+      this.filesByPath.clear();
+      for (const file of this.project.files) {
+        this.filesByPath.set(file.path, file);
+      }
+    }
+  }
+
+  private toProjectRelativePath(filePath: string): string | null {
+    if (!filePath) return null;
+
+    if (filePath.startsWith(this.dirPath + '/')) {
+      return filePath.replace(this.dirPath + '/', '');
+    }
+
+    if (!filePath.startsWith('/')) {
+      return null;
+    }
+
+    try {
+      const normalizedPath = realpathSync(filePath);
+      if (normalizedPath.startsWith(this.dirPath + '/')) {
+        return normalizedPath.replace(this.dirPath + '/', '');
+      }
+    } catch (error) {
+      // If normalization fails, return null
+    }
+
+    return null;
+  }
+
+  private buildSourceFileIndex(): void {
+    this.sourceFileByPath.clear();
+    this.typeCheckerByPath.clear();
+
+    for (const program of this.programs) {
+      const checker = program.getTypeChecker();
+      for (const sf of program.getSourceFiles()) {
+        // Skip node_modules files to keep the index small
+        if (sf.fileName.includes('node_modules')) {
+          continue;
+        }
+
+        const relativePath = this.toProjectRelativePath(sf.fileName);
+        if (!relativePath) continue;
+
+        if (!this.sourceFileByPath.has(relativePath)) {
+          this.sourceFileByPath.set(relativePath, sf);
+          this.typeCheckerByPath.set(relativePath, checker);
+        }
+      }
+    }
   }
 }

package/analyzer-template/packages/analyze/src/lib/analysisContext.ts

@@ -48,6 +48,12 @@ export class AnalysisContext implements ImmutableAnalysisContext {
   public analysesAdded: Analysis[]; // TODO: Remove this when we switch to immutable maps
   private projectNodeModuleMocks: Mock[];
   private baselineMode: boolean = false;
+  /**
+   * Parent context for delegating lookups when not found locally.
+   * Used by private contexts created via forEntityAnalysis() to see analyses
+   * added to the main context after the fork.
+   */
+  private parentContext?: AnalysisContext;
 
   /**
    * Create a new AnalysisContext with optional initial maps and mocks
@@ -56,16 +62,19 @@ export class AnalysisContext implements ImmutableAnalysisContext {
     primaryEntity,
     initialEntityMap,
     initialAnalysisMap,
+    parentContext,
   }: {
     primaryEntity?: Entity;
     initialEntityMap?: EntityMap;
     initialAnalysisMap?: AnalysisMap;
+    parentContext?: AnalysisContext;
   } = {}) {
     this.primaryEntity = primaryEntity;
     this.entityMap = initialEntityMap || {};
     this.entitiesAdded = []; // TODO: Remove this when we switch to immutable maps
     this.analysisMap = initialAnalysisMap || {};
     this.analysesAdded = []; // TODO: Remove this when we switch to immutable maps
+    this.parentContext = parentContext;
   }
   setPrimaryAnalysis(analysis: Analysis): void {
     if (!this.primaryEntity) {
@@ -102,15 +111,22 @@ export class AnalysisContext implements ImmutableAnalysisContext {
       primaryEntity: entity,
       initialEntityMap: { ...this.entityMap },
       initialAnalysisMap: { ...this.analysisMap },
+      parentContext: this,
     });
   }
 
   /**
-   * Get a read-only view of an entity by file path and entity name
+   * Get a read-only view of an entity by file path and entity name.
+   * Falls back to parent context if not found locally (for private contexts).
    * @returns The entity or undefined if not found
    */
   getEntity(filePath: string, entityName: string): ReadonlyEntity | undefined {
-    return this.entityMap[filePath]?.[entityName];
+    const entity = this.entityMap[filePath]?.[entityName];
+    // Fall back to parent context if not found locally
+    if (!entity && this.parentContext) {
+      return this.parentContext.getEntity(filePath, entityName);
+    }
+    return entity;
   }
 
   /**
@@ -126,7 +142,8 @@ export class AnalysisContext implements ImmutableAnalysisContext {
   }
 
   /**
-   * Get a read-only view of an analysis by file path and entity name
+   * Get a read-only view of an analysis by file path and entity name.
+   * Falls back to parent context if not found locally (for private contexts).
    * @returns The analysis or undefined if not found
    */
   getAnalysis(
@@ -134,7 +151,23 @@ export class AnalysisContext implements ImmutableAnalysisContext {
     entityName: string,
     withEntity = false,
   ): ReadonlyAnalysis | undefined {
-    const analysis = this.analysisMap[filePath]?.[entityName];
+    let analysis = this.analysisMap[filePath]?.[entityName];
+
+    // Fall back to parent context if not found locally
+    // This allows private contexts (created via forEntityAnalysis) to see
+    // analyses added to the main context after the fork
+    if (!analysis && this.parentContext) {
+      analysis = this.parentContext.getAnalysis(
+        filePath,
+        entityName,
+        withEntity,
+      ) as Analysis | undefined;
+      // If found in parent and withEntity was already handled by parent, return directly
+      if (analysis) {
+        return analysis;
+      }
+    }
+
     if (withEntity && analysis) {
       analysis.entity ||= this.getMutableEntity(filePath, entityName);
     }
@@ -183,6 +216,13 @@ export class AnalysisContext implements ImmutableAnalysisContext {
       this.analysisMap[filePath] = {};
     }
     this.analysisMap[filePath][entityName] = analysis;
+
+    // Also add the entity if it's attached to the analysis.
+    // This ensures that when getAnalysis is called with withEntity=true,
+    // the entity will be available in the entity map.
+    if (analysis.entity) {
+      this.addEntity(analysis.entity);
+    }
   }
 
   /**

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

@@ -95,8 +95,13 @@ export function createProgramFromTsConfigPath(
     throw new Error('Could not parse tsconfig.json');
   }
 
-  // Filter file names based on exclude patterns to reduce memory usage
-  let fileNames = parsedCommandLine.fileNames;
+  // Always filter out node_modules from root files to prevent OOM on large projects.
+  // This only removes them as root compilation targets — TypeScript's module resolution
+  // still follows imports into node_modules for type info when processing source files.
+  let fileNames = parsedCommandLine.fileNames.filter(
+    (f) => !f.includes('/node_modules/'),
+  );
+
   if (excludePatterns && excludePatterns.length > 0) {
     const regexPatterns = excludePatterns
       .map((pattern) => {

package/analyzer-template/packages/analyze/src/lib/asts/nodes/getNodeType.ts

@@ -39,6 +39,7 @@ export function getNodeType(node: ts.Node, sourceFile: ts.SourceFile) {
     case 'StringLiteral':
     case 'NumericLiteral':
     case 'ObjectLiteralExpression':
+    case 'ArrayLiteralExpression':
       nodeType = 'data';
       break;
     case 'TypeAliasDeclaration':

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

@@ -7,6 +7,11 @@ interface GetAllDeclaredEntityNodesArgs {
   entities?: { [key: string]: ts.Node };
 }
 
+const allDeclaredEntityNodesCache = new WeakMap<
+  ts.SourceFile,
+  { [key: string]: ts.Node }
+>();
+
 /**
  * Returns all declared entity nodes in a source file.
  *
@@ -24,6 +29,14 @@ export function getAllDeclaredEntityNodes({
   entities = {},
 }: GetAllDeclaredEntityNodesArgs): { [key: string]: ts.Node } {
   try {
+    const isRootCall = !possibleIdentifierNode && !entityNode;
+    if (isRootCall) {
+      const cached = allDeclaredEntityNodesCache.get(sourceFile);
+      if (cached) {
+        return cached;
+      }
+    }
+
     if (!possibleIdentifierNode) {
       possibleIdentifierNode = sourceFile;
     }
@@ -34,6 +47,9 @@ export function getAllDeclaredEntityNodes({
         entities[possibleIdentifierNode.text] =
           entityNode ?? possibleIdentifierNode;
       }
+      if (isRootCall) {
+        allDeclaredEntityNodesCache.set(sourceFile, entities);
+      }
       return entities;
     }
 
@@ -225,6 +241,9 @@ export function getAllDeclaredEntityNodes({
       }
     });
 
+    if (isRootCall) {
+      allDeclaredEntityNodesCache.set(sourceFile, entities);
+    }
     return entities;
   } catch (e) {
     console.log(