myaidev-method 0.2.23 → 0.2.24-2

package/bin/cli.js

@@ -7,7 +7,17 @@ import fs from 'fs-extra';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import inquirer from 'inquirer';
-import { getASCIIBanner, getSPARCBreakdown, getInitSuccessMessage } from '../src/lib/ascii-banner.js';
+import {
+  getASCIIBanner,
+  getSPARCBreakdown,
+  getInitSuccessMessage,
+  getWorkflowBanner,
+  getContentWorkflowSuccess,
+  getVisualWorkflowSuccess,
+  getDevWorkflowSuccess,
+  getPublishWorkflowSuccess,
+  getDeployWorkflowSuccess
+} from '../src/lib/ascii-banner.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -31,53 +41,174 @@ program
   .version('0.2.22')
   .description('MyAIDev Method - Comprehensive development framework with SPARC methodology');
 
+// Helper function for CLI type selection
+async function selectCLIType(options) {
+  if (options.claude) return 'claude';
+  if (options.gemini) return 'gemini';
+  if (options.codex) return 'codex';
+
+  // Interactive selection if no flag provided
+  const answer = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'cliType',
+      message: 'Which AI CLI are you configuring for?',
+      choices: [
+        { name: 'Claude Code (Recommended)', value: 'claude' },
+        { name: 'Gemini CLI', value: 'gemini' },
+        { name: 'Codex CLI / OpenCode', value: 'codex' }
+      ],
+      default: 'claude'
+    }
+  ]);
+  return answer.cliType;
+}
+
 // Modular workflow installation commands
 program
   .command('content')
   .description('Install content creation workflow')
   .option('--claude', 'Install for Claude Code')
+  .option('--gemini', 'Install for Gemini CLI')
+  .option('--codex', 'Install for Codex CLI')
   .option('--dry-run', 'Show what would be installed without making changes')
   .option('--verbose', 'Show detailed progress')
   .action(async (options) => {
-    await loadWorkflowSystem();
-    const installer = new WorkflowInstaller({
-      projectRoot: process.cwd(),
-      verbose: options.verbose,
-      dryRun: options.dryRun
-    });
-    await installer.install(['content']);
+    // Display workflow banner
+    console.log(getWorkflowBanner('content'));
+
+    const cliType = await selectCLIType(options);
+
+    // For non-Claude CLIs, inform user about limited support
+    if (cliType !== 'claude') {
+      console.log(chalk.yellow(`\nNote: Content workflow is optimized for Claude Code.`));
+      console.log(chalk.gray(`Some features may have limited support for ${cliType}.\n`));
+    }
+
+    const spinner = ora('Installing content creation workflow...').start();
+
+    try {
+      await loadWorkflowSystem();
+      const installer = new WorkflowInstaller({
+        projectRoot: process.cwd(),
+        verbose: options.verbose,
+        dryRun: options.dryRun
+      });
+      const result = await installer.install(['content']);
+
+      if (options.dryRun) {
+        spinner.succeed(chalk.yellow('Dry run complete - no changes made'));
+      } else {
+        spinner.succeed(chalk.green('Content workflow installed successfully!'));
+
+        // Display rich success message
+        console.log(getContentWorkflowSuccess(result.results || [], cliType));
+
+        console.log(chalk.cyan(`\n🔄 Restart ${cliType} to load your new content commands!`));
+      }
+    } catch (error) {
+      spinner.fail(chalk.red('Failed to install content workflow'));
+      console.error(chalk.red(error.message));
+      if (options.verbose) console.error(error);
+      process.exit(1);
+    }
   });
 
 program
   .command('visual')
   .description('Install visual content generation workflow')
   .option('--claude', 'Install for Claude Code')
