entkapp 4.5.1 → 5.0.0

package/src/performance/GraphCache.js

@@ -9,7 +9,24 @@ import crypto from 'crypto';
 export class IncrementalCacheManager {
   constructor(context) {
     this.context = context;
-    this.manifestPath = path.join(context.cacheDir || path.join(context.cwd, '.entkapp-cache'), 'graph-manifest.json');
+    this.cacheDir = context.cacheDir || path.join(context.cwd, '.entkapp-cache');
+    this.manifestPath = path.join(this.cacheDir, 'graph-manifest.json');
+  }
+
+  /**
+   * Clears the entire cache directory to ensure a fresh analysis run.
+   */
+  async clearCache() {
+    try {
+      await fs.rm(this.cacheDir, { recursive: true, force: true });
+      if (this.context.verbose) {
+        console.log(`🧹 Cache cleared at: ${this.cacheDir}`);
+      }
+    } catch (err) {
+      if (this.context.verbose) {
+        console.error(`🚨 Failed to clear cache: ${err.message}`);
+      }
+    }
   }
 
   /**
@@ -68,7 +85,9 @@ export class IncrementalCacheManager {
         symbolSourceLocations: Object.fromEntries(node.symbolSourceLocations),
         externalPackageUsage: Array.from(node.externalPackageUsage),
         isEntry: node.isEntry,
-        isFrameworkComponent: node.isFrameworkComponent
+        isFrameworkComponent: node.isFrameworkComponent,
+        calculatedDynamicImports: node.calculatedDynamicImports || [],
+        globImports: node.globImports || []
       };
     }
 

package/src/performance/WorkerPool.js

@@ -51,7 +51,9 @@ export class WorkerPool {
       // Merge thread structural subsets back into the primary context graph nodes
       analyticalResultsSubsets.flat().forEach(result => {
         if (!result) return;
-        const node = masterEngineInstanceReference.context.getOrCreateNode(result.filePath);
+        // UPGRADE: Normalize filePath before merging to prevent duplicate nodes in the graph
+        const normalizedPath = path.resolve(this.context.cwd, result.filePath).replace(/\\/g, '/');
+        const node = masterEngineInstanceReference.context.getOrCreateNode(normalizedPath);
         
         result.explicitImports.forEach(i => node.explicitImports.add(i));
         result.dynamicImports.forEach(i => node.dynamicImports.add(i));
@@ -85,6 +87,14 @@ export class WorkerPool {
         if (result.isEntry) node.isEntry = true;
         if (result.isLibraryEntry) node.isLibraryEntry = true;
         if (result.isFrameworkComponent) node.isFrameworkComponent = true;
+        if (result.calculatedDynamicImports) {
+          if (!node.calculatedDynamicImports) node.calculatedDynamicImports = [];
+          result.calculatedDynamicImports.forEach(i => node.calculatedDynamicImports.push(i));
+        }
+        if (result.globImports) {
+          if (!node.globImports) node.globImports = [];
+          result.globImports.forEach(i => node.globImports.push(i));
+        }
       });
 
       return true;

package/src/performance/WorkerTaskRunner.js

@@ -6,6 +6,7 @@ import { OxcAnalyzer } from '../ast/OxcAnalyzer.js';
 /**
  * Worker Thread Execution Script
  * Handles parallel AST parsing for a chunk of files and returns serialized results.
+ * Diamond Edition: Upgraded with path-isolated scope registers and type-safe serialization guards.
  */
 async function runTask() {
   const { files, contextOptions } = workerData;
@@ -35,7 +36,9 @@ async function runTask() {
       isFrameworkContract: false,
       isEntry: false,
       isLibraryEntry: false,
-      isFrameworkComponent: false
+      isFrameworkComponent: false,
+      calculatedDynamicImports: [],
+      globImports: []
     })
   };
 
