entkapp 5.3.1 → 5.4.0

package/src/plugins/PluginRegistry.js

@@ -111,6 +111,31 @@ export class PluginRegistry {
         return this.plugins.get(name);
     }
 
+    /**
+     * Version 5.4.0: Collect entry points from all plugins for a given file.
+     * @param {string} content - The file content
+     * @param {string} filePath - The absolute path to the file
+     * @returns {Array<string>} List of detected entry points
+     */
+    detectEntryPointsFromContent(content, filePath) {
+        const entryPoints = [];
+        for (const plugin of this.plugins.values()) {
+            if (typeof plugin.detectEntryPoints === 'function') {
+                try {
+                    const detected = plugin.detectEntryPoints(content, filePath);
+                    if (Array.isArray(detected)) {
+                        entryPoints.push(...detected);
+                    }
+                } catch (e) {
+                    if (this.context?.verbose) {
+                        console.warn(`[PluginRegistry] Entry detection failed for plugin "${plugin.name}" on ${filePath}:`, e.message);
+                    }
+                }
+            }
+        }
+        return entryPoints;
+    }
+
     async getActivePlugins(baseDir) {
         const active = [];
         for (const plugin of this.plugins.values()) {
@@ -121,6 +146,25 @@ export class PluginRegistry {
         return active;
     }
 
+    /**
+     * Version 5.3.0: Run content analysis on a node using all active plugins.
+     * @param {GraphNode} node - The node to analyze
+     * @param {string} filePath - The absolute path to the file
+     */
+    async runPluginAnalysis(node, filePath) {
+        for (const plugin of this.plugins.values()) {
+            if (typeof plugin.analyze === 'function') {
+                try {
+                    await plugin.analyze(node, filePath);
+                } catch (e) {
+                    if (this.context?.verbose) {
+                        console.warn(`[PluginRegistry] Analysis failed for plugin "${plugin.name}" on ${filePath}:`, e.message);
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * Version 5.0.0: Run dependency diagnostics across all registered plugins.
      * Returns a consolidated list of missing/misplaced dependencies and orphaned configs.

package/src/plugins/ecosystems/UltimateBundle.js

@@ -8,6 +8,7 @@
 import path from 'path';
 import fs from 'fs/promises';
 import { BasePlugin } from '../BasePlugin.js';
+import { FrameworkConfigParser } from '../../resolution/FrameworkConfigParser.js';
 
 
 export class GraphQLPlugin extends BasePlugin {
@@ -211,6 +212,27 @@ export class NuxtPlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode) {
+        const parser = new FrameworkConfigParser(this.context);
+        const { aliases, entries } = parser.parse(node.rawCode, filePath);
+        if (aliases.size > 0) node.frameworkAliases = aliases;
+        if (entries.size > 0) node.frameworkEntries = entries;
+        if (node.rawCode.includes('modules:')) node.hasNuxtModules = true;
+        if (node.rawCode.includes('components:')) node.hasNuxtComponentsConfig = true;
+      }
+    }
+  }
 }
 
 export class RemixPlugin extends BasePlugin {
@@ -233,6 +255,21 @@ export class RemixPlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (filePath.endsWith('remix.config.js') || filePath.includes('vite.config.')) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (filePath.endsWith('remix.config.js')) {
+      node.isEntry = true;
+      if (node.rawCode?.includes('ignoredRouteFiles:')) node.hasRemixIgnoredRoutes = true;
+      if (node.rawCode?.includes('serverBuildPath:')) node.hasRemixServerBuildPath = true;
+    }
+  }
 }
 
 export class SvelteKitPlugin extends BasePlugin {
@@ -251,6 +288,29 @@ export class SvelteKitPlugin extends BasePlugin {
   async isActive(baseDir) {
     try { await fs.access(path.join(baseDir, 'svelte.config.js')); return true; } catch { return false; }
   }
+  detectEntryPoints(content, filePath) {
+    if (filePath.includes('svelte.config.')) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (filePath.includes('svelte.config.')) {
+      node.isEntry = true;
+      if (node.rawCode) {
+        const parser = new FrameworkConfigParser(this.context);
+        const { aliases, entries } = parser.parse(node.rawCode, filePath);
+        if (aliases.size > 0) {
+          node.frameworkAliases = aliases;
+          node.hasSvelteAliases = true;
+        }
+        if (entries.size > 0) node.frameworkEntries = entries;
+        if (node.rawCode.includes('adapter:')) node.hasSvelteAdapter = true;
+      }
+    }
+  }
 }
 
 export class AstroPlugin extends BasePlugin {
@@ -265,12 +325,39 @@ export class AstroPlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode) {
+        const parser = new FrameworkConfigParser(this.context);
+        const { aliases, entries } = parser.parse(node.rawCode, filePath);
+        if (aliases.size > 0) node.frameworkAliases = aliases;
+        if (entries.size > 0) node.frameworkEntries = entries;
+        if (node.rawCode.includes('integrations:')) node.hasAstroIntegrations = true;
+        if (node.rawCode.includes('output:')) node.hasAstroOutputConfig = true;
+      }
+    }
+  }
 }
 
 export class VitepressPlugin extends BasePlugin {
   get name() { return 'vitepress'; }
   getConfigFiles() { return ['package.json']; }
   getRequiredPackages() { return [{ name: 'vitepress', dev: true }]; }
+  
+  getRoutePatterns() {
+    // Protection: Every file inside a .vitepress folder is treated as an entry point
+    return [/\/\.vitepress\//];
+  }
+
   async isActive(baseDir) {
     try {
       const pkgJson = JSON.parse(await fs.readFile(path.join(baseDir, 'package.json'), 'utf8'));
@@ -282,6 +369,62 @@ export class VitepressPlugin extends BasePlugin {
       return hasDep;
     } catch { return false; }
   }
+
+  async runDependencyDiagnostics(baseDir) {
+    const diagnostics = await super.runDependencyDiagnostics(baseDir);
+    
+    let pkg = null;
+    try {
+      const raw = await fs.readFile(path.join(baseDir, 'package.json'), 'utf8');
+      pkg = JSON.parse(raw);
+    } catch { return diagnostics; }
+
+    const scripts = pkg.scripts || {};
+    const allDeps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    const hasVitepressDep = 'vitepress' in allDeps;
+    
+    // Check if any script uses vitepress
+    const hasVitepressCommand = Object.values(scripts).some(s => s.includes('vitepress'));
+    
+    // Logic for .vitepress folder existence
+    let hasVitepressFolder = false;
+    const possibleDirs = ['.vitepress', 'docs/.vitepress', 'docs/docs/.vitepress'];
+    for (const d of possibleDirs) {
+      try {
+        await fs.access(path.join(baseDir, d));
+        hasVitepressFolder = true;
+        break;
+      } catch {}
+    }
+
+    // Scenario 1: build cmd/dependency exists but no folder -> unused dependency
+    if ((hasVitepressCommand || hasVitepressDep) && !hasVitepressFolder) {
+      diagnostics.push({
+        plugin: this.name,
+        severity: 'warning',
+        message: `Plugin "${this.name}": "vitepress" is defined in package.json or scripts, but no ".vitepress" folder was found. This might be an unused dependency.`
+      });
+    }
+
+    // Scenario 2: folder exists but no dependency -> missing dependency
+    if (hasVitepressFolder && !hasVitepressDep) {
+      diagnostics.push({
+        plugin: this.name,
+        severity: 'error',
+        message: `Plugin "${this.name}": ".vitepress" folder exists, but "vitepress" package is not installed in package.json.`
+      });
+    }
+
+    return diagnostics;
+  }
+
+  async analyze(node, filePath) {
+    // If it's a config file inside .vitepress, mark it
+    if (filePath.includes('/.vitepress/config.') || filePath.includes('/.vitepress/theme/')) {
+      node.isEntry = true;
+      node.isVitepressInternal = true;
+    }
+  }
 }
 
 export class GatsbyPlugin extends BasePlugin {
@@ -321,6 +464,14 @@ export class NextJsPlugin extends BasePlugin {
     }
     return false;
   }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode?.includes('rewrites')) node.hasNextRewrites = true;
+      if (node.rawCode?.includes('redirects')) node.hasNextRedirects = true;
+      if (node.rawCode?.includes('images:')) node.hasNextImageConfig = true;
+    }
+  }
 }
 
 export class ReactPlugin extends BasePlugin {
@@ -443,6 +594,42 @@ export class VitePlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (filePath.includes('vite.config.')) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (filePath.includes('vite.config.')) {
+      // Mark config as an entry so its own dependencies are tracked
+      node.isEntry = true;
+      
+      // UPGRADE: Use FrameworkConfigParser for deep structural extraction
+      if (node.rawCode) {
+        const parser = new FrameworkConfigParser(this.context);
+        const { aliases, entries } = parser.parse(node.rawCode, filePath);
+        
+        if (aliases.size > 0) {
+          node.frameworkAliases = aliases;
+          node.viteAliasesDetected = true;
+        }
+        
+        if (entries.size > 0) {
+          node.frameworkEntries = entries;
+          node.hasCustomViteInputs = true;
+        }
+
+        // Detect Plugins (Keep existing simple check)
+        const pluginsPattern = /plugins\s*:\s*\[([\s\S]*?)\]/g;
+        if (pluginsPattern.test(node.rawCode)) {
+          node.hasVitePlugins = true;
+        }
+      }
+    }
+  }
 }
 
 export class EsbuildPlugin extends BasePlugin {
@@ -479,6 +666,30 @@ export class WebpackPlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode?.includes('entry:')) node.hasWebpackEntries = true;
+      if (node.rawCode?.includes('resolve:')) node.hasWebpackResolve = true;
+      if (node.rawCode?.includes('plugins:')) node.hasWebpackPlugins = true;
+    }
+  }
 }
 
 export class ParcelPlugin extends BasePlugin {
@@ -521,6 +732,14 @@ export class TailwindPlugin extends BasePlugin {
     }
     return false;
   }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode?.includes('content:')) node.hasTailwindContent = true;