+  .option('--gemini', 'Install for Gemini CLI')
+  .option('--codex', 'Install for Codex CLI')
   .option('--dry-run', 'Show what would be installed without making changes')
   .option('--verbose', 'Show detailed progress')
   .action(async (options) => {
-    await loadWorkflowSystem();
-    const installer = new WorkflowInstaller({
-      projectRoot: process.cwd(),
-      verbose: options.verbose,
-      dryRun: options.dryRun
-    });
-    await installer.install(['visual']);
+    // Display workflow banner
+    console.log(getWorkflowBanner('visual'));
+
+    const cliType = await selectCLIType(options);
+
+    // For non-Claude CLIs, inform user about limited support
+    if (cliType !== 'claude') {
+      console.log(chalk.yellow(`\nNote: Visual workflow is optimized for Claude Code.`));
+      console.log(chalk.gray(`Some features may have limited support for ${cliType}.\n`));
+    }
+
+    const spinner = ora('Installing visual content generation workflow...').start();
+
+    try {
+      await loadWorkflowSystem();
+      const installer = new WorkflowInstaller({
+        projectRoot: process.cwd(),
+        verbose: options.verbose,
+        dryRun: options.dryRun
+      });
+      const result = await installer.install(['visual']);
+
+      if (options.dryRun) {
+        spinner.succeed(chalk.yellow('Dry run complete - no changes made'));
+      } else {
+        spinner.succeed(chalk.green('Visual workflow installed successfully!'));
+
+        // Display rich success message
+        console.log(getVisualWorkflowSuccess(result.results || [], cliType));
+
+        console.log(chalk.cyan(`\n🔄 Restart ${cliType} to load your new visual commands!`));
+      }
+    } catch (error) {
+      spinner.fail(chalk.red('Failed to install visual workflow'));
+      console.error(chalk.red(error.message));
+      if (options.verbose) console.error(error);
+      process.exit(1);
+    }
   });
 
 program
   .command('dev')
   .description('Install development workflow (SPARC methodology)')
   .option('--claude', 'Install for Claude Code')
+  .option('--gemini', 'Install for Gemini CLI')
+  .option('--codex', 'Install for Codex CLI')
   .option('--dry-run', 'Show what would be installed without making changes')
   .option('--verbose', 'Show detailed progress')
   .action(async (options) => {
-    await loadWorkflowSystem();
-    const installer = new WorkflowInstaller({
-      projectRoot: process.cwd(),
-      verbose: options.verbose,
-      dryRun: options.dryRun
-    });
-    await installer.install(['development']);
+    // Display workflow banner
+    console.log(getWorkflowBanner('development'));
+
+    const cliType = await selectCLIType(options);
+
+    if (cliType !== 'claude') {
+      console.log(chalk.yellow(`\nNote: Development workflow is optimized for Claude Code.`));
+      console.log(chalk.gray(`Some features may have limited support for ${cliType}.\n`));
+    }
+
+    const spinner = ora('Installing SPARC development workflow...').start();
+
+    try {
+      await loadWorkflowSystem();
+      const installer = new WorkflowInstaller({
+        projectRoot: process.cwd(),
+        verbose: options.verbose,
+        dryRun: options.dryRun
+      });
+      const result = await installer.install(['development']);
+
+      if (options.dryRun) {
+        spinner.succeed(chalk.yellow('Dry run complete - no changes made'));
+      } else {
+        spinner.succeed(chalk.green('Development workflow installed successfully!'));
+
+        // Display rich success message
+        console.log(getDevWorkflowSuccess(result.results || [], cliType));
+
+        console.log(chalk.cyan(`\n🔄 Restart ${cliType} to load your new development commands!`));
+      }
+    } catch (error) {
+      spinner.fail(chalk.red('Failed to install development workflow'));
+      console.error(chalk.red(error.message));
+      if (options.verbose) console.error(error);
+      process.exit(1);
+    }
   });
 
 program
@@ -90,7 +221,9 @@ program
   .option('--dry-run', 'Show what would be installed without making changes')
   .option('--verbose', 'Show detailed progress')
   .action(async (options) => {
-    await loadWorkflowSystem();
+    // Display workflow banner
+    console.log(getWorkflowBanner('publish'));
+
     const workflows = [];
     if (options.wordpress) workflows.push('publish-wordpress');
     if (options.payloadcms) workflows.push('publish-payloadcms');
@@ -103,12 +236,34 @@ program
       console.log(chalk.gray('  --wordpress, --payloadcms, --static, or --all'));
       process.exit(1);
     }
-    const installer = new WorkflowInstaller({
-      projectRoot: process.cwd(),
-      verbose: options.verbose,
-      dryRun: options.dryRun
-    });
-    await installer.install(workflows);
+
+    const spinner = ora('Installing publishing workflows...').start();
+
+    try {
+      await loadWorkflowSystem();
+      const installer = new WorkflowInstaller({
+        projectRoot: process.cwd(),
+        verbose: options.verbose,
+        dryRun: options.dryRun
+      });
+      const result = await installer.install(workflows);
+
+      if (options.dryRun) {
+        spinner.succeed(chalk.yellow('Dry run complete - no changes made'));
+      } else {
+        spinner.succeed(chalk.green('Publishing workflows installed successfully!'));
+
+        // Display rich success message
+        console.log(getPublishWorkflowSuccess(workflows, result.results || [], 'claude'));
+
+        console.log(chalk.cyan(`\n🔄 Restart Claude Code to load your new publishing commands!`));
+      }
+    } catch (error) {
+      spinner.fail(chalk.red('Failed to install publishing workflows'));
+      console.error(chalk.red(error.message));
+      if (options.verbose) console.error(error);
+      process.exit(1);
+    }
   });
 
 program
