entkapp 4.5.1 → 5.0.0

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,40 @@
-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;
+  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);
     }
-
-    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
-        }
-    }
-    // -----------------------------------------
-
-    // 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 {
-        }
-      }
-    }
-
-    // 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 {
-        }
-      }
+    if (this.context.verbose && original !== normalized) {
+       // console.log(`[Path-DEBUG] Normalized: ${original} -> ${normalized}`);
     }
+    return normalized;
+  }
 
-    // Rule C: Standard file system lookups
-    try {
-      const resolvedPath = this.nativeResolver(containingDir, effectiveSpecifier);
+  resolveModulePath(sourceFile, specifier) {
+    const cleanSource = this.normalizePath(sourceFile);
+    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'];
       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);
+                }
+            }
+        });
+    }
+}

package/src/resolution/PathMapper.js

@@ -1,125 +1,5 @@
-import fs from 'fs/promises';
-import path from 'path';
-
-/**
- * Advanced TSConfig / JSConfig Compilation Path Alias Mapper
- * Resolves deeply nested route mappings, wildcards, and base URL overrides.
- */
 export class PathMapper {
-  constructor(context) {
-    this.context = context;
-    this.baseUrl = '.';
-    this.absoluteBaseUrl = context.cwd;
-    this.mappings = []; // Collection of { prefix, suffix, targets[] }
-  }
-
-  /**
-   * Reads, cleans, and indexes custom alias entries from tsconfig.json files.
-   * @param {string} tsconfigFilename - Target designator (typically tsconfig.json)
-   */
-  async loadMappings(tsconfigFilename = 'tsconfig.json') {
-    const configPath = path.resolve(this.context.cwd, tsconfigFilename);
-    
-    try {
-      await fs.access(configPath);
-      const rawText = await fs.readFile(configPath, 'utf8');
-      
-      // Strip inline single-line and block comments before parsing
-      // Improved regex to handle more edge cases in tsconfig comments
-      const jsonCleanText = rawText
-        .replace(/\/\*[\s\S]*?\*\/|(?<=[^\\:])\/\/.*$/gm, '')
-        .replace(/,(\s*[\]}])/g, '$1'); // Remove trailing commas
-        
-      const tsconfig = JSON.parse(jsonCleanText);
-
-      if (!tsconfig.compilerOptions) return;
-
-      const opts = tsconfig.compilerOptions;
-      
-      // v6 Path Resolution Fix (Knip Issue #1794)
-      // Ensure baseUrl is correctly resolved relative to the tsconfig file location
-      const configDir = path.dirname(configPath);
-      if (opts.baseUrl) {
-        this.baseUrl = opts.baseUrl;
-        this.absoluteBaseUrl = path.resolve(configDir, this.baseUrl);
-      } else {
-        this.absoluteBaseUrl = configDir;
-      }
-
-      if (opts.paths) {
-        for (const [aliasPattern, targetArrays] of Object.entries(opts.paths)) {
-          this.registerPatternRule(aliasPattern, targetArrays);
-        }
-      }
-    } catch (error) {
-      if (this.context.verbose) {
-        console.warn(`⚠️ [PathMapper Override] Proceeding without custom path configurations. Source: ${error.message}`);
-      }
-    }
-  }
-
-  /**
-   * Registers structural lookup parameters for alias strings.
-   */
-  registerPatternRule(pattern, targets) {
-    const wildcardIndex = pattern.indexOf('*');
-
-    if (wildcardIndex === -1) {
-      this.mappings.push({
-        isExact: true,
-        pattern,
-        targets: targets.map(t => path.normalize(t))
-      });
-      return;
-    }
-
-    const prefix = pattern.slice(0, wildcardIndex);
-    const suffix = pattern.slice(wildcardIndex + 1);
-
-    this.mappings.push({
-      isExact: false,
-      prefix,
-      suffix,
-      targets: targets.map(t => path.normalize(t))
-    });
-  }
-
-  /**
-   * Resolves a raw import specifier against mapped path patterns.
-   * @param {string} specifier - Raw text from import declaration (e.g., '@ui/button')
-   * @returns {Array<string>} Candidates of absolute filesystem paths to try resolving
-   */
-  resolveCandidatePaths(specifier) {
-    const matchingCandidates = [];
-
-    for (const rule of this.mappings) {
-      if (rule.isExact) {
-        if (specifier === rule.pattern) {
-          rule.targets.forEach(target => {
-            matchingCandidates.push(path.resolve(this.absoluteBaseUrl, target));
-          });
-        }
-      } else {
-        // Evaluate wildcard pattern matches
-        if (specifier.startsWith(rule.prefix) && specifier.endsWith(rule.suffix)) {
-          const extractedWildcardContent = specifier.slice(
-            rule.prefix.length,
-            specifier.length - rule.suffix.length
-          );
-
-          rule.targets.forEach(targetTemplate => {
-            const interpolatedTarget = targetTemplate.replace('*', extractedWildcardContent);
-            matchingCandidates.push(path.resolve(this.absoluteBaseUrl, interpolatedTarget));
-          });
-        }
-      }
-    }
-
-    // Fall back to direct lookup relative to the base URL
-    if (!specifier.startsWith('.') && !path.isAbsolute(specifier)) {
-      matchingCandidates.push(path.resolve(this.absoluteBaseUrl, specifier));
-    }
-
-    return matchingCandidates;
-  }
+  constructor(context) { this.context = context; }
+  async loadMappings() {}
+  resolvePath(p) { return p; }
 }

