@ts-stack/cycle-detector 1.1.0 → 1.1.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ts-stack/cycle-detector",
   "type": "module",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "bin": {
     "cycle-detector": "./dist/index.js"
   },
@@ -21,7 +21,7 @@
   },
   "scripts": {
     "start": "npm run build && node dist/index.js",
-    "test": "npm run build-test && npm run esm-jest",
+    "test": "npm run build-test && npm run esm-jest --",
     "esm-jest": "node --experimental-vm-modules --no-warnings=ExperimentalWarning node_modules/jest/bin/jest.js",
     "build": "tsc -b tsconfig.build.json",
     "build-test": "tsc -b tsconfig.unit.json",
@@ -40,14 +40,15 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/jest": "^29.5.14",
+    "@types/jest": "^30.0.0",
     "@types/node": "^26.0.0",
     "eslint": "^10.5.0",
-    "jest": "^29.7.0",
+    "jest": "^30.4.2",
     "nodemon": "^3.1.14",
     "prettier": "^3.8.4",
     "rimraf": "^5.0.10",
     "ts-node": "^10.9.2",
+    "type-fest": "^5.7.0",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.62.0"
   },

package/src/index.ts

@@ -11,26 +11,21 @@ const graph = new Map<string, string[]>();
 const allUniqueCycles: string[][] = [];
 const globalDetectedCycles = new Set<string>();
 
-const packageMetaCache = new Map<string, { pkgDir: string; srcDirName: string; outDirName: string; } | null>();
 const compilerOptionsCache = new Map<string, ts.CompilerOptions>();
-
-let globalProjectPath: string | undefined;
+const sourceFileCache = new Map<string, ts.SourceFile>();
+const topLevelUsageCache = new Map<string, boolean>();
+const exportedHoistedFunctionsCache = new Map<string, Set<string>>();
+const resolvedSourceCache = new Map<string, string>(); // Performance cache for path mapping
 
 function parseArgs() {
   const args = [...process.argv.slice(2)];
-  let projectPath: string | undefined;
   const entryPatterns: string[] = [];
 
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--project' || args[i] === '-p') {
-      projectPath = args[i + 1];
-      i++;
-    } else {
-      entryPatterns.push(args[i]);
-    }
+    entryPatterns.push(args[i]);
   }
 