@@ -119,19 +274,43 @@ program
   .option('--dry-run', 'Show what would be installed without making changes')
   .option('--verbose', 'Show detailed progress')
   .action(async (options) => {
-    await loadWorkflowSystem();
+    // Display workflow banner
+    console.log(getWorkflowBanner('deploy'));
+
     const workflows = [];
     if (options.coolify) workflows.push('coolify');
     if (options.all) workflows.push('deployment', 'coolify');
     if (workflows.length === 0) {
       workflows.push('deployment');
     }
-    const installer = new WorkflowInstaller({
-      projectRoot: process.cwd(),
-      verbose: options.verbose,
-      dryRun: options.dryRun
-    });
-    await installer.install(workflows);
+
+    const spinner = ora('Installing deployment workflows...').start();
+
+    try {
+      await loadWorkflowSystem();
+      const installer = new WorkflowInstaller({
+        projectRoot: process.cwd(),
+        verbose: options.verbose,
+        dryRun: options.dryRun
+      });
+      const result = await installer.install(workflows);
+
+      if (options.dryRun) {
+        spinner.succeed(chalk.yellow('Dry run complete - no changes made'));
+      } else {
+        spinner.succeed(chalk.green('Deployment workflows installed successfully!'));
+
+        // Display rich success message
+        console.log(getDeployWorkflowSuccess(workflows, result.results || [], 'claude'));
+
+        console.log(chalk.cyan(`\n🔄 Restart Claude Code to load your new deployment commands!`));
+      }
+    } catch (error) {
+      spinner.fail(chalk.red('Failed to install deployment workflows'));
+      console.error(chalk.red(error.message));
+      if (options.verbose) console.error(error);
+      process.exit(1);
+    }
   });
 
 // Workflow management commands
@@ -210,11 +389,12 @@ program
           {
             type: 'list',
             name: 'cliType',
-            message: 'Which AI CLI are you configuring for?',
+            message: 'Which AI CLI are you configuring for? (claude|gemini|codex|opencode)',
             choices: [
               { name: 'Claude Code', value: 'claude' },
               { name: 'Gemini CLI', value: 'gemini' },
-              { name: 'Codex CLI', value: 'codex' }
+              { name: 'Codex CLI', value: 'codex' },
+              { name: 'Opencode CLI', value: 'opencode'}
             ]
           }
         ]);
@@ -1039,4 +1219,156 @@ program
     }
   });
 