package/src/resolution/TSConfigLoader.js

@@ -0,0 +1,76 @@
+import fs from 'fs';
+import path from 'path';
+import ts from 'typescript';
+
+export class TSConfigLoader {
+    constructor(targetDir) {
+        this.targetDir = targetDir;
+    }
+
+    /**
+     * Lädt und parst die tsconfig.json.
+     * @returns {Object|null} Parsed config oder null.
+     */
+    load() {
+        const configPath = path.join(this.targetDir, 'tsconfig.json');
+        if (!fs.existsSync(configPath)) return null;
+
+        try {
+            const content = fs.readFileSync(configPath, 'utf8');
+            const result = ts.parseConfigFileTextWithComments(configPath, content);
+            
+            if (result.error) {
+                return null;
+            }
+
+            const parsed = ts.parseJsonConfigFileContent(
+                result.config,
+                ts.sys,
+                this.targetDir
+            );
+
+            return parsed;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    /**
+     * Erstellt eine Mapping-Funktion für Aliases aus der tsconfig.
+     * @param {Object} parsedConfig 
+     * @returns {Function} Mapper function.
+     */
+    getAliasMapper(parsedConfig) {
+        if (!parsedConfig || !parsedConfig.options || !parsedConfig.options.paths) {
+            return (source) => source;
+        }
+
+        const { paths, baseUrl } = parsedConfig.options;
+        const base = baseUrl ? path.resolve(this.targetDir, baseUrl) : this.targetDir;
+
+        return (source) => {
+            for (const pattern in paths) {
+                const regexPattern = pattern.replace(/\*/, '(.*)');
+                const regex = new RegExp(`^${regexPattern}$`);
+                const match = source.match(regex);
+
+                if (match) {
+                    const replacements = paths[pattern];
+                    for (const replacement of replacements) {
+                        const resolvedReplacement = replacement.replace(/\*/, match[1]);
+                        const fullPath = path.resolve(base, resolvedReplacement);
+                        
+                        // Prüfe ob Datei existiert
+                        const extensions = ['', '.ts', '.tsx', '.js', '.jsx'];
+                        for (const ext of extensions) {
+                            if (fs.existsSync(fullPath + ext)) {
+                                return fullPath + ext;
+                            }
+                        }
+                    }
+                }
+            }
+            return source;
+        };
+    }
+}