entkapp 5.4.0 → 5.6.0

package/src/plugins/BasePlugin.js

@@ -5,7 +5,7 @@ import path from 'path';
  * Base class for all entkapp plugins.
  * Defines the contract for ecosystem detection, entry point mapping,
  * and missing dependency / devDependency detection.
- * Version 5.4.0: Added detectEntryPoints() for dynamic framework entry detection.
+ * Version 5.0.0: Added getMissingDependencies(), getOrphanedConfigs(), runDependencyDiagnostics().
  */
 export class BasePlugin {
     constructor(context) {
@@ -34,17 +34,6 @@ export class BasePlugin {
         return [];
     }
 
-    /**
-     * Version 5.4.0: Dynamically detect entry points from a file's content.
-     * Useful for parsing vite.config.ts, webpack.config.js, etc.
-     * @param {string} content - The file content
-     * @param {string} filePath - The absolute path to the file
-     * @returns {Array<string>} List of relative or absolute entry point paths
-     */
-    detectEntryPoints(content, filePath) {
-        return [];
-    }
-
     /**
      * Returns symbols that are implicitly required/exported by the framework.
      */
@@ -54,13 +43,25 @@ export class BasePlugin {
 
     /**
      * Returns the npm package names required for this plugin to work.
+     * Each entry is either a string or an object:
+     *   { name: string, dev?: boolean, optional?: boolean }
+     *   - dev: true  => expected in devDependencies
+     *   - dev: false => expected in dependencies
+     *   - optional   => only warn, not error
+     *
+     * Override in subclasses to enable automatic dependency checking.
+     * @returns {Array<string | {name: string, dev?: boolean, optional?: boolean}>}
      */
     getRequiredPackages() {
         return [];
     }
 
     /**
-     * Checks whether all required packages are present in package.json.
+     * Version 5.0.0: Checks whether all required packages are present in package.json.
+     * Returns an array of diagnostic objects describing missing or misplaced dependencies.
+     *
+     * @param {string} baseDir - The project root directory
+     * @returns {Promise<Array>}
      */
     async getMissingDependencies(baseDir) {
         const diagnostics = [];
@@ -146,7 +147,11 @@ export class BasePlugin {
     }
 
     /**
-     * Checks for config files that exist without the corresponding package.
+     * Version 5.0.0: Checks for config files that exist without the corresponding package.
+     * Detects "orphaned" configs – e.g. .prettierrc exists but prettier is not installed.
+     *
+     * @param {string} baseDir
+     * @returns {Promise<Array>}
      */
     async getOrphanedConfigs(baseDir) {
         const diagnostics = [];
@@ -190,7 +195,11 @@ export class BasePlugin {
     }
 
     /**
-     * Run all dependency diagnostics (missing + orphaned).
+     * Version 5.0.0: Run all dependency diagnostics (missing + orphaned).
+     * Convenience method combining getMissingDependencies and getOrphanedConfigs.
+     *
+     * @param {string} baseDir
+     * @returns {Promise<Array>}
      */
     async runDependencyDiagnostics(baseDir) {
         const [missing, orphaned] = await Promise.all([
@@ -201,7 +210,9 @@ export class BasePlugin {
     }
 
     /**
-     * Dynamic getter for custom plugin properties.
+     * Version 3.2.0: Dynamic getter for custom plugin properties.
+     * @param {string} key - The property key to retrieve
+     * @returns {any} The value of the custom property
      */
     get(key) {
         const methodName = `get${key.charAt(0).toUpperCase() + key.slice(1)}`;

package/src/plugins/BasePlugin.mjs

@@ -0,0 +1,240 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Base class for all entkapp plugins.
+ * Defines the contract for ecosystem detection, entry point mapping,
+ * and missing dependency / devDependency detection.
+ * Version 5.0.0: Added getMissingDependencies(), getOrphanedConfigs(), runDependencyDiagnostics().
+ */
+export class BasePlugin {
+    constructor(context) {
+        this.context = context;
+        this.customGetters = new Map();
+    }
+
+    /**
+     * Unique identifier for the plugin (e.g., 'nextjs').
+     */
+    get name() {
+        throw new Error('Plugin must implement name getter');
+    }
+
+    /**
+     * Returns a list of configuration files that indicate this ecosystem is active.
+     */
+    getConfigFiles() {
+        return [];
+    }
+
+    /**
+     * Returns regex patterns for files that should be treated as entry points.
+     */
+    getRoutePatterns() {
+        return [];
+    }
+
+    /**
+     * Returns symbols that are implicitly required/exported by the framework.
+     */
+    getRequiredSystemContracts() {
+        return ['default'];
+    }
+
+    /**
+     * Returns the npm package names required for this plugin to work.
+     * Each entry is either a string or an object:
+     *   { name: string, dev?: boolean, optional?: boolean }
+     *   - dev: true  => expected in devDependencies
+     *   - dev: false => expected in dependencies
+     *   - optional   => only warn, not error
+     *
+     * Override in subclasses to enable automatic dependency checking.
+     * @returns {Array<string | {name: string, dev?: boolean, optional?: boolean}>}
+     */
+    getRequiredPackages() {
+        return [];
+    }
+
+    /**
+     * Version 5.0.0: Checks whether all required packages are present in package.json.
+     * Returns an array of diagnostic objects describing missing or misplaced dependencies.
+     *
+     * @param {string} baseDir - The project root directory
+     * @returns {Promise<Array>}
+     */
+    async getMissingDependencies(baseDir) {
+        const diagnostics = [];
+        const requiredPackages = this.getRequiredPackages();
+        if (requiredPackages.length === 0) return diagnostics;
+
+        let pkg = null;
+        try {
+            const raw = await fs.readFile(path.join(baseDir, 'package.json'), 'utf8');
+            pkg = JSON.parse(raw);
+        } catch {
+            return diagnostics;
+        }
+
+        const deps = pkg.dependencies || {};
+        const devDeps = pkg.devDependencies || {};
+
+        for (const entry of requiredPackages) {
+            const pkgName = typeof entry === 'string' ? entry : entry.name;
+            const isDev = typeof entry === 'object' ? entry.dev : undefined;
+            const isOptional = typeof entry === 'object' ? (entry.optional ?? false) : false;
+
+            const inDeps = pkgName in deps;
+            const inDevDeps = pkgName in devDeps;
+            const found = inDeps ? 'dependencies' : inDevDeps ? 'devDependencies' : null;
+
+            if (!found) {
+                let triggerFile = null;
+                for (const cfgFile of this.getConfigFiles()) {
+                    try {
+                        await fs.access(path.join(baseDir, cfgFile));
+                        triggerFile = cfgFile;
+                        break;
+                    } catch { /* not found */ }
+                }
+
+                const expectedIn = isDev === true ? 'devDependencies' : isDev === false ? 'dependencies' : 'either';
+                const severity = isOptional ? 'warning' : 'error';
+
+                let message = `Plugin "${this.name}": package "${pkgName}" is not installed`;
+                if (triggerFile) {
+                    message += ` (config file "${triggerFile}" was found)`;
+                }
+                if (isDev === true) {
+                    message += ` — expected in devDependencies`;
+                } else if (isDev === false) {
+                    message += ` — expected in dependencies`;
+                }
+
+                diagnostics.push({
+                    plugin: this.name,
+                    package: pkgName,
+                    expectedIn,
+                    foundIn: null,
+                    configFile: triggerFile,
+                    severity,
+                    message,
+                });
+            } else if (isDev === true && found === 'dependencies') {
+                diagnostics.push({
+                    plugin: this.name,
+                    package: pkgName,
+                    expectedIn: 'devDependencies',
+                    foundIn: 'dependencies',
+                    configFile: null,
+                    severity: 'warning',
+                    message: `Plugin "${this.name}": package "${pkgName}" is in "dependencies" but should be in "devDependencies"`,
+                });
+            } else if (isDev === false && found === 'devDependencies') {
+                diagnostics.push({
+                    plugin: this.name,
+                    package: pkgName,
+                    expectedIn: 'dependencies',
+                    foundIn: 'devDependencies',
+                    configFile: null,
+                    severity: 'warning',
+                    message: `Plugin "${this.name}": package "${pkgName}" is in "devDependencies" but should be in "dependencies"`,
+                });
+            }
+        }
+
+        return diagnostics;
+    }
+
+    /**
+     * Version 5.0.0: Checks for config files that exist without the corresponding package.
+     * Detects "orphaned" configs – e.g. .prettierrc exists but prettier is not installed.
+     *
+     * @param {string} baseDir
+     * @returns {Promise<Array>}
+     */
+    async getOrphanedConfigs(baseDir) {
+        const diagnostics = [];
+        const requiredPackages = this.getRequiredPackages();
+        if (requiredPackages.length === 0) return diagnostics;
+
+        let pkg = null;
+        try {
+            const raw = await fs.readFile(path.join(baseDir, 'package.json'), 'utf8');
+            pkg = JSON.parse(raw);
+        } catch {
+            return diagnostics;
+        }
+
+        const allDeps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+
+        const anyPackagePresent = requiredPackages.some(entry => {
+            const pkgName = typeof entry === 'string' ? entry : entry.name;
+            return pkgName in allDeps;
+        });
+
+        if (!anyPackagePresent) {
+            for (const cfgFile of this.getConfigFiles()) {
+                try {
+                    await fs.access(path.join(baseDir, cfgFile));
+                    const missingPkgs = requiredPackages
+                        .map(e => typeof e === 'string' ? e : e.name)
+                        .filter(n => !(n in allDeps));
+
+                    diagnostics.push({
+                        plugin: this.name,
+                        configFile: cfgFile,
+                        severity: 'error',
+                        message: `Plugin "${this.name}": config file "${cfgFile}" exists but required package(s) [${missingPkgs.join(', ')}] are not installed`,
+                    });
+                } catch { /* file not found */ }
+            }
+        }
+
+        return diagnostics;
+    }
+
+    /**
+     * Version 5.0.0: Run all dependency diagnostics (missing + orphaned).
+     * Convenience method combining getMissingDependencies and getOrphanedConfigs.
+     *
+     * @param {string} baseDir
+     * @returns {Promise<Array>}
+     */
+    async runDependencyDiagnostics(baseDir) {
+        const [missing, orphaned] = await Promise.all([
+            this.getMissingDependencies(baseDir),
+            this.getOrphanedConfigs(baseDir),
+        ]);
+        return [...missing, ...orphaned];
+    }
+
+    /**
+     * Version 3.2.0: Dynamic getter for custom plugin properties.
+     * @param {string} key - The property key to retrieve
+     * @returns {any} The value of the custom property
+     */
+    get(key) {
+        const methodName = `get${key.charAt(0).toUpperCase() + key.slice(1)}`;
+        if (typeof this[methodName] === 'function') {
+            return this[methodName]();
+        }
+        return this.customGetters.get(key);
+    }
+
+    /**
+     * Optional: Logic to detect if the plugin should be active in the given directory.
+     */
+    async isActive(baseDir) {
+        const configFiles = this.getConfigFiles();
+        for (const file of configFiles) {
+            try {
+                await fs.access(path.join(baseDir, file));
+                return true;
+            } catch {
+                continue;
+            }
+        }
+        return false;
+    }
+}

package/src/plugins/PluginRegistry.js

@@ -111,31 +111,6 @@ 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()) {
@@ -146,25 +121,6 @@ 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/PluginRegistry.mjs

@@ -0,0 +1,203 @@
+import { loadAdditionalPlugins } from "./ecosystems/PluginLoader.mjs";
+import path from 'path';
+import fs from 'fs/promises';
+import { pathToFileURL } from 'url';
+import { AllPluginClasses } from './ecosystems/UltimateBundle.mjs';
+/**
+ * ============================================================================
+ * Plugin Registry for entkapp v5.0.0
+ * ============================================================================
+ * Advanced Plugin Registry supporting Builtin and Custom plugins.
+ * v5.0.0: Added runAllDependencyDiagnostics() for project-wide dependency checks.
+ */
+export class PluginRegistry {
+    constructor(context) {
+        this.context = context;
+        this.plugins = new Map();
+        this.config = null;
+    }
+
+    async init(projectRoot) {
+        const configPath = path.join(projectRoot, 'entkapp', 'config.json');
+        try {
+            const configRaw = await fs.readFile(configPath, 'utf8');
+            this.config = JSON.parse(configRaw);
+        } catch (e) {
+            this.config = {
+                useBuiltinPlugins: true,
+                useCustomPlugins: true,
+            };
+        }
+        if (this.config.useBuiltinPlugins !== false) {
+            await this.loadBuiltinPlugins();
+        }
+        if (this.config.useCustomPlugins !== false) {
+            await this.loadCustomPlugins(projectRoot);
+        }
+    }
+
+    async loadBuiltinPlugins() {
+        // Delegate to PluginLoader which registers all built-in plugins
+        loadAdditionalPlugins(this);
+
+        // Also load TypeScript and Next.js plugins (primary framework plugins)
+        
+
+        AllPluginClasses.forEach(PluginClass => {
+            this.register(new PluginClass(this.context));
+        });
+    }
+    async loadCustomPlugins(projectRoot) {
+        const pluginsDir = path.join(projectRoot, 'entkapp', 'plugins');
+        try {
+            const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                let pluginPath = path.join(pluginsDir, entry.name);
+                // Folder-based plugin support
+                if (entry.isDirectory()) {
+                    const files = await fs.readdir(pluginPath);
+                    if (files.includes('index.ts')) {
+                        pluginPath = path.join(pluginPath, 'index.ts');
+                    } else if (files.includes('index.mjs')) {
+                        pluginPath = path.join(pluginPath, 'index.mjs');
+                    } else {
+                        continue;
+                    }
+                }
+                if (pluginPath.endsWith('.ts')) {
+                    await this.loadTypeScriptPlugin(pluginPath);
+                } else if (pluginPath.endsWith('.mjs') || pluginPath.endsWith('.mjs')) {
+                    await this.loadJavaScriptPlugin(pluginPath);
+                }
+            }
+        } catch (e) {
+            // No custom plugins or dir missing
+        }
+    }
+
+    async loadJavaScriptPlugin(pluginPath) {
+        try {
+            const pluginModule = await import(pathToFileURL(pluginPath).href);
+            const PluginClass = pluginModule.default || pluginModule;
+            const pluginInstance = new PluginClass(this.context);
+            this.register(pluginInstance);
+        } catch (e) {
+            console.error(`[PluginRegistry] Failed to load JS plugin ${pluginPath}:`, e);
+        }
+    }
+
+    async loadTypeScriptPlugin(pluginPath) {
+        try {
+            if (this.context?.verbose) {
+                console.log(`[PluginRegistry] Transpiling TS plugin: ${pluginPath}`);
+            }
+            await this.loadJavaScriptPlugin(pluginPath);
+        } catch (e) {
+            console.error(`[PluginRegistry] Failed to load TS plugin ${pluginPath}:`, e);
+        }
+    }
+
+    register(plugin) {
+        if (plugin && plugin.name) {
+            this.plugins.set(plugin.name, plugin);
+        }
+    }
+
+    getPlugins() {
+        return Array.from(this.plugins.values());
+    }
+
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
+
+    async getActivePlugins(baseDir) {
+        const active = [];
+        for (const plugin of this.plugins.values()) {
+            if (await plugin.isActive(baseDir)) {
+                active.push(plugin);
+            }
+        }
+        return active;
+    }
+
+    /**
+     * Version 5.0.0: Run dependency diagnostics across all registered plugins.
+     * Returns a consolidated list of missing/misplaced dependencies and orphaned configs.
+     *
+     * @param {string} baseDir - The project root directory to check
+     * @returns {Promise<Array<{
+     *   plugin: string,
+     *   severity: 'error' | 'warning',
+     *   message: string,
+     *   package?: string,
+     *   configFile?: string,
+     *   expectedIn?: string,
+     *   foundIn?: string | null
+     * }>>}
+     */
+    async runAllDependencyDiagnostics(baseDir) {
+        const allDiagnostics = [];
+        const seenMessages = new Set();
+
+        for (const plugin of this.plugins.values()) {
+            if (typeof plugin.runDependencyDiagnostics === 'function') {
+                try {
+                    const diagnostics = await plugin.runDependencyDiagnostics(baseDir);
+                    for (const d of diagnostics) {
+                        // Deduplicate by message to avoid noise from overlapping plugins
+                        if (!seenMessages.has(d.message)) {
+                            seenMessages.add(d.message);
+                            allDiagnostics.push(d);
+                        }
+                    }
+                } catch (e) {
+                    if (this.context?.verbose) {
+                        console.warn(`[PluginRegistry] Dependency diagnostic failed for plugin "${plugin.name}":`, e.message);
+                    }
+                }
+            }
+        }
+
+        // Sort: errors first, then warnings; then alphabetically by plugin name
+        return allDiagnostics.sort((a, b) => {
+            if (a.severity !== b.severity) return a.severity === 'error' ? -1 : 1;
+            return a.plugin.localeCompare(b.plugin);
+        });
+    }
+
+    /**
+     * Version 5.0.0: Format dependency diagnostics for console output.
+     * @param {Array} diagnostics - Result of runAllDependencyDiagnostics()
+     * @returns {string} Formatted string ready for console output
+     */
+    formatDependencyDiagnostics(diagnostics) {
+        if (diagnostics.length === 0) {
+            return '[entkapp] No missing dependencies detected.';
+        }
+
+        const errors = diagnostics.filter(d => d.severity === 'error');
+        const warnings = diagnostics.filter(d => d.severity === 'warning');
+
+        const lines = [];
+        lines.push(`[entkapp] Dependency Diagnostics: ${errors.length} error(s), ${warnings.length} warning(s)`);
+        lines.push('');
+
+        if (errors.length > 0) {
+            lines.push('  Errors:');
+            for (const d of errors) {
+                lines.push(`    [ERROR]  ${d.message}`);
+            }
+            lines.push('');
+        }
+
+        if (warnings.length > 0) {
+            lines.push('  Warnings:');
+            for (const d of warnings) {
+                lines.push(`    [WARN]   ${d.message}`);
+            }
+        }
+
+        return lines.join('\n');
+    }
+}