@wundr.io/cli 1.0.12 → 1.0.14

package/dist/commands/plugins.js

@@ -0,0 +1,685 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginCommands = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const error_handler_1 = require("../utils/error-handler");
+const logger_1 = require("../utils/logger");
+/**
+ * Plugin commands for managing CLI extensions
+ */
+class PluginCommands {
+    program;
+    configManager;
+    pluginManager;
+    constructor(program, configManager, pluginManager) {
+        this.program = program;
+        this.configManager = configManager;
+        this.pluginManager = pluginManager;
+        this.registerCommands();
+    }
+    registerCommands() {
+        const pluginCmd = this.program
+            .command('plugin')
+            .alias('plugins')
+            .description('manage CLI plugins and extensions');
+        // List plugins
+        pluginCmd
+            .command('list')
+            .alias('ls')
+            .description('list installed plugins')
+            .option('--available', 'show available plugins from registry')
+            .option('--enabled-only', 'show only enabled plugins')
+            .action(async (options) => {
+            await this.listPlugins(options);
+        });
+        // Install plugin
+        pluginCmd
+            .command('install <plugin>')
+            .description('install a plugin')
+            .option('--version <version>', 'specific version to install')
+            .option('--registry <url>', 'custom registry URL')
+            .option('--force', 'force reinstall if already exists')
+            .action(async (plugin, options) => {
+            await this.installPlugin(plugin, options);
+        });
+        // Uninstall plugin
+        pluginCmd
+            .command('uninstall <plugin>')
+            .alias('remove')
+            .description('uninstall a plugin')
+            .option('--force', 'skip confirmation')
+            .action(async (plugin, options) => {
+            await this.uninstallPlugin(plugin, options);
+        });
+        // Enable plugin
+        pluginCmd
+            .command('enable <plugin>')
+            .description('enable a plugin')
+            .action(async (plugin) => {
+            await this.enablePlugin(plugin);
+        });
+        // Disable plugin
+        pluginCmd
+            .command('disable <plugin>')
+            .description('disable a plugin')
+            .action(async (plugin) => {
+            await this.disablePlugin(plugin);
+        });
+        // Plugin info
+        pluginCmd
+            .command('info <plugin>')
+            .description('show plugin information')
+            .action(async (plugin) => {
+            await this.showPluginInfo(plugin);
+        });
+        // Update plugins
+        pluginCmd
+            .command('update [plugin]')
+            .description('update plugin(s)')
+            .option('--all', 'update all plugins')
+            .action(async (plugin, options) => {
+            await this.updatePlugin(plugin, options);
+        });
+        // Create plugin
+        pluginCmd
+            .command('create <name>')
+            .description('create a new plugin')
+            .option('--template <template>', 'plugin template', 'basic')
+            .option('--interactive', 'create plugin interactively')
+            .action(async (name, options) => {
+            await this.createPlugin(name, options);
+        });
+        // Publish plugin
+        pluginCmd
+            .command('publish')
+            .description('publish plugin to registry')
+            .option('--registry <url>', 'registry URL')
+            .option('--dry-run', 'show what would be published')
+            .action(async (options) => {
+            await this.publishPlugin(options);
+        });
+        // Search plugins
+        pluginCmd
+            .command('search <query>')
+            .description('search for plugins')
+            .option('--registry <url>', 'registry URL')
+            .option('--limit <count>', 'limit results', '20')
+            .action(async (query, options) => {
+            await this.searchPlugins(query, options);
+        });
+        // Plugin development
+        pluginCmd.command('dev').description('plugin development tools');
+        pluginCmd
+            .command('dev link <path>')
+            .description('link local plugin for development')
+            .action(async (pluginPath) => {
+            await this.linkPlugin(pluginPath);
+        });
+        pluginCmd
+            .command('dev unlink <plugin>')
+            .description('unlink development plugin')
+            .action(async (plugin) => {
+            await this.unlinkPlugin(plugin);
+        });
+        pluginCmd
+            .command('dev test <plugin>')
+            .description('test a plugin')
+            .option('--coverage', 'run with coverage')
+            .action(async (plugin, options) => {
+            await this.testPlugin(plugin, options);
+        });
+        // Plugin configuration
+        pluginCmd
+            .command('config <plugin>')
+            .description('configure plugin settings');
+        pluginCmd
+            .command('config <plugin> set <key> <value>')
+            .description('set plugin configuration')
+            .action(async (plugin, key, value) => {
+            await this.setPluginConfig(plugin, key, value);
+        });
+        pluginCmd
+            .command('config <plugin> get [key]')
+            .description('get plugin configuration')
+            .action(async (plugin, key) => {
+            await this.getPluginConfig(plugin, key);
+        });
+    }
+    /**
+     * List installed plugins
+     */
+    async listPlugins(options) {
+        try {
+            if (options.available) {
+                await this.listAvailablePlugins();
+            }
+            else {
+                await this.listInstalledPlugins(options.enabledOnly);
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_LIST_FAILED', 'Failed to list plugins', { options }, true);
+        }
+    }
+    /**
+     * Install a plugin
+     */
+    async installPlugin(plugin, options) {
+        try {
+            logger_1.logger.info(`Installing plugin: ${chalk_1.default.cyan(plugin)}`);
+            // Check if plugin already exists
+            if (!options.force &&
+                (await this.pluginManager.isPluginInstalled(plugin))) {
+                logger_1.logger.warn(`Plugin ${plugin} is already installed. Use --force to reinstall.`);
+                return;
+            }
+            await this.pluginManager.installPlugin(plugin, {
+                version: options.version,
+                registry: options.registry,
+                force: options.force,
+            });
+            logger_1.logger.success(`Plugin ${plugin} installed successfully`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_INSTALL_FAILED', 'Failed to install plugin', { plugin, options }, true);
+        }
+    }
+    /**
+     * Uninstall a plugin
+     */
+    async uninstallPlugin(plugin, options) {
+        try {
+            if (!(await this.pluginManager.isPluginInstalled(plugin))) {
+                logger_1.logger.warn(`Plugin ${plugin} is not installed`);
+                return;
+            }
+            if (!options.force) {
+                const inquirer = await Promise.resolve().then(() => tslib_1.__importStar(require('inquirer')));
+                const { confirm } = await inquirer.default.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: `Uninstall plugin ${plugin}?`,
+                        default: false,
+                    },
+                ]);
+                if (!confirm) {
+                    logger_1.logger.info('Uninstall cancelled');
+                    return;
+                }
+            }
+            await this.pluginManager.uninstallPlugin(plugin);
+            logger_1.logger.success(`Plugin ${plugin} uninstalled successfully`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_UNINSTALL_FAILED', 'Failed to uninstall plugin', { plugin, options }, true);
+        }
+    }
+    /**
+     * Enable a plugin
+     */
+    async enablePlugin(plugin) {
+        try {
+            if (!(await this.pluginManager.isPluginInstalled(plugin))) {
+                throw new Error(`Plugin ${plugin} is not installed`);
+            }
+            await this.pluginManager.enablePlugin(plugin);
+            logger_1.logger.success(`Plugin ${plugin} enabled`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_ENABLE_FAILED', 'Failed to enable plugin', { plugin }, true);
+        }
+    }
+    /**
+     * Disable a plugin
+     */
+    async disablePlugin(plugin) {
+        try {
+            if (!(await this.pluginManager.isPluginInstalled(plugin))) {
+                throw new Error(`Plugin ${plugin} is not installed`);
+            }
+            await this.pluginManager.disablePlugin(plugin);
+            logger_1.logger.success(`Plugin ${plugin} disabled`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_DISABLE_FAILED', 'Failed to disable plugin', { plugin }, true);
+        }
+    }
+    /**
+     * Show plugin information
+     */
+    async showPluginInfo(plugin) {
+        try {
+            const pluginInfo = await this.pluginManager.getPluginInfo(plugin);
+            if (!pluginInfo) {
+                logger_1.logger.warn(`Plugin ${plugin} not found`);
+                return;
+            }
+            console.log(chalk_1.default.blue(`\nPlugin Information: ${plugin}`));
+            console.log(`Name: ${pluginInfo.name}`);
+            console.log(`Version: ${pluginInfo.version}`);
+            console.log(`Description: ${pluginInfo.description || 'No description'}`);
+            console.log(`Author: ${pluginInfo.author || 'Unknown'}`);
+            console.log(`Status: ${pluginInfo.enabled ? 'Enabled' : 'Disabled'}`);
+            console.log(`Commands: ${pluginInfo.commands?.length || 0}`);
+            console.log(`Hooks: ${pluginInfo.hooks?.length || 0}`);
+            if (pluginInfo.dependencies && pluginInfo.dependencies.length > 0) {
+                console.log(`Dependencies: ${pluginInfo.dependencies.join(', ')}`);
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_INFO_FAILED', 'Failed to show plugin info', { plugin }, true);
+        }
+    }
+    /**
+     * Update plugin(s)
+     */
+    async updatePlugin(plugin, options) {
+        try {
+            if (options.all) {
+                logger_1.logger.info('Updating all plugins...');
+                await this.pluginManager.updateAllPlugins();
+                logger_1.logger.success('All plugins updated');
+            }
+            else if (plugin) {
+                logger_1.logger.info(`Updating plugin: ${chalk_1.default.cyan(plugin)}`);
+                await this.pluginManager.updatePlugin(plugin);
+                logger_1.logger.success(`Plugin ${plugin} updated`);
+            }
+            else {
+                throw new Error('Specify a plugin name or use --all');
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_UPDATE_FAILED', 'Failed to update plugin(s)', { plugin, options }, true);
+        }
+    }
+    /**
+     * Create a new plugin
+     */
+    async createPlugin(name, options) {
+        try {
+            logger_1.logger.info(`Creating plugin: ${chalk_1.default.cyan(name)}`);
+            let pluginConfig;
+            if (options.interactive) {
+                pluginConfig = await this.createInteractivePlugin(name);
+            }
+            else {
+                pluginConfig = await this.createPluginFromTemplate(name, options.template);
+            }
+            const pluginPath = path_1.default.join(process.cwd(), name);
+            await this.generatePluginStructure(pluginPath, pluginConfig);
+            logger_1.logger.success(`Plugin ${name} created at ${pluginPath}`);
+            logger_1.logger.info('Next steps:');
+            logger_1.logger.info(`  cd ${name}`);
+            logger_1.logger.info('  npm install');
+            logger_1.logger.info('  wundr plugin dev link .');
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_CREATE_FAILED', 'Failed to create plugin', { name, options }, true);
+        }
+    }
+    /**
+     * Publish plugin to registry
+     */
+    async publishPlugin(options) {
+        try {
+            logger_1.logger.info('Publishing plugin...');
+            if (options.dryRun) {
+                logger_1.logger.info('Dry run - would publish:');
+                // Show what would be published
+            }
+            else {
+                await this.pluginManager.publishPlugin({
+                    registry: options.registry,
+                });
+                logger_1.logger.success('Plugin published successfully');
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_PUBLISH_FAILED', 'Failed to publish plugin', { options }, true);
+        }
+    }
+    /**
+     * Search for plugins
+     */
+    async searchPlugins(query, options) {
+        try {
+            logger_1.logger.info(`Searching for plugins: ${chalk_1.default.cyan(query)}`);
+            const results = await this.pluginManager.searchPlugins(query, {
+                registry: options.registry,
+                limit: parseInt(options.limit),
+            });
+            if (results.length === 0) {
+                logger_1.logger.info('No plugins found');
+                return;
+            }
+            console.log(`\nFound ${results.length} plugin(s):`);
+            console.table(results.map(plugin => ({
+                Name: plugin.name,
+                Version: plugin.version,
+                Description: plugin.description || 'No description',
+                Downloads: plugin.downloads || 0,
+                Updated: plugin.updated
+                    ? new Date(plugin.updated).toLocaleDateString()
+                    : 'Unknown',
+            })));
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_SEARCH_FAILED', 'Failed to search plugins', { query, options }, true);
+        }
+    }
+    /**
+     * Link local plugin for development
+     */
+    async linkPlugin(pluginPath) {
+        try {
+            const absolutePath = path_1.default.resolve(pluginPath);
+            if (!(await fs_extra_1.default.pathExists(absolutePath))) {
+                throw new Error(`Plugin path does not exist: ${absolutePath}`);
+            }
+            await this.pluginManager.linkPlugin(absolutePath);
+            logger_1.logger.success(`Plugin linked: ${absolutePath}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_LINK_FAILED', 'Failed to link plugin', { pluginPath }, true);
+        }
+    }
+    /**
+     * Unlink development plugin
+     */
+    async unlinkPlugin(plugin) {
+        try {
+            await this.pluginManager.unlinkPlugin(plugin);
+            logger_1.logger.success(`Plugin unlinked: ${plugin}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_UNLINK_FAILED', 'Failed to unlink plugin', { plugin }, true);
+        }
+    }
+    /**
+     * Test a plugin
+     */
+    async testPlugin(plugin, options) {
+        try {
+            logger_1.logger.info(`Testing plugin: ${chalk_1.default.cyan(plugin)}`);
+            await this.pluginManager.testPlugin(plugin, {
+                coverage: options.coverage,
+            });
+            logger_1.logger.success(`Plugin ${plugin} tests passed`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_TEST_FAILED', 'Failed to test plugin', { plugin, options }, true);
+        }
+    }
+    /**
+     * Set plugin configuration
+     */
+    async setPluginConfig(plugin, key, value) {
+        try {
+            await this.pluginManager.setPluginConfig(plugin, key, value);
+            logger_1.logger.success(`Plugin configuration updated: ${plugin}.${key} = ${value}`);
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_CONFIG_SET_FAILED', 'Failed to set plugin configuration', { plugin, key, value }, true);
+        }
+    }
+    /**
+     * Get plugin configuration
+     */
+    async getPluginConfig(plugin, key) {
+        try {
+            if (key) {
+                const value = await this.pluginManager.getPluginConfig(plugin, key);
+                console.log(`${key}: ${value}`);
+            }
+            else {
+                const config = await this.pluginManager.getPluginConfig(plugin);
+                console.log(JSON.stringify(config, null, 2));
+            }
+        }
+        catch (error) {
+            throw error_handler_1.errorHandler.createError('WUNDR_PLUGIN_CONFIG_GET_FAILED', 'Failed to get plugin configuration', { plugin, key }, true);
+        }
+    }
+    /**
+     * Helper methods for plugin operations
+     */
+    async listInstalledPlugins(enabledOnly = false) {
+        const plugins = await this.pluginManager.getInstalledPlugins();
+        const filteredPlugins = enabledOnly
+            ? plugins.filter(p => p.enabled)
+            : plugins;
+        if (filteredPlugins.length === 0) {
+            logger_1.logger.info(enabledOnly ? 'No enabled plugins found' : 'No plugins installed');
+            return;
+        }
+        logger_1.logger.info(`${enabledOnly ? 'Enabled plugins' : 'Installed plugins'} (${filteredPlugins.length}):`);
+        const pluginData = filteredPlugins.map(plugin => ({
+            Name: plugin.name,
+            Version: plugin.version,
+            Status: plugin.enabled ? '✅ Enabled' : '❌ Disabled',
+            Commands: plugin.commands?.length || 0,
+            Description: plugin.description || 'No description',
+        }));
+        console.table(pluginData);
+    }
+    async listAvailablePlugins() {
+        const plugins = await this.pluginManager.getAvailablePlugins();
+        if (plugins.length === 0) {
+            logger_1.logger.info('No plugins available in registry');
+            return;
+        }
+        logger_1.logger.info(`Available plugins (${plugins.length}):`);
+        const pluginData = plugins.map(plugin => ({
+            Name: plugin.name,
+            Version: plugin.version,
+            Downloads: plugin.downloads || 0,
+            Updated: plugin.updated
+                ? new Date(plugin.updated).toLocaleDateString()
+                : 'Unknown',
+            Description: plugin.description || 'No description',
+        }));
+        console.table(pluginData);
+    }
+    async createInteractivePlugin(name) {
+        const inquirer = await Promise.resolve().then(() => tslib_1.__importStar(require('inquirer')));
+        return await inquirer.default.prompt([
+            {
+                type: 'input',
+                name: 'description',
+                message: 'Plugin description:',
+            },
+            {
+                type: 'input',
+                name: 'author',
+                message: 'Author name:',
+            },
+            {
+                type: 'input',
+                name: 'version',
+                message: 'Initial version:',
+                default: '1.0.0',
+            },
+            {
+                type: 'checkbox',
+                name: 'features',
+                message: 'Plugin features:',
+                choices: [
+                    'Commands',
+                    'Hooks',
+                    'Configuration',
+                    'Templates',
+                    'Middleware',
+                ],
+            },
+        ]);
+    }
+    async createPluginFromTemplate(name, template) {
+        const templates = {
+            basic: {
+                description: `A basic Wundr plugin: ${name}`,
+                features: ['Commands'],
+            },
+            advanced: {
+                description: `An advanced Wundr plugin: ${name}`,
+                features: ['Commands', 'Hooks', 'Configuration'],
+            },
+            template: {
+                description: `A template-based Wundr plugin: ${name}`,
+                features: ['Templates', 'Commands'],
+            },
+        };
+        return templates[template] || templates['basic'];
+    }
+    async generatePluginStructure(pluginPath, config) {
+        await fs_extra_1.default.ensureDir(pluginPath);
+        // Create package.json
+        const packageJson = {
+            name: path_1.default.basename(pluginPath),
+            version: config.version || '1.0.0',
+            description: config.description,
+            main: 'dist/index.js',
+            types: 'dist/index.d.ts',
+            files: ['dist'],
+            scripts: {
+                build: 'tsc',
+                dev: 'tsc --watch',
+                test: 'jest',
+            },
+            peerDependencies: {
+                '@wundr/cli': '^1.0.0',
+            },
+            devDependencies: {
+                typescript: '^5.0.0',
+                '@types/node': '^20.0.0',
+                jest: '^29.0.0',
+            },
+            wundr: {
+                plugin: true,
+                commands: config.features?.includes('Commands') || false,
+                hooks: config.features?.includes('Hooks') || false,
+                templates: config.features?.includes('Templates') || false,
+            },
+        };
+        await fs_extra_1.default.writeJson(path_1.default.join(pluginPath, 'package.json'), packageJson, {
+            spaces: 2,
+        });
+        // Create TypeScript config
+        const tsConfig = {
+            compilerOptions: {
+                target: 'ES2020',
+                module: 'CommonJS',
+                outDir: './dist',
+                rootDir: './src',
+                strict: true,
+                esModuleInterop: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                declaration: true,
+                declarationMap: true,
+                sourceMap: true,
+            },
+            include: ['src/**/*'],
+            exclude: ['node_modules', 'dist'],
+        };
+        await fs_extra_1.default.writeJson(path_1.default.join(pluginPath, 'tsconfig.json'), tsConfig, {
+            spaces: 2,
+        });
+        // Create source directory and files
+        const srcDir = path_1.default.join(pluginPath, 'src');
+        await fs_extra_1.default.ensureDir(srcDir);
+        // Create main plugin file
+        const pluginCode = this.generatePluginCode(path_1.default.basename(pluginPath), config);
+        await fs_extra_1.default.writeFile(path_1.default.join(srcDir, 'index.ts'), pluginCode);
+        // Create README
+        const readme = this.generatePluginReadme(path_1.default.basename(pluginPath), config);
+        await fs_extra_1.default.writeFile(path_1.default.join(pluginPath, 'README.md'), readme);
+    }
+    generatePluginCode(name, config) {
+        return `import { Plugin, PluginContext } from '@wundr/cli';
+
+export default class ${this.toPascalCase(name)}Plugin implements Plugin {
+  name = '${name}';
+  version = '${config.version || '1.0.0'}';
+  description = '${config.description}';
+
+  async activate(context: PluginContext): Promise<void> {
+    // Plugin activation logic
+    context.logger.info('${name} plugin activated');
+
+    ${config.features?.includes('Commands') ? this.generateCommandCode(name) : ''}
+    ${config.features?.includes('Hooks') ? this.generateHookCode(name) : ''}
+  }
+
+  async deactivate(): Promise<void> {
+    // Plugin deactivation logic
+  }
+}
+`;
+    }
+    generateCommandCode(name) {
+        return `
+    // Register commands
+    context.registerCommand({
+      name: '${name}',
+      description: '${name} plugin command',
+      action: async (args, options, ctx) => {
+        ctx.logger.info('${name} command executed');
+      }
+    });
+`;
+    }
+    generateHookCode(name) {
+        return `
+    // Register hooks
+    context.registerHook({
+      event: 'before-command',
+      handler: async (data, ctx) => {
+        ctx.logger.debug('${name} hook: before-command');
+      }
+    });
+`;
+    }
+    generatePluginReadme(name, config) {
+        return `# ${name}
+
+${config.description}
+
+## Installation
+
+\`\`\`bash
+wundr plugin install ${name}
+\`\`\`
+
+## Usage
+
+\`\`\`bash
+wundr ${name}
+\`\`\`
+
+## Development
+
+\`\`\`bash
+npm install
+npm run build
+wundr plugin dev link .
+\`\`\`
+
+## License
+
+MIT
+`;
+    }
+    toPascalCase(str) {
+        return str
+            .split(/[-_\s]/)
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+    }
+}
+exports.PluginCommands = PluginCommands;
+//# sourceMappingURL=plugins.js.map