myaidev-method 0.3.4 → 0.3.5

package/bin/cli.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
-import { program } from 'commander';
-import chalk from 'chalk';
-import ora from 'ora';
-import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import inquirer from 'inquirer';
+import { program } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import inquirer from "inquirer";
 import {
   getASCIIBanner,
   getSPARCBreakdown,
@@ -16,14 +16,101 @@ import {
   getVisualWorkflowSuccess,
   getDevWorkflowSuccess,
   getPublishWorkflowSuccess,
-  getDeployWorkflowSuccess
-} from '../src/lib/ascii-banner.js';
-import { registerAuthCommands } from '../src/cli/commands/auth.js';
-import { registerAddonCommand } from '../src/cli/commands/addon.js';
+  getDeployWorkflowSuccess,
+} from "../src/lib/ascii-banner.js";
+import { registerAuthCommands } from "../src/cli/commands/auth.js";
+import { registerAddonCommand } from "../src/cli/commands/addon.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// ── Installation Packs ─────────────────────────────────────────────────
+// Skills shared across all packs (always installed)
+const CORE_SKILLS = [
+  "configure",
+  "company-config",
+  "myai-configurator",
+];
+
+const INSTALL_PACKS = {
+  content: {
+    name: "Content Creation",
+    audience: "Marketers & Content Teams",
+    description: "Content writing, SEO, visual generation, and multi-platform publishing",
+    skills: [
+      ...CORE_SKILLS,
+      "myai-content-writer",
+      "myai-content-rules-setup",
+      "myai-content-verifier",
+      "myai-proprietary-content-verifier",
+      "myai-content-production-coordinator",
+      "myai-content-enrichment",
+      "myai-content-ideation",
+      "myai-visual-generator",
+      "myai-infographic",
+      "wordpress-publisher",
+      "payloadcms-publisher",
+      "astro-publisher",
+      "docusaurus-publisher",
+      "mintlify-publisher",
+      "deployer",
+      "coolify-deployer",
+    ],
+  },
+  design: {
+    name: "Design",
+    audience: "Designers & Creative Teams",
+    description: "Figma design capture, visual generation, and design tooling",
+    skills: [
+      ...CORE_SKILLS,
+      "myaidev-figma",
+      "myaidev-figma-configure",
+      "myai-visual-generator",
+      "myai-infographic",
+    ],
+  },
+  dev: {
+    name: "Development",
+    audience: "Software Engineers",
+    description: "SPARC methodology, security testing, deployment, publishing, and skill development",
+    skills: [
+      ...CORE_SKILLS,
+      "myaidev-workflow",
+      "myaidev-architect",
+      "myaidev-coder",
+      "myaidev-tester",
+      "myaidev-reviewer",
+      "myaidev-documenter",
+      "myaidev-analyze",
+      "myaidev-debug",
+      "myaidev-refactor",
+      "myaidev-performance",
+      "myaidev-migrate",
+      "security-tester",
+      "security-auditor",
+      "git-workflow",
+      "deployer",
+      "coolify-deployer",
+      "openstack-manager",
+      "wordpress-publisher",
+      "payloadcms-publisher",
+      "astro-publisher",
+      "docusaurus-publisher",
+      "mintlify-publisher",
+      "myai-skill-builder",
+      "skill-contributor",
+    ],
+  },
+};
+
+function getAllSkillNames() {
+  const all = new Set();
+  for (const pack of Object.values(INSTALL_PACKS)) {
+    for (const s of pack.skills) all.add(s);
+  }
+  return [...all];
+}
+
 // Import WorkflowInstaller dynamically for modular installation
 let WorkflowInstaller;
 let getWorkflowNames;
@@ -31,8 +118,9 @@ let getWorkflowsByCategory;
 
 async function loadWorkflowSystem() {
   if (!WorkflowInstaller) {
-    const { default: Installer } = await import('../src/lib/workflow-installer.js');
-    const workflows = await import('../src/config/workflows.js');
+    const { default: Installer } =
+      await import("../src/lib/workflow-installer.js");
+    const workflows = await import("../src/config/workflows.js");
     WorkflowInstaller = Installer;
     getWorkflowNames = workflows.getWorkflowNames;
     getWorkflowsByCategory = workflows.getWorkflowsByCategory;
@@ -40,77 +128,89 @@ async function loadWorkflowSystem() {
 }
 
 program
-  .version('0.3.3')
+  .version("0.3.5")
   .enablePositionalOptions()
-  .description('MyAIDev Method - Comprehensive development framework with SPARC methodology');
+  .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';
+  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?',
+      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' }
+        { name: "Claude Code (Recommended)", value: "claude" },
+        { name: "Gemini CLI", value: "gemini" },
+        { name: "Codex CLI / OpenCode", value: "codex" },
       ],
-      default: 'claude'
-    }
+      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')
+  .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) => {
     // Display workflow banner
-    console.log(getWorkflowBanner('content'));
+    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`));
+    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();
+    const spinner = ora("Installing content creation workflow...").start();
 
     try {
       await loadWorkflowSystem();
       const installer = new WorkflowInstaller({
         projectRoot: process.cwd(),
         verbose: options.verbose,
-        dryRun: options.dryRun
+        dryRun: options.dryRun,
       });
-      const result = await installer.install(['content']);
+      const result = await installer.install(["content"]);
 
       if (options.dryRun) {
-        spinner.succeed(chalk.yellow('Dry run complete - no changes made'));
+        spinner.succeed(chalk.yellow("Dry run complete - no changes made"));
       } else {
-        spinner.succeed(chalk.green('Content workflow installed successfully!'));
+        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!`));
+        console.log(
+          chalk.cyan(
+            `\n🔄 Restart ${cliType} to load your new content commands!`,
+          ),
+        );
       }
     } catch (error) {
-      spinner.fail(chalk.red('Failed to install content workflow'));
+      spinner.fail(chalk.red("Failed to install content workflow"));
       console.error(chalk.red(error.message));
       if (options.verbose) console.error(error);
       process.exit(1);
@@ -118,48 +218,58 @@ program
   });
 
 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')
+  .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) => {
     // Display workflow banner
-    console.log(getWorkflowBanner('visual'));
+    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`));
+    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();
+    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
+        dryRun: options.dryRun,
       });
-      const result = await installer.install(['visual']);
+      const result = await installer.install(["visual"]);
 
       if (options.dryRun) {
-        spinner.succeed(chalk.yellow('Dry run complete - no changes made'));
+        spinner.succeed(chalk.yellow("Dry run complete - no changes made"));
       } else {
-        spinner.succeed(chalk.green('Visual workflow installed successfully!'));
+        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!`));
+        console.log(
+          chalk.cyan(
+            `\n🔄 Restart ${cliType} to load your new visual commands!`,
+          ),
+        );
       }
     } catch (error) {
-      spinner.fail(chalk.red('Failed to install visual workflow'));
+      spinner.fail(chalk.red("Failed to install visual workflow"));
       console.error(chalk.red(error.message));
       if (options.verbose) console.error(error);
       process.exit(1);
@@ -167,47 +277,59 @@ program
   });
 
 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')