+      if (node.rawCode?.includes('theme:')) node.hasTailwindTheme = true;
+      if (node.rawCode?.includes('plugins:')) node.hasTailwindPlugins = true;
+    }
+  }
 }
 
 export class PostcssPlugin extends BasePlugin {
@@ -665,6 +884,13 @@ export class JestPlugin extends BasePlugin {
   async isActive(baseDir) {
     try { await fs.access(path.join(baseDir, 'jest.config.js')); return true; } catch { return false; }
   }
+  async analyze(node, filePath) {
+    if (filePath.endsWith('jest.config.js')) {
+      node.isEntry = true;
+      if (node.rawCode?.includes('testEnvironment:')) node.hasJestTestEnv = true;
+      if (node.rawCode?.includes('setupFiles:')) node.hasJestSetupFiles = true;
+    }
+  }
 }
 
 export class VitestPlugin extends BasePlugin {
@@ -677,6 +903,39 @@ export class VitestPlugin extends BasePlugin {
     }
     return false;
   }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  detectEntryPoints(content, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      const parser = new FrameworkConfigParser(this.context);
+      const { entries } = parser.parse(content, filePath);
+      return Array.from(entries);
+    }
+    return [];
+  }
+  async analyze(node, filePath) {
+    if (this.getConfigFiles().some(f => filePath.endsWith(f))) {
+      node.isEntry = true;
+      if (node.rawCode) {
+        const parser = new FrameworkConfigParser(this.context);
+        const { aliases, entries } = parser.parse(node.rawCode, filePath);
+        if (aliases.size > 0) {
+          node.frameworkAliases = aliases;
+          node.hasWebpackAliases = true;
+        }
+        if (entries.size > 0) {
+          node.frameworkEntries = entries;
+          node.hasWebpackEntries = true;
+        }
+      }
+    }
+  }
 }
 
 export class PlaywrightPlugin extends BasePlugin {

package/src/resolution/ConfigLoader.js

@@ -3,73 +3,239 @@ import path from 'path';
 
 /**
  * ConfigLoader
- * Loads and merges entkapp configuration from multiple sources:
- * - entkapp/config.json (project config)
- * - entkapp.config.js / entkapp.config.mjs (JS config)
- * - package.json "entkapp" key
- * - CLI flags (passed as overrides)
+ *
+ * Loads and merges entkapp configuration from multiple sources.
+ * Supports Monorepo detection for pnpm, npm/yarn/bun, Lerna, Turbo, and Nx.
  */
 export class ConfigLoader {
-  constructor(cwd) { 
-    this.cwd = cwd; 
+  constructor(cwd) {
+    this.cwd = cwd;
   }
 
   async loadConfig(overrides = {}) {
     let config = this._defaultConfig();
 
-    // 1. Try entkapp/config.json
+    // 1. entkapp/config.json
     const jsonConfigPath = path.join(this.cwd, 'entkapp', 'config.json');
     try {
       const raw = await fs.readFile(jsonConfigPath, 'utf8');
-      // Strip comments from JSON (JSONC support)
       const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
-      const parsed = JSON.parse(stripped);
-      config = this._merge(config, parsed);
+      config = this._merge(config, JSON.parse(stripped));
     } catch (e) {}
 
-    // 2. Try entkapp.config.js / entkapp.config.mjs
-    for (const configFile of ['entkapp.config.mjs', 'entkapp.config.js', 'entkapp.config.cjs']) {
+    // 2. entkapp.config.ts / .mjs / .js / .cjs
+    for (const configFile of ['entkapp.config.ts', 'entkapp.config.mjs', 'entkapp.config.js', 'entkapp.config.cjs']) {
       const jsConfigPath = path.join(this.cwd, configFile);
       try {
         const mod = await import(jsConfigPath);
         const jsConfig = mod.default || mod;
-        if (typeof jsConfig === 'object') {
+        if (typeof jsConfig === 'object' && jsConfig !== null) {
           config = this._merge(config, jsConfig);
           break;
         }
       } catch (e) {}
     }
 
-    // 3. Try package.json "entkapp" key
-    const pkgPath = path.join(this.cwd, 'package.json');
+    // 3. package.json "entkapp" key
     try {
-      const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf8'));
+      const pkg = JSON.parse(await fs.readFile(path.join(this.cwd, 'package.json'), 'utf8'));
       if (pkg.entkapp && typeof pkg.entkapp === 'object') {
         config = this._merge(config, pkg.entkapp);
       }
     } catch (e) {}
 
-    // 4. Apply CLI overrides
+    // 4. Workspace / monorepo packages
+    const workspaceData = await this.loadWorkspaceConfigs();
+    if (workspaceData.packages.length > 0) {
+      config.workspace = true;
+      config.workspacePackages = workspaceData.packages;
+      config.workspaceTsConfigs = workspaceData.tsConfigs;
+      config.workspaceConfigFiles = workspaceData.configFiles;
+      config.monorepoConfigs = workspaceData.monorepoConfigs;
+    }
+
+    // 5. CLI overrides
     config = this._merge(config, overrides);
 
+    // Final sanity check: ensure arrays exist
+    if (!Array.isArray(config.entryPoints)) config.entryPoints = [];
+    if (!Array.isArray(config.workspacePackages)) config.workspacePackages = [];
+    if (!Array.isArray(config.workspaceTsConfigs)) config.workspaceTsConfigs = [];
+    if (!Array.isArray(config.workspaceConfigFiles)) config.workspaceConfigFiles = [];
+
     return config;
   }
 
+  async loadWorkspaceConfigs() {
+    const result = {
+      packages: [],
+      tsConfigs: [],
+      configFiles: [],
+      monorepoConfigs: {}
+    };
+
+    // Load global configs first
+    const globalConfigs = ['turbo.json', 'nx.json', 'lerna.json'];
+    for (const file of globalConfigs) {
+      try {
+        const content = JSON.parse(await fs.readFile(path.join(this.cwd, file), 'utf8'));
+        result.monorepoConfigs[file] = content;
+      } catch (e) {}
+    }
+
+    const patterns = await this._resolveWorkspacePatterns();
+    if (patterns.length === 0) return result;
+
+    for (const pattern of patterns) {
+      const dirs = await this._expandGlob(pattern);
+      for (const dir of dirs) {
+        await this._readPackageDir(dir, result);
+      }
+    }
+
+    return result;
+  }
+
+  async _resolveWorkspacePatterns() {
+    const pnpmPatterns = await this._parseWorkspaceYaml('pnpm-workspace.yaml');
+    if (pnpmPatterns.length > 0) return pnpmPatterns;
+
+    try {
+      const pkg = JSON.parse(await fs.readFile(path.join(this.cwd, 'package.json'), 'utf8'));
+      if (pkg.workspaces) {
+        return Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages || [];
+      }
+    } catch (e) {}
+
+    try {
+      const lerna = JSON.parse(await fs.readFile(path.join(this.cwd, 'lerna.json'), 'utf8'));
+      if (lerna.packages) return lerna.packages;
+    } catch (e) {}
+
+    return this._parseWorkspaceYaml('workspace.yaml');
+  }
+
+  async _parseWorkspaceYaml(fileName) {
+    const filePath = path.join(this.cwd, fileName);
+    try {
+      const raw = await fs.readFile(filePath, 'utf8');
+      const patterns = [];
+      const lines = raw.split('\n');
+      let inPackages = false;
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        if (/^packages\s*:/.test(trimmed)) {
+          inPackages = true;
+          const inlineMatch = trimmed.match(/^packages\s*:\s*\[([^\]]*)\]/);
+          if (inlineMatch) {
+            inPackages = false;
+            for (const item of inlineMatch[1].split(',')) {
+              const val = item.trim().replace(/^['"]|['"]$/g, '');
+              if (val) patterns.push(val);
+            }
+          }
+          continue;
+        }
+        if (inPackages) {
+          if (line.match(/^[a-zA-Z0-9_-]/) && trimmed.endsWith(':')) {
+            inPackages = false;
+            continue;
+          }
+          if (trimmed.startsWith('-')) {
+            const val = trimmed.substring(1).trim().replace(/^['"]|['"]$/g, '');
+            if (val) patterns.push(val);
+          }
+        }
+      }
+      return patterns;
+    } catch (e) {
+      return [];
+    }
+  }
+
+  async _readPackageDir(dir, result) {
+    const normalizedDir = dir.replace(/\\/g, '/');
+    let packageName;
+
+    try {
+      const pkg = JSON.parse(await fs.readFile(path.join(dir, 'package.json'), 'utf8'));
+      packageName = pkg.name;
+      result.packages.push({
+        dir: normalizedDir,
+        name: packageName,
+        entkappConfig: (pkg.entkapp && typeof pkg.entkapp === 'object') ? pkg.entkapp : {}
+      });
+    } catch (e) {
+      // If no package.json, skip as requested in WorkSpaceGraph logic
+      return;
+    }
+
+    // tsconfig.json
+    try {
+      const tsconfigRaw = await fs.readFile(path.join(dir, 'tsconfig.json'), 'utf8');
+      const stripped = tsconfigRaw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+      result.tsConfigs.push({ dir: normalizedDir, name: packageName, tsconfig: JSON.parse(stripped) });
+    } catch (e) {}
+
+    // *.config.ts / .js
+    try {
+      const entries = await fs.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isFile() || !/\.config\.(ts|js|mjs|cjs)$/.test(entry.name)) continue;
+        const filePath = path.join(dir, entry.name).replace(/\\/g, '/');
+        try {
+          const content = await fs.readFile(filePath, 'utf8');
+          result.configFiles.push({ dir: normalizedDir, name: packageName, fileName: entry.name, filePath, content });
+        } catch (e) {}
+      }
+    } catch (e) {}
+  }
+
+  async _expandGlob(pattern) {
+    const results = [];
+    const cleanPattern = pattern.replace(/\/$/, '');
+    if (cleanPattern.includes('*')) {
+      const parts = cleanPattern.split('/');
+      const wildcardIndex = parts.findIndex(p => p.includes('*'));
+      const baseDir = path.join(this.cwd, ...parts.slice(0, wildcardIndex));
+      try {
+        const entries = await fs.readdir(baseDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith('.')) {
+            const fullPath = path.join(baseDir, entry.name);
+            try {
+              await fs.access(path.join(fullPath, 'package.json'));
+              results.push(fullPath.replace(/\\/g, '/'));
+            } catch (e) {}
+          }
+        }
+      } catch (e) {}
+    } else {
+      const fullPath = path.resolve(this.cwd, cleanPattern);
+      try {
+        const stat = await fs.stat(fullPath);
+        if (stat.isDirectory()) results.push(fullPath.replace(/\\/g, '/'));
+      } catch (e) {}
+    }
+    return results;
+  }
+
   _defaultConfig() {
     return {
       interface: 'CLI',
       useBuiltinPlugins: true,
       useCustomPlugins: true,
-      options: {
-        verbose: false,
-        fastMode: true,
-        selfHealing: true
-      },
+      options: { verbose: false, fastMode: true, selfHealing: true },
       enabledPlugins: [],
       ignoreDependencies: ['entkapp', '@types/*'],
       exclude: ['node_modules', '.git', 'dist', 'build', 'coverage'],
       entryPoints: [],
-      workspace: false
+      workspace: false,
+      workspacePackages: [],
+      workspaceTsConfigs: [],
+      workspaceConfigFiles: [],
+      monorepoConfigs: {}
     };
   }
 
@@ -79,8 +245,6 @@ export class ConfigLoader {
     for (const key of Object.keys(override)) {
       if (key === 'options' && typeof override[key] === 'object') {
         result.options = { ...(base.options || {}), ...override[key] };
-      } else if (Array.isArray(override[key])) {
-        result[key] = override[key];
       } else {
         result[key] = override[key];
       }