-  return { entryPatterns, projectPath };
+  return { entryPatterns };
 }
 
 function isRuntimeImport(node: ts.ImportDeclaration | ts.ExportDeclaration): boolean {
@@ -40,12 +35,17 @@ function isRuntimeImport(node: ts.ImportDeclaration | ts.ExportDeclaration): boo
   }
 
   if (ts.isImportDeclaration(node)) {
-    if (!node.importClause) return true;
-    if (node.importClause.phaseModifier) return false;
+    if (node.importClause?.phaseModifier) return false;
+    if (!node.importClause) return true; // Side-effect import
+
+    if (node.importClause.name) return true; // Default import present
 
     const namedBindings = node.importClause.namedBindings;
-    if (namedBindings && ts.isNamedImports(namedBindings)) {
-      return !namedBindings.elements.every((el) => el.isTypeOnly);
+    if (namedBindings) {
+      if (ts.isNamespaceImport(namedBindings)) return true;
+      if (ts.isNamedImports(namedBindings)) {
+        return !namedBindings.elements.every((el) => el.isTypeOnly);
+      }
     }
     return true;
   }
@@ -55,18 +55,14 @@ function isRuntimeImport(node: ts.ImportDeclaration | ts.ExportDeclaration): boo
 
 function getCompilerOptionsForFile(filePath: string): ts.CompilerOptions {
   const currentDir = path.dirname(filePath);
-
   const cachedOptions = compilerOptionsCache.get(currentDir);
-  if (cachedOptions !== undefined) {
-    return cachedOptions;
-  }
+  if (cachedOptions !== undefined) return cachedOptions;
 
-  const configPath = ts.findConfigFile(currentDir, ts.sys.fileExists, 'tsconfig.json') || globalProjectPath;
+  const configPath = ts.findConfigFile(currentDir, ts.sys.fileExists, 'tsconfig.json');
 
   if (configPath) {
     const resolvedConfigPath = path.resolve(configPath);
     const configDir = path.dirname(resolvedConfigPath);
-
     const cachedConfig = compilerOptionsCache.get(resolvedConfigPath);
     if (cachedConfig !== undefined) {
       compilerOptionsCache.set(currentDir, cachedConfig);
@@ -77,7 +73,6 @@ function getCompilerOptionsForFile(filePath: string): ts.CompilerOptions {
       const configFile = ts.readConfigFile(resolvedConfigPath, ts.sys.readFile);
       const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, configDir);
       const options = parsedConfig.options || {};
-
       compilerOptionsCache.set(resolvedConfigPath, options);
       compilerOptionsCache.set(currentDir, options);
       return options;
@@ -89,54 +84,78 @@ function getCompilerOptionsForFile(filePath: string): ts.CompilerOptions {
   return {};
 }
 
-function getPackageMeta(filePath: string) {
-  let currentDir = path.dirname(filePath);
-  const visitedDirs: string[] = [];
+/**
+ * Universal resolution engine: safely maps compiled assets (.js, .d.ts) back to source files (.ts)
+ * Works flawlessly for standalone packages, polyrepos, and complex monorepos alike.
+ */
+function convertToSourcePath(resolvedPath: string): string {
+  // If it's already a source file and not trapped inside a known build directory, return it directly
+  if (/\.(ts|tsx|mts|cts)$/.test(resolvedPath) && !/[\\/](dist|build|lib|out|cjs|esm|bin)[\\/]/i.test(resolvedPath)) {
+    return resolvedPath;
+  }
+
+  const extensions = ['.ts', '.tsx', '.mts', '.cts'];
+
+  // Strip execution/declaration extensions to get the base file signature
+  let baseName = resolvedPath;
+  if (baseName.endsWith('.d.ts')) baseName = baseName.slice(0, -5);
+  else if (baseName.endsWith('.d.mts')) baseName = baseName.slice(0, -6);
+  else if (baseName.endsWith('.d.cts')) baseName = baseName.slice(0, -6);
+  else if (baseName.endsWith('.js')) baseName = baseName.slice(0, -3);
+  else if (baseName.endsWith('.mjs')) baseName = baseName.slice(0, -4);
+  else if (baseName.endsWith('.cjs')) baseName = baseName.slice(0, -4);
+  else if (baseName.endsWith('.jsx')) baseName = baseName.slice(0, -4);
+
+  // Strategy 1: Direct Extension Swap (In-place builds or matching structures)
+  for (const ext of extensions) {
+    if (fs.existsSync(baseName + ext)) return baseName + ext;
+  }
 
-  while (currentDir && currentDir !== path.parse(currentDir).root) {
-    const cached = packageMetaCache.get(currentDir);
-    if (cached !== undefined) {
-      for (const d of visitedDirs) packageMetaCache.set(d, cached);
-      return cached;
+  // Strategy 2: Adaptive Path Segment Replacement (Remaps build directories to source directories)
+  const buildDirs = ['dist', 'build', 'lib', 'out', 'cjs', 'esm', 'bin'];
+  const srcDirs = ['src', 'source', '.']; // '.' fallback for flat root architectures
+
+  for (const bDir of buildDirs) {
+    const regex = new RegExp(`([\\\\/])${bDir}([\\\\/])`, 'i');
+    if (regex.test(baseName)) {
+      for (const sDir of srcDirs) {
+        // Skip illegal mappings that loop 'lib' back onto 'lib'
+        if (bDir.toLowerCase() === sDir.toLowerCase()) continue;
+
+        const replacedBase = baseName.replace(regex, `$1${sDir}$2`);
+        for (const ext of extensions) {
+          if (fs.existsSync(replacedBase + ext)) return replacedBase + ext;
+        }
+      }
     }
+  }
 
-    const pkgJsonPath = path.join(currentDir, 'package.json');
-    if (fs.existsSync(pkgJsonPath)) {
-      try {
-        const content = fs.readFileSync(pkgJsonPath, 'utf8');
-        const pkg = JSON.parse(content);
-
-        let outDirName = 'dist';
-        const mainField = pkg.main || pkg.types || pkg.typings || '';
-        if (mainField) {
-          const parts = path.normalize(mainField).split(path.sep);
-          if (parts.length > 1 && parts[0] !== '.' && parts[0] !== '..') {
-            outDirName = parts[0];
-          } else if (parts.length > 2 && (parts[0] === '.' || parts[0] === '..')) {
-            outDirName = parts[1];
+  // Strategy 3: Boundary-driven subpath mapping via closest package.json
+  let currentDir = path.dirname(resolvedPath);
+  while (currentDir && currentDir !== path.parse(currentDir).root) {
+    if (fs.existsSync(path.join(currentDir, 'package.json'))) {
+      for (const sDir of ['src', 'source']) {
+        const srcDirPath = path.join(currentDir, sDir);
+        if (fs.existsSync(srcDirPath)) {
+          const relativeToPackage = path.relative(currentDir, baseName);
+          const pathParts = relativeToPackage.split(path.sep);
+
+          if (pathParts.length > 1) {
+            // Drop the first segment (which is the output folder like 'dist' or 'lib')
+            const subPath = pathParts.slice(1).join(path.sep);
+            for (const ext of extensions) {
+              const targetFile = path.join(srcDirPath, subPath + ext);
+              if (fs.existsSync(targetFile)) return targetFile;
+            }
           }
         }
-
-        let srcDirName = 'src';
-        if (fs.existsSync(path.join(currentDir, 'source'))) srcDirName = 'source';
-        else if (fs.existsSync(path.join(currentDir, 'lib'))) srcDirName = 'lib';
-
-        const meta = { pkgDir: currentDir, srcDirName, outDirName };
-        packageMetaCache.set(currentDir, meta);
-        for (const d of visitedDirs) packageMetaCache.set(d, meta);
-        return meta;
-      } catch {
-        packageMetaCache.set(currentDir, null);
-        for (const d of visitedDirs) packageMetaCache.set(d, null);
-        return null;
       }
+      break;
     }
-
-    visitedDirs.push(currentDir);
     currentDir = path.dirname(currentDir);
   }
 
-  return null;
+  return resolvedPath;
 }
 
 function resolveModule(moduleName: string, containingFile: string, options: ts.CompilerOptions): string | null {
@@ -145,47 +164,20 @@ function resolveModule(moduleName: string, containingFile: string, options: ts.C
 
   const resolvedFileName = path.resolve(result.resolvedModule.resolvedFileName);
 
-  if (resolvedFileName.includes(`${path.sep}node_modules${path.sep}`)) {
-    return null;
-  }
-
-  const meta = getPackageMeta(resolvedFileName);
-  if (meta) {
-    const { pkgDir, srcDirName, outDirName } = meta;
-    const srcDirPath = path.join(pkgDir, srcDirName);
-
-    if (resolvedFileName.startsWith(srcDirPath + path.sep)) {
-      return resolvedFileName;
-    }
-
-    const outDirPath = path.join(pkgDir, outDirName);
-    if (resolvedFileName.startsWith(outDirPath + path.sep) || resolvedFileName === outDirPath) {
-      const relativeToOut = path.relative(outDirPath, resolvedFileName);
-      let baseName = relativeToOut;
-
-      if (baseName.endsWith('.d.ts')) baseName = baseName.slice(0, -5);
-      else if (baseName.endsWith('.d.mts')) baseName = baseName.slice(0, -6);
-      else if (baseName.endsWith('.d.cts')) baseName = baseName.slice(0, -6);
-      else if (baseName.endsWith('.js')) baseName = baseName.slice(0, -3);
-      else if (baseName.endsWith('.mjs')) baseName = baseName.slice(0, -4);
-      else if (baseName.endsWith('.cjs')) baseName = baseName.slice(0, -4);
-      else if (baseName.endsWith('.jsx')) baseName = baseName.slice(0, -4);
-
-      const extensions = ['.ts', '.tsx', '.mts', '.cts'];
-      for (const ext of extensions) {
-        const targetSrcFile = path.join(srcDirPath, baseName + ext);
-        if (fs.existsSync(targetSrcFile)) {
-          return targetSrcFile;
-        }
-      }
-    }
+  // Run universal mapping first
+  let sourcePath = resolvedSourceCache.get(resolvedFileName);
+  if (!sourcePath) {
+    sourcePath = convertToSourcePath(resolvedFileName);
+    resolvedSourceCache.set(resolvedFileName, sourcePath);
   }
 
-  if (result.resolvedModule.isExternalLibraryImport) {
+  // Safety filter: Ignore true external node_modules.
+  // Symlinked monorepo packages will successfully map to their local paths above and bypass this check.
+  if (sourcePath.includes(`${path.sep}node_modules${path.sep}`)) {
     return null;
   }
 
-  return resolvedFileName;
+  return result.resolvedModule.isExternalLibraryImport ? null : sourcePath;
 }
 
 function getCanonicalCycleKey(cycle: string[]): string {
@@ -194,9 +186,7 @@ function getCanonicalCycleKey(cycle: string[]): string {
 
   let minIdx = 0;
   for (let i = 1; i < nodes.length; i++) {
-    if (nodes[i] < nodes[minIdx]) {
-      minIdx = i;
-    }
+    if (nodes[i] < nodes[minIdx]) minIdx = i;
   }
 
   const rotated = [...nodes.slice(minIdx), ...nodes.slice(0, minIdx)];
@@ -209,8 +199,14 @@ function parseFile(filePath: string) {
   graph.set(filePath, []);
 
   const options = getCompilerOptionsForFile(filePath);
-  const content = fs.readFileSync(filePath, 'utf8');
-  const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+
+  let sourceFile = sourceFileCache.get(filePath);
+  if (!sourceFile) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    sourceFileCache.set(filePath, sourceFile);
+  }
+
   const imports: string[] = [];
 
   function walk(node: ts.Node) {
@@ -232,17 +228,93 @@ function parseFile(filePath: string) {
   for (const dep of imports) parseFile(dep);
 }
 
-/**
- * Checks if a specific file import creates an immediate execution (top-level) risk.
- */
+function getExportedHoistedFunctions(filePath: string): Set<string> {
+  if (exportedHoistedFunctionsCache.has(filePath)) {
+    return exportedHoistedFunctionsCache.get(filePath)!;
+  }
+
+  const hoisted = new Set<string>();
+  if (!fs.existsSync(filePath)) {
+    exportedHoistedFunctionsCache.set(filePath, hoisted);
+    return hoisted;
+  }
+
+  let sourceFile = sourceFileCache.get(filePath);
+  if (!sourceFile) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+      sourceFileCache.set(filePath, sourceFile);
+    } catch {
+      exportedHoistedFunctionsCache.set(filePath, hoisted);
+      return hoisted;
+    }
+  }
+
+  const localHoistedFuncs = new Set<string>();
+
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement)) {
+      if (statement.name) {
+        localHoistedFuncs.add(statement.name.text);
+      }
+      const hasExport = statement.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      const hasDefault = statement.modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+
+      if (hasExport) {
+        if (hasDefault) hoisted.add('default');
+        else if (statement.name) hoisted.add(statement.name.text);
+      }
+    }
+  }
+
+  for (const statement of sourceFile.statements) {
+    if (ts.isExportDeclaration(statement)) {
+      if (!statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        for (const el of statement.exportClause.elements) {
+          const localName = el.propertyName ? el.propertyName.text : el.name.text;
+          const exportedName = el.name.text;
+          if (localHoistedFuncs.has(localName)) {
+            hoisted.add(exportedName);
+          }
+        }
+      }
+    } else if (ts.isExportAssignment(statement)) {
+      if (!statement.isExportEquals && ts.isIdentifier(statement.expression)) {
+        if (localHoistedFuncs.has(statement.expression.text)) {
+          hoisted.add('default');
+        }
+      }
+    }
+  }
+
+  exportedHoistedFunctionsCache.set(filePath, hoisted);
+  return hoisted;
+}
+
 function hasTopLevelUsage(fromFile: string, toFile: string): boolean {
   if (!fs.existsSync(fromFile)) return false;
 
+  const cacheKey = `${fromFile}-->${toFile}`;
+  if (topLevelUsageCache.has(cacheKey)) return topLevelUsageCache.get(cacheKey)!;
+
   const options = getCompilerOptionsForFile(fromFile);
-  const content = fs.readFileSync(fromFile, 'utf8');
-  const sourceFile = ts.createSourceFile(fromFile, content, ts.ScriptTarget.Latest, true);
 
-  const importedSymbols = new Set<string>();
+  let sourceFile = sourceFileCache.get(fromFile);
+  if (!sourceFile) {
+    try {
+      const content = fs.readFileSync(fromFile, 'utf8');
+      sourceFile = ts.createSourceFile(fromFile, content, ts.ScriptTarget.Latest, true);
+      sourceFileCache.set(fromFile, sourceFile);
+    } catch {
+      topLevelUsageCache.set(cacheKey, false);
+      return false;
+    }
+  }
+
+  const hoistedExports = getExportedHoistedFunctions(toFile);
+  const localToExportedName = new Map<string, string>();
+  let namespaceImportName: string | null = null;
   let hasSideEffectOrReExport = false;
 
   function findImports(node: ts.Node) {
@@ -254,13 +326,18 @@ function hasTopLevelUsage(fromFile: string, toFile: string): boolean {
           if (resolved === toFile) {
             if (ts.isImportDeclaration(node) && node.importClause) {
               const clause = node.importClause;
-              if (clause.name) importedSymbols.add(clause.name.text);
+              if (clause.name) {
+                localToExportedName.set(clause.name.text, 'default');
+              }
               if (clause.namedBindings) {
                 if (ts.isNamespaceImport(clause.namedBindings)) {
-                  importedSymbols.add(clause.namedBindings.name.text);
+                  namespaceImportName = clause.namedBindings.name.text;
                 } else if (ts.isNamedImports(clause.namedBindings)) {
                   for (const el of clause.namedBindings.elements) {
-                    importedSymbols.add(el.name.text);
+                    if (el.isTypeOnly) continue;
+
+                    const exportedName = el.propertyName ? el.propertyName.text : el.name.text;
+                    localToExportedName.set(el.name.text, exportedName);
                   }
                 }
               }
@@ -276,8 +353,14 @@ function hasTopLevelUsage(fromFile: string, toFile: string): boolean {
 
   findImports(sourceFile);
 
-  if (hasSideEffectOrReExport) return true;
-  if (importedSymbols.size === 0) return false;
+  if (hasSideEffectOrReExport) {
+    topLevelUsageCache.set(cacheKey, true);
+    return true;
+  }
+  if (localToExportedName.size === 0 && !namespaceImportName) {
+    topLevelUsageCache.set(cacheKey, false);
+    return false;
+  }
 
   let dangerousTopLevelUsage = false;
 
@@ -299,41 +382,67 @@ function hasTopLevelUsage(fromFile: string, toFile: string): boolean {
     }
 
     if (ts.isPropertyDeclaration(node)) {
-      const isStatic = node.modifiers?.some(m => m.kind === ts.SyntaxKind.StaticKeyword);
-      if (!isStatic) {
-        currentScopeLazy = true; 
-      }
+      const isStatic = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
+      if (!isStatic) currentScopeLazy = true;
     }
 
     if (!currentScopeLazy && ts.isIdentifier(node)) {
-      if (importedSymbols.has(node.text)) {
+      const isImportedSymbol = localToExportedName.has(node.text);
+      const isNamespaceReference = namespaceImportName && node.text === namespaceImportName;
+
+      if (isImportedSymbol || isNamespaceReference) {
         const parent = node.parent;
-        
-        const isImportDeclarationRef = 
-          ts.isImportSpecifier(parent) || 
-          ts.isImportClause(parent) || 
-          ts.isNamespaceImport(parent);
-
-        if (!isImportDeclarationRef) {
-          let isInTypeContext = false;
-          let checkParent: ts.Node | undefined = parent;
-          while (checkParent && checkParent !== sourceFile) {
-            if (
-              ts.isTypeNode(checkParent) || 
-              ts.isTypeReferenceNode(checkParent) || 
-              ts.isTypeAliasDeclaration(checkParent) || 
-              ts.isInterfaceDeclaration(checkParent)
-            ) {
-              isInTypeContext = true;
-              break;
-            }
-            checkParent = checkParent.parent;
+
+        const isImportOrExportDeclarationRef =
+          ts.isImportSpecifier(parent) ||
+          ts.isImportClause(parent) ||
+          ts.isNamespaceImport(parent) ||
+          ts.isExportSpecifier(parent);
+
+        if (isImportOrExportDeclarationRef) return;
+        if (ts.isPropertyAccessExpression(parent) && parent.name === node) return;
+        if (ts.isPropertyAssignment(parent) && parent.name === node) return;
+        if (
+          (ts.isMethodDeclaration(parent) ||
+            ts.isPropertyDeclaration(parent) ||
+            ts.isClassDeclaration(parent) ||
+            ts.isInterfaceDeclaration(parent) ||
+            ts.isFunctionDeclaration(parent)) &&
+          parent.name === node
+        ) {
+          return;
+        }
+
+        if (isImportedSymbol) {
+          const exportedName = localToExportedName.get(node.text)!;
+          if (hoistedExports.has(exportedName)) return;
+        }
+
+        if (isNamespaceReference) {
+          if (ts.isPropertyAccessExpression(parent) && parent.expression === node) {
+            const propName = parent.name.text;
+            if (hoistedExports.has(propName)) return;
           }
+        }
 
-          if (!isInTypeContext) {
-            dangerousTopLevelUsage = true;
-            return;
+        let isInTypeContext = false;
+        let checkParent: ts.Node | undefined = parent;
+        while (checkParent && checkParent !== sourceFile) {
+          if (
+            ts.isTypeNode(checkParent) ||
+            ts.isTypeReferenceNode(checkParent) ||
+            ts.isTypeAliasDeclaration(checkParent) ||
+            ts.isInterfaceDeclaration(checkParent)
+          ) {
+            isInTypeContext = true;
+            break;
           }
+          checkParent = checkParent.parent;
+        }
+
+        if (!isInTypeContext) {
+          dangerousTopLevelUsage = true;
+          return;
         }
       }
     }
@@ -342,6 +451,7 @@ function hasTopLevelUsage(fromFile: string, toFile: string): boolean {
   }
 
   checkNodeUsage(sourceFile, false);
+  topLevelUsageCache.set(cacheKey, dangerousTopLevelUsage);
   return dangerousTopLevelUsage;
 }
 
@@ -356,16 +466,13 @@ function canReach(start: string, target: string): boolean {
     seen.add(current);
 
     const deps = graph.get(current) || [];
-    for (const dep of deps) {
-      stack.push(dep);
-    }
+    for (const dep of deps) stack.push(dep);
   }
   return false;
 }
 
 function main() {
-  const { entryPatterns, projectPath } = parseArgs();
-  globalProjectPath = projectPath;
+  const { entryPatterns } = parseArgs();
 
   if (entryPatterns.length === 0) {
     console.error('❌ Error: Please specify at least one entry point or glob pattern.');
@@ -432,36 +539,27 @@ function main() {
   }
 
   for (const entryPoint of entryPoints) {
-    if (!visited.has(entryPoint)) {
-      findCycles(entryPoint);
-    }
+    if (!visited.has(entryPoint)) findCycles(entryPoint);
   }
 
   const criticalCycles: string[][] = [];
 
   for (const cycle of allUniqueCycles) {
     let isHarmfulCycle = false;
-
     for (let i = 0; i < cycle.length - 1; i++) {
       if (hasTopLevelUsage(cycle[i], cycle[i + 1])) {
         isHarmfulCycle = true;
         break;
       }
     }
-
-    if (isHarmfulCycle) {
-      criticalCycles.push(cycle);
-    }
+    if (isHarmfulCycle) criticalCycles.push(cycle);
   }
 
   const entryPointCycles = new Map<string, string[][]>();
-  for (const ep of entryPoints) {
-    entryPointCycles.set(ep, []);
-  }
+  for (const ep of entryPoints) entryPointCycles.set(ep, []);
 
   for (const cycle of criticalCycles) {
     const firstFile = cycle[0];
-
     const matchedEp = entryPoints.find((ep) => {
       const epDir = path.dirname(ep);
       return firstFile.startsWith(epDir + path.sep) || firstFile === ep;
@@ -471,15 +569,11 @@ function main() {
       entryPointCycles.get(matchedEp)!.push(cycle);
     } else {
       const reachingEp = entryPoints.find((ep) => canReach(ep, firstFile));
-      if (reachingEp) {
-        entryPointCycles.get(reachingEp)!.push(cycle);
-      } else {
-        entryPointCycles.get(entryPoints[0])!.push(cycle);
-      }
+      if (reachingEp) entryPointCycles.get(reachingEp)!.push(cycle);
+      else entryPointCycles.get(entryPoints[0])!.push(cycle);
     }
   }
 
-  // Phase 4: Output the clean, perfectly targeted report
   let globalHasCycles = false;
 
   for (const entryPoint of entryPoints) {
@@ -489,14 +583,12 @@ function main() {
     if (cycles.length > 0) {
       globalHasCycles = true;
       console.error(`❌ ${absoluteEntry} — Found ${cycles.length} critical circular dependencies:`);
-      
+
       cycles.forEach((cycle, index) => {
         console.error(`  ${index + 1})`, '-'.repeat(80));
-        
         for (let i = 1; i < cycle.length; i++) {
-          const nextFile = (i === cycle.length - 1) ? cycle[1] : cycle[i + 1];
+          const nextFile = i === cycle.length - 1 ? cycle[1] : cycle[i + 1];
           const isTopLevel = hasTopLevelUsage(cycle[i], nextFile);
-          
           const prefix = isTopLevel ? '  💥 [Top-level] ' : '  ⏳ [Lazy]      ';
           console.error(`${prefix}${path.resolve(cycle[i])}`);
         }