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

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

@@ -84,6 +84,17 @@ export class FileAnalyzer {
     }
   }
 
+  /**
+   * Returns only declared entity nodes (not identifier references).
+   * Use this when you need to find entities that can be replaced/mocked.
+   */
+  getAllDeclaredEntityNodes() {
+    if (!this.sourceFile) return {};
+    return lib.asts.sourceFiles.getAllDeclaredEntityNodes({
+      sourceFile: this.sourceFile,
+    });
+  }
+
   getNodeCode(node: ts.Node, removeComments = false) {
     if (!this.sourceFile) return '';
     if (removeComments) {
@@ -138,11 +149,121 @@ export class FileAnalyzer {
     });
   }
 
+  /**
+   * Get the code for a declared entity (not identifier references).
+   * Use this when you need to find code that can be replaced/mocked.
+   */
+  getDeclaredEntityCode(entityName: string, removeComments = false) {
+    if (!this.sourceFile) return '';
+    const entityNode = lib.asts.sourceFiles.getDeclaredEntityNode({
+      entityName,
+      sourceFile: this.sourceFile,
+    });
+
+    if (removeComments) {
+      const printer = ts.createPrinter({ removeComments: true });
+      return printer.printNode(
+        ts.EmitHint.Unspecified,
+        entityNode,
+        this.sourceFile,
+      );
+    }
+
+    return entityNode.getText(this.sourceFile);
+  }
+
   getAllExports(): Record<string, ExportedFunction> {
     if (!this.sourceFile) return {};
     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 = this.projectAnalyzer.project.files.find(
+        (f) => f.path === targetPath,
+      );
+
+      if (!targetFile && targetPath.includes('/dist/')) {
+        const srcPath = targetPath.replace('/dist/', '/src/');
+        targetFile = this.projectAnalyzer.project.files.find(
+          (f) => f.path === srcPath,
+        );
+        if (targetFile) {
+          targetPath = srcPath;
+        }
+
+        // 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',
+          );
+          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);
@@ -244,11 +365,16 @@ export class FileAnalyzer {
 
         for (let i = 0; i < uniqueRelevantExpressions.length; i++) {
           const relevantExpression = uniqueRelevantExpressions[i];
-          if (
-            relevantExpression.exportName === '*' &&
+          // Resolve namespace imports for local packages (not external libraries).
+          // A module is local if it's not external OR if it resolves to a path outside node_modules
+          // (handles local monorepo packages like @codeyam/ui-components).
+          // If resolvedFileName is undefined, we can't determine location, so treat as external.
+          const isLocalModule =
             resolvedModule &&
-            !resolvedModule.isExternalLibraryImport
-          ) {
+            (!resolvedModule.isExternalLibraryImport ||
+              (resolvedModule.resolvedFileName &&
+                !resolvedModule.resolvedFileName.includes('node_modules')));
+          if (relevantExpression.exportName === '*' && isLocalModule) {
             uniqueRelevantExpressions.splice(i, 1);
             uniqueRelevantExpressions.push(
               ...this.resolveNamespaceImport(
@@ -261,11 +387,18 @@ export class FileAnalyzer {
         }
 
         if (uniqueRelevantExpressions.length > 0) {
-          // Debug logging for ./types imports
+          // A module is external if TypeScript says so AND the resolved path is in node_modules.
+          // This handles local monorepo packages (like @codeyam/ui-components) which TypeScript
+          // marks as isExternalLibraryImport=true because they're symlinked, but actually
+          // resolve to files inside the project (not in node_modules).
+          const isExternalLibrary =
+            (resolvedModule?.isExternalLibraryImport ?? true) &&
+            (resolvedModule?.resolvedFileName?.includes('node_modules') ??
+              true);
           return [
             importedFilePath,
             {
-              externalLibrary: resolvedModule?.isExternalLibraryImport ?? true,
+              externalLibrary: isExternalLibrary,
               resolvedPath: resolvedModule?.resolvedFileName,
               exportInfos: uniqueRelevantExpressions,
             },
@@ -302,14 +435,41 @@ 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(
+          let importedFile = this.projectAnalyzer.project.files.find(
             (f) => f.path === 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 = this.projectAnalyzer.project.files.find(
+              (f) => f.path === srcPath,
+            );
+            if (importedFile) {
+              projectPath = srcPath;
+            }
+
+            // If not found, try with different extensions
+            if (!importedFile) {
+              const basePath = srcPath
+                .replace(/\.d\.ts$/, '')
+                .replace(/\.js$/, '');
+              importedFile = this.projectAnalyzer.project.files.find(
+                (f) =>
+                  f.path === basePath + '.ts' || f.path === basePath + '.tsx',
+              );
+              if (importedFile) {
+                projectPath = importedFile.path;
+              }
+            }
+          }
+
           if (!importedFile) {
             // File not found in project.files, but still preserve resolvedPath
             return [
@@ -337,10 +497,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,
@@ -660,8 +849,9 @@ export class FileAnalyzer {
   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/asts/nodes/getNodeType.ts

@@ -17,7 +17,7 @@ export function getNodeType(node: ts.Node, sourceFile: ts.SourceFile) {
       nodeType = 'function';
       break;
     case 'ClassDeclaration':
-      nodeType = 'function';
+      nodeType = 'class';
       break;
     case 'ExportDeclaration':
     case 'ExportAssignment':

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

@@ -163,7 +163,8 @@ export function isFunction(
     ts.isFunctionDeclaration(node) ||
     ts.isFunctionExpression(node) ||
     ts.isArrowFunction(node) ||
-    ts.isCallExpression(node)
+    ts.isCallExpression(node) ||
+    ts.isClassDeclaration(node)
   );
 }
 

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

@@ -0,0 +1,238 @@
+import ts from 'typescript';
+
+interface GetAllDeclaredEntityNodesArgs {
+  sourceFile: ts.SourceFile;
+  possibleIdentifierNode?: ts.Node;
+  entityNode?: ts.Node;
+  entities?: { [key: string]: ts.Node };
+}
+
+/**
+ * Returns all declared entity nodes in a source file.
+ *
+ * Unlike getAllEntityNodes, this function only returns actual declarations
+ * (variables, functions, classes, interfaces, types, enums, exports).
+ * It does NOT include identifier references in initializers or call expressions.
+ *
+ * Use this when you need to find entities that can be replaced/mocked.
+ * Use getAllEntityNodes when you need to track all identifiers (e.g., for dependency analysis).
+ */
+export function getAllDeclaredEntityNodes({
+  sourceFile,
+  possibleIdentifierNode,
+  entityNode,
+  entities = {},
+}: GetAllDeclaredEntityNodesArgs): { [key: string]: ts.Node } {
+  try {
+    if (!possibleIdentifierNode) {
+      possibleIdentifierNode = sourceFile;
+    }
+
+    // Handle direct Identifier (e.g., from declaration.name)
+    if (ts.isIdentifier(possibleIdentifierNode)) {
+      if (!entities[possibleIdentifierNode.text]) {
+        entities[possibleIdentifierNode.text] =
+          entityNode ?? possibleIdentifierNode;
+      }
+      return entities;
+    }
+
+    if (ts.isBindingElement(possibleIdentifierNode)) {
+      const lastChild = possibleIdentifierNode.getChildAt(
+        possibleIdentifierNode.getChildCount(sourceFile) - 1,
+      );
+
+      if (ts.isIdentifier(lastChild)) {
+        entities[lastChild.text] = entityNode;
+      } else if (
+        ts.isObjectBindingPattern(lastChild) ||
+        ts.isArrayBindingPattern(lastChild)
+      ) {
+        entities = {
+          ...entities,
+          ...getAllDeclaredEntityNodes({
+            sourceFile,
+            possibleIdentifierNode: lastChild,
+            entityNode,
+            entities,
+          }),
+        };
+      }
+      return entities;
+    }
+
+    possibleIdentifierNode.forEachChild((child) => {
+      try {
+        const safeEntityNode = entityNode ?? child;
+
+        // For VariableDeclaration, only traverse the name (not the initializer)
+        // This prevents registering identifier references as declarations
+        if (ts.isVariableDeclaration(child)) {
+          entities = {
+            ...getAllDeclaredEntityNodes({
+              sourceFile,
+              possibleIdentifierNode: child.name,
+              entityNode: safeEntityNode,
+              entities,
+            }),
+            ...entities,
+          };
+        } else if (
+          ts.isBindingElement(child) ||
+          ts.isModuleDeclaration(child) ||
+          ts.isNamedExports(child)
+        ) {
+          entities = {
+            ...getAllDeclaredEntityNodes({
+              sourceFile,
+              possibleIdentifierNode: child,
+              entityNode: safeEntityNode,
+              entities,
+            }),
+            ...entities,
+          };
+        }
+
+        if (ts.isVariableDeclarationList(child)) {
+          child.declarations.forEach((declaration) => {
+            entities = {
+              ...getAllDeclaredEntityNodes({
+                sourceFile,
+                possibleIdentifierNode: declaration.name,
+                entityNode: safeEntityNode,
+                entities,
+              }),
+              ...entities,
+            };
+          });
+        }
+
+        if (ts.isVariableStatement(child)) {
+          entities = {
+            ...getAllDeclaredEntityNodes({
+              sourceFile,
+              possibleIdentifierNode: child.declarationList,
+              entityNode: safeEntityNode,
+              entities,
+            }),
+            ...entities,
+          };
+        }
+
+        if (ts.isObjectBindingPattern(child)) {
+          const entityNodes = child.elements.reduce((acc, element) => {
+            return {
+              ...getAllDeclaredEntityNodes({
+                sourceFile,
+                possibleIdentifierNode: element,
+                entityNode: safeEntityNode,
+                entities,
+              }),
+              ...acc,
+            };
+          }, {});
+
+          for (const key in entityNodes) {
+            entities[key] = safeEntityNode;
+          }
+        }
+
+        if (ts.isArrayBindingPattern(child)) {
+          entities = {
+            ...entities,
+            ...child.elements.reduce((acc, element) => {
+              return {
+                ...getAllDeclaredEntityNodes({
+                  sourceFile,
+                  possibleIdentifierNode: element,
+                  entityNode: safeEntityNode,
+                  entities,
+                }),
+                ...acc,
+              };
+            }, {}),
+          };
+        }
+
+        if (
+          ts.isFunctionDeclaration(child) ||
+          ts.isTypeAliasDeclaration(child) ||
+          ts.isInterfaceDeclaration(child) ||
+          ts.isClassDeclaration(child) ||
+          ts.isEnumDeclaration(child)
+        ) {
+          if (!entities[child.name?.text ?? 'default']) {
+            entities[child.name?.text ?? 'default'] = safeEntityNode;
+
+            if (ts.isFunctionDeclaration(child) && child.modifiers) {
+              const isDefaultExport =
+                child.modifiers.some(
+                  (modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword,
+                ) &&
+                child.modifiers.some(
+                  (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword,
+                );
+
+              if (isDefaultExport) {
+                entities['default'] = safeEntityNode;
+              }
+            }
+          }
+        }
+
+        if (ts.isExportDeclaration(child)) {
+          if (child.exportClause) {
+            entities = {
+              ...getAllDeclaredEntityNodes({
+                sourceFile,
+                possibleIdentifierNode: child.exportClause,
+                entityNode: safeEntityNode,
+                entities,
+              }),
+              ...entities,
+            };
+          }
+        }
+
+        if (ts.isExportAssignment(child)) {
+          // For declared entities, always point to the export statement itself
+          // (not the original declaration) so mock replacement works correctly.
+          // e.g., for `export default prisma;`, we want to replace the export
+          // statement, not the prisma variable declaration.
+          entities['default'] = safeEntityNode;
+        }
+
+        if (ts.isExportSpecifier(child)) {
+          const nameText = child.name.getText(sourceFile);
+          if (child.propertyName) {
+            const propertyNameText = child.propertyName.getText(sourceFile);
+            entities[nameText] = entities[propertyNameText] ?? safeEntityNode;
+            if (propertyNameText !== 'default' && !entities[propertyNameText]) {
+              entities[propertyNameText] = safeEntityNode;
+            }
+          } else {
+            entities[nameText] = entities[nameText] ?? safeEntityNode;
+          }
+        }
+      } catch (e) {
+        console.log(
+          'CodeYam Error: Error Getting All Declared Entity Nodes Child',
+          ts.SyntaxKind[child.kind],
+          child.getText(sourceFile),
+          e,
+        );
+        throw e;
+      }
+    });
+
+    return entities;
+  } catch (e) {
+    console.log(
+      'CodeYam Error: Error Getting All Declared Entity Nodes',
+      ts.SyntaxKind[possibleIdentifierNode.kind],
+      possibleIdentifierNode.getText(sourceFile),
+      e,
+    );
+    throw e;
+  }
+}

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

@@ -54,13 +54,15 @@ export function getAllExportedNodes(
   }
 
   function processNamedExports(node: ts.NamedExports) {
+    const parent = node.parent as ts.ExportDeclaration | undefined;
+
     node.elements.forEach((element) => {
       const name = element.name.text;
       const propertyName = element.propertyName
         ? element.propertyName.text
         : name;
-      const importedSource = node.parent.moduleSpecifier
-        ? node.parent.moduleSpecifier.getText(sourceFile)
+      const importedSource = parent?.moduleSpecifier
+        ? parent.moduleSpecifier.getText(sourceFile)
         : undefined;
 
       if (importedSource) {

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

@@ -5,6 +5,7 @@ export interface ExportedFunction {
   code: string;
   isDefaultExport: boolean;
   isNamespaceExport: boolean;
+  isStarExport?: boolean;
   directImportPath?: string;
   directImportName?: string;
 }
@@ -103,19 +104,21 @@ export function getAllExports(
   }
 
   function processNamedExports(node: ts.NamedExports) {
+    const parent = node.parent as ts.ExportDeclaration | undefined;
+
     node.elements.forEach((element) => {
       const name = element.name.text;
       const propertyName = element.propertyName
         ? element.propertyName.text
         : name;
-      const importedSource = node.parent.moduleSpecifier
-        ? node.parent.moduleSpecifier.getText(sourceFile)
+      const importedSource = parent?.moduleSpecifier
+        ? parent.moduleSpecifier.getText(sourceFile)
         : undefined;
 
       if (importedSource) {
         const directImportPath = importedSource?.replace(/['"]/g, '');
         const directImport = (
-          node.parent.exportClause as ts.NamedExports
+          parent?.exportClause as ts.NamedExports | undefined
         )?.elements?.find(
           (e) => (e.propertyName || e.name).text === propertyName,
         );
@@ -200,12 +203,38 @@ export function getAllExports(
       }
     } else if (ts.isExportAssignment(node) && !node.isExportEquals) {
       processExportAssignment(node);
-    } else if (ts.isExportDeclaration(node) && node.exportClause) {
-      if (ts.isNamedExports(node.exportClause)) {
-        processNamedExports(node.exportClause);
-      } else if (ts.isNamespaceExport(node.exportClause)) {
-        const name = node.exportClause.name.text;
-        addExport(name, node, false);
+    } else if (ts.isExportDeclaration(node)) {
+      if (node.exportClause) {
+        if (ts.isNamedExports(node.exportClause)) {
+          processNamedExports(node.exportClause);
+        } else if (ts.isNamespaceExport(node.exportClause)) {
+          const name = node.exportClause.name.text;
+          addExport(name, node, false);
+        }
+      } else if (node.moduleSpecifier) {
+        // Handle star exports: export * from './path'
+        // The exportClause is undefined for star exports
+        const moduleSpecifier = node.moduleSpecifier.getText(sourceFile);
+        const directImportPath = moduleSpecifier.replace(/['"]/g, '');
+
+        // Use a synthetic name based on the path to track this star export
+        // The * symbol indicates this is a star export that needs to be followed
+        const starExportName = `*:${directImportPath}`;
+
+        let code: string;
+        try {
+          code = node.getFullText(sourceFile).trim();
+        } catch (error) {
+          code = `export * from '${directImportPath}'`;
+        }
+
+        exportsCodeMap[starExportName] = {
+          code,
+          isDefaultExport: false,
+          isNamespaceExport: false,
+          isStarExport: true,
+          directImportPath,
+        };
       }
     }
   });

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

@@ -0,0 +1,25 @@
+import ts from 'typescript';
+import * as lib from '../../index';
+
+/**
+ * Get the AST node for a declared entity by name.
+ * Unlike getEntityNode, this only finds actual declarations (not identifier references).
+ */
+export function getDeclaredEntityNode({
+  entityName,
+  sourceFile,
+}: {
+  entityName: string;
+  sourceFile: ts.SourceFile;
+}) {
+  const entityNodes = lib.asts.sourceFiles.getAllDeclaredEntityNodes({
+    sourceFile,
+  });
+  const entityNode = entityNodes[entityName];
+
+  if (!entityNode) {
+    throw new Error('getDeclaredEntityNode: Entity not found');
+  }
+
+  return entityNode;
+}

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

@@ -11,7 +11,9 @@ export { getSourceFilesForAllImports } from './getSourceFilesForAllImports';
 export { getImportMappings } from './getImportMappings';
 export { getAllEntities } from './getAllEntities';
 export { getAllEntityNodes } from './getAllEntityNodes';
+export { getAllDeclaredEntityNodes } from './getAllDeclaredEntityNodes';
 export { getEntityNode } from './getEntityNode';
+export { getDeclaredEntityNode } from './getDeclaredEntityNode';
 export { getAllExports } from './getAllExports';
 export { getAllExportedNodes } from './getAllExportedNodes';
 export { getImportsAnalysis } from './getImportsAnalysis';