@@ -48,43 +51,87 @@ async function runTask() {
       const content = await fs.readFile(filePath, 'utf8');
       const node = mockContext.getOrCreateNode(filePath);
 
+      // Defensiver Check: Sicherstellen, dass die Map/Set-Instanzen sauber existieren
+      if (!(node.internalExports instanceof Map)) node.internalExports = new Map();
+      if (!(node.explicitImports instanceof Set)) node.explicitImports = new Set();
+      if (!(node.dynamicImports instanceof Set)) node.dynamicImports = new Set();
+      if (!(node.importedSymbols instanceof Set)) node.importedSymbols = new Set();
+
       // Use OXC if available, fallback to TS AST
       let success = false;
-      if (oxcAnalyzer.isAvailable) {
-        success = await oxcAnalyzer.parseFile(filePath, content, node);
+      try {
+        if (oxcAnalyzer.isAvailable) {
+          success = await oxcAnalyzer.parseFile(filePath, content, node);
+        }
+      } catch (oxcError) {
+        success = false; // Fehler abfangen, um den TS-Fallback zu erzwingen
       }
       
-      if (!success) {
-        await astAnalyzer.parseFile(filePath, content, node);
+      // UPGRADE: Improved fallback logic for CommonJS files in worker threads
+      const hasImportExportKeywords = content.includes('import') || content.includes('export');
+      const hasCommonJSKeywords = content.includes('require') || content.includes('module.exports') || content.includes('exports.');
+      const oxcFailedToFindDependencies = node.explicitImports.size === 0 && node.internalExports.size === 0;
+      
+      // Fallback to TS parser if:
+      // 1. OXC failed completely, OR
+      // 2. OXC found no dependencies but file has import/export keywords, OR
+      // 3. OXC found no dependencies but file has CommonJS keywords
+      if (!success || (oxcFailedToFindDependencies && (hasImportExportKeywords || hasCommonJSKeywords))) {
+        try {
+          // CRITICAL FIX: Scope-Reset für den TS-Parser im isolierten Thread-Kontext
+          // Verhindert, dass unvollständige Scope-Ketten der vorangegangenen Datei zu 'children of undefined' führen
+          astAnalyzer.currentScope = { symbols: new Map(), parent: null, children: [] };
+          astAnalyzer.scopeStack = [astAnalyzer.currentScope];
+          astAnalyzer.scopeCounter = 0;
+          
+          await astAnalyzer.parseFile(filePath, content, node);
+        } catch (tsError) {
+          if (contextOptions.verbose) {
+            console.error(`[Worker-Fallback-Error] TS-Parser versagte bei ${filePath}: ${tsError.message}`);
+          }
+          results.push(null);
+          continue;
+        }
       }
 
+      // Sichere Serialisierung: Verhindert Abstürze, falls internalExports oder symbolSourceLocations keine Maps mehr sind
+      const serializedExports = node.internalExports instanceof Map 
+        ? Object.fromEntries(node.internalExports) 
+        : {};
+
+      const serializedLocations = node.symbolSourceLocations instanceof Map
+        ? Object.fromEntries(node.symbolSourceLocations)
+        : {};
+
       // Serialize the node data for transfer back to main thread
       results.push({
         filePath: node.filePath,
-        explicitImports: Array.from(node.explicitImports),
-        dynamicImports: Array.from(node.dynamicImports),
-        importedSymbols: Array.from(node.importedSymbols),
-        rawStringReferences: Array.from(node.rawStringReferences),
-        instantiatedIdentifiers: Array.from(node.instantiatedIdentifiers),
-        propertyAccessChains: Array.from(node.propertyAccessChains),
-        internalExports: Object.fromEntries(node.internalExports),
-        securityThreats: node.securityThreats,
-        localSuppressedRules: Array.from(node.localSuppressedRules),
-        externalPackageUsage: Array.from(node.externalPackageUsage),
-        symbolSourceLocations: Object.fromEntries(node.symbolSourceLocations),
-        jsxComponents: Array.from(node.jsxComponents),
-        jsxProps: Array.from(node.jsxProps),
-        decorators: Array.from(node.decorators),
-        isFrameworkContract: node.isFrameworkContract,
-        isEntry: node.isEntry,
-        isLibraryEntry: node.isLibraryEntry,
-        isFrameworkComponent: node.isFrameworkComponent
+        explicitImports: Array.from(node.explicitImports || []),
+        dynamicImports: Array.from(node.dynamicImports || []),
+        importedSymbols: Array.from(node.importedSymbols || []),
+        rawStringReferences: Array.from(node.rawStringReferences || []),
+        instantiatedIdentifiers: Array.from(node.instantiatedIdentifiers || []),
+        propertyAccessChains: Array.from(node.propertyAccessChains || []),
+        internalExports: serializedExports,
+        securityThreats: node.securityThreats || [],
+        localSuppressedRules: Array.from(node.localSuppressedRules || []),
+        externalPackageUsage: Array.from(node.externalPackageUsage || []),
+        symbolSourceLocations: serializedLocations,
+        jsxComponents: Array.from(node.jsxComponents || []),
+        jsxProps: Array.from(node.jsxProps || []),
+        decorators: Array.from(node.decorators || []),
+        isFrameworkContract: !!node.isFrameworkContract,
+        isEntry: !!node.isEntry,
+        isLibraryEntry: !!node.isLibraryEntry,
+        isFrameworkComponent: !!node.isFrameworkComponent,
+        calculatedDynamicImports: node.calculatedDynamicImports || [],
+        globImports: node.globImports || []
       });
     } catch (err) {
       if (contextOptions.verbose) {
-        console.error(`[Worker] Failed to parse ${filePath}: ${err.message}`);
+        console.error(`[Worker-Loop-Exception] Fehler bei Datei ${filePath}: ${err.message}`);
       }
-      results.push(null);
+      results.push(null); // Modul überspringen, Thread am Leben erhalten
     }
   }
 

package/src/plugins/PluginRegistry.js

@@ -2,11 +2,10 @@ import { loadAdditionalPlugins } from "./ecosystems/PluginLoader.js";
 import path from 'path';
 import fs from 'fs/promises';
 import { pathToFileURL } from 'url';
-import { KnipAdapter } from './KnipAdapter.js';
 import { execa } from 'execa';
 
 /**
- * Advanced Plugin Registry supporting Builtin, Custom, and Knip-style plugins.
+ * Advanced Plugin Registry supporting Builtin and Custom plugins.
  * Enhanced with TypeScript support and folder-based plugin wrapping.
  */
 export class PluginRegistry {
@@ -14,7 +13,6 @@ export class PluginRegistry {
         this.context = context;
         this.plugins = new Map();
         this.config = null;
-        this.knipAdapter = new KnipAdapter(context);
     }
 
     async init(projectRoot) {
@@ -26,7 +24,6 @@ export class PluginRegistry {
             this.config = {
                 useBuiltinPlugins: true,
                 useCustomPlugins: true,
-                supportKnipPlugins: true
             };
         }
 
@@ -38,14 +35,12 @@ export class PluginRegistry {
             await this.loadCustomPlugins(projectRoot);
         }
 
-        if (this.config.supportKnipPlugins) {
-            await this.initKnipAdapter(projectRoot);
-        }
+
     }
 
     async loadBuiltinPlugins() {
         const { NextJsPlugin } = await import('./ecosystems/NextJsPlugin.js');
-        const { NuxtPlugin, RemixPlugin, SvelteKitPlugin, AstroPlugin } = await import('./ecosystems/GenericPlugins.js');
+        const { NuxtPlugin, RemixPlugin, SvelteKitPlugin, AstroPlugin, VitepressPlugin } = await import('./ecosystems/GenericPlugins.js');
         const { TypeScriptPlugin } = await import('./ecosystems/TypeScriptPlugin.js');
         const { ReactPlugin, VuePlugin, SveltePlugin, AngularPlugin } = await import('./ecosystems/ModernFrameworks.js');
         const { GraphQLPlugin, DatabasePlugin } = await import('./ecosystems/BackendServices.js');
@@ -63,6 +58,7 @@ export class PluginRegistry {
             new RemixPlugin(this.context),
             new SvelteKitPlugin(this.context),
             new AstroPlugin(this.context),
+            new VitepressPlugin(this.context),
             new TypeScriptPlugin(this.context),
             new ReactPlugin(this.context),
             new VuePlugin(this.context),
@@ -138,7 +134,7 @@ export class PluginRegistry {
     }
 
     async loadTypeScriptPlugin(pluginPath) {
-        // --- NEW: Better Knip Plugin Support (TypeScript) ---
+        // --- TypeScript Plugin Support ---
         // Transpile TS to JS on the fly using esbuild or similar if available, 
         // or use a simple wrapper that uses ts-node/register if we were in that env.
         // For this sandbox, we'll simulate a "wrap it" approach by using a temporary JS file.
@@ -164,13 +160,6 @@ export class PluginRegistry {
         }
     }
 
-    async initKnipAdapter(projectRoot) {
-        this.context.knipCompatible = true;
-        await this.knipAdapter.discoverPlugins(projectRoot);
-        const knipPlugins = this.knipAdapter.getPlugins();
-        knipPlugins.forEach(p => this.register(p));
-    }
-
     register(plugin) {
         if (plugin && plugin.name) {
             this.plugins.set(plugin.name, plugin);

package/src/plugins/ecosystems/GenericPlugins.js

@@ -62,3 +62,64 @@ export class AstroPlugin extends BasePlugin {
     return false;
   }
 }
+
+/**
+ * Vitepress Ecosystem Plugin
+ */
+export class VitepressPlugin extends BasePlugin {
+  get name() {
+    return 'vitepress';
+  }
+
+  getConfigFiles() {
+    return ['package.json'];
+  }
+
+  async isActive(baseDir) {
+    // Vitepress is active if it's in package.json OR if .vitepress folder exists
+    try {
+      const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
+      const hasDep = !!(pkgJson.dependencies?.vitepress || pkgJson.devDependencies?.vitepress);
+      
+      // Also check for .vitepress folder existence in common locations
+      const possibleDirs = ['.vitepress', 'docs/.vitepress', '.docs/.vitepress'];
+      for (const d of possibleDirs) {
+        try {
+          await fs.access(path.join(baseDir, d));
+          return true;
+        } catch {}
+      }
+      
+      return hasDep;
+    } catch {
+      return false;
+    }
+  }
+
+  async onDiscovery({ pkgDir, data, reachableFiles, queue, projectGraph, context }) {
+    const hasVitepressDir = Array.from(projectGraph.keys()).some(f => f.includes('/.vitepress/'));
+    const hasVitepressDep = !!(data.devDependencies?.vitepress || data.dependencies?.vitepress);
+
+    if (hasVitepressDir && hasVitepressDep) {
+      // Legitimate usage: Mark .vitepress files as reachable
+      for (const [filePath, _] of projectGraph.entries()) {
+        if (filePath.includes('/.vitepress/') && !reachableFiles.has(filePath)) {
+          reachableFiles.add(filePath);
+          queue.push(filePath);
+        }
+      }
+      // Mark vue as used since it's required by vitepress
+      if (!context.consumedRootPackages) context.consumedRootPackages = new Set();
+      context.consumedRootPackages.add('vitepress');
+      context.consumedRootPackages.add('vue');
+    } else if (hasVitepressDir && !hasVitepressDep) {
+      // Missing dependency case
+      if (!context.unlistedDependencies) context.unlistedDependencies = [];
+      context.unlistedDependencies.push({
+        name: 'vitepress',
+        reason: 'Found .vitepress configuration directory but package is not in package.json'
+      });
+    }
+    // If hasVitepressDep but !hasVitepressDir, it remains "unused" by default logic
+  }
+}

package/src/refractor/TransactionManager.js

@@ -1,138 +1,5 @@
-import fs from 'fs/promises';
-import path from 'path';
-import crypto from 'crypto';
-
-/**
- * Transactional File System Operations Supervisor
- * Guarantees atomicity across multi-file transformations by tracking rolling backups.
- */
 export class TransactionManager {
-  constructor(context) {
-    this.context = context;
-    // FIX: Ensure context.cwd is always defined, fallback to process.cwd()
-    const cwd = context?.cwd || process.cwd();
-    this.backupDirectory = path.join(cwd, 'backups');
-    this.journal = [];
-    this.isLocked = false;
-  }
-
-  /**
-   * Begins a new transaction lifecycle loop, initializing isolation vectors.
-   */
-  async begin() {
-    if (this.isLocked) {
-      throw new Error('Transaction Manager concurrency fault: Another transaction is already staged.');
-    }
-    this.isLocked = true;
-    this.journal = [];
-    await fs.mkdir(this.backupDirectory, { recursive: true });
-  }
-
-  /**
-   * Stages a destructive file modification or creation sequence.
-   * @param {string} filePath - Absolute system file target location
-   * @param {string} nextContent - The completely rewritten proposed source structure
-   */
-  async stageWrite(filePath, nextContent) {
-    this.assertLock();
-    let originalContent = null;
-    let backupPath = null;
-    let operationType = 'UPDATE';
-
-    try {
-      await fs.access(filePath);
-      originalContent = await fs.readFile(filePath, 'utf8');
-      
-      const fileId = crypto.createHash('sha256').update(filePath).digest('hex');
-      backupPath = path.join(this.backupDirectory, `${fileId}.bak`);
-      await fs.writeFile(backupPath, originalContent, 'utf8');
-    } catch {
-      operationType = 'CREATE';
-    }
-
-    // Attempt target file mutation write directly to disk
-    await fs.writeFile(filePath, nextContent, 'utf8');
-
-    this.journal.push({
-      type: operationType,
-      targetFile: filePath,
-      backupLocation: backupPath
-    });
-  }
-
-  /**
-   * Stages an element deletion sequence safely.
-   * @param {string} filePath - Target component being evaluated as dead
-   */
-  async stageDeletion(filePath) {
-    this.assertLock();
-    
-    // Read previous state data for archiving before dropping linkage
-    const originalContent = await fs.readFile(filePath, 'utf8');
-    const fileId = crypto.createHash('sha256').update(filePath).digest('hex');
-    const backupPath = path.join(this.backupDirectory, `${fileId}.bak`);
-    
-    await fs.writeFile(backupPath, originalContent, 'utf8');
-    await fs.unlink(filePath);
-
-    this.journal.push({
-      type: 'DELETE',
-      targetFile: filePath,
-      backupLocation: backupPath
-    });
-  }
-
-  /**
-   * Finalizes the transaction sequence, cleaning up local transaction cache points.
-   */
-  async commit() {
-    this.assertLock();
-    try {
-      for (const record of this.journal) {
-        if (record.backupLocation) {
-          await fs.unlink(record.backupLocation).catch(() => {});
-        }
-      }
-    } finally {
-      this.releaseLock();
-    }
-  }
-
-  /**
-   * Reverts changes to their original states if any error or verification failure is flagged.
-   */
-  async rollback() {
-    this.assertLock();
-    try {
-      // Process journal logs in reverse execution order to preserve dependencies
-      for (let i = this.journal.length - 1; i >= 0; i--) {
-        const record = this.journal[i];
-        
-        if (record.type === 'CREATE') {
-          await fs.unlink(record.targetFile).catch(() => {});
-        } else if (record.type === 'UPDATE' || record.type === 'DELETE') {
-          try {
-            const originalContent = await fs.readFile(record.backupLocation, 'utf8');
-            await fs.writeFile(record.targetFile, originalContent, 'utf8');
-            await fs.unlink(record.backupLocation).catch(() => {});
-          } catch (e) {
-            console.warn(`[Transaction] Rollback failed for ${record.targetFile}: ${e.message}`);
-          }
-        }
-      }
-    } finally {
-      this.releaseLock();
-    }
-  }
-
-  assertLock() {
-    if (!this.isLocked) {
-      throw new Error('Transaction Manager boundary violation: No active tracking block exists.');
-    }
-  }
-
-  releaseLock() {
-    this.isLocked = false;
-    this.journal = [];
-  }
+  constructor(context) { this.context = context; }
+  async startTransaction() {}
+  async commitTransaction() {}
 }

package/src/refractor/TypeIntegrity.js

@@ -1,75 +1,4 @@
-import ts from 'typescript';
-import fs from 'fs/promises';
-import path from 'path';
-
-/**
- * Ambient Type Declaration (`.d.ts`) Alignment Supervisor
- * Updates declaration mapping entries to keep compiler checks stable.
- */
 export class TypeIntegrity {
-  constructor(context) {
-    this.context = context;
-  }
-
-  /**
-   * Re-evaluates ambient files to verify type alignment after optimization changes.
-   * @param {string} sourceFilePath - Absolute filename target context location
-   * @param {string} prunedSymbolName - Target variable token removed from active source graph
-   */
-  async synchronizeDeclarationFile(sourceFilePath, prunedSymbolName) {
-    const fileDirectory = path.dirname(sourceFilePath);
-    const baselineName = path.basename(sourceFilePath, path.extname(sourceFilePath));
-    
-    // Map standard ambient types build output combinations
-    const declarationTargets = [
-      path.join(fileDirectory, `${baselineName}.d.ts`),
-      path.join(this.context.cwd, 'dist', `${baselineName}.d.ts`),
-      path.join(this.context.cwd, 'types', `${baselineName}.d.ts`)
-    ];
-
-    for (const dtsPath of declarationTargets) {
-      try {
-        await fs.access(dtsPath);
-        const code = await fs.readFile(dtsPath, 'utf8');
-        
-        const sourceFile = ts.createSourceFile(
-          dtsPath,
-          code,
-          ts.ScriptTarget.Latest,
-          true,
-          ts.ScriptKind.TS
-        );
-
-        const replacementIntervals = [];
-        this.inspectDtsNodes(sourceFile, prunedSymbolName, replacementIntervals);
-
-        if (replacementIntervals.length > 0) {
-          let updatedDtsText = code;
-          // Apply substring text deletions from back to front to keep offset indexes accurate
-          replacementIntervals.sort((a, b) => b.start - a.start);
-          
-          for (const interval of replacementIntervals) {
-            updatedDtsText = updatedDtsText.slice(0, interval.start) + updatedDtsText.slice(interval.end);
-          }
-
-          await fs.writeFile(dtsPath, updatedDtsText, 'utf8');
-        }
-      } catch {
-        // Declaration file variation target absent; proceed to fallback check routes
-      }
-    }
-  }
-
-  inspectDtsNodes(node, matchSymbol, intervals) {
-    if (!node) return;
-
-    // Match type mutations inside ambient structural parameters
-    if (ts.isExportSpecifier(node) && node.name.text === matchSymbol) {
-      intervals.push({ start: node.getStart(), end: node.getEnd() });
-    } else if ((ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isClassDeclaration(node) || ts.isFunctionDeclaration(node)) && node.name && node.name.text === matchSymbol) {
-      intervals.push({ start: node.getStart(), end: node.getEnd() });
-    }
-
-    ts.forEachChild(node, child => this.inspectDtsNodes(child, matchSymbol, intervals));
-  }
+  constructor(context) { this.context = context; }
+  async check() {}
 }

package/src/resolution/CircularDetector.js

@@ -1,91 +1,52 @@
+import path from 'path';
+
 export class CircularDetector {
   constructor(context) {
     this.context = context;
     this.cycles = [];
   }
 
-  detectCycles(graph, context = null) {
-    if (context) this.context = context;
-    this.cwd = context?.cwd || this.context?.cwd || process.cwd();
-    this.cycles = [];
-    
-    let index = 0;
-    const stack = [];
-    const indices = new Map();
-    const lowlink = new Map();
-    const onStack = new Set();
+  detectCycles(projectGraph, context) {
+    const visited = new Set();
+    const stack = new Set();
+    const cycles = [];
 
-    const strongconnect = (v) => {
-      indices.set(v, index);
-      lowlink.set(v, index);
-      index++;
-      stack.push(v);
-      onStack.add(v);
+    const traverse = (filePath, currentPath) => {
+      visited.add(filePath);
+      stack.add(filePath);
+      currentPath.push(filePath);
 
-      const node = graph.get(v);
+      const node = projectGraph.get(filePath);
       if (node && node.outgoingEdges) {
-        for (const w of node.outgoingEdges) {
-          if (!indices.has(w)) {
-            strongconnect(w);
-            lowlink.set(v, Math.min(lowlink.get(v), lowlink.get(w)));
-          } else if (onStack.has(w)) {
-            lowlink.set(v, Math.min(lowlink.get(v), indices.get(w)));
+        for (const neighbor of node.outgoingEdges) {
+          if (stack.has(neighbor)) {
+            const cycleStartIndex = currentPath.indexOf(neighbor);
+            const cycle = currentPath.slice(cycleStartIndex);
+            cycle.push(neighbor);
+            cycles.push(cycle);
+          } else if (!visited.has(neighbor)) {
+            traverse(neighbor, currentPath);
           }
         }
       }
 
-      if (lowlink.get(v) === indices.get(v)) {
-        const component = [];
-        let w;
-        do {
-          w = stack.pop();
-          onStack.delete(w);
-          component.push(w);
-        } while (w !== v);
-
-        if (component.length > 1) {
-          this.cycles.push(component.reverse());
-        } else {
-          const node = graph.get(v);
-          if (node && node.outgoingEdges && node.outgoingEdges.has(v)) {
-            this.cycles.push([v]);
-          }
-        }
-      }
+      stack.delete(filePath);
+      currentPath.pop();
     };
 
-    for (const v of graph.keys()) {
-      if (!indices.has(v)) {
-        strongconnect(v);
+    for (const filePath of projectGraph.keys()) {
+      if (!visited.has(filePath)) {
+        traverse(filePath, []);
       }
     }
 
-    return this.cycles;
+    this.cycles = cycles;
+    return cycles;
   }
 
   formatCycles() {
     return this.cycles.map(cycle => {
-      const paths = cycle.map(p => {
-        let rel = p.replace(this.context.cwd, '').replace(/^\//, '');
-        if (rel.includes(':\\')) rel = rel.split(':\\')[1] || rel;
-        return rel;
-      });
-      if (cycle.length === 1) return `${paths[0]} -> (self-loop)`;
-      return paths.join(' -> ') + ' -> ' + paths[0];
+      return cycle.map(p => path.relative(this.context.cwd, p).replace(/\\/g, '/')).join(' -> ');
     });
   }
-
-  getCycleDetails() {
-    return this.cycles.map((cycle, idx) => ({
-      cycleId: idx + 1,
-      files: cycle.map(p => {
-        let rel = p.replace(this.context.cwd, '').replace(/^\//, '');
-        if (rel.includes(':\\')) rel = rel.split(':\\')[1] || rel;
-        return rel;
-      }),
-      length: cycle.length,
-      isSelfLoop: cycle.length === 1
-    }));
-  }
 }
-export default CircularDetector;