@codeyam/codeyam-cli 0.1.0-staging.e38f7bd → 0.1.0-staging.fef152f

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,
@@ -47,6 +49,11 @@ export class ProjectAnalyzer {
     // 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 +80,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 +91,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 +151,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 +260,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) {
@@ -320,5 +349,63 @@ export class ProjectAnalyzer {
     // 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/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/nodes/index.ts

@@ -7,6 +7,7 @@ export { getCallExpressionNames } from './getCallExpressionNames';
 export { getNodeType } from './getNodeType';
 export { getFunctionNodeType } from './getFunctionNodeType';
 export { isDefaultExport } from './isDefaultExport';
+export { isAsyncFunction } from './isAsyncFunction';
 
 interface ImportInfo {
   packageName: string;

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

@@ -0,0 +1,67 @@
+import ts from 'typescript';
+
+/**
+ * Checks if a node represents an async function or component.
+ * This includes:
+ * - Function declarations with async modifier
+ * - Arrow functions with async modifier
+ * - Variable declarations initialized with async functions
+ * - Method declarations with async modifier
+ */
+export function isAsyncFunction(node: ts.Node): boolean {
+  if (!node) return false;
+
+  // Direct function declaration: async function foo() {}
+  if (ts.isFunctionDeclaration(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Arrow function: const foo = async () => {}
+  if (ts.isArrowFunction(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Function expression: const foo = async function() {}
+  if (ts.isFunctionExpression(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Method declaration: async method() {}
+  if (ts.isMethodDeclaration(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Variable declaration: const foo = async () => {} or const foo = async function() {}
+  if (ts.isVariableDeclaration(node) && node.initializer) {
+    return isAsyncFunction(node.initializer);
+  }
+
+  // Variable statement: export const foo = async () => {}
+  if (ts.isVariableStatement(node)) {
+    for (const decl of node.declarationList.declarations) {
+      if (decl.initializer && isAsyncFunction(decl.initializer)) {
+        return true;
+      }
+    }
+  }
+
+  // Export assignment: export default async function() {}
+  if (ts.isExportAssignment(node) && node.expression) {
+    return isAsyncFunction(node.expression);
+  }
+
+  return false;
+}
+
+function hasAsyncModifier(
+  node:
+    | ts.FunctionDeclaration
+    | ts.ArrowFunction
+    | ts.FunctionExpression
+    | ts.MethodDeclaration,
+): boolean {
+  if (!node.modifiers) return false;
+  return node.modifiers.some(
+    (modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword,
+  );
+}

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(

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);
 }