+  .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) => {
     // Display workflow banner
-    console.log(getWorkflowBanner('development'));
+    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`));
+    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();
+    const spinner = ora("Installing SPARC development workflow...").start();
 
     try {
       await loadWorkflowSystem();
       const installer = new WorkflowInstaller({
         projectRoot: process.cwd(),
         verbose: options.verbose,
-        dryRun: options.dryRun
+        dryRun: options.dryRun,
       });
-      const result = await installer.install(['development']);
+      const result = await installer.install(["development"]);
 
       if (options.dryRun) {
-        spinner.succeed(chalk.yellow('Dry run complete - no changes made'));
+        spinner.succeed(chalk.yellow("Dry run complete - no changes made"));
       } else {
-        spinner.succeed(chalk.green('Development workflow installed successfully!'));
+        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!`));
+        console.log(
+          chalk.cyan(
+            `\n🔄 Restart ${cliType} to load your new development commands!`,
+          ),
+        );
       }
     } catch (error) {
-      spinner.fail(chalk.red('Failed to install development workflow'));
+      spinner.fail(chalk.red("Failed to install development workflow"));
       console.error(chalk.red(error.message));
       if (options.verbose) console.error(error);
       process.exit(1);
@@ -215,54 +337,70 @@ program
   });
 
 program
