@codeyam/codeyam-cli 0.1.0-staging.ad31e3e → 0.1.0-staging.ad88eeb

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,
@@ -177,6 +184,89 @@ export class FileAnalyzer {
     return lib.asts.sourceFiles.getAllExports(this.sourceFile);
   }
 
+  /**
+   * Find an export by following star export chains.
+   * When a file has `export * from './path'`, this method will recursively
+   * resolve the path and search for the export in the target module.
+   *
+   * @param exportName The name of the export to find
+   * @param visited Set of already visited file paths to prevent infinite loops
+   * @returns The export info with resolved path if found, undefined otherwise
+   */
+  findExportThroughStarExports(
+    exportName: string,
+    visited: Set<string> = new Set(),
+  ): { export: ExportedFunction; resolvedPath: string } | undefined {
+    if (!this.file?.path || visited.has(this.file.path)) {
+      return undefined;
+    }
+    visited.add(this.file.path);
+
+    const exports = this.getAllExports();
+
+    // First, check if the export exists directly
+    const directExport = exports[exportName];
+    if (directExport) {
+      return { export: directExport, resolvedPath: this.file.path };
+    }
+
+    // If not found directly, look for star exports and follow them
+    const starExports = Object.entries(exports).filter(
+      ([_, exp]) => exp.isStarExport,
+    );
+
+    for (const [_, starExport] of starExports) {
+      if (!starExport.directImportPath) continue;
+
+      // Resolve the star export path
+      const resolvedModule = this.getResolvedModule(
+        starExport.directImportPath,
+      );
+      if (!resolvedModule) continue;
+
+      const resolvedPath = this.projectAnalyzer.getRelativePath(
+        resolvedModule.resolvedFileName,
+      );
+
+      // Handle dist -> src mapping for workspace packages
+      let targetPath = resolvedPath;
+      let targetFile = getFileByPathSafe(this.projectAnalyzer, targetPath);
+
+      if (!targetFile && targetPath.includes('/dist/')) {
+        const srcPath = targetPath.replace('/dist/', '/src/');
+        targetFile = getFileByPathSafe(this.projectAnalyzer, srcPath);
+        if (targetFile) {
+          targetPath = srcPath;
+        }
+
+        // Try with different extensions if still not found
+        if (!targetFile) {
+          const basePath = srcPath.replace(/\.d\.ts$/, '').replace(/\.js$/, '');
+          targetFile =
+            getFileByPathSafe(this.projectAnalyzer, basePath + '.ts') ??
+            getFileByPathSafe(this.projectAnalyzer, basePath + '.tsx');
+          if (targetFile) {
+            targetPath = targetFile.path;
+          }
+        }
+      }
+
+      if (!targetFile) continue;
+
+      // Recursively search in the target file
+      const targetAnalyzer = this.projectAnalyzer.getFileAnalyzer(targetFile);
+      const result = targetAnalyzer.findExportThroughStarExports(
+        exportName,
+        visited,
+      );
+      if (result) {
+        return result;
+      }
+    }
+
+    return undefined;
+  }
+
   getImportsAnalysis() {
     if (!this.sourceFile) return {};
     return lib.asts.sourceFiles.getImportsAnalysis(this.sourceFile);
@@ -214,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],
@@ -261,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);
           },
         );
 
@@ -348,14 +438,39 @@ export class FileAnalyzer {
           }
 
           const relativePath = this.projectAnalyzer.getRelativePath(importPath);
-          const projectPath = this.projectAnalyzer.getRelativePath(
+          let projectPath = this.projectAnalyzer.getRelativePath(
             resolvedImport.resolvedFileName,
           );
 
-          const 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"),
+          // but our project.files contains source files in src/. Try mapping dist -> src.
+          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 = getFileByPathSafe(this.projectAnalyzer, srcPath);
+            if (importedFile) {
+              projectPath = srcPath;
+            }
+
+            // If not found, try with different extensions
+            if (!importedFile) {
+              const basePath = srcPath
+                .replace(/\.d\.ts$/, '')
+                .replace(/\.js$/, '');
+              importedFile =
+                getFileByPathSafe(this.projectAnalyzer, basePath + '.ts') ??
+                getFileByPathSafe(this.projectAnalyzer, basePath + '.tsx');
+              if (importedFile) {
+                projectPath = importedFile.path;
+              }
+            }
+          }
+
           if (!importedFile) {
             // File not found in project.files, but still preserve resolvedPath
             return [
@@ -383,10 +498,39 @@ export class FileAnalyzer {
               );
             }
 
-            const importedExport = importedExports[exportInfo.exportName];
-            const directImportPath = importedExport?.directImportPath;
+            let importedExport = importedExports[exportInfo.exportName];
+            let directImportPath = importedExport?.directImportPath;
+            let foundThroughStarExports = false;
+
+            // If export not found directly, try following star export chains
+            // This handles cases like `export * from './client'` where the actual
+            // export is defined in a re-exported module
+            if (
+              !importedExport &&
+              typeof importedFileAnalyer.findExportThroughStarExports ===
+                'function'
+            ) {
+              const starExportResult =
+                importedFileAnalyer.findExportThroughStarExports(
+                  exportInfo.exportName,
+                );
+              if (starExportResult) {
+                // Found the export through star exports - update the resolved path
+                // The directImportPath is effectively the resolved path where we found it
+                directImportPath = starExportResult.export.directImportPath;
+                // Update exportInfo with the resolved location
+                if (!exportInfo.resolvedPath) {
+                  exportInfo.resolvedPath = starExportResult.resolvedPath;
+                }
+                importedExport = starExportResult.export;
+                foundThroughStarExports = true;
+              }
+            }
 
-            if (directImportPath) {
+            // Skip recursive processing if we found the export through star exports,
+            // since we already have the resolved path and the recursive call would
+            // use the wrong file analyzer (the original file, not where we found the export)
+            if (directImportPath && !foundThroughStarExports) {
               const directImportResolvedImports =
                 importedFileAnalyer.getResolvedImportsRelevantToFunctionName(
                   exportInfo.exportName,
@@ -448,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 => {
@@ -494,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(
@@ -703,11 +852,26 @@ export class FileAnalyzer {
     return getEntityType({ entityName, sourceFile: this.sourceFile });
   }
 
+  /**
+   * Checks if the entity (function/component) is async.
+   * Async functions in Next.js are Server Components that need special handling.
+   */
+  isEntityAsync(entityName: string): boolean {
+    if (!this.sourceFile) return false;
+    const entityNode = lib.asts.sourceFiles.getEntityNode({
+      entityName,
+      sourceFile: this.sourceFile,
+    });
+    if (!entityNode) return false;
+    return lib.asts.nodes.isAsyncFunction(entityNode);
+  }
+
   getEntityStartAndEnd(entityName: string): { start: number; end: number } {
     if (!this.sourceFile) return { start: 0, end: 0 };
     const node = this.getAllEntityNodes()[entityName];
+    if (!node) return { start: 0, end: 0 };
     const start = this.sourceFile.getLineAndCharacterOfPosition(
-      node.getStart(),
+      node.getStart(this.sourceFile),
     ).line;
     const end = this.sourceFile.getLineAndCharacterOfPosition(
       node.getEnd(),

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