+// Installation detection command (Plugin Architecture Support)
+program
+  .command('detect')
+  .description('Detect MyAIDev Method installation state (legacy vs plugin)')
+  .option('--json', 'Output as JSON')
+  .action(async (options) => {
+    try {
+      const { detectInstallation, getInstallationStatus } = await import('../src/lib/installation-detector.js');
+
+      if (options.json) {
+        const detection = await detectInstallation(process.cwd());
+        console.log(JSON.stringify(detection, null, 2));
+      } else {
+        const status = await getInstallationStatus(process.cwd());
+        console.log(status);
+      }
+    } catch (error) {
+      console.error(chalk.red('Failed to detect installation:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Plugin information command
+program
+  .command('plugin-info')
+  .description('Show plugin architecture information and capabilities')
+  .action(async () => {
+    console.log(chalk.cyan('\n🔌 MyAIDev Method Plugin Architecture\n'));
+    console.log(chalk.white('════════════════════════════════════════════════════════════════\n'));
+
+    console.log(chalk.yellow('📦 Installation Methods:\n'));
+    console.log('  1. Legacy (npx):     npx myaidev-method init --claude');
+    console.log('  2. Plugin:           /plugin install myaidev-method\n');
+
+    console.log(chalk.yellow('🎯 Command Formats:\n'));
+    console.log('  Legacy:              /myai-content-writer, /myai-configure');
+    console.log('  Namespaced:          /myaidev-method:content-writer\n');
+
+    console.log(chalk.yellow('📚 Available Skill Packs:\n'));
+    console.log('  • content      - Content creation & WordPress publishing');
+    console.log('  • visual       - AI image/video generation');
+    console.log('  • development  - SPARC methodology for software dev');
+    console.log('  • publishing   - Multi-platform publishing (WP, Payload, Static)');
+    console.log('  • deployment   - Coolify deployment automation');
+    console.log('  • security     - Security testing & auditing');
+    console.log('  • openstack    - OpenStack VM management\n');
+
+    console.log(chalk.yellow('📁 Plugin Structure:\n'));
+    console.log('  .claude-plugin/plugin.json  - Plugin manifest');
+    console.log('  skills/                     - SKILL.md files');
+    console.log('  commands/                   - Command definitions');
+    console.log('  agents/                     - Agent definitions');
+    console.log('  hooks/hooks.json            - Lifecycle hooks\n');
+
+    console.log(chalk.yellow('🔗 More Information:\n'));
+    console.log('  Documentation:   https://github.com/myaione/myaidev-method');
+    console.log('  Plugin Catalog:  https://myaidev.com/plugins/myaidev-method\n');
+  });
+
+// Upgrade command (legacy to plugin)
+program
+  .command('upgrade')
+  .description('Upgrade from legacy installation to plugin architecture')
+  .option('--dry-run', 'Show what would be upgraded without making changes')
+  .action(async (options) => {
+    try {
+      const { detectInstallation, checkUpgradeAvailability } = await import('../src/lib/installation-detector.js');
+      const detection = await detectInstallation(process.cwd());
+
+      console.log(chalk.cyan('\n🔄 MyAIDev Method Upgrade Check\n'));
+
+      if (detection.installationType === 'none') {
+        console.log(chalk.yellow('⚠️  No MyAIDev Method installation detected.'));
+        console.log(chalk.gray('\nRun "npx myaidev-method init --claude" to install first.\n'));
+        return;
+      }
+
+      if (detection.installationType === 'plugin' || detection.installationType === 'both') {
+        console.log(chalk.green('✅ Plugin architecture already enabled.'));
+        console.log(chalk.gray('\nNo upgrade needed.\n'));
+        return;
+      }
+
+      const upgrade = await checkUpgradeAvailability(process.cwd());
+
+      console.log(chalk.yellow('📋 Current Installation: Legacy (npx-based)\n'));
+
+      console.log(chalk.green('✨ Upgrade Benefits:'));
+      for (const benefit of upgrade.upgradeBenefits) {
+        console.log(`   • ${benefit}`);
+      }
+
+      console.log(chalk.blue('\n🔒 Preserved Features:'));
+      for (const feature of upgrade.preservedFeatures) {
+        console.log(`   • ${feature}`);
+      }
+
+      if (options.dryRun) {
+        console.log(chalk.yellow('\n[DRY RUN] Would create:'));
+        console.log('   • .claude-plugin/plugin.json');
+        console.log('   • skills/ directory with SKILL.md files');
+        console.log('   • hooks/hooks.json');
+        console.log('\n[DRY RUN] No changes made.\n');
+        return;
+      }
+
+      // Prompt for confirmation
+      const answer = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'proceed',
+          message: 'Proceed with upgrade to plugin architecture?',
+          default: true
+        }
+      ]);
+
+      if (!answer.proceed) {
+        console.log(chalk.gray('\nUpgrade cancelled.\n'));
+        return;
+      }
+
+      const spinner = ora('Upgrading to plugin architecture...').start();
+
+      // Copy plugin files from the package to the project
+      const packageRoot = path.dirname(__dirname);
+
+      // Create .claude-plugin directory
+      await fs.ensureDir(path.join(process.cwd(), '.claude-plugin'));
+      await fs.copy(
+        path.join(packageRoot, '.claude-plugin', 'plugin.json'),
+        path.join(process.cwd(), '.claude-plugin', 'plugin.json')
+      );
+
+      // Create hooks directory
+      await fs.ensureDir(path.join(process.cwd(), 'hooks'));
+      await fs.copy(
+        path.join(packageRoot, 'hooks', 'hooks.json'),
+        path.join(process.cwd(), 'hooks', 'hooks.json')
+      );
+
+      spinner.succeed(chalk.green('Upgrade complete!'));
+
+      console.log(chalk.cyan('\n✅ Plugin architecture enabled.'));
+      console.log(chalk.gray('   Both /myai-* and /myaidev-method:* commands now available.'));
+      console.log(chalk.yellow('\n🔄 Restart Claude Code to load new capabilities.\n'));
+
+    } catch (error) {
+      console.error(chalk.red('Failed to upgrade:'), error.message);
+      process.exit(1);
+    }
+  });
+
 program.parse(process.argv);