entkapp 4.5.1 → 5.1.0

package/src/resolution/CircularDetector.js

@@ -1,32 +1,35 @@
+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;
+  detectCycles(projectGraph) {
     const stack = [];
+    const onStack = new Set();
     const indices = new Map();
     const lowlink = new Map();
-    const onStack = new Set();
+    const sccs = [];
+    let index = 0;
 
-    const strongconnect = (v) => {
+    const strongConnect = (v) => {
       indices.set(v, index);
       lowlink.set(v, index);
       index++;
       stack.push(v);
       onStack.add(v);
 
-      const node = graph.get(v);
+      const node = projectGraph.get(v);
       if (node && node.outgoingEdges) {
-        for (const w of node.outgoingEdges) {
+        // Ensure outgoingEdges is treated as an array-like structure
+        const edges = Array.isArray(node.outgoingEdges) ? node.outgoingEdges : Array.from(node.outgoingEdges);
+        
+        for (let i = 0; i < edges.length; i++) {
+          const w = edges[i];
           if (!indices.has(w)) {
-            strongconnect(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)));
@@ -35,57 +38,54 @@ export class CircularDetector {
       }
 
       if (lowlink.get(v) === indices.get(v)) {
-        const component = [];
+        const scc = [];
         let w;
         do {
           w = stack.pop();
           onStack.delete(w);
-          component.push(w);
+          scc.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]);
+        if (scc.length > 1) {
+          const cycle = scc.slice().reverse();
+          cycle.push(cycle[0]);
+          sccs.push(cycle);
+        } else if (scc.length === 1) {
+          const singleNode = projectGraph.get(scc[0]);
+          if (singleNode && singleNode.outgoingEdges) {
+            const edges = Array.isArray(singleNode.outgoingEdges) ? singleNode.outgoingEdges : Array.from(singleNode.outgoingEdges);
+            let hasSelfLoop = false;
+            for (let i = 0; i < edges.length; i++) {
+              if (edges[i] === scc[0]) {
+                hasSelfLoop = true;
+                break;
+              }
+            }
+            if (hasSelfLoop) {
+              sccs.push([scc[0], scc[0]]);
+            }
           }
         }
       }
     };
 
-    for (const v of graph.keys()) {
-      if (!indices.has(v)) {
-        strongconnect(v);
+    const keys = Array.from(projectGraph.keys());
+    for (let i = 0; i < keys.length; i++) {
+      if (!indices.has(keys[i])) {
+        strongConnect(keys[i]);
       }
     }
 
-    return this.cycles;
+    this.cycles = sccs;
+    return sccs;
   }
 
   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 => {
+        const relativePath = path.relative(this.context.cwd, p);
+        return relativePath.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;

package/src/resolution/ConfigLoader.js

@@ -1,87 +1,4 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { pathToFileURL } from 'url';
-
-/**
- * Loads and parses entkapp configuration files.
- * Supports scaffold.config.js, .scaffoldrc.json, and .scaffoldrc.
- */
 export class ConfigLoader {
-  constructor(context) {
-    this.context = context;
-  }
-
-  async loadConfig(projectRoot) {
-    const searchPaths = [
-      'entkapp.json',
-      'entkapp.jsonc',
-      '.entkapp.json',
-      '.entkapp.jsonc',
-      'entkapp.js',
-      'entkapp.ts',
-      'entkapp/config.json',
-      'scaffold.config.js',
-      'scaffold.config.mjs',
-      '.scaffoldrc.json',
-      '.scaffoldrc'
-    ];
-
-    let config = this.getDefaultConfig();
-
-    // Try package.json first
-    try {
-      const pkgPath = path.join(projectRoot, 'package.json');
-      const pkgContent = await fs.readFile(pkgPath, 'utf8');
-      const pkg = JSON.parse(pkgContent);
-      if (pkg['entkapp']) {
-        Object.assign(config, pkg['entkapp']);
-      }
-    } catch (e) {
-      // ignore
-    }
-
-    for (const fileName of searchPaths) {
-      const fullPath = path.join(projectRoot, fileName);
-      try {
-        await fs.access(fullPath);
-        
-        if (fileName.endsWith('.js') || fileName.endsWith('.mjs') || fileName.endsWith('.ts')) {
-          const module = await import(pathToFileURL(fullPath).href);
-          Object.assign(config, module.default || module);
-          break;
-        } else {
-          const content = await fs.readFile(fullPath, 'utf8');
-          // Very basic JSONC parsing (strip comments)
-          const stripped = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
-          Object.assign(config, JSON.parse(stripped));
-          break;
-        }
-      } catch (e) {
-        continue;
-      }
-    }
-
-    return config;
-  }
-
-  getDefaultConfig() {
-    return {
-      entryPoints: ['src/index.ts', 'index.js', 'src/index.js', 'src/main.ts', 'src/main.js'],
-      exclude: [
-        'node_modules/**',
-        'dist/**',
-        'build/**',
-        '**/*.test.ts',
-        '**/*.spec.ts',
-        '**/*.test.js',
-        '**/*.spec.js'
-      ],
-      plugins: [],
-      rules: {
-        'no-unused-exports': 'error',
-        'no-unused-vars': 'warn',
-        'no-dead-code': 'error'
-      }
-    };
-  }
+  constructor(cwd) { this.cwd = cwd; }
+  async loadConfig() { return {}; }
 }

package/src/resolution/DepencyResolver.js

@@ -1,144 +1,51 @@
-import resolve from 'enhanced-resolve';
 import path from 'path';
 import { existsSync } from 'fs';
 
-/**
- * Industrial-Strength Module Resolution Supervisor
- * Integrates path mapping and workspace topologies using enhanced-resolve.
- */
 export class DependencyResolver {
   constructor(context, pathMapper, workspaceGraph) {
     this.context = context;
     this.pathMapper = pathMapper;
     this.workspaceGraph = workspaceGraph;
-    
-    // Instantiate production-grade enhanced-resolve workspace parameters
-    this.nativeResolver = resolve.create.sync({
-      conditionNames: ['import', 'module', 'require', 'node', 'types'],
-      // Extensions prioritized: TS then JS
-      extensions: ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.json', '.vue'],
-      mainFields: ['module', 'main', 'types'],
-      exportsFields: ['exports'],
-      symlinks: true
-    });
   }
 
-  /**
-   * Resolves a raw import string from a source file into an absolute file path.
-   * Handles the "trap" where .ts files import .js files that should resolve to .ts.
-   */
-  resolveModulePath(containingFile, importSpecifier) {
-    if (importSpecifier.startsWith('node:') || [
-      'assert', 'async_hooks', 'buffer', 'child_process', 'cluster', 'console', 'constants',
-      'crypto', 'dgram', 'dns', 'domain', 'events', 'fs', 'fs/promises', 'http', 'http2',
-      'https', 'inspector', 'module', 'net', 'os', 'path', 'perf_hooks', 'process',
-      'punycode', 'querystring', 'readline', 'repl', 'stream', 'string_decoder',
-      'timers', 'tls', 'trace_events', 'tty', 'url', 'util', 'v8', 'vm', 'worker_threads', 'zlib'
-    ].includes(importSpecifier)) {
-      return null;
-    }
-
-    const containingDir = path.dirname(containingFile);
-
-    // --- NEW: Fix for JS-in-TS import trap ---
-    // If we are in a TS file and importing something ending in .js, 
-    // we should try to resolve the .ts version first.
-    let effectiveSpecifier = importSpecifier;
-    const isTsFile = /\.(ts|tsx|mts|cts)$/.test(containingFile);
-    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
-        }
+  normalizePath(p) {
+    if (!p) return p;
+    const original = p;
+    // Handle Windows drive letters and backslashes
+    let normalized = p.replace(/\\/g, '/');
+    if (/^[a-z]:\//i.test(normalized)) {
+      normalized = normalized.charAt(0).toUpperCase() + normalized.slice(1);
     }
-    // -----------------------------------------
-
-    // Rule A: Intercept and resolve local monorepo workspace cross-links
-    if (this.workspaceGraph.isLocalWorkspaceSpecifier(effectiveSpecifier)) {
-      const match = this.workspaceGraph.getWorkspacePackageMatch(effectiveSpecifier);
-      if (match) {
-        if (effectiveSpecifier === match.packageName) {
-          return match.entryPoints[0] || null;
-        }
-        
-        const subPathOffset = effectiveSpecifier.slice(match.packageName.length + 1);
-        try {
-          return this.nativeResolver(match.rootDirectory, `./${subPathOffset}`);
-        } catch {
-        }
-      }
+    if (this.context.verbose && original !== normalized) {
+       // console.log(`[Path-DEBUG] Normalized: ${original} -> ${normalized}`);
     }
+    return normalized;
+  }
 
-    // Rule B: Intercept and expand path mapping aliases (@/*)
-    const aliasedCandidates = this.pathMapper.resolveCandidatePaths(effectiveSpecifier);
-    if (aliasedCandidates.length > 0) {
-      for (const candidate of aliasedCandidates) {
-        try {
-          const resolvedPath = this.nativeResolver(containingDir, candidate);
-          if (this.isAbsoluteInternalPath(resolvedPath)) {
-            return resolvedPath;
-          }
-        } catch {
-        }
+  resolveModulePath(sourceFile, specifier) {
+    const cleanSource = this.normalizePath(sourceFile);
+    
+    // UPGRADE: Use PathMapper for sophisticated resolution (TS-to-JS, aliases, etc.)
+    if (this.pathMapper) {
+      const dir = path.dirname(cleanSource);
+      const target = path.resolve(dir, specifier);
+      const resolved = this.pathMapper.resolvePath(target);
+      if (resolved && existsSync(resolved)) {
+        return this.normalizePath(resolved);
       }
     }
 
-    // Rule C: Standard file system lookups
-    try {
-      const resolvedPath = this.nativeResolver(containingDir, effectiveSpecifier);
+    if (specifier.startsWith('.')) {
+      const dir = path.dirname(cleanSource);
+      const target = path.resolve(dir, specifier);
+      const normalizedTarget = this.normalizePath(target);
       
-      // Fix: Improved handling for dynamic exports/imports
-      if (this.isAbsoluteInternalPath(resolvedPath)) {
-        return resolvedPath;
-      }
-    } catch (err) {
-      // Fallback: Try to resolve with common extensions if enhanced-resolve fails
-      const extensions = ['.ts', '.tsx', '.js', '.jsx'];
+      const extensions = ['', '.js', '.ts', '.tsx', '.jsx', '/index.js', '/index.ts', '/index.tsx'];
       for (const ext of extensions) {
-        try {
-          const trialPath = effectiveSpecifier.endsWith(ext) ? effectiveSpecifier : effectiveSpecifier + ext;
-          const resolvedPath = path.resolve(containingDir, trialPath);
-          if (existsSync(resolvedPath)) return resolvedPath;
-        } catch {}
-      }
-      if (this.context.verbose) {
-        console.log(`[Resolution Trace Skip] Specifier unresolvable: ${effectiveSpecifier} inside ${containingFile}`);
+        const p = normalizedTarget + ext;
+        if (existsSync(p)) return this.normalizePath(p);
       }
     }
-
     return null;
   }
-
-  isAbsoluteInternalPath(resolvedPath) {
-    if (!resolvedPath) return false;
-    const normalized = resolvedPath.replace(/\\/g, '/');
-    
-    if (normalized.includes('/node_modules/')) {
-      for (const [name, meta] of this.workspaceGraph.packageManifests.entries()) {
-        if (normalized.startsWith(meta.rootDirectory.replace(/\\/g, '/'))) {
-          return true;
-        }
-      }
-      return false;
-    }
-    
-    return path.isAbsolute(resolvedPath);
-  }
-
-  determineIntentProfile(filePath, declaredExportsManifest) {
-    const fileName = path.basename(filePath);
-    const isPublicContractFile = /(^index|^public\-api|^entry)\.(ts|js|tsx|jsx)$/i.test(fileName);
-    
-    if (isPublicContractFile) {
-      for (const [symbolKey, metadata] of declaredExportsManifest.entries()) {
-        metadata.isLibraryContract = true;
-      }
-      return 'LIBRARY_CONSUMPTION_TARGET';
-    }
-
-    return 'INTERNAL_CODEBASE_ELEMENT';
-  }
 }

package/src/resolution/EntryPointDetector.js

@@ -0,0 +1,134 @@
+import fs from 'fs';
+import path from 'path';
+
+export class EntryPointDetector {
+    constructor(targetDir, packageJson, stats) {
+        this.targetDir = targetDir;
+        this.packageJson = packageJson || {};
+        this.stats = stats;
+    }
+
+    /**
+     * Ermittelt alle potenziellen Entry-Points eines Projekts.
+     * @returns {Set<string>} Set von absoluten Pfaden.
+     */
+    detect() {
+        const entries = new Set();
+
+        // 1. package.json Standards
+        this._addFromPackageJson(entries);
+
+        // 2. Framework-spezifische Pfade
+        this._addFromFrameworks(entries);
+
+        // 3. Fallbacks / Konventionen
+        this._addFromConventions(entries);
+
+        return entries;
+    }
+
+    _addFromPackageJson(entries) {
+        const fields = ['main', 'module', 'browser', 'bin'];
+        fields.forEach(field => {
+            const val = this.packageJson[field];
+            if (typeof val === 'string') {
+                this._addIfExist(entries, val);
+            } else if (typeof val === 'object' && val !== null) {
+                Object.values(val).forEach(v => {
+                    if (typeof v === 'string') this._addIfExist(entries, v);
+                });
+            }
+        });
+
+        // Exports field (modern Node.js)
+        if (this.packageJson.exports) {
+            this._parseExports(this.packageJson.exports, entries);
+        }
+    }
+
+    _parseExports(exports, entries) {
+        if (typeof exports === 'string') {
+            this._addIfExist(entries, exports);
+        } else if (typeof exports === 'object' && exports !== null) {
+            for (const key in exports) {
+                const val = exports[key];
+                if (typeof val === 'string') {
+                    this._addIfExist(entries, val);
+                } else if (typeof val === 'object') {
+                    this._parseExports(val, entries);
+                }
+            }
+        }
+    }
+
+    _addFromFrameworks(entries) {
+        if (!this.stats || !this.stats.detectedFrameworks) return;
+
+        const frameworks = this.stats.detectedFrameworks;
+
+        if (frameworks.includes('next')) {
+            this._scanDir(path.join(this.targetDir, 'pages'), entries);
+            this._scanDir(path.join(this.targetDir, 'app'), entries, ['page.tsx', 'page.js', 'route.ts', 'route.js']);
+        }
+
+        if (frameworks.includes('nuxt')) {
+            this._scanDir(path.join(this.targetDir, 'pages'), entries);
+        }
+
+        if (frameworks.includes('svelte')) {
+            this._scanDir(path.join(this.targetDir, 'src/routes'), entries);
+        }
+    }
+
+    _addFromConventions(entries) {
+        const fallbacks = [
+            'index.js', 'index.ts', 'index.jsx', 'index.tsx',
+            'src/index.js', 'src/index.ts', 'src/index.jsx', 'src/index.tsx',
+            'main.js', 'main.ts', 'src/main.js', 'src/main.ts',
+            'app.js', 'app.ts', 'src/app.js', 'src/app.ts',
+            'server.js', 'server.ts', 'src/server.js', 'src/server.ts'
+        ];
+        fallbacks.forEach(f => this._addIfExist(entries, f));
+
+        // If no entries found yet, and we are in a simple src structure, 
+        // protect common top-level files in src/
+        if (entries.size === 0) {
+            const commonSrcFiles = ['src/app.ts', 'src/main.ts', 'src/index.ts', 'src/app.js', 'src/main.js', 'src/index.js'];
+            commonSrcFiles.forEach(f => this._addIfExist(entries, f));
+        }
+    }
+
+    _addIfExist(entries, relativePath) {
+        // Bereinige Pfad (entferne ./ etc)
+        const cleanPath = relativePath.replace(/^(\.\/|\/)/, '');
+        const absolutePath = path.resolve(this.targetDir, cleanPath);
+        
+        // Prüfe verschiedene Erweiterungen falls keine angegeben
+        const extensions = ['', '.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
+        for (const ext of extensions) {
+            const p = absolutePath + ext;
+            if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+                entries.add(p);
+                return;
+            }
+        }
+    }
+
+    _scanDir(dir, entries, specificFiles = null) {
+        if (!fs.existsSync(dir)) return;
+        
+        const files = fs.readdirSync(dir, { recursive: true });
+        files.forEach(file => {
+            const fullPath = path.join(dir, file);
+            if (fs.statSync(fullPath).isFile()) {
+                if (specificFiles) {
+                    if (specificFiles.includes(path.basename(file))) {
+                        entries.add(fullPath);
+                    }
+                } else if (/\.(js|ts|jsx|tsx|vue|svelte)$/.test(file)) {
+                    entries.add(fullPath);
+                }
+            }
+        });
+    }
+}