-  .command('publish')
-  .description('Install publishing workflows')
-  .option('--wordpress', 'Install WordPress publishing')
-  .option('--payloadcms', 'Install PayloadCMS publishing')
-  .option('--static', 'Install static site publishing')
-  .option('--all', 'Install all publishing workflows')
-  .option('--dry-run', 'Show what would be installed without making changes')
-  .option('--verbose', 'Show detailed progress')
+  .command("publish")
+  .description("Install publishing workflows")
+  .option("--wordpress", "Install WordPress publishing")
+  .option("--payloadcms", "Install PayloadCMS publishing")
+  .option("--static", "Install static site publishing")
+  .option("--all", "Install all publishing workflows")
+  .option("--dry-run", "Show what would be installed without making changes")
+  .option("--verbose", "Show detailed progress")
   .action(async (options) => {
     // Display workflow banner
-    console.log(getWorkflowBanner('publish'));
+    console.log(getWorkflowBanner("publish"));
 
     const workflows = [];
-    if (options.wordpress) workflows.push('publish-wordpress');
-    if (options.payloadcms) workflows.push('publish-payloadcms');
-    if (options.static) workflows.push('publish-static');
+    if (options.wordpress) workflows.push("publish-wordpress");
+    if (options.payloadcms) workflows.push("publish-payloadcms");
+    if (options.static) workflows.push("publish-static");
     if (options.all) {
-      workflows.push('publish-wordpress', 'publish-payloadcms', 'publish-static');
+      workflows.push(
+        "publish-wordpress",
+        "publish-payloadcms",
+        "publish-static",
+      );
     }
     if (workflows.length === 0) {
-      console.log(chalk.yellow('Please specify at least one publishing workflow:'));
-      console.log(chalk.gray('  --wordpress, --payloadcms, --static, or --all'));
+      console.log(
+        chalk.yellow("Please specify at least one publishing workflow:"),
+      );
+      console.log(
+        chalk.gray("  --wordpress, --payloadcms, --static, or --all"),
+      );
       process.exit(1);
     }
 
-    const spinner = ora('Installing publishing workflows...').start();
+    const spinner = ora("Installing publishing workflows...").start();
 
     try {
       await loadWorkflowSystem();
       const installer = new WorkflowInstaller({
         projectRoot: process.cwd(),
         verbose: options.verbose,
-        dryRun: options.dryRun
+        dryRun: options.dryRun,
       });
       const result = await installer.install(workflows);
 
       if (options.dryRun) {
-        spinner.succeed(chalk.yellow('Dry run complete - no changes made'));
+        spinner.succeed(chalk.yellow("Dry run complete - no changes made"));
       } else {
-        spinner.succeed(chalk.green('Publishing workflows installed successfully!'));
+        spinner.succeed(
+          chalk.green("Publishing workflows installed successfully!"),
+        );
 
         // Display rich success message
-        console.log(getPublishWorkflowSuccess(workflows, result.results || [], 'claude'));
+        console.log(
+          getPublishWorkflowSuccess(workflows, result.results || [], "claude"),
+        );
 
-        console.log(chalk.cyan(`\n🔄 Restart Claude Code to load your new publishing commands!`));
+        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'));
+      spinner.fail(chalk.red("Failed to install publishing workflows"));
       console.error(chalk.red(error.message));
       if (options.verbose) console.error(error);
       process.exit(1);
@@ -270,46 +408,54 @@ program
   });
 
 program
-  .command('deploy')
-  .description('Install deployment workflows')
-  .option('--coolify', 'Install Coolify deployment')
-  .option('--all', 'Install all deployment workflows')
-  .option('--dry-run', 'Show what would be installed without making changes')
-  .option('--verbose', 'Show detailed progress')
+  .command("deploy")
+  .description("Install deployment workflows")
+  .option("--coolify", "Install Coolify deployment")
+  .option("--all", "Install all deployment workflows")
+  .option("--dry-run", "Show what would be installed without making changes")
+  .option("--verbose", "Show detailed progress")
   .action(async (options) => {
     // Display workflow banner
-    console.log(getWorkflowBanner('deploy'));
+    console.log(getWorkflowBanner("deploy"));
 
     const workflows = [];
-    if (options.coolify) workflows.push('coolify');
-    if (options.all) workflows.push('deployment', 'coolify');
+    if (options.coolify) workflows.push("coolify");
+    if (options.all) workflows.push("deployment", "coolify");
     if (workflows.length === 0) {
-      workflows.push('deployment');
+      workflows.push("deployment");
     }
 
-    const spinner = ora('Installing deployment workflows...').start();
+    const spinner = ora("Installing deployment workflows...").start();
 
     try {
       await loadWorkflowSystem();
       const installer = new WorkflowInstaller({
         projectRoot: process.cwd(),
         verbose: options.verbose,
-        dryRun: options.dryRun
+        dryRun: options.dryRun,
       });
       const result = await installer.install(workflows);
 
       if (options.dryRun) {
-        spinner.succeed(chalk.yellow('Dry run complete - no changes made'));
+        spinner.succeed(chalk.yellow("Dry run complete - no changes made"));
       } else {
-        spinner.succeed(chalk.green('Deployment workflows installed successfully!'));
+        spinner.succeed(
+          chalk.green("Deployment workflows installed successfully!"),
+        );
 
         // Display rich success message
-        console.log(getDeployWorkflowSuccess(workflows, result.results || [], 'claude'));
+        console.log(
+          getDeployWorkflowSuccess(workflows, result.results || [], "claude"),
+        );
 
-        console.log(chalk.cyan(`\n🔄 Restart Claude Code to load your new deployment commands!`));
+        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'));
+      spinner.fail(chalk.red("Failed to install deployment workflows"));
       console.error(chalk.red(error.message));
       if (options.verbose) console.error(error);
       process.exit(1);
@@ -318,38 +464,38 @@ program
 
 // Workflow management commands
 program
-  .command('add <workflow>')
-  .description('Add a workflow to your installation')
-  .option('--dry-run', 'Show what would be installed without making changes')
-  .option('--verbose', 'Show detailed progress')
+  .command("add <workflow>")
+  .description("Add a workflow to your installation")
+  .option("--dry-run", "Show what would be installed without making changes")
+  .option("--verbose", "Show detailed progress")
   .action(async (workflow, options) => {
     await loadWorkflowSystem();
     const installer = new WorkflowInstaller({
       projectRoot: process.cwd(),
       verbose: options.verbose,
-      dryRun: options.dryRun
+      dryRun: options.dryRun,
     });
     await installer.install([workflow]);
   });
 
 program
-  .command('remove <workflow>')
-  .description('Remove a workflow from your installation')
-  .option('--dry-run', 'Show what would be removed without making changes')
-  .option('--verbose', 'Show detailed progress')
+  .command("remove <workflow>")
+  .description("Remove a workflow from your installation")
+  .option("--dry-run", "Show what would be removed without making changes")
+  .option("--verbose", "Show detailed progress")
   .action(async (workflow, options) => {
     await loadWorkflowSystem();
     const installer = new WorkflowInstaller({
       projectRoot: process.cwd(),
       verbose: options.verbose,
-      dryRun: options.dryRun
+      dryRun: options.dryRun,
     });
     await installer.removeWorkflow(workflow);
   });
 
 program
-  .command('list')
-  .description('List installed workflows')
+  .command("list")
+  .description("List installed workflows")
   .action(async () => {
     await loadWorkflowSystem();
     const installer = new WorkflowInstaller({ projectRoot: process.cwd() });
@@ -357,8 +503,8 @@ program
   });
 
 program
-  .command('status')
-  .description('Show workflow installation status')
+  .command("status")
+  .description("Show workflow installation status")
   .action(async () => {
     await loadWorkflowSystem();
     const installer = new WorkflowInstaller({ projectRoot: process.cwd() });
@@ -366,105 +512,193 @@ program
   });
 
 program
-  .command('init')
-  .description('Initialize complete AI CLI configuration (all workflows)')
-  .option('--claude', 'Initialize for Claude Code')
-  .option('--gemini', 'Initialize for Gemini CLI')
-  .option('--codex', 'Initialize for Codex CLI')
+  .command("init")
+  .description("Initialize AI CLI configuration with a skill pack")
+  .option("--claude", "Initialize for Claude Code")
+  .option("--gemini", "Initialize for Gemini CLI")
+  .option("--codex", "Initialize for Codex CLI")
+  .option("--pack <pack>", "Install a specific pack: content, design, dev, or full")
   .action(async (options) => {
-    const spinner = ora('Initializing AI CLI configuration...').start();
-    
     try {
       const cwd = process.cwd();
+
+      // Step 1: Determine CLI type
       let cliType = null;
-      
-      // Determine CLI type
       if (options.claude) {
-        cliType = 'claude';
+        cliType = "claude";
       } else if (options.gemini) {
-        cliType = 'gemini';
+        cliType = "gemini";
       } else if (options.codex) {
-        cliType = 'codex';
+        cliType = "codex";
       } else {
-        spinner.stop();
-        // Interactive selection if no flag provided
         const answer = await inquirer.prompt([
           {
-            type: 'list',
-            name: 'cliType',
-            message: 'Which AI CLI are you configuring for? (claude|gemini|codex|opencode)',
+            type: "list",
+            name: "cliType",
+            message: "Which AI CLI are you configuring for?",
             choices: [
-              { name: 'Claude Code', value: 'claude' },
-              { name: 'Gemini CLI', value: 'gemini' },
-              { name: 'Codex CLI', value: 'codex' },
-              { name: 'Opencode CLI', value: 'opencode'}
-            ]
-          }
+              { name: "Claude Code (Recommended)", value: "claude" },
+              { name: "Gemini CLI", value: "gemini" },
+              { name: "Codex CLI / OpenCode", value: "codex" },
+            ],
+            default: "claude",
+          },
         ]);
         cliType = answer.cliType;
-        spinner.start();
       }
-      
-      if (cliType === 'claude') {
-        // Create Claude Code standard structure
-        await setupClaude(cwd);
-      } else if (cliType === 'gemini') {
-        await setupGemini(cwd);
-      } else if (cliType === 'codex') {
-        await setupCodex(cwd);
+
+      // Step 2: Determine pack
+      let pack = options.pack || null;
+      if (pack && !["content", "design", "dev", "full"].includes(pack)) {
+        console.log(chalk.red(`\nUnknown pack: "${pack}"`));
+        console.log(chalk.gray("Available packs: content, design, dev, full\n"));
+        process.exit(1);
+      }
+
+      if (!pack) {
+        console.log("");
+        const answer = await inquirer.prompt([
+          {
+            type: "list",
+            name: "pack",
+            message: "What do you want to use MyAIDev Method for?",
+            choices: [
+              {
+                name: `${chalk.green("Content Creation")} ${chalk.gray("— For marketers: writing, SEO, visuals, publishing")}`,
+                value: "content",
+              },
+              {
+                name: `${chalk.magenta("Design")}            ${chalk.gray("— For designers: Figma capture, visual generation")}`,
+                value: "design",
+              },
+              {
+                name: `${chalk.blue("Development")}       ${chalk.gray("— For engineers: SPARC, security, deploy, git")}`,
+                value: "dev",
+              },
+              {
+                name: `${chalk.yellow("Full")}              ${chalk.gray("— Everything (all skills)")}`,
+                value: "full",
+              },
+            ],
+          },
+        ]);
+        pack = answer.pack;
+      }
+
+      // Resolve skill list
+      let skillList;
+      let packLabel;
+      if (pack === "full") {
+        skillList = null; // null = install all
+        packLabel = "Full (all skills)";
+      } else {
+        const packDef = INSTALL_PACKS[pack];
+        skillList = packDef.skills;
+        packLabel = `${packDef.name} — ${packDef.audience}`;
       }
-      
-      spinner.succeed(chalk.green(`Successfully initialized ${cliType} configuration!`));
 
-      // Display ASCII banner and SPARC methodology
+      // Step 3: Install
+      const spinner = ora(`Installing ${packLabel}...`).start();
+
+      if (cliType === "claude") {
+        await setupClaude(cwd, skillList);
+      } else if (cliType === "gemini") {
+        await setupGemini(cwd, skillList);
+      } else if (cliType === "codex") {
+        await setupCodex(cwd, skillList);
+      }
+
+      spinner.succeed(
+        chalk.green(`Successfully initialized ${cliType} with ${packLabel}!`),
+      );
+
+      // Display ASCII banner
       console.log(getASCIIBanner());
       console.log(getSPARCBreakdown());
       console.log(getInitSuccessMessage(cliType));
 
-      if (cliType === 'claude') {
-        console.log(chalk.magenta('\n🧠 Skills Installed (.claude/skills/):'));
-        console.log(chalk.gray('   24 skills covering development, content, publishing, deployment, security'));
-        console.log(chalk.gray(''));
-        console.log(chalk.green('   Development:  myaidev-workflow, myaidev-architect, myaidev-coder, myaidev-tester'));
-        console.log(chalk.green('   Content:      content-writer, content-rules-setup, content-coordinator'));
-        console.log(chalk.yellow('   Publishing:   wordpress, payloadcms, docusaurus, mintlify, astro'));
-        console.log(chalk.blue('   Deploy/Infra: deployer, coolify-deployer, openstack-manager'));
-        console.log(chalk.cyan('   Git:          git-workflow (pr, release, sync, hotfix)'));
-        console.log(chalk.red('   Security:     security-tester, security-auditor'));
-        console.log(chalk.gray('   Config:       configure (interactive setup wizard)'));
-
-        console.log(chalk.cyan('\n⚙️  Get started:'));
-        console.log(chalk.white('   1. npx myaidev-method login') + chalk.gray('  — authenticate with the marketplace'));
-        console.log(chalk.white('   2. npx myaidev-method addon list') + chalk.gray('  — browse available skills'));
-        console.log(chalk.white('   3. npx myaidev-method addon install <name>') + chalk.gray('  — install a skill'));
-        console.log(chalk.gray('\n   • Use the configure skill to set up platform credentials'));
-        console.log(chalk.gray('   • Skills are invoked naturally in conversation'));
-        console.log(chalk.gray('   • Visit: https://github.com/myaione/myaidev-method'));
+      // Display installed skills summary
+      if (cliType === "claude") {
+        const installedCount = skillList
+          ? skillList.length
+          : (await fs.readdir(path.join(cwd, ".claude", "skills"))).filter(
+              async (d) => (await fs.stat(path.join(cwd, ".claude", "skills", d))).isDirectory()
+            ).length;
+
+        console.log(chalk.magenta(`\n🧠 Skills Installed (.claude/skills/):`));
+        console.log(chalk.gray(`   ${packLabel} — ${skillList ? skillList.length : 'all'} skills\n`));
+
+        if (pack === "content" || pack === "full") {
+          console.log(chalk.green("   Content:      myai-content-writer, myai-content-production-coordinator, myai-content-ideation"));
+          console.log(chalk.green("   Visual:       myai-visual-generator, myai-infographic"));
+          console.log(chalk.yellow("   Publishing:   wordpress, payloadcms, docusaurus, mintlify, astro"));
+        }
+        if (pack === "design" || pack === "full") {
+          console.log(chalk.magenta("   Design:       myaidev-figma, myaidev-figma-configure"));
+          console.log(chalk.magenta("   Visual:       myai-visual-generator, myai-infographic"));
+        }
+        if (pack === "dev" || pack === "full") {
+          console.log(chalk.blue("   SPARC:        myaidev-workflow, myaidev-architect, myaidev-coder, myaidev-tester"));
+          console.log(chalk.cyan("   Git:          git-workflow (pr, release, sync, hotfix)"));
+          console.log(chalk.red("   Security:     security-tester, security-auditor"));
+          console.log(chalk.blue("   Deploy:       deployer, coolify-deployer, openstack-manager"));
+          console.log(chalk.blue("   Skills:       myai-skill-builder, skill-contributor"));
+        }
+        console.log(chalk.gray("   Config:       configure, company-config, myai-configurator"));
+
+        console.log(chalk.cyan("\n⚙️  Get started:"));
+        console.log(
+          chalk.white("   1. npx myaidev-method login") +
+            chalk.gray("  — authenticate with the marketplace"),
+        );
+        console.log(
+          chalk.white("   2. npx myaidev-method addon list") +
+            chalk.gray("  — browse available skills"),
+        );
+        console.log(
+          chalk.white("   3. npx myaidev-method addon install <name>") +
+            chalk.gray("  — install a skill"),
+        );
+        console.log(
+          chalk.gray("\n   • Use the configure skill to set up platform credentials"),
+        );
+        console.log(
+          chalk.gray("   • Add more skills later: npx myaidev-method init --claude --pack <pack>"),
+        );
+        console.log(
+          chalk.gray("   • Visit: https://github.com/myaione/myaidev-method"),
+        );
       }
       console.log(chalk.cyan(`\n🔄 Restart ${cliType} to load skills!`));
-      
     } catch (error) {
-      spinner.fail(chalk.red('Failed to initialize configuration'));
+      if (error.name === 'ExitPromptError') {
+        console.log(chalk.gray("\nCancelled.\n"));
+        return;
+      }
+      console.error(chalk.red("Failed to initialize configuration"));
       console.error(error);
       process.exit(1);
     }
   });
 
-async function setupClaude(projectDir) {
+async function setupClaude(projectDir, skillFilter = null) {
   // Create .claude directory structure — skills-only architecture
-  const claudeDir = path.join(projectDir, '.claude');
-  const mcpDir = path.join(claudeDir, 'mcp');
+  const claudeDir = path.join(projectDir, ".claude");
+  const mcpDir = path.join(claudeDir, "mcp");
 
   await fs.ensureDir(claudeDir);
   await fs.ensureDir(mcpDir);
 
   // Copy skills (each skill is a directory with SKILL.md + optional agents/)
-  const sourceSkillsDir = path.join(__dirname, '..', 'skills');
+  // If skillFilter is null, install all skills. Otherwise only install listed ones.
+  const sourceSkillsDir = path.join(__dirname, "..", "skills");
   if (await fs.pathExists(sourceSkillsDir)) {
-    const skillsDir = path.join(claudeDir, 'skills');
+    const skillsDir = path.join(claudeDir, "skills");
     await fs.ensureDir(skillsDir);
     const skillDirs = await fs.readdir(sourceSkillsDir);
+    const allowedSkills = skillFilter ? new Set(skillFilter) : null;
     for (const skillName of skillDirs) {
+      if (allowedSkills && !allowedSkills.has(skillName)) continue;
       const skillPath = path.join(sourceSkillsDir, skillName);
       const stat = await fs.stat(skillPath);
       if (stat.isDirectory()) {
@@ -474,56 +708,61 @@ async function setupClaude(projectDir) {
   }
 
   // Copy MCP server files
-  const templateMcpDir = path.join(__dirname, '..', 'src', 'mcp');
+  const templateMcpDir = path.join(__dirname, "..", "src", "mcp");
   if (await fs.pathExists(templateMcpDir)) {
     const mcpFiles = await fs.readdir(templateMcpDir);
     for (const file of mcpFiles) {
-      if (file.endsWith('.js') || file.endsWith('.json')) {
-        await fs.copy(
-          path.join(templateMcpDir, file),
-          path.join(mcpDir, file)
-        );
+      if (file.endsWith(".js") || file.endsWith(".json")) {
+        await fs.copy(path.join(templateMcpDir, file), path.join(mcpDir, file));
       }
     }
   }
-  
+
   // Create CLAUDE.md configuration file from template
-  const claudeMdTemplate = path.join(__dirname, '..', 'src', 'templates', 'claude', 'CLAUDE.md');
+  const claudeMdTemplate = path.join(
+    __dirname,
+    "..",
+    "src",
+    "templates",
+    "claude",
+    "CLAUDE.md",
+  );
   if (await fs.pathExists(claudeMdTemplate)) {
-    await fs.copy(claudeMdTemplate, path.join(claudeDir, 'CLAUDE.md'));
+    await fs.copy(claudeMdTemplate, path.join(claudeDir, "CLAUDE.md"));
   }
-  
+
   // Copy the comprehensive .env.example from package
-  const sourceEnvExample = path.join(__dirname, '..', '.env.example');
+  const sourceEnvExample = path.join(__dirname, "..", ".env.example");
   if (await fs.pathExists(sourceEnvExample)) {
-    await fs.copy(sourceEnvExample, path.join(projectDir, '.env.example'));
+    await fs.copy(sourceEnvExample, path.join(projectDir, ".env.example"));
   }
 
   // Create .myaidev-method directory for scripts and utilities
   // This allows agents to access publishing/deployment scripts in non-Node.js projects
-  const myaidevDir = path.join(projectDir, '.myaidev-method');
-  const scriptsDir = path.join(myaidevDir, 'scripts');
-  const libDir = path.join(myaidevDir, 'lib');
+  const myaidevDir = path.join(projectDir, ".myaidev-method");
+  const scriptsDir = path.join(myaidevDir, "scripts");
+  const libDir = path.join(myaidevDir, "lib");
 
   await fs.ensureDir(scriptsDir);
   await fs.ensureDir(libDir);
 
   // Copy all executable scripts
-  const sourceScriptsDir = path.join(__dirname, '..', 'src', 'scripts');
+  const sourceScriptsDir = path.join(__dirname, "..", "src", "scripts");
   if (await fs.pathExists(sourceScriptsDir)) {
     const scriptFiles = await fs.readdir(sourceScriptsDir);
     for (const file of scriptFiles) {
-      if (file.endsWith('.js') && file !== 'init-project.js') { // Skip init script
+      if (file.endsWith(".js") && file !== "init-project.js") {
+        // Skip init script
         await fs.copy(
           path.join(sourceScriptsDir, file),
-          path.join(scriptsDir, file)
+          path.join(scriptsDir, file),
         );
       }
     }
   }
 
   // Copy all utility libraries
-  const sourceLibDir = path.join(__dirname, '..', 'src', 'lib');
+  const sourceLibDir = path.join(__dirname, "..", "src", "lib");
   if (await fs.pathExists(sourceLibDir)) {
     await fs.copy(sourceLibDir, libDir);
   }
@@ -531,99 +770,121 @@ async function setupClaude(projectDir) {
   // Copy package.json and install dependencies in .myaidev-method
   // This ensures scripts have access to required npm packages
   const packageJson = {
-    "name": "myaidev-method-scripts",
-    "version": "1.0.0",
-    "type": "module",
-    "private": true,
-    "dependencies": {
+    name: "myaidev-method-scripts",
+    version: "1.0.0",
+    type: "module",
+    private: true,
+    dependencies: {
       "node-fetch": "^3.3.2",
-      "marked": "^11.0.0",
+      marked: "^11.0.0",
       "gray-matter": "^4.0.3",
-      "dotenv": "^16.4.1",
-      "chalk": "^5.3.0",
-      "ora": "^8.0.1"
-    }
+      dotenv: "^16.4.1",
+      chalk: "^5.3.0",
+      ora: "^8.0.1",
+    },
   };
 
   await fs.writeFile(
-    path.join(myaidevDir, 'package.json'),
-    JSON.stringify(packageJson, null, 2)
+    path.join(myaidevDir, "package.json"),
+    JSON.stringify(packageJson, null, 2),
   );
 
   // Install dependencies in .myaidev-method directory
-  console.log(chalk.gray('\n   Installing script dependencies...'));
-  const { execSync } = await import('child_process');
+  console.log(chalk.gray("\n   Installing script dependencies..."));
+  const { execSync } = await import("child_process");
   try {
-    execSync('npm install', {
+    execSync("npm install", {
       cwd: myaidevDir,
-      stdio: 'inherit'
+      stdio: "inherit",
     });
-    console.log(chalk.green('   ✓ Dependencies installed successfully'));
+    console.log(chalk.green("   ✓ Dependencies installed successfully"));
   } catch (error) {
-    console.log(chalk.yellow('   ⚠ Failed to install dependencies automatically'));
-    console.log(chalk.gray('   Run: cd .myaidev-method && npm install'));
+    console.log(
+      chalk.yellow("   ⚠ Failed to install dependencies automatically"),
+    );
+    console.log(chalk.gray("   Run: cd .myaidev-method && npm install"));
   }
 
-  // Note: MCP integration disabled for now - using native tools for WordPress REST API
+  // Note: fal.ai MCP server configured in settings.json for visual generation
+  // WordPress MCP integration still uses native REST API approach
 
   // Copy documentation files to project root (limited to essential guides)
   const docsToMerge = [
-    'USER_GUIDE.md',
-    'DEV_WORKFLOW_GUIDE.md',
-    'PUBLISHING_GUIDE.md'
+    "USER_GUIDE.md",
+    "DEV_WORKFLOW_GUIDE.md",
+    "PUBLISHING_GUIDE.md",
   ];
 
   for (const docFile of docsToMerge) {
-    const sourcePath = path.join(__dirname, '..', docFile);
+    const sourcePath = path.join(__dirname, "..", docFile);
     if (await fs.pathExists(sourcePath)) {
       await fs.copy(sourcePath, path.join(projectDir, docFile));
     }
   }
 
   // Copy template documentation (WordPress integration, etc.)
-  const templateDocsDir = path.join(__dirname, '..', 'src', 'templates', 'docs');
+  const templateDocsDir = path.join(
+    __dirname,
+    "..",
+    "src",
+    "templates",
+    "docs",
+  );
   if (await fs.pathExists(templateDocsDir)) {
     const docFiles = await fs.readdir(templateDocsDir);
     for (const file of docFiles) {
-      if (file.endsWith('.md')) {
+      if (file.endsWith(".md")) {
         const destPath = path.join(projectDir, file);
         // Only copy if destination doesn't exist (don't overwrite user customizations)
-        if (!await fs.pathExists(destPath)) {
-          await fs.copy(
-            path.join(templateDocsDir, file),
-            destPath
-          );
+        if (!(await fs.pathExists(destPath))) {
+          await fs.copy(path.join(templateDocsDir, file), destPath);
         }
       }
     }
   }
 
   // Create content-rules.md if it doesn't already exist
-  const contentRulesPath = path.join(projectDir, 'content-rules.md');
-  if (!await fs.pathExists(contentRulesPath)) {
-    const contentRulesTemplate = path.join(__dirname, '..', 'content-rules.example.md');
+  const contentRulesPath = path.join(projectDir, "content-rules.md");
+  if (!(await fs.pathExists(contentRulesPath))) {
+    const contentRulesTemplate = path.join(
+      __dirname,
+      "..",
+      "content-rules-example.md",
+    );
     if (await fs.pathExists(contentRulesTemplate)) {
       await fs.copy(contentRulesTemplate, contentRulesPath);
-      console.log(chalk.green('   ✓ Created content-rules.md for customizable content generation'));
+      console.log(
+        chalk.green(
+          "   ✓ Created content-rules.md for customizable content generation",
+        ),
+      );
     }
   } else {
-    console.log(chalk.gray('   ℹ content-rules.md already exists, skipping creation'));
+    console.log(
+      chalk.gray("   ℹ content-rules.md already exists, skipping creation"),
+    );
   }
 
   // Save installation version for update tracking
-  const pkgJson = await fs.readJson(path.join(__dirname, '..', 'package.json'));
-  const versionFile = path.join(claudeDir, '.myaidev-version');
+  const pkgJson = await fs.readJson(path.join(__dirname, "..", "package.json"));
+  const versionFile = path.join(claudeDir, ".myaidev-version");
   await fs.writeFile(versionFile, pkgJson.version);
 
   // Copy statusline script and configure settings.json
-  const statuslineSrc = path.join(__dirname, '..', 'src', 'statusline', 'statusline.sh');
-  const statuslineDest = path.join(claudeDir, 'statusline.sh');
+  const statuslineSrc = path.join(
+    __dirname,
+    "..",
+    "src",
+    "statusline",
+    "statusline.sh",
+  );
+  const statuslineDest = path.join(claudeDir, "statusline.sh");
   if (await fs.pathExists(statuslineSrc)) {
     await fs.copy(statuslineSrc, statuslineDest);
     await fs.chmod(statuslineDest, 0o755);
 
     // Create or merge .claude/settings.json with statusLine config
-    const settingsPath = path.join(claudeDir, 'settings.json');
+    const settingsPath = path.join(claudeDir, "settings.json");
     let settings = {};
     if (await fs.pathExists(settingsPath)) {
       try {
@@ -633,35 +894,51 @@ async function setupClaude(projectDir) {
       }
     }
     settings.statusLine = {
-      type: 'command',
-      command: '.claude/statusline.sh'
+      type: "command",
+      command: ".claude/statusline.sh",
     };
     settings.extraKnownMarketplaces = {
-      'myaidev-marketplace': {
+      "myaidev-marketplace": {
         source: {
-          source: 'github',
-          repo: 'myaione/myaidev-marketplace'
-        }
-      }
+          source: "github",
+          repo: "myaione/myaidev-marketplace",
+        },
+      },
+    };
+    // Configure MCP servers for enhanced tool access
+    settings.mcpServers = settings.mcpServers || {};
+    settings.mcpServers["fal-ai"] = {
+      command: "npx",
+      args: ["-y", "fal-ai-mcp-server"],
+      env: {
+        FAL_KEY: "",
+      },
     };
     await fs.writeJson(settingsPath, settings, { spaces: 2 });
-    console.log(chalk.green('   ✓ Status line configured'));
+    console.log(chalk.green("   ✓ Status line configured"));
+    console.log(
+      chalk.green(
+        "   ✓ fal.ai MCP server configured (set FAL_KEY to activate)",
+      ),
+    );
   }
 }
 
-async function setupGemini(projectDir) {
+async function setupGemini(projectDir, skillFilter = null) {
   // Setup Gemini CLI — skills-based architecture
   // Gemini CLI supports Agent Skills standard natively (.gemini/skills/)
-  const geminiDir = path.join(projectDir, '.gemini');
+  const geminiDir = path.join(projectDir, ".gemini");
   await fs.ensureDir(geminiDir);
 
   // Copy skills (same SKILL.md format works cross-platform)
-  const sourceSkillsDir = path.join(__dirname, '..', 'skills');
+  const sourceSkillsDir = path.join(__dirname, "..", "skills");
   if (await fs.pathExists(sourceSkillsDir)) {
-    const skillsDir = path.join(geminiDir, 'skills');
+    const skillsDir = path.join(geminiDir, "skills");
     await fs.ensureDir(skillsDir);
     const skillDirs = await fs.readdir(sourceSkillsDir);
+    const allowedSkills = skillFilter ? new Set(skillFilter) : null;
     for (const skillName of skillDirs) {
+      if (allowedSkills && !allowedSkills.has(skillName)) continue;
       const skillPath = path.join(sourceSkillsDir, skillName);
       const stat = await fs.stat(skillPath);
       if (stat.isDirectory()) {
@@ -685,7 +962,7 @@ Skills are discovered automatically. Gemini activates them when relevant to your
 
 ### Content & Publishing
 - \`content-writer\` - SEO-optimized content creation
-- \`wordpress-publisher\` / \`payloadcms-publisher\` / \`astro-publisher\` / \`docusaurus-publisher\` / \`mintlify-publisher\`
+- \`content-publisher\` - Multi-platform publishing (WordPress, PayloadCMS, Astro, Docusaurus, Mintlify)
 
 ### DevOps
 - \`deployer\` / \`coolify-deployer\` - Multi-environment deployment
@@ -704,22 +981,24 @@ Skills are discovered automatically. Gemini activates them when relevant to your
 \`\`\`
 `;
 
-  await fs.writeFile(path.join(geminiDir, 'GEMINI.md'), geminiMd);
+  await fs.writeFile(path.join(geminiDir, "GEMINI.md"), geminiMd);
 }
 
-async function setupCodex(projectDir) {
+async function setupCodex(projectDir, skillFilter = null) {
   // Setup Codex/OpenCode — skills-based architecture
   // Codex supports Agent Skills standard (experimental via experimental.skills)
-  const codexDir = path.join(projectDir, '.codex');
+  const codexDir = path.join(projectDir, ".codex");
   await fs.ensureDir(codexDir);
 
   // Copy skills (same SKILL.md format works cross-platform)
-  const sourceSkillsDir = path.join(__dirname, '..', 'skills');
+  const sourceSkillsDir = path.join(__dirname, "..", "skills");
   if (await fs.pathExists(sourceSkillsDir)) {
-    const skillsDir = path.join(codexDir, 'skills');
+    const skillsDir = path.join(codexDir, "skills");
     await fs.ensureDir(skillsDir);
     const skillDirs = await fs.readdir(sourceSkillsDir);
+    const allowedSkills = skillFilter ? new Set(skillFilter) : null;
     for (const skillName of skillDirs) {
+      if (allowedSkills && !allowedSkills.has(skillName)) continue;
       const skillPath = path.join(sourceSkillsDir, skillName);
       const stat = await fs.stat(skillPath);
       if (stat.isDirectory()) {
@@ -743,7 +1022,7 @@ Enable experimental skills support: \`experimental.skills = true\` in settings.
 
 ### Content & Publishing
 - \`content-writer\` - SEO-optimized content creation
-- \`wordpress-publisher\` / \`payloadcms-publisher\` / \`astro-publisher\` / \`docusaurus-publisher\` / \`mintlify-publisher\`
+- \`content-publisher\` - Multi-platform publishing (WordPress, PayloadCMS, Astro, Docusaurus, Mintlify)
 
 ### DevOps
 - \`deployer\` / \`coolify-deployer\` - Multi-environment deployment
@@ -753,115 +1032,159 @@ Enable experimental skills support: \`experimental.skills = true\` in settings.
 - \`security-tester\` / \`security-auditor\`
 `;
 
-  await fs.writeFile(path.join(codexDir, 'AGENTS.md'), agentsMd);
+  await fs.writeFile(path.join(codexDir, "AGENTS.md"), agentsMd);
 }
 
 program
-  .command('update')
-  .description('Update MyAIDev Method components to latest version')
-  .option('--claude', 'Update Claude Code configuration')
-  .option('--gemini', 'Update Gemini CLI configuration')
-  .option('--codex', 'Update Codex CLI configuration')
-  .option('--force', 'Force update all files without prompting')
-  .option('--dry-run', 'Show what would be updated without making changes')
-  .option('--verbose', 'Show detailed progress')
-  .option('--smart', 'Smart update: keep customizations, add new files (no prompts)')
-  .option('--accept-all', 'Accept all updates: replace all files (no prompts)')
-  .option('--keep-mine', 'Keep all customizations: only add new files (no prompts)')
+  .command("update")
+  .description("Update MyAIDev Method components to latest version")
+  .option("--claude", "Update Claude Code configuration")
+  .option("--gemini", "Update Gemini CLI configuration")
+  .option("--codex", "Update Codex CLI configuration")
+  .option("--force", "Force update all files without prompting")
+  .option("--dry-run", "Show what would be updated without making changes")
+  .option("--verbose", "Show detailed progress")
+  .option(
+    "--smart",
+    "Smart update: keep customizations, add new files (no prompts)",
+  )
+  .option("--accept-all", "Accept all updates: replace all files (no prompts)")
+  .option(
+    "--keep-mine",
+    "Keep all customizations: only add new files (no prompts)",
+  )
   .action(async (options) => {
-    const ora = (await import('ora')).default;
-    const { fileURLToPath } = await import('url');
-    const updateManager = await import('../src/lib/update-manager.js');
+    const ora = (await import("ora")).default;
+    const { fileURLToPath } = await import("url");
+    const updateManager = await import("../src/lib/update-manager.js");
 
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
-    const packageRoot = path.join(__dirname, '..');
+    const packageRoot = path.join(__dirname, "..");
 
     try {
       const cwd = process.cwd();
 
       // Display branding banner
       console.log(getASCIIBanner());
-      console.log(chalk.cyan.bold('                         ⚡ Update Manager\n'));
+      console.log(
+        chalk.cyan.bold("                         ⚡ Update Manager\n"),
+      );
 
       // Detect existing installation
-      const spinner = ora('Detecting MyAIDev Method installation...').start();
+      const spinner = ora("Detecting MyAIDev Method installation...").start();
       const installation = await updateManager.detectExistingInstallation(cwd);
 
       if (!installation) {
-        spinner.fail('No MyAIDev Method installation found');
-        console.log(chalk.gray('   Run: npx myaidev-method@latest init --claude'));
+        spinner.fail("No MyAIDev Method installation found");
+        console.log(
+          chalk.gray("   Run: npx myaidev-method@latest init --claude"),
+        );
         process.exit(1);
       }
 
-      spinner.succeed(`Found ${installation.type} installation (v${installation.currentVersion})`);
+      spinner.succeed(
+        `Found ${installation.type} installation (v${installation.currentVersion})`,
+      );
 
       // Get package version
-      const packageJson = await fs.readJson(path.join(packageRoot, 'package.json'));
+      const packageJson = await fs.readJson(
+        path.join(packageRoot, "package.json"),
+      );
       const newVersion = packageJson.version;
 
       // Check if already up to date
       if (installation.currentVersion === newVersion && !options.force) {
-        console.log(chalk.green('\n✅ Already up to date!\n'));
+        console.log(chalk.green("\n✅ Already up to date!\n"));
         process.exit(0);
       }
 
       // Generate change summary
-      const summarySpinner = ora('Analyzing changes...').start();
-      const components = ['skills', 'scripts', 'lib', 'mcp', 'config', 'docs'];
+      const summarySpinner = ora("Analyzing changes...").start();
+      const components = ["skills", "scripts", "lib", "mcp", "config", "docs"];
       const summary = await updateManager.generateChangeSummary(
-        components, cwd, installation.type, packageRoot
+        components,
+        cwd,
+        installation.type,
+        packageRoot,
       );
-      summarySpinner.succeed('Change analysis complete');
+      summarySpinner.succeed("Change analysis complete");
 
       // Display summary dashboard
-      console.log('');
-      updateManager.displayChangeSummary(summary, installation.currentVersion, newVersion);
+      console.log("");
+      updateManager.displayChangeSummary(
+        summary,
+        installation.currentVersion,
+        newVersion,
+      );
 
       // Dry run mode - just show summary and exit
       if (options.dryRun) {
-        console.log(chalk.yellow('\n📋 DRY RUN — No changes were made.'));
-        console.log(chalk.gray('  Run without --dry-run to apply updates.\n'));
+        console.log(chalk.yellow("\n📋 DRY RUN — No changes were made."));
+        console.log(chalk.gray("  Run without --dry-run to apply updates.\n"));
         process.exit(0);
       }
 
       // Determine strategy (CLI flag or prompt)
       let strategy;
       if (options.smart) {
-        strategy = 'smart';
-        console.log(chalk.cyan('\n🚀 Using Smart Update strategy (--smart flag)\n'));
+        strategy = "smart";
+        console.log(
+          chalk.cyan("\n🚀 Using Smart Update strategy (--smart flag)\n"),
+        );
       } else if (options.acceptAll) {
-        strategy = 'accept-all';
-        console.log(chalk.cyan('\n📥 Using Accept All strategy (--accept-all flag)\n'));
+        strategy = "accept-all";
+        console.log(
+          chalk.cyan("\n📥 Using Accept All strategy (--accept-all flag)\n"),
+        );
       } else if (options.keepMine) {
-        strategy = 'keep-all';
-        console.log(chalk.cyan('\n🛡️  Using Keep All strategy (--keep-mine flag)\n'));
+        strategy = "keep-all";
+        console.log(
+          chalk.cyan("\n🛡️  Using Keep All strategy (--keep-mine flag)\n"),
+        );
       } else if (options.force) {
-        strategy = 'accept-all';
-        console.log(chalk.cyan('\n📥 Using Accept All strategy (--force flag)\n'));
+        strategy = "accept-all";
+        console.log(
+          chalk.cyan("\n📥 Using Accept All strategy (--force flag)\n"),
+        );
       } else {
         strategy = await updateManager.promptUpdateStrategy(summary);
       }
 
       // Create timestamped backup directory
-      const backupDir = await updateManager.createTimestampedBackup(cwd, installation.type);
+      const backupDir = await updateManager.createTimestampedBackup(
+        cwd,
+        installation.type,
+      );
 
       // Execute selected strategy
       let results;
-      console.log(chalk.cyan('\n📦 Applying updates...\n'));
+      console.log(chalk.cyan("\n📦 Applying updates...\n"));
 
-      if (strategy === 'auto' || (summary.modified.length === 0)) {
+      if (strategy === "auto" || summary.modified.length === 0) {
         // No conflicts - just add new files
-        results = await updateManager.executeKeepAll(summary, { verbose: options.verbose });
-      } else if (strategy === 'smart') {
-        results = await updateManager.executeSmartUpdate(summary, backupDir, { verbose: options.verbose });
-      } else if (strategy === 'accept-all') {
-        results = await updateManager.executeAcceptAll(summary, backupDir, { verbose: options.verbose });
-      } else if (strategy === 'keep-all') {
-        results = await updateManager.executeKeepAll(summary, { verbose: options.verbose });
-      } else if (strategy === 'by-category') {
-        results = await updateManager.executeCategoryUpdate(summary, backupDir, { verbose: options.verbose });
-      } else if (strategy === 'individual') {
+        results = await updateManager.executeKeepAll(summary, {
+          verbose: options.verbose,
+        });
+      } else if (strategy === "smart") {
+        results = await updateManager.executeSmartUpdate(summary, backupDir, {
+          verbose: options.verbose,
+        });
+      } else if (strategy === "accept-all") {
+        results = await updateManager.executeAcceptAll(summary, backupDir, {
+          verbose: options.verbose,
+        });
+      } else if (strategy === "keep-all") {
+        results = await updateManager.executeKeepAll(summary, {
+          verbose: options.verbose,
+        });
+      } else if (strategy === "by-category") {
+        results = await updateManager.executeCategoryUpdate(
+          summary,
+          backupDir,
+          { verbose: options.verbose },
+        );
+      } else if (strategy === "individual") {
         // Fall back to old file-by-file for this mode
         results = { updated: [], kept: [], added: [], backedUp: [] };
         for (const f of summary.new) {
@@ -873,11 +1196,15 @@ program
           }
         }
         for (const f of summary.modified) {
-          const action = await updateManager.promptForConflict(f.file, f.targetPath, f.sourcePath);
-          if (action === 'replace') {
+          const action = await updateManager.promptForConflict(
+            f.file,
+            f.targetPath,
+            f.sourcePath,
+          );
+          if (action === "replace") {
             await fs.copy(f.sourcePath, f.targetPath);
             results.updated.push(f.file);
-          } else if (action === 'backup') {
+          } else if (action === "backup") {
             const backupPath = path.join(backupDir, f.componentType, f.file);
             await fs.ensureDir(path.dirname(backupPath));
             await fs.copy(f.targetPath, backupPath);
@@ -898,9 +1225,8 @@ program
 
       // Display final results
       updateManager.displayUpdateResults(results, backupDir, newVersion);
-
     } catch (error) {
-      console.error(chalk.red('\n❌ Update failed:'));
+      console.error(chalk.red("\n❌ Update failed:"));
       console.error(error.message);
       if (options.verbose) {
         console.error(error);
@@ -910,49 +1236,52 @@ program
   });
 
 program
-  .command('claudeweb')
-  .description('Start MyAIDev Method Web UI with Claude Code Viewer')
-  .option('-p, --port <port>', 'Port to run server on', '3400')
-  .option('--single-user', 'Run in single-user mode')
-  .option('--multi-user', 'Run in multi-user mode')
-  .option('--db-path <path>', 'SQLite database path')
+  .command("claudeweb")
+  .description("Start MyAIDev Method Web UI with Claude Code Viewer")
+  .option("-p, --port <port>", "Port to run server on", "3400")
+  .option("--single-user", "Run in single-user mode")
+  .option("--multi-user", "Run in multi-user mode")
+  .option("--db-path <path>", "SQLite database path")
   .action(async (options) => {
     console.log(getASCIIBanner());
-    console.log(chalk.blue('\n🌐 Starting MyAIDev Method Web UI...\n'));
+    console.log(chalk.blue("\n🌐 Starting MyAIDev Method Web UI...\n"));
 
     process.env.PORT = options.port;
     if (options.dbPath) {
       process.env.SQLITE_DB_PATH = options.dbPath;
     }
     if (options.singleUser) {
-      process.env.SINGLE_USER_MODE = 'true';
-      console.log(chalk.cyan('📌 Running in single-user mode'));
+      process.env.SINGLE_USER_MODE = "true";
+      console.log(chalk.cyan("📌 Running in single-user mode"));
     }
     if (options.multiUser) {
-      process.env.MULTI_USER_MODE = 'true';
-      console.log(chalk.cyan('📌 Running in multi-user mode'));
+      process.env.MULTI_USER_MODE = "true";
+      console.log(chalk.cyan("📌 Running in multi-user mode"));
     }
 
     try {
-      const serverModule = await import('../dist/server/main.js');
-      console.log(chalk.green('\n✅ Server module loaded successfully'));
+      const serverModule = await import("../dist/server/main.js");
+      console.log(chalk.green("\n✅ Server module loaded successfully"));
     } catch (error) {
-      console.error(chalk.red('\n❌ Failed to start server:'));
+      console.error(chalk.red("\n❌ Failed to start server:"));
       console.error(error);
-      console.log(chalk.yellow('\n💡 Make sure you have built the server first:'));
-      console.log(chalk.gray('   npm run build:server'));
+      console.log(
+        chalk.yellow("\n💡 Make sure you have built the server first:"),
+      );
+      console.log(chalk.gray("   npm run build:server"));
       process.exit(1);
     }
   });
 
 // Installation detection command (Plugin Architecture Support)
 program
-  .command('detect')
-  .description('Detect MyAIDev Method installation state (legacy vs plugin)')
-  .option('--json', 'Output as JSON')
+  .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');
+      const { detectInstallation, getInstallationStatus } =
+        await import("../src/lib/installation-detector.js");
 
       if (options.json) {
         const detection = await detectInstallation(process.cwd());
@@ -962,137 +1291,162 @@ program
         console.log(status);
       }
     } catch (error) {
-      console.error(chalk.red('Failed to detect installation:'), error.message);
+      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')
+  .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');
+    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:              /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')
+  .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 { 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'));
+      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'));
+      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'));
+      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.yellow("📋 Current Installation: Legacy (npx-based)\n"),
+      );
 
-      console.log(chalk.green('✨ Upgrade Benefits:'));
+      console.log(chalk.green("✨ Upgrade Benefits:"));
       for (const benefit of upgrade.upgradeBenefits) {
         console.log(`   • ${benefit}`);
       }
 
-      console.log(chalk.blue('\n🔒 Preserved Features:'));
+      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');
+        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
-        }
+          type: "confirm",
+          name: "proceed",
+          message: "Proceed with upgrade to plugin architecture?",
+          default: true,
+        },
       ]);
 
       if (!answer.proceed) {
-        console.log(chalk.gray('\nUpgrade cancelled.\n'));
+        console.log(chalk.gray("\nUpgrade cancelled.\n"));
         return;
       }
 
-      const spinner = ora('Upgrading to plugin architecture...').start();
+      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.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')
+        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.ensureDir(path.join(process.cwd(), "hooks"));
       await fs.copy(
-        path.join(packageRoot, 'hooks', 'hooks.json'),
-        path.join(process.cwd(), 'hooks', 'hooks.json')
+        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'));
+      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);
+      console.error(chalk.red("Failed to upgrade:"), error.message);
       process.exit(1);
     }
   });
@@ -1101,4 +1455,4 @@ program
 registerAuthCommands(program);
 registerAddonCommand(program);
 
-program.parse(process.argv);
+program.parse(process.argv);