entkapp 4.4.1 → 4.5.0

package/src/ast/DeadCodeDetector.js

@@ -62,6 +62,11 @@ export class DeadCodeDetector {
           }
         }
 
+        // Additional check for library entries or index files
+        if (!isUsed && (node.isLibraryEntry || filePath.toLowerCase().includes('index'))) {
+          isUsed = true;
+        }
+
         if (!isUsed) {
           deadExports.push({ file: filePath, symbol: exportName, line: exportInfo.start });
         }

package/src/ast/OxcAnalyzer.js

@@ -1,3 +1,5 @@
+import path from 'path';
+
 export class OxcAnalyzer {
   constructor(context) {
     this.context = context;
@@ -8,8 +10,7 @@ export class OxcAnalyzer {
   async init() {
     if (this.isAvailable) return true;
     try {
-      const oxc = await import("oxc-parser");
-      this.oxc = oxc;
+      this.oxc = await import("oxc-parser");
       this.isAvailable = true;
       return true;
     } catch (e) {
@@ -36,42 +37,55 @@ export class OxcAnalyzer {
     }
 
     try {
-      // Fix: Ensure filePath is correctly handled for OXC (Windows path issue)
-      const normalizedPath = filePath.replace(/\\/g, '/');
+      // Fix: Remove BOM if present (confuses some Rust parsers)
+      const cleanContent = content.startsWith('\uFEFF') ? content.slice(1) : content;
       
-      // Try passing the path directly as the second argument if the object-based options fail
-      // Some versions of oxc-parser expect a string as the second argument for the filename
+      // Fix: Use absolute path with forward slashes for OXC (most stable for Rust on Windows)
+      const normalizedPath = filePath.replace(/\\/g, '/');
+      const normalizedContent = cleanContent.replace(/\/([gimuy]*)([nh]+)([gimuy]*)/g, (match, p1, p2, p3) => {
+        if (this.context.verbose) console.log(`[OXC] Normalizing regex flag: ${p2} at ${filePath}`);
+        return `/${p1}${p3}`;
+      });
       let result;
       try {
-        result = this.oxc.parseSync(content, {
-          sourceType: "module",
-          sourceFilename: normalizedPath,
-          lang: "typescript"
-        });
+        // ONLY USE FLAT SIGNATURE: parseSync(sourceText, sourceFilename)
+        // This avoids the "rust type String" conversion error seen with configuration objects.
+        result = this.oxc.parseSync(normalizedContent, normalizedPath);
       } catch (e) {
-        // Fallback for versions that expect the path as second argument
-        result = this.oxc.parseSync(content, normalizedPath);
+        // Silent fallback to TS Compiler if OXC fails
+        return false;
+      }
+
+      if (this.context.verbose) {
+        console.log(`[OXC] Parsed ${filePath} using flat signature`);
       }
 
       // Fix: Handle cases where OXC returns a JSON string instead of an object
       // Stabilize result through JSON round-trip to fix N-API conversion issues on Windows
-      let parsedResult;
+let parsedResult;
       try {
         parsedResult = typeof result === 'string' ? JSON.parse(result) : JSON.parse(JSON.stringify(result));
       } catch (err) {
-        if (typeof result === 'object') {
-          parsedResult = result; // Last resort
-        } else {
-          throw new Error("OXC returned an invalid format");
-        }
+        parsedResult = result;
+      }
+      // REPORT OXC ERRORS: If the parser found syntax errors, show them in verbose mode
+      if (this.context.verbose && parsedResult.errors && parsedResult.errors.length > 0) {
+        console.log(`[OXC] ❌ Parser reported ${parsedResult.errors.length} errors for ${normalizedPath}:`);
+        parsedResult.errors.forEach(err => console.log(`  - ${err.message || err}`));
       }
 
-      let ast;
+      let ast = (parsedResult && parsedResult.program) ? parsedResult : { program: parsedResult };
+      fileNode.ast = ast.program;
+      fileNode.jsxComponents = new Set();
+      fileNode.jsxProps = new Set();
+      fileNode.decorators = new Set();
       if (parsedResult && typeof parsedResult === 'object') {
         if (parsedResult.program) {
           ast = parsedResult;
         } else if (parsedResult.ast) {
           ast = { program: parsedResult.ast };
+        } else if (parsedResult.body || parsedResult.type === 'Program') {
+          ast = { program: parsedResult };
         } else {
           ast = { program: parsedResult };
         }
@@ -84,8 +98,45 @@ export class OxcAnalyzer {
       fileNode.jsxProps = new Set();
       fileNode.decorators = new Set();
 
+      if (this.context.verbose) {
+        console.log(`[OXC] Analyzing ${filePath}`);
+      }
       this.walkOxcAst(ast.program, fileNode, content);
       
+      // 7. Success confirmation
+      if (this.context.verbose) {
+        console.log(`[OXC] Successfully parsed and analyzed ${filePath}`);
+      }
+      // Fallback: If OXC found 0 imports but the file has content that looks like it has imports, 
+      // return false to trigger the TS Compiler API fallback. This is a safety anchor.
+      if (fileNode.explicitImports.size === 0 && (content.includes('import') || content.includes('export')) && content.length > 50) {
+        if (this.context.verbose) {
+          console.log(`[OXC] ⚠️ Parser yielded 0 imports/exports for ${filePath}. Engaging TS Compiler fallback for accuracy.`);
+          
+          // DEEP DIAGNOSTICS: Inspect the first few nodes of the AST to see what OXC is actually producing
+          if (ast.program && ast.program.body && ast.program.body.length > 0) {
+            console.log(`[OXC-DEBUG] AST Program Body Length: ${ast.program.body.length}`);
+            const firstNodes = ast.program.body.slice(0, 3).map(n => ({
+              type: n.type,
+              hasSource: !!n.source,
+              hasDeclaration: !!n.declaration,
+              specifiersCount: n.specifiers ? n.specifiers.length : 0
+            }));
+            console.log(`[OXC-DEBUG] First 3 Nodes structure: ${JSON.stringify(firstNodes, null, 2)}`);
+          } else {
+            console.log(`[OXC-DEBUG] AST Program Body is EMPTY or UNDEFINED.`);
+          }
+        }
+        return false;
+      }
+
+      if (this.context.verbose) {
+        console.log(`[OXC] Found ${fileNode.explicitImports.size} imports in ${filePath}`);
+        if (fileNode.explicitImports.size > 0) {
+          console.log(`[OXC] Imports for ${filePath}: ${Array.from(fileNode.explicitImports).join(', ')}`);
+        }
+      }
+      
       const lines = content.split('\n');
       const getLineCol = (pos) => {
         let count = 0;
@@ -154,6 +205,7 @@ export class OxcAnalyzer {
   }
 
   handleImportDeclaration(node, fileNode) {
+    if (!node.source || typeof node.source.value !== 'string') return;
     const specifier = node.source.value;
     fileNode.explicitImports.add(specifier);
 
@@ -164,8 +216,11 @@ export class OxcAnalyzer {
     if (node.specifiers) {
       node.specifiers.forEach((spec) => {
         if (spec.type === "ImportSpecifier") {
-          const importedName = spec.imported.name || (spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value);
-          fileNode.importedSymbols.add(`${specifier}:${importedName}`);
+          // In OXC, imported name can be in .imported.name or .imported.value
+          const importedName = spec.imported.name || spec.imported.value || (spec.imported.type === "Identifier" ? spec.imported.name : null);
+          if (importedName) {
+            fileNode.importedSymbols.add(`${specifier}:${importedName}`);
+          }
         } else if (spec.type === "ImportDefaultSpecifier") {
           fileNode.importedSymbols.add(`${specifier}:default`);
         } else if (spec.type === "ImportNamespaceSpecifier") {

package/src/index.js

@@ -134,7 +134,7 @@ export class RefactoringEngine {
 
       // Pass 3: Process source file tokens using high-performance concurrent workers
       let parallelParseCompleted = false;
-      if (sourceCodeFilesList.length > 10) {
+      if (sourceCodeFilesList.length > 1) {
         parallelParseCompleted = await this.workerPool.parallelAnalyzeCodebase(sourceCodeFilesList, this);
       }
 
@@ -176,9 +176,12 @@ export class RefactoringEngine {
         await this.magicDetector.injectVirtualConsumerEdges(filePath, node, activeFrameworkEcosystems);
         
         // Fix: Explicitly protect entry points defined in local configuration
+        const slashify = (p) => path.resolve(this.context.cwd, p).replace(/\\/g, '/');
         if (this.context.entryPoints && this.context.entryPoints.some(ep => {
-          const absEp = path.resolve(this.context.cwd, ep);
-          return absEp === filePath || absEp === filePath.replace(/\.[^/.]+$/, "");
+          const absEp = slashify(ep);
+          const cleanAbsEp = absEp.replace(/\.[^/.]+$/, "");
+          const cleanFilePath = slashify(filePath).replace(/\.[^/.]+$/, "");
+          return absEp === slashify(filePath) || cleanAbsEp === cleanFilePath;
         })) {
           node.isLibraryEntry = true;
         }
@@ -220,7 +223,18 @@ export class RefactoringEngine {
 
       // Pass 4: Evaluate graph edges and link connections across the codebase mesh
       console.log(ansis.dim('🔗 Linking graph edges and checking structural usage paths...'));
+      if (this.context.verbose) {
+        console.log(`[Linker] Starting dependency graph linkage for ${this.context.projectGraph.size} nodes.`);
+      }
       await this.linkDependencyGraph();
+      if (this.context.verbose) {
+        const totalEdges = Array.from(this.context.projectGraph.values()).reduce((sum, node) => sum + node.outgoingEdges.size, 0);
+        console.log(`[Linker] Completed linkage. Total edges created: ${totalEdges}`);
+      }
+
+      if (this.context.options.visualize) {
+        await this._generateVisualization(this.context.projectGraph);
+      }
 
       // NEW: Circular Dependency Detection
       console.log(ansis.dim('🔄 Detecting circular dependencies...'));
@@ -243,37 +257,37 @@ export class RefactoringEngine {
         // In a real scenario, we'd need the actual AST object here.
         const ast = fileNode.ast || {}; // Assuming AST is stored in fileNode
         this.advancedAnalysis.buildCFG(filePath, ast);
-        this.advancedAnalysis.handleComputedExports(fileNode, ast);
-        const unreachableCode = this.advancedAnalysis.analyzeReachability(filePath);
-        if (unreachableCode.length > 0) {
-          console.log(ansis.yellow(`  ⚠️ Unreachable code detected in ${path.relative(this.context.cwd, filePath)}: ${unreachableCode.length} blocks`));
-        }
-        const taintFindings = this.advancedAnalysis.performTaintAnalysis(filePath, ast);
-        if (taintFindings.length > 0) {
-          console.log(ansis.red(`  🚨 Taint violations detected in ${path.relative(this.context.cwd, filePath)}: ${taintFindings.length} findings`));
-          taintFindings.forEach(f => console.log(ansis.dim(`    • ${f.type} at ${f.file}:${f.line} (Sink: ${f.sink})`)));
-          this.context.allSecretFindings.push(...taintFindings); // Add taint findings to overall secrets
-        }
+        // this.advancedAnalysis.handleComputedExports(fileNode, ast);
+        // const unreachableCode = this.advancedAnalysis.analyzeReachability(filePath);
+        // if (unreachableCode.length > 0) {
+        //   console.log(ansis.yellow(`  ⚠️ Unreachable code detected in ${path.relative(this.context.cwd, filePath)}: ${unreachableCode.length} blocks`));
+        // }
+        // const taintFindings = this.advancedAnalysis.performTaintAnalysis(filePath, ast);
+        // if (taintFindings.length > 0) {
+        //   console.log(ansis.red(`  🚨 Taint violations detected in ${path.relative(this.context.cwd, filePath)}: ${taintFindings.length} findings`));
+        //   taintFindings.forEach(f => console.log(ansis.dim(`    • ${f.type} at ${f.file}:${f.line} (Sink: ${f.sink})`)));
+        //   this.context.allSecretFindings.push(...taintFindings); // Add taint findings to overall secrets
+        // }
 
         // Detect unused members
-        const unusedMembers = this.advancedAnalysis.detectUnusedMembers(fileNode);
-        if (unusedMembers.length > 0) {
-          console.log(ansis.yellow(`  ⚠️ Unused members detected in ${path.relative(this.context.cwd, filePath)}:`));
-          unusedMembers.forEach(m => console.log(ansis.dim(`    • ${m.member}: ${m.message}`)));
-        }
+        // const unusedMembers = this.advancedAnalysis.detectUnusedMembers(fileNode);
+        // if (unusedMembers.length > 0) {
+        //   console.log(ansis.yellow(`  ⚠️ Unused members detected in ${path.relative(this.context.cwd, filePath)}:`));
+        //   unusedMembers.forEach(m => console.log(ansis.dim(`    • ${m.member}: ${m.message}`)));
+        // }
 
         // NEW: Type-Jail Analysis
-        const typeJailViolations = this.workspaceDiagnostic.analyzeTypeJail(fileNode);
-        if (typeJailViolations.length > 0) {
-          console.log(ansis.yellow(`  ⚠️ Type-Jail violations in ${path.relative(this.context.cwd, filePath)}:`));
-          typeJailViolations.forEach(v => console.log(ansis.dim(`    • ${v.message}`)));
-        }
+        // const typeJailViolations = this.workspaceDiagnostic.analyzeTypeJail(fileNode);
+        // if (typeJailViolations.length > 0) {
+        //   console.log(ansis.yellow(`  ⚠️ Type-Jail violations in ${path.relative(this.context.cwd, filePath)}:`));
+        //   typeJailViolations.forEach(v => console.log(ansis.dim(`    • ${v.message}`)));
+        // }
 
         // NEW: Ghost Code Detection
-        const ghostExports = this.advancedAnalysis.detectGhostCode(fileNode, this.context.projectGraph);
-        if (ghostExports.length > 0) {
-          console.log(ansis.yellow(`  👻 Ghost exports detected in ${path.relative(this.context.cwd, filePath)}: [${ghostExports.join(', ')}]`));
-        }
+        // const ghostExports = this.advancedAnalysis.detectGhostCode(fileNode, this.context.projectGraph);
+        // if (ghostExports.length > 0) {
+        //   console.log(ansis.yellow(`  👻 Ghost exports detected in ${path.relative(this.context.cwd, filePath)}: [${ghostExports.join(', ')}]`));
+        // }
       }
 
       // NEW: Workspace Diagnostic & Architecture Enforcement
@@ -578,6 +592,60 @@ export class RefactoringEngine {
       }
       analysisSummary.unlistedDependencies = this.context.unlistedDependencies || [];
       
+      // NEW: Advanced Program Analysis v4.5.0 (JIT, Topology, SAST)
+      const advancedResults = this.advancedAnalysis.runAll(this.context.projectGraph, this.workspaceGraph.packageManifests);
+      
+      if (this.context.options.verbose) {
+        if (advancedResults.jitWarnings.length > 0) {
+          console.log(ansis.bold.yellow(`\n⚡ JIT Optimization Warnings (${advancedResults.jitWarnings.length}):`));
+          advancedResults.jitWarnings.forEach(w => console.log(ansis.yellow(`  • [${w.type}] ${w.message} (${w.file}:${w.line})`)));
+        }
+        if (advancedResults.securityFindings.length > 0) {
+          console.log(ansis.bold.red(`\n🛡️  Security Vulnerabilities (${advancedResults.securityFindings.length}):`));
+          advancedResults.securityFindings.forEach(w => console.log(ansis.red(`  • [${w.type}] ${w.message} (${w.file}:${w.line})`)));
+        }
+        if (advancedResults.topologyWarnings.length > 0) {
+          console.log(ansis.bold.blue(`\n🌐 Topology & Reachability Warnings (${advancedResults.topologyWarnings.length}):`));
+          advancedResults.topologyWarnings.forEach(w => console.log(ansis.blue(`  • [${w.type}] ${w.message} (${w.file})`)));
+        }
+        if (advancedResults.integrityWarnings.length > 0) {
+          console.log(ansis.bold.cyan(`\n📊 Config Integrity Checks (${advancedResults.integrityWarnings.length}):`));
+          advancedResults.integrityWarnings.forEach(w => console.log(ansis.cyan(`  • [${w.type}] ${w.message} (${w.file})`)));
+        }
+        if (advancedResults.leakWarnings.length > 0) {
+          console.log(ansis.bold.magenta(`\n💧 Event Leak Risk Analysis (${advancedResults.leakWarnings.length}):`));
+          advancedResults.leakWarnings.forEach(w => console.log(ansis.magenta(`  • [${w.type}] ${w.message} (${w.file}:${w.line})`)));
+        }
+        if (advancedResults.binaryWarnings.length > 0) {
+          console.log(ansis.bold.white(`\n🏗️  Binary Shaking Audit (${advancedResults.binaryWarnings.length}):`));
+          advancedResults.binaryWarnings.forEach(w => console.log(ansis.white(`  • [${w.type}] ${w.message} (${w.file}:${w.line})`)));
+        }
+        if (advancedResults.sandboxViolations.length > 0) {
+          console.log(ansis.bold.bgRed.white(`\n🧱 Architectural Sandbox Violations (${advancedResults.sandboxViolations.length}):`));
+          advancedResults.sandboxViolations.forEach(w => console.log(ansis.red(`  • [${w.type}] ${w.message} (${w.file})`)));
+        }
+        if (advancedResults.dereferenceWarnings.length > 0) {
+          console.log(ansis.bold.bgBlack.red(`\n💥 Guaranteed Runtime Exceptions (${advancedResults.dereferenceWarnings.length}):`));
+          advancedResults.dereferenceWarnings.forEach(w => console.log(ansis.red(`  • [${w.type}] ${w.message} (${w.file}:${w.line})`)));
+        }
+        if (advancedResults.cloneFindings.length > 0) {
+          console.log(ansis.bold.bgCyan.black(`\n👯 Structural AST Clones Detected (${advancedResults.cloneFindings.length}):`));
+          advancedResults.cloneFindings.forEach(w => console.log(ansis.cyan(`  • [${w.type}] ${w.message} (${w.file}:${w.line})`)));
+        }
+        if (advancedResults.scopeWarnings.length > 0) {
+          console.log(ansis.bold.bgGreen.black(`\n🔭 Scope Minimization Suggestions (${advancedResults.scopeWarnings.length}):`));
+          advancedResults.scopeWarnings.forEach(w => console.log(ansis.green(`  • [${w.type}] ${w.message} (${w.file}:${w.line})`)));
+        }
+        if (advancedResults.loopWarnings.length > 0) {
+          console.log(ansis.bold.bgYellow.black(`\n🔄 Infinite Execution Proofs (${advancedResults.loopWarnings.length}):`));
+          advancedResults.loopWarnings.forEach(w => console.log(ansis.yellow(`  • [${w.type}] ${w.message} (${w.file}:${w.line})`)));
+        }
+        if (advancedResults.configWarnings.length > 0) {
+          console.log(ansis.bold.bgBlue.white(`\n🧼 Configuration Sanitizer (${advancedResults.configWarnings.length}):`));
+          advancedResults.configWarnings.forEach(w => console.log(ansis.blue(`  • [${w.type}] ${w.message} (${w.file}:${w.line})`)));
+        }
+      }
+
       const cycles = cyclesResult; // Use the already detected cycles
       
       const structuralModificationsStaged = 
@@ -683,6 +751,104 @@ export class RefactoringEngine {
     }
   }
 
+  async _generateVisualization(graph) {
+    console.log(ansis.bold.green('\n🌐 [VISUALIZER] Generating Interactive Execution Graph...'));
+    
+    const nodes = [];
+    const edges = [];
+    const fileToIndex = new Map();
+    let idCounter = 1;
+
+    for (const [file, node] of graph.entries()) {
+      const relPath = path.relative(this.context.cwd, file);
+      const id = idCounter++;
+      fileToIndex.set(file, id);
+      nodes.push({
+        id,
+        label: relPath,
+        color: node.isLibraryEntry ? '#ff7675' : '#74b9ff',
+        shape: node.isLibraryEntry ? 'diamond' : 'dot',
+        size: node.isLibraryEntry ? 25 : 15
+      });
+    }
+
+    for (const [file, node] of graph.entries()) {
+      const fromId = fileToIndex.get(file);
+      node.outgoingEdges.forEach(edgeFile => {
+        const toId = fileToIndex.get(edgeFile);
+        if (toId) {
+          edges.push({ from: fromId, to: toId, arrows: 'to' });
+        }
+      });
+    }
+
+    const html = `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>entkapp Execution Graph</title>
+  <script type="text/javascript" src="https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"></script>
+  <style type="text/css">
+    body, html { margin: 0; padding: 0; width: 100%; height: 100%; overflow: hidden; background-color: #2d3436; color: #dfe6e9; font-family: sans-serif; }
+    #network { width: 100%; height: 100%; }
+    #header { position: absolute; top: 10px; left: 10px; z-index: 10; pointer-events: none; }
+    h1 { margin: 0; font-size: 1.5rem; color: #fab1a0; }
+    .legend { margin-top: 5px; font-size: 0.9rem; }
+    .legend-item { display: inline-block; margin-right: 15px; }
+    .dot { display: inline-block; width: 10px; height: 10px; border-radius: 50%; margin-right: 5px; }
+  </style>
+</head>
+<body>
+  <div id="header">
+    <h1>entkapp Execution Graph</h1>
+    <div class="legend">
+      <div class="legend-item"><span class="dot" style="background-color: #ff7675; border-radius: 0; transform: rotate(45deg);"></span> Entry Point</div>
+      <div class="legend-item"><span class="dot" style="background-color: #74b9ff;"></span> Module</div>
+    </div>
+  </div>
+  <div id="network"></div>
+  <script type="text/javascript">
+    const nodes = new vis.DataSet(${JSON.stringify(nodes)});
+    const edges = new vis.DataSet(${JSON.stringify(edges)});
+    const container = document.getElementById('network');
+    const data = { nodes, edges };
+    const options = {
+      nodes: { font: { color: '#dfe6e9', size: 14 } },
+      edges: { color: { color: '#636e72', highlight: '#fab1a0' }, width: 2 },
+      physics: {
+        forceAtlas2Based: { gravitationalConstant: -50, centralGravity: 0.01, springLength: 100, springConstant: 0.08 },
+        maxVelocity: 50,
+        solver: 'forceAtlas2Based',
+        timestep: 0.35,
+        stabilization: { iterations: 150 }
+      }
+    };
+    new vis.Network(container, data, options);
+  </script>
+</body>
+</html>`;
+
+    const http = await import('http');
+    const server = http.createServer((req, res) => {
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      res.end(html);
+    });
+
+    const port = 3000;
+    server.listen(port, () => {
+      console.log(ansis.bold.cyan(`\n🚀 Web Viewer active at: http://localhost:${port}`));
+      console.log(ansis.yellow('Press Ctrl+C to terminate the session and continue...'));
+    });
+
+    return new Promise((resolve) => {
+      process.on('SIGINT', () => {
+        server.close();
+        console.log(ansis.bold.red('\n🛑 Web Viewer stopped.'));
+        resolve();
+      });
+    });
+  }
+
   async discoverSourceFiles(dir, fileList) {
     const entries = await fs.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
@@ -702,10 +868,16 @@ export class RefactoringEngine {
 
   async linkDependencyGraph() {
     for (const [filePath, node] of this.context.projectGraph.entries()) {
+      if (this.context.verbose && node.explicitImports.size > 0) {
+        console.log(`[Linker] Linking ${node.explicitImports.size} imports from ${path.relative(this.context.cwd, filePath)}`);
+      }
       // Pass A: Link all explicit imports (static + dynamic + re-export sources)
       for (const specifier of node.explicitImports) {
         const resolvedPath = this.resolver.resolveModulePath(filePath, specifier);
         if (resolvedPath && this.context.projectGraph.has(resolvedPath)) {
+          if (this.context.verbose) {
+            console.log(`  -> Resolved ${specifier} to ${path.relative(this.context.cwd, resolvedPath)}`);
+          }
           this.context.projectGraph.get(resolvedPath).incomingEdges.add(filePath);
           node.outgoingEdges.add(resolvedPath);
           
@@ -727,10 +899,20 @@ export class RefactoringEngine {
           }
         }
       }
+      // Auto-detect root index as entry point if no entry points are defined
+      const rootIndexFiles = ['src/index.ts', 'src/index.js', 'index.ts', 'index.js'];
+      const slashify = (p) => path.resolve(this.context.cwd, p).replace(/\\/g, '/');
+      for (const indexFile of rootIndexFiles) {
+        const absIndex = slashify(indexFile);
+        if (this.context.projectGraph.has(absIndex)) {
+          this.context.projectGraph.get(absIndex).isLibraryEntry = true;
+        }
+      }
 
       // Pass B: Link named-symbol imports through barrel/re-export chains
       for (const specToken of node.importedSymbols) {
-        const delimiterIndex = specToken.indexOf(':');
+        // Fix: Use lastIndexOf for Windows paths (C:/path:symbol)
+        const delimiterIndex = specToken.lastIndexOf(':');
         if (delimiterIndex === -1) continue;
         const specifier = specToken.slice(0, delimiterIndex);
         const symbol = specToken.slice(delimiterIndex + 1);
@@ -822,5 +1004,7 @@ export class RefactoringEngine {
     if (cachedRecord.localSuppressedRules) cachedRecord.localSuppressedRules.forEach(r => node.localSuppressedRules.add(r));
     if (cachedRecord.calculatedDynamicImports) node.calculatedDynamicImports = cachedRecord.calculatedDynamicImports;
     if (cachedRecord.isLibraryEntry !== undefined) node.isLibraryEntry = cachedRecord.isLibraryEntry;
+    if (cachedRecord.isEntry !== undefined) node.isEntry = cachedRecord.isEntry;
+    if (cachedRecord.isFrameworkComponent !== undefined) node.isFrameworkComponent = cachedRecord.isFrameworkComponent;
   }
 }

package/src/performance/GraphCache.js

@@ -66,7 +66,9 @@ export class IncrementalCacheManager {
         securityThreats: node.securityThreats || [],
         localSuppressedRules: Array.from(node.localSuppressedRules),
         symbolSourceLocations: Object.fromEntries(node.symbolSourceLocations),
-        externalPackageUsage: Array.from(node.externalPackageUsage)
+        externalPackageUsage: Array.from(node.externalPackageUsage),
+        isEntry: node.isEntry,
+        isFrameworkComponent: node.isFrameworkComponent
       };
     }
 

package/src/performance/WorkerPool.js

@@ -82,6 +82,9 @@ export class WorkerPool {
         if (result.jsxProps) result.jsxProps.forEach(p => node.jsxProps.add(p));
         if (result.decorators) result.decorators.forEach(d => node.decorators.add(d));
         if (result.isFrameworkContract) node.isFrameworkContract = true;
+        if (result.isEntry) node.isEntry = true;
+        if (result.isLibraryEntry) node.isLibraryEntry = true;
+        if (result.isFrameworkComponent) node.isFrameworkComponent = true;
       });
 
       return true;
@@ -96,7 +99,13 @@ export class WorkerPool {
   executeChunkInsideThread(fileChunkSubset) {
     return new Promise((resolve, reject) => {
       const workerInstance = new Worker(this.workerScriptPath, { type: 'module',
-        workerData: { files: fileChunkSubset, contextOptions: { verbose: this.context.verbose } }
+        workerData: { 
+          files: fileChunkSubset, 
+          contextOptions: { 
+            verbose: this.context.verbose,
+            cwd: this.context.cwd
+          } 
+        }
       });
 
       workerInstance.on('message', (payload) => resolve(payload));

package/src/performance/WorkerTaskRunner.js

@@ -1,7 +1,7 @@
 import { parentPort, workerData } from 'worker_threads';
 import fs from 'fs/promises';
 import { ASTAnalyzer } from '../ast/ASTAnalyzer.js';
-import { OxcAnalyzer } from '../analyzers/OxcAnalyzer.js';
+import { OxcAnalyzer } from '../ast/OxcAnalyzer.js';
 
 /**
  * Worker Thread Execution Script
@@ -14,6 +14,7 @@ async function runTask() {
   // Create a minimal context for analyzers
   const mockContext = {
     verbose: contextOptions.verbose,
+    cwd: contextOptions.cwd || process.cwd(),
     projectGraph: new Map(),
     getOrCreateNode: (path) => ({
       filePath: path,
@@ -31,7 +32,10 @@ async function runTask() {
       jsxComponents: new Set(),
       jsxProps: new Set(),
       decorators: new Set(),
-      isFrameworkContract: false
+      isFrameworkContract: false,
+      isEntry: false,
+      isLibraryEntry: false,
+      isFrameworkComponent: false
     })
   };
 
@@ -71,7 +75,10 @@ async function runTask() {
         jsxComponents: Array.from(node.jsxComponents),
         jsxProps: Array.from(node.jsxProps),
         decorators: Array.from(node.decorators),
-        isFrameworkContract: node.isFrameworkContract
+        isFrameworkContract: node.isFrameworkContract,
+        isEntry: node.isEntry,
+        isLibraryEntry: node.isLibraryEntry,
+        isFrameworkComponent: node.isFrameworkComponent
       });
     } catch (err) {
       if (contextOptions.verbose) {

package/src/resolution/DepencyResolver.js

@@ -45,14 +45,13 @@ export class DependencyResolver {
     // we should try to resolve the .ts version first.
     let effectiveSpecifier = importSpecifier;
     const isTsFile = /\.(ts|tsx|mts|cts)$/.test(containingFile);
-    if (isTsFile && importSpecifier.endsWith('.js')) {
-        // Try replacing .js with .ts
+    if (importSpecifier.endsWith('.js')) {
         const tsSpecifier = importSpecifier.replace(/\.js$/, '.ts');
         try {
             const resolvedTs = this.nativeResolver(containingDir, tsSpecifier);
             if (this.isAbsoluteInternalPath(resolvedTs)) return resolvedTs;
         } catch (e) {
-            // Fall back to original specifier if .ts version doesn't exist
+            // Fall back to original specifier
         }
     }
     // -----------------------------------------
@@ -106,7 +105,7 @@ export class DependencyResolver {
         } catch {}
       }
       if (this.context.verbose) {
-        console.debug(`[Resolution Trace Skip] Specifier unresolvable: ${effectiveSpecifier} inside ${containingFile}`);
+        console.log(`[Resolution Trace Skip] Specifier unresolvable: ${effectiveSpecifier} inside ${containingFile}`);
       }
     }