@girardmedia/bootspring 1.1.0

package/cli/plugin.js

@@ -0,0 +1,451 @@
+/**
+ * Bootspring Plugin Command
+ * Manage project plugins
+ *
+ * @package bootspring
+ * @command plugin
+ */
+
+const path = require('path');
+const config = require('../core/config');
+const utils = require('../core/utils');
+
+/**
+ * Plugin definitions
+ */
+const PLUGINS = {
+  auth: {
+    name: 'Authentication',
+    description: 'User authentication and authorization',
+    providers: ['clerk', 'nextauth', 'auth0', 'supabase'],
+    defaultProvider: 'clerk',
+    features: ['social_login', 'email_password', 'magic_link', 'organizations', 'rbac'],
+    requiredEnv: {
+      clerk: ['NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY', 'CLERK_SECRET_KEY'],
+      nextauth: ['NEXTAUTH_SECRET', 'NEXTAUTH_URL'],
+      auth0: ['AUTH0_CLIENT_ID', 'AUTH0_CLIENT_SECRET', 'AUTH0_ISSUER'],
+      supabase: ['NEXT_PUBLIC_SUPABASE_URL', 'SUPABASE_SERVICE_ROLE_KEY']
+    },
+    skills: ['auth/clerk', 'auth/nextauth']
+  },
+  payments: {
+    name: 'Payments',
+    description: 'Payment processing and subscriptions',
+    providers: ['stripe', 'paddle', 'lemonsqueezy'],
+    defaultProvider: 'stripe',
+    features: ['checkout', 'subscriptions', 'webhooks', 'invoices', 'usage_billing'],
+    requiredEnv: {
+      stripe: ['STRIPE_SECRET_KEY', 'STRIPE_WEBHOOK_SECRET'],
+      paddle: ['PADDLE_VENDOR_ID', 'PADDLE_API_KEY'],
+      lemonsqueezy: ['LEMONSQUEEZY_API_KEY', 'LEMONSQUEEZY_SIGNING_SECRET']
+    },
+    skills: ['payments/stripe', 'payments/webhooks']
+  },
+  database: {
+    name: 'Database',
+    description: 'Database ORM and migrations',
+    providers: ['prisma', 'drizzle', 'typeorm', 'mongoose'],
+    defaultProvider: 'prisma',
+    features: ['migrations', 'transactions', 'soft_deletes', 'seeding'],
+    requiredEnv: {
+      prisma: ['DATABASE_URL'],
+      drizzle: ['DATABASE_URL'],
+      typeorm: ['DATABASE_URL'],
+      mongoose: ['MONGODB_URI']
+    },
+    skills: ['database/prisma', 'database/drizzle']
+  },
+  testing: {
+    name: 'Testing',
+    description: 'Testing frameworks and utilities',
+    providers: ['vitest', 'jest', 'playwright'],
+    defaultProvider: 'vitest',
+    features: ['unit', 'integration', 'e2e', 'coverage', 'mocking'],
+    requiredEnv: {},
+    skills: ['testing/vitest', 'testing/playwright']
+  },
+  security: {
+    name: 'Security',
+    description: 'Security checks and protections',
+    providers: ['default'],
+    defaultProvider: 'default',
+    features: ['input_validation', 'rate_limiting', 'csrf', 'cors', 'owasp_checks'],
+    requiredEnv: {},
+    skills: ['security/validation', 'security/rate-limiting']
+  },
+  ai: {
+    name: 'AI Integration',
+    description: 'AI model integration and utilities',
+    providers: ['anthropic', 'openai', 'google'],
+    defaultProvider: 'anthropic',
+    features: ['streaming', 'tool_use', 'structured_output', 'embeddings', 'rag'],
+    requiredEnv: {
+      anthropic: ['ANTHROPIC_API_KEY'],
+      openai: ['OPENAI_API_KEY'],
+      google: ['GOOGLE_AI_API_KEY']
+    },
+    skills: ['ai/streaming', 'ai/tool-use']
+  }
+};
+
+/**
+ * List all plugins
+ */
+function listPlugins() {
+  const cfg = config.load();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Plugins${utils.COLORS.reset}
+${utils.COLORS.dim}Extensible functionality for your project${utils.COLORS.reset}
+`);
+
+  for (const [id, plugin] of Object.entries(PLUGINS)) {
+    const userPlugin = cfg.plugins?.[id] || {};
+    const enabled = userPlugin.enabled !== false && (userPlugin.enabled || userPlugin.provider);
+    const provider = userPlugin.provider || plugin.defaultProvider;
+
+    const statusIcon = enabled
+      ? `${utils.COLORS.green}●${utils.COLORS.reset}`
+      : `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+
+    const statusText = enabled
+      ? `${utils.COLORS.green}enabled${utils.COLORS.reset} (${provider})`
+      : `${utils.COLORS.dim}disabled${utils.COLORS.reset}`;
+
+    console.log(`  ${statusIcon} ${utils.COLORS.cyan}${id}${utils.COLORS.reset}`);
+    console.log(`    ${plugin.description}`);
+    console.log(`    Status: ${statusText}`);
+    console.log();
+  }
+
+  utils.print.dim('Use "bootspring plugin show <name>" for details');
+}
+
+/**
+ * Show plugin details
+ */
+function showPlugin(pluginId) {
+  const plugin = PLUGINS[pluginId];
+
+  if (!plugin) {
+    utils.print.error(`Plugin not found: ${pluginId}`);
+    utils.print.dim('Use "bootspring plugin list" to see available plugins');
+    return;
+  }
+
+  const cfg = config.load();
+  const userPlugin = cfg.plugins?.[pluginId] || {};
+  const enabled = userPlugin.enabled !== false && (userPlugin.enabled || userPlugin.provider);
+  const currentProvider = userPlugin.provider || plugin.defaultProvider;
+  const enabledFeatures = userPlugin.features || [];
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ ${plugin.name} Plugin${utils.COLORS.reset}
+${utils.COLORS.dim}${plugin.description}${utils.COLORS.reset}
+
+${utils.COLORS.bold}Status${utils.COLORS.reset}
+  Enabled: ${enabled ? `${utils.COLORS.green}yes${utils.COLORS.reset}` : `${utils.COLORS.dim}no${utils.COLORS.reset}`}
+  Provider: ${currentProvider}
+
+${utils.COLORS.bold}Available Providers${utils.COLORS.reset}
+${plugin.providers.map(p => {
+  const isCurrent = p === currentProvider;
+  const icon = isCurrent ? `${utils.COLORS.green}●${utils.COLORS.reset}` : `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+  return `  ${icon} ${p}${isCurrent ? ' (current)' : ''}`;
+}).join('\n')}
+
+${utils.COLORS.bold}Available Features${utils.COLORS.reset}
+${plugin.features.map(f => {
+  const isEnabled = enabledFeatures.includes(f);
+  const icon = isEnabled ? `${utils.COLORS.green}✓${utils.COLORS.reset}` : `${utils.COLORS.dim}○${utils.COLORS.reset}`;
+  return `  ${icon} ${f}`;
+}).join('\n')}
+`);
+
+  // Show required environment variables
+  const requiredEnv = plugin.requiredEnv[currentProvider];
+  if (requiredEnv && requiredEnv.length > 0) {
+    console.log(`${utils.COLORS.bold}Required Environment Variables${utils.COLORS.reset}`);
+    for (const envVar of requiredEnv) {
+      const hasValue = !!process.env[envVar];
+      const icon = hasValue
+        ? `${utils.COLORS.green}✓${utils.COLORS.reset}`
+        : `${utils.COLORS.red}✗${utils.COLORS.reset}`;
+      console.log(`  ${icon} ${envVar}`);
+    }
+    console.log();
+  }
+
+  // Show related skills
+  if (plugin.skills.length > 0) {
+    console.log(`${utils.COLORS.bold}Related Skills${utils.COLORS.reset}`);
+    for (const skill of plugin.skills) {
+      console.log(`  ${utils.COLORS.dim}bootspring skill show ${skill}${utils.COLORS.reset}`);
+    }
+    console.log();
+  }
+
+  console.log(`${utils.COLORS.bold}Configuration${utils.COLORS.reset}
+  Edit ${utils.COLORS.cyan}bootspring.config.js${utils.COLORS.reset}:
+
+  plugins: {
+    ${pluginId}: {
+      enabled: true,
+      provider: '${currentProvider}',
+      features: ['${plugin.features.slice(0, 3).join("', '")}']
+    }
+  }
+`);
+}
+
+/**
+ * Enable a plugin
+ */
+function enablePlugin(pluginId, options = {}) {
+  const plugin = PLUGINS[pluginId];
+
+  if (!plugin) {
+    utils.print.error(`Plugin not found: ${pluginId}`);
+    return;
+  }
+
+  const provider = options.provider || plugin.defaultProvider;
+
+  if (!plugin.providers.includes(provider)) {
+    utils.print.error(`Invalid provider: ${provider}`);
+    utils.print.dim(`Valid providers: ${plugin.providers.join(', ')}`);
+    return;
+  }
+
+  utils.print.success(`To enable ${pluginId} plugin with ${provider}:`);
+  console.log(`
+  Edit ${utils.COLORS.cyan}bootspring.config.js${utils.COLORS.reset}:
+
+  plugins: {
+    ${pluginId}: {
+      enabled: true,
+      provider: '${provider}',
+      features: ['${plugin.features.slice(0, 3).join("', '")}']
+    }
+  }
+`);
+
+  // Show required env vars
+  const requiredEnv = plugin.requiredEnv[provider];
+  if (requiredEnv && requiredEnv.length > 0) {
+    console.log(`${utils.COLORS.bold}Add to .env:${utils.COLORS.reset}`);
+    for (const envVar of requiredEnv) {
+      console.log(`  ${envVar}=your_value_here`);
+    }
+    console.log();
+  }
+
+  console.log(`${utils.COLORS.dim}Then run: bootspring generate${utils.COLORS.reset}`);
+}
+
+/**
+ * Disable a plugin
+ */
+function disablePlugin(pluginId) {
+  const plugin = PLUGINS[pluginId];
+
+  if (!plugin) {
+    utils.print.error(`Plugin not found: ${pluginId}`);
+    return;
+  }
+
+  utils.print.success(`To disable ${pluginId} plugin:`);
+  console.log(`
+  Edit ${utils.COLORS.cyan}bootspring.config.js${utils.COLORS.reset}:
+
+  plugins: {
+    ${pluginId}: {
+      enabled: false
+    }
+  }
+`);
+  console.log(`${utils.COLORS.dim}Then run: bootspring generate${utils.COLORS.reset}`);
+}
+
+/**
+ * Validate plugins
+ */
+function validatePlugins() {
+  const cfg = config.load();
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Plugin Validation${utils.COLORS.reset}
+`);
+
+  let issues = 0;
+
+  for (const [id, plugin] of Object.entries(PLUGINS)) {
+    const userPlugin = cfg.plugins?.[id] || {};
+    const enabled = userPlugin.enabled !== false && (userPlugin.enabled || userPlugin.provider);
+
+    if (!enabled) continue;
+
+    const provider = userPlugin.provider || plugin.defaultProvider;
+    const requiredEnv = plugin.requiredEnv[provider] || [];
+
+    let pluginOk = true;
+    const missingEnv = [];
+
+    for (const envVar of requiredEnv) {
+      if (!process.env[envVar]) {
+        missingEnv.push(envVar);
+        pluginOk = false;
+      }
+    }
+
+    if (pluginOk) {
+      console.log(`  ${utils.COLORS.green}✓${utils.COLORS.reset} ${id} (${provider})`);
+    } else {
+      console.log(`  ${utils.COLORS.red}✗${utils.COLORS.reset} ${id} (${provider})`);
+      console.log(`    ${utils.COLORS.dim}Missing: ${missingEnv.join(', ')}${utils.COLORS.reset}`);
+      issues++;
+    }
+  }
+
+  console.log();
+
+  if (issues === 0) {
+    utils.print.success('All enabled plugins are properly configured');
+  } else {
+    utils.print.warning(`${issues} plugin(s) have missing configuration`);
+  }
+}
+
+/**
+ * Show skills for a plugin
+ */
+function showPluginSkills(pluginId) {
+  const plugin = PLUGINS[pluginId];
+
+  if (!plugin) {
+    utils.print.error(`Plugin not found: ${pluginId}`);
+    return;
+  }
+
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ ${plugin.name} Skills${utils.COLORS.reset}
+`);
+
+  if (plugin.skills.length === 0) {
+    utils.print.dim('No skills available for this plugin');
+    return;
+  }
+
+  for (const skill of plugin.skills) {
+    console.log(`  ${utils.COLORS.cyan}${skill}${utils.COLORS.reset}`);
+    console.log(`    ${utils.COLORS.dim}bootspring skill show ${skill}${utils.COLORS.reset}`);
+  }
+
+  console.log();
+}
+
+/**
+ * Show plugin help
+ */
+function showHelp() {
+  console.log(`
+${utils.COLORS.cyan}${utils.COLORS.bold}⚡ Bootspring Plugin${utils.COLORS.reset}
+${utils.COLORS.dim}Manage project plugins${utils.COLORS.reset}
+
+${utils.COLORS.bold}Usage:${utils.COLORS.reset}
+  bootspring plugin <command> [args]
+
+${utils.COLORS.bold}Commands:${utils.COLORS.reset}
+  ${utils.COLORS.cyan}list${utils.COLORS.reset}              List all plugins with status
+  ${utils.COLORS.cyan}show${utils.COLORS.reset} <name>       Show plugin details
+  ${utils.COLORS.cyan}enable${utils.COLORS.reset} <name>     Instructions to enable plugin
+  ${utils.COLORS.cyan}disable${utils.COLORS.reset} <name>    Instructions to disable plugin
+  ${utils.COLORS.cyan}validate${utils.COLORS.reset}          Check plugin configuration
+  ${utils.COLORS.cyan}skills${utils.COLORS.reset} <name>     Show skills for a plugin
+
+${utils.COLORS.bold}Options:${utils.COLORS.reset}
+  --provider <name>   Specify provider when enabling
+
+${utils.COLORS.bold}Examples:${utils.COLORS.reset}
+  bootspring plugin list
+  bootspring plugin show auth
+  bootspring plugin enable auth --provider clerk
+  bootspring plugin validate
+  bootspring plugin skills payments
+`);
+}
+
+/**
+ * Run plugin command
+ */
+async function run(args) {
+  const parsedArgs = utils.parseArgs(args);
+  const subcommand = parsedArgs._[0] || 'list';
+  const subargs = parsedArgs._.slice(1);
+
+  switch (subcommand) {
+    case 'list':
+    case 'ls':
+      listPlugins();
+      break;
+
+    case 'show':
+    case 'info':
+      if (!subargs[0]) {
+        utils.print.error('Please specify a plugin name');
+        utils.print.dim('Usage: bootspring plugin show <name>');
+        return;
+      }
+      showPlugin(subargs[0]);
+      break;
+
+    case 'enable':
+      if (!subargs[0]) {
+        utils.print.error('Please specify a plugin name');
+        utils.print.dim('Usage: bootspring plugin enable <name>');
+        return;
+      }
+      enablePlugin(subargs[0], { provider: parsedArgs.provider });
+      break;
+
+    case 'disable':
+      if (!subargs[0]) {
+        utils.print.error('Please specify a plugin name');
+        utils.print.dim('Usage: bootspring plugin disable <name>');
+        return;
+      }
+      disablePlugin(subargs[0]);
+      break;
+
+    case 'validate':
+    case 'check':
+      validatePlugins();
+      break;
+
+    case 'skills':
+      if (!subargs[0]) {
+        utils.print.error('Please specify a plugin name');
+        utils.print.dim('Usage: bootspring plugin skills <name>');
+        return;
+      }
+      showPluginSkills(subargs[0]);
+      break;
+
+    case 'help':
+    case '-h':
+    case '--help':
+      showHelp();
+      break;
+
+    default:
+      // Check if it's a plugin name (shortcut for show)
+      if (PLUGINS[subcommand]) {
+        showPlugin(subcommand);
+      } else {
+        utils.print.error(`Unknown subcommand: ${subcommand}`);
+        showHelp();
+      }
+  }
+}
+
+module.exports = { run, PLUGINS, listPlugins, showPlugin, enablePlugin, disablePlugin, validatePlugins };