musubi-sdd 0.1.0

package/bin/musubi-init.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+
+/**
+ * MUSUBI Initialization Script
+ *
+ * Initializes a new project with MUSUBI SDD tools for various AI coding agents:
+ * - Claude Code: .claude/skills/ (25 skills) + .claude/commands/
+ * - GitHub Copilot: .github/prompts/
+ * - Cursor: .cursor/commands/
+ * - Gemini CLI: .gemini/commands/
+ * - Codex CLI: .codex/prompts/
+ * - Qwen Code: .qwen/commands/
+ * - Windsurf: .windsurf/workflows/
+ *
+ * All agents get:
+ * - steering/ directory with project memory
+ * - templates/ for documents
+ * - Constitutional governance
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+
+const TEMPLATE_DIR = path.join(__dirname, '..', 'src', 'templates');
+const SHARED_TEMPLATE_DIR = path.join(TEMPLATE_DIR, 'shared');
+const AGENTS_TEMPLATE_DIR = path.join(TEMPLATE_DIR, 'agents');
+
+/**
+ * Main initialization function
+ * @param {object} agent - Agent definition from registry
+ * @param {string} agentKey - Agent key (e.g., 'claude-code', 'cursor')
+ */
+async function main(agent, agentKey) {
+  // If called directly without agent parameter, default to Claude Code
+  if (!agent) {
+    const { getAgentDefinition } = require('../src/agents/registry');
+    agent = getAgentDefinition('claude-code');
+    agentKey = 'claude-code';
+  }
+
+  console.log(chalk.blue.bold('\n🎯 MUSUBI - Ultimate Specification Driven Development\n'));
+  console.log(chalk.white(`Initializing for: ${chalk.bold(agent.label)}\n`));
+
+  // Check if already initialized for this agent
+  const agentDir = agent.layout.agentDir;
+  if (fs.existsSync(agentDir)) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: `MUSUBI for ${agent.label} is already initialized. Overwrite?`,
+        default: false
+      }
+    ]);
+
+    if (!overwrite) {
+      console.log(chalk.yellow('Initialization cancelled.'));
+      process.exit(0);
+    }
+  }
+
+  // Collect project information
+  const prompts = [
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Project name:',
+      default: path.basename(process.cwd())
+    },
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Project description:',
+      default: 'A software project using MUSUBI SDD'
+    },
+    {
+      type: 'list',
+      name: 'projectType',
+      message: 'Project type:',
+      choices: ['Greenfield (0→1)', 'Brownfield (1→n)', 'Both']
+    }
+  ];
+
+  // Skills selection is only for Claude Code (Skills API exclusive)
+  if (agent.features.hasSkills) {
+    prompts.push({
+      type: 'checkbox',
+      name: 'skills',
+      message: 'Select skills to install (all recommended):',
+      choices: [
+        { name: 'Core (orchestrator, steering, constitution-enforcer)', value: 'core', checked: true },
+        { name: 'Requirements & Planning (requirements-analyst, project-manager, change-impact-analyzer)', value: 'requirements', checked: true },
+        { name: 'Architecture & Design (system-architect, api-designer, database-schema-designer, ui-ux-designer)', value: 'architecture', checked: true },
+        { name: 'Development (software-developer)', value: 'development', checked: true },
+        { name: 'Quality & Review (test-engineer, code-reviewer, bug-hunter, quality-assurance, traceability-auditor)', value: 'quality', checked: true },
+        { name: 'Security & Performance (security-auditor, performance-optimizer)', value: 'security', checked: true },
+        { name: 'Infrastructure (devops-engineer, cloud-architect, database-administrator, site-reliability-engineer, release-coordinator)', value: 'infrastructure', checked: true },
+        { name: 'Documentation (technical-writer, ai-ml-engineer)', value: 'documentation', checked: true }
+      ]
+    });
+  }
+
+  prompts.push(
+    {
+      type: 'confirm',
+      name: 'createSteering',
+      message: 'Generate initial steering context?',
+      default: true
+    },
+    {
+      type: 'confirm',
+      name: 'createConstitution',
+      message: 'Create constitutional governance?',
+      default: true
+    }
+  );
+
+  const answers = await inquirer.prompt(prompts);
+
+  console.log(chalk.green('\n✨ Initializing MUSUBI...\n'));
+
+  // Create directory structure (agent-specific + shared)
+  const dirs = [
+    'steering',
+    'steering/rules',
+    'templates',
+    'storage/specs',
+    'storage/changes',
+    'storage/features'
+  ];
+
+  // Add agent-specific directories
+  if (agent.layout.skillsDir) {
+    dirs.unshift(agent.layout.skillsDir);
+  }
+  if (agent.layout.commandsDir) {
+    dirs.unshift(agent.layout.commandsDir);
+  }
+  if (agent.layout.agentDir && !dirs.includes(agent.layout.agentDir)) {
+    dirs.unshift(agent.layout.agentDir);
+  }
+
+  for (const dir of dirs) {
+    await fs.ensureDir(dir);
+    console.log(chalk.gray(`  Created ${dir}/`));
+  }
+
+  // Install skills (Claude Code only)
+  if (agent.features.hasSkills && answers.skills) {
+    const skillGroups = {
+      core: ['orchestrator', 'steering', 'constitution-enforcer'],
+      requirements: ['requirements-analyst', 'project-manager', 'change-impact-analyzer'],
+      architecture: ['system-architect', 'api-designer', 'database-schema-designer', 'ui-ux-designer'],
+      development: ['software-developer'],
+      quality: ['test-engineer', 'code-reviewer', 'bug-hunter', 'quality-assurance', 'traceability-auditor'],
+      security: ['security-auditor', 'performance-optimizer'],
+      infrastructure: ['devops-engineer', 'cloud-architect', 'database-administrator', 'site-reliability-engineer', 'release-coordinator'],
+      documentation: ['technical-writer', 'ai-ml-engineer']
+    };
+
+    let skillCount = 0;
+    for (const group of answers.skills) {
+      for (const skill of skillGroups[group]) {
+        await copySkill(skill, agent);
+        skillCount++;
+      }
+    }
+
+    console.log(chalk.green(`\n  Installed ${skillCount} skills`));
+  }
+
+  // Install commands/prompts/workflows
+  if (agent.features.hasCommands) {
+    await copyCommands(agent, agentKey);
+    const commandType = agentKey === 'github-copilot' || agentKey === 'codex' ? 'prompts' :
+                        agentKey === 'windsurf' ? 'workflows' : 'commands';
+    console.log(chalk.green(`  Installed ${commandType}`));
+  }
+
+  // Generate steering context
+  if (answers.createSteering) {
+    await generateSteering(answers);
+    console.log(chalk.green('  Generated steering context'));
+  }
+
+  // Create constitution
+  if (answers.createConstitution) {
+    await createConstitution();
+    console.log(chalk.green('  Created constitutional governance'));
+  }
+
+  // Create README
+  await createReadme(answers, agent, agentKey);
+  console.log(chalk.green(`  Created ${agent.layout.docFile || 'MUSUBI.md'} guide`));
+
+  // Success message
+  console.log(chalk.blue.bold(`\n✅ MUSUBI initialization complete for ${agent.label}!\n`));
+  console.log(chalk.white('Next steps:'));
+  console.log(chalk.gray('  1. Review steering/ context files'));
+  console.log(chalk.gray('  2. Review steering/rules/constitution.md'));
+
+  if (agent.features.hasSkills) {
+    console.log(chalk.gray(`  3. Start using ${agent.label} with MUSUBI skills`));
+  } else {
+    console.log(chalk.gray(`  3. Start using ${agent.label} with MUSUBI`));
+  }
+
+  const cmdExample = agent.commands.requirements.replace(' <feature>', ' authentication');
+  console.log(chalk.gray(`  4. Try commands: ${cmdExample}\n`));
+  console.log(chalk.cyan('Learn more: https://github.com/your-org/musubi\n'));
+}
+
+async function copySkill(skillName, agent) {
+  const srcDir = path.join(AGENTS_TEMPLATE_DIR, 'claude-code', 'skills', skillName);
+  const destDir = path.join(agent.layout.skillsDir, skillName);
+  await fs.copy(srcDir, destDir);
+}
+
+async function copyCommands(agent, agentKey) {
+  const srcDir = path.join(AGENTS_TEMPLATE_DIR, agentKey, 'commands');
+  const destDir = agent.layout.commandsDir;
+
+  // If agent-specific templates don't exist yet, fall back to Claude Code templates
+  if (!fs.existsSync(srcDir)) {
+    const fallbackSrc = path.join(AGENTS_TEMPLATE_DIR, 'claude-code', 'commands');
+    await fs.copy(fallbackSrc, destDir);
+  } else {
+    await fs.copy(srcDir, destDir);
+  }
+}
+
+async function generateSteering(answers) {
+  const steeringTemplates = path.join(SHARED_TEMPLATE_DIR, 'steering');
+
+  // Copy and customize steering files
+  const files = ['structure.md', 'tech.md', 'product.md'];
+  for (const file of files) {
+    let content = await fs.readFile(path.join(steeringTemplates, file), 'utf8');
+
+    // Replace placeholders
+    content = content.replace(/\{\{PROJECT_NAME\}\}/g, answers.projectName);
+    content = content.replace(/\{\{DESCRIPTION\}\}/g, answers.description);
+    content = content.replace(/\{\{DATE\}\}/g, new Date().toISOString().split('T')[0]);
+
+    await fs.writeFile(path.join('steering', file), content);
+  }
+}
+
+async function createConstitution() {
+  const constitutionTemplate = path.join(SHARED_TEMPLATE_DIR, 'constitution', 'constitution.md');
+  await fs.copy(constitutionTemplate, 'steering/rules/constitution.md');
+}
+
+async function createReadme(answers, agent, agentKey) {
+  const skillsSection = agent.features.hasSkills && answers.skills
+    ? `This project uses **MUSUBI** (Ultimate Specification Driven Development) with ${answers.skills.length} skill groups.
+
+### Available Skills
+
+Check \`${agent.layout.skillsDir}/\` directory for all installed skills.
+
+`
+    : `This project uses **MUSUBI** (Ultimate Specification Driven Development).
+
+`;
+
+  const commandType = agentKey === 'github-copilot' || agentKey === 'codex' ? 'Prompts' :
+                      agentKey === 'windsurf' ? 'Workflows' : 'Commands';
+
+  const readme = `# MUSUBI - ${answers.projectName}
+
+${answers.description}
+
+## Initialized with MUSUBI SDD for ${agent.label}
+
+${skillsSection}
+### ${commandType}
+
+- \`${agent.commands.steering}\` - Generate/update project memory
+- \`${agent.commands.requirements}\` - Create EARS requirements
+- \`${agent.commands.design}\` - Generate C4 + ADR design
+- \`${agent.commands.tasks}\` - Break down into tasks
+- \`${agent.commands.implement}\` - Execute implementation
+- \`${agent.commands.validate}\` - Validate constitutional compliance
+
+### Project Memory
+
+- \`steering/structure.md\` - Architecture patterns
+- \`steering/tech.md\` - Technology stack
+- \`steering/product.md\` - Product context
+- \`steering/rules/constitution.md\` - 9 Constitutional Articles
+
+### Learn More
+
+- [MUSUBI Documentation](https://github.com/your-org/musubi)
+- [Constitutional Governance](steering/rules/constitution.md)
+- [8-Stage SDD Workflow](steering/rules/workflow.md)
+
+---
+
+**Agent**: ${agent.label}
+**Initialized**: ${new Date().toISOString().split('T')[0]}
+**MUSUBI Version**: 0.1.0
+`;
+
+  const filename = agent.layout.docFile || 'MUSUBI.md';
+  await fs.writeFile(filename, readme);
+}
+
+// Export for use from musubi.js
+module.exports = main;
+
+// Allow direct execution for backward compatibility
+if (require.main === module) {
+  main().catch(err => {
+    console.error(chalk.red('\n❌ Initialization failed:'), err.message);
+    process.exit(1);
+  });
+}

package/bin/musubi.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+
+/**
+ * MUSUBI CLI - Main Entry Point
+ *
+ * Provides commands for managing MUSUBI SDD projects:
+ * - musubi init       - Initialize project with MUSUBI
+ * - musubi status     - Show MUSUBI project status
+ * - musubi validate   - Validate constitutional compliance
+ * - musubi version    - Show version information
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const { detectAgentFromFlags, getAgentDefinition, getAllAliasFlags } = require('../src/agents/registry');
+
+const program = new Command();
+
+// Package info
+const packageJson = require('../package.json');
+
+program
+  .name('musubi')
+  .description('MUSUBI - Ultimate Specification Driven Development Tool')
+  .version(packageJson.version, '-v, --version', 'Output the current version');
+
+// ============================================================================
+// Command: init
+// ============================================================================
+const initCommand = program
+  .command('init')
+  .description('Initialize MUSUBI in current project');
+
+// Add all agent selection flags dynamically
+const aliasFlags = getAllAliasFlags();
+aliasFlags.forEach(flag => {
+  initCommand.option(`--${flag}`, `Select agent: ${flag}`);
+});
+
+initCommand.action((options) => {
+  const agentKey = detectAgentFromFlags(options);
+  const agent = getAgentDefinition(agentKey);
+
+  console.log(chalk.blue(`Initializing MUSUBI for ${chalk.bold(agent.label)}...`));
+  console.log(chalk.gray(`Description: ${agent.description}\n`));
+
+  // Delegate to musubi-init.js with agent info
+  require('./musubi-init.js')(agent, agentKey);
+});
+
+// ============================================================================
+// Command: status
+// ============================================================================
+program
+  .command('status')
+  .description('Show MUSUBI project status')
+  .action(async () => {
+    console.log(chalk.blue.bold('\n📊 MUSUBI Project Status\n'));
+
+    const cwd = process.cwd();
+
+    // Check if MUSUBI is initialized
+    const skillsDir = path.join(cwd, '.claude', 'skills');
+    const steeringDir = path.join(cwd, 'steering');
+
+    if (!fs.existsSync(skillsDir) && !fs.existsSync(steeringDir)) {
+      console.log(chalk.yellow('⚠️  MUSUBI is not initialized in this project.'));
+      console.log(chalk.gray('\nRun: musubi init\n'));
+      process.exit(1);
+    }
+
+    console.log(chalk.green('✅ MUSUBI is initialized\n'));
+
+    // Count skills
+    if (fs.existsSync(skillsDir)) {
+      const skills = fs.readdirSync(skillsDir);
+      console.log(chalk.white(`📁 Claude Code Skills: ${skills.length} installed`));
+      console.log(chalk.gray(`   Location: .claude/skills/\n`));
+    }
+
+    // Check steering files
+    console.log(chalk.white('🧭 Steering Context:'));
+    const steeringFiles = ['structure.md', 'tech.md', 'product.md'];
+    let steeringComplete = true;
+
+    for (const file of steeringFiles) {
+      const filePath = path.join(steeringDir, file);
+      if (fs.existsSync(filePath)) {
+        const stats = fs.statSync(filePath);
+        const lastModified = stats.mtime.toISOString().split('T')[0];
+        console.log(chalk.green(`   ✅ ${file} (updated: ${lastModified})`));
+      } else {
+        console.log(chalk.red(`   ❌ ${file} (missing)`));
+        steeringComplete = false;
+      }
+    }
+
+    if (!steeringComplete) {
+      console.log(chalk.yellow('\n⚠️  Steering files incomplete. Run: /sdd-steering'));
+    }
+
+    // Check constitutional governance
+    const constitutionPath = path.join(steeringDir, 'rules', 'constitution.md');
+    if (fs.existsSync(constitutionPath)) {
+      console.log(chalk.green('\n✅ Constitutional Governance: Enabled'));
+    } else {
+      console.log(chalk.yellow('\n⚠️  Constitutional Governance: Not found'));
+    }
+
+    // Check for specifications
+    const specsDir = path.join(cwd, 'storage', 'specs');
+    if (fs.existsSync(specsDir)) {
+      const specs = fs.readdirSync(specsDir).filter(f => f.endsWith('.md'));
+      console.log(chalk.white(`\n📄 Specifications: ${specs.length} documents`));
+      if (specs.length > 0) {
+        console.log(chalk.gray('   Latest specs:'));
+        specs.slice(0, 5).forEach(spec => {
+          console.log(chalk.gray(`   - ${spec}`));
+        });
+      }
+    }
+
+    console.log(chalk.blue('\n💡 Next steps:'));
+    console.log(chalk.gray('   - Review steering files in steering/'));
+    console.log(chalk.gray('   - Create requirements: /sdd-requirements [feature]'));
+    console.log(chalk.gray('   - Validate compliance: musubi validate\n'));
+  });
+
+// ============================================================================
+// Command: validate
+// ============================================================================
+program
+  .command('validate [feature]')
+  .description('Validate constitutional compliance')
+  .option('-a, --all', 'Validate all features')
+  .option('-v, --verbose', 'Verbose output')
+  .action(async (feature, options) => {
+    console.log(chalk.blue.bold('\n🔍 MUSUBI Validation\n'));
+
+    const cwd = process.cwd();
+    const steeringDir = path.join(cwd, 'steering');
+    const constitutionPath = path.join(steeringDir, 'rules', 'constitution.md');
+
+    // Check if MUSUBI is initialized
+    if (!fs.existsSync(constitutionPath)) {
+      console.log(chalk.red('❌ MUSUBI not initialized or constitution.md missing'));
+      console.log(chalk.gray('\nRun: musubi init\n'));
+      process.exit(1);
+    }
+
+    console.log(chalk.white('📋 Validation Checklist:\n'));
+
+    // Article I: Library-First
+    console.log(chalk.white('Article I: Library-First Principle'));
+    const libDir = path.join(cwd, 'lib');
+    if (fs.existsSync(libDir)) {
+      const libraries = fs.readdirSync(libDir).filter(f => {
+        return fs.statSync(path.join(libDir, f)).isDirectory();
+      });
+      if (libraries.length > 0) {
+        console.log(chalk.green(`   ✅ ${libraries.length} libraries found in lib/`));
+        if (options.verbose) {
+          libraries.forEach(lib => console.log(chalk.gray(`      - ${lib}`)));
+        }
+      } else {
+        console.log(chalk.yellow('   ⚠️  No libraries found in lib/'));
+      }
+    } else {
+      console.log(chalk.yellow('   ⚠️  lib/ directory not found'));
+    }
+
+    // Article II: CLI Interface
+    console.log(chalk.white('\nArticle II: CLI Interface Mandate'));
+    if (fs.existsSync(libDir)) {
+      const libraries = fs.readdirSync(libDir).filter(f => {
+        return fs.statSync(path.join(libDir, f)).isDirectory();
+      });
+      let cliCount = 0;
+      libraries.forEach(lib => {
+        const cliPath = path.join(libDir, lib, 'cli.ts');
+        const cliJsPath = path.join(libDir, lib, 'cli.js');
+        if (fs.existsSync(cliPath) || fs.existsSync(cliJsPath)) {
+          cliCount++;
+          if (options.verbose) {
+            console.log(chalk.green(`   ✅ ${lib}/cli.ts`));
+          }
+        } else if (options.verbose) {
+          console.log(chalk.red(`   ❌ ${lib}/cli.ts (missing)`));
+        }
+      });
+      if (cliCount === libraries.length && libraries.length > 0) {
+        console.log(chalk.green(`   ✅ All ${libraries.length} libraries have CLI interfaces`));
+      } else {
+        console.log(chalk.yellow(`   ⚠️  ${cliCount}/${libraries.length} libraries have CLI`));
+      }
+    }
+
+    // Article IV: EARS Format
+    console.log(chalk.white('\nArticle IV: EARS Requirements Format'));
+    const specsDir = path.join(cwd, 'storage', 'specs');
+    if (fs.existsSync(specsDir)) {
+      const requirementFiles = fs.readdirSync(specsDir)
+        .filter(f => f.includes('requirements') && f.endsWith('.md'));
+
+      if (requirementFiles.length > 0) {
+        console.log(chalk.green(`   ✅ ${requirementFiles.length} requirements documents found`));
+
+        // Basic EARS pattern check
+        let earsCompliant = 0;
+        requirementFiles.forEach(file => {
+          const content = fs.readFileSync(path.join(specsDir, file), 'utf8');
+          const hasEarsPatterns = /\b(WHEN|WHILE|IF|WHERE|SHALL)\b/.test(content);
+          if (hasEarsPatterns) {
+            earsCompliant++;
+            if (options.verbose) {
+              console.log(chalk.green(`      ✅ ${file}`));
+            }
+          } else if (options.verbose) {
+            console.log(chalk.yellow(`      ⚠️  ${file} (no EARS patterns detected)`));
+          }
+        });
+
+        if (earsCompliant === requirementFiles.length) {
+          console.log(chalk.green(`   ✅ All requirements use EARS format`));
+        } else {
+          console.log(chalk.yellow(`   ⚠️  ${earsCompliant}/${requirementFiles.length} documents have EARS patterns`));
+        }
+      } else {
+        console.log(chalk.gray('   ℹ️  No requirements documents found'));
+      }
+    } else {
+      console.log(chalk.gray('   ℹ️  storage/specs/ not found'));
+    }
+
+    // Article VI: Project Memory
+    console.log(chalk.white('\nArticle VI: Project Memory (Steering System)'));
+    const steeringFiles = ['structure.md', 'tech.md', 'product.md'];
+    let steeringCount = 0;
+    steeringFiles.forEach(file => {
+      const filePath = path.join(steeringDir, file);
+      if (fs.existsSync(filePath)) {
+        steeringCount++;
+        if (options.verbose) {
+          console.log(chalk.green(`   ✅ steering/${file}`));
+        }
+      } else if (options.verbose) {
+        console.log(chalk.red(`   ❌ steering/${file} (missing)`));
+      }
+    });
+
+    if (steeringCount === 3) {
+      console.log(chalk.green('   ✅ All steering files present'));
+    } else {
+      console.log(chalk.yellow(`   ⚠️  ${steeringCount}/3 steering files present`));
+    }
+
+    // Summary
+    console.log(chalk.blue('\n📊 Validation Summary:'));
+    console.log(chalk.white('   For comprehensive validation, use Claude Code:'));
+    console.log(chalk.gray('   /sdd-validate [feature-name]\n'));
+    console.log(chalk.white('   Or invoke skills directly:'));
+    console.log(chalk.gray('   @constitution-enforcer validate [path]'));
+    console.log(chalk.gray('   @traceability-auditor validate requirements.md\n'));
+  });
+
+// ============================================================================
+// Command: info
+// ============================================================================
+program
+  .command('info')
+  .description('Show MUSUBI version and environment info')
+  .action(() => {
+    const { getAgentList } = require('../src/agents/registry');
+
+    console.log(chalk.blue.bold('\n🎯 MUSUBI Information\n'));
+    console.log(chalk.white(`Version: ${packageJson.version}`));
+    console.log(chalk.white(`Description: ${packageJson.description}`));
+    console.log(chalk.white(`License: ${packageJson.license}\n`));
+
+    console.log(chalk.white('Environment:'));
+    console.log(chalk.gray(`   Node.js: ${process.version}`));
+    console.log(chalk.gray(`   npm: ${process.env.npm_config_user_agent?.split(' ')[0] || 'N/A'}`));
+    console.log(chalk.gray(`   Platform: ${process.platform}`));
+    console.log(chalk.gray(`   CWD: ${process.cwd()}\n`));
+
+    console.log(chalk.white('Supported AI Coding Agents (7):'));
+    const agents = getAgentList();
+    agents.forEach(agentKey => {
+      const agent = getAgentDefinition(agentKey);
+      const flags = agent.aliasFlags.join(', ');
+      console.log(chalk.gray(`   ${agent.label} - ${flags}`));
+    });
+    console.log('');
+
+    console.log(chalk.white('Documentation:'));
+    console.log(chalk.gray('   https://github.com/your-org/musubi\n'));
+
+    console.log(chalk.white('25 Claude Code Skills:'));
+    console.log(chalk.gray('   Orchestration: orchestrator, steering, constitution-enforcer'));
+    console.log(chalk.gray('   Requirements: requirements-analyst, project-manager, change-impact-analyzer'));
+    console.log(chalk.gray('   Architecture: system-architect, api-designer, database-schema-designer, ui-ux-designer'));
+    console.log(chalk.gray('   Development: software-developer'));
+    console.log(chalk.gray('   Quality: test-engineer, code-reviewer, bug-hunter, quality-assurance, traceability-auditor'));
+    console.log(chalk.gray('   Security: security-auditor, performance-optimizer'));
+    console.log(chalk.gray('   Infrastructure: devops-engineer, cloud-architect, database-administrator, site-reliability-engineer, release-coordinator'));
+    console.log(chalk.gray('   Documentation: technical-writer, ai-ml-engineer\n'));
+  });
+
+// ============================================================================
+// Command: help (custom formatting)
+// ============================================================================
+program.on('--help', () => {
+  console.log('');
+  console.log('Examples:');
+  console.log('  $ musubi init                    # Initialize MUSUBI (Claude Code, default)');
+  console.log('  $ musubi init --cursor           # Initialize for Cursor IDE');
+  console.log('  $ musubi init --copilot          # Initialize for GitHub Copilot');
+  console.log('  $ musubi init --gemini           # Initialize for Gemini CLI');
+  console.log('  $ musubi init --codex            # Initialize for Codex CLI');
+  console.log('  $ musubi init --qwen             # Initialize for Qwen Code');
+  console.log('  $ musubi init --windsurf         # Initialize for Windsurf IDE');
+  console.log('  $ musubi status                  # Show project status');
+  console.log('  $ musubi validate                # Quick validation check');
+  console.log('  $ musubi info                    # Show version and supported agents');
+  console.log('');
+  console.log('Agent Selection Flags:');
+  console.log('  --claude, --claude-code          # Claude Code (default)');
+  console.log('  --copilot, --github-copilot      # GitHub Copilot');
+  console.log('  --cursor                         # Cursor IDE');
+  console.log('  --gemini, --gemini-cli           # Gemini CLI');
+  console.log('  --codex, --codex-cli             # Codex CLI');
+  console.log('  --qwen, --qwen-code              # Qwen Code');
+  console.log('  --windsurf                       # Windsurf IDE');
+  console.log('');
+  console.log('Claude Code Usage (default):');
+  console.log('  /sdd-steering                    # Generate project memory');
+  console.log('  /sdd-requirements [feature]      # Create EARS requirements');
+  console.log('  /sdd-design [feature]            # Generate technical design');
+  console.log('  /sdd-tasks [feature]             # Break down into tasks');
+  console.log('  /sdd-implement [feature]         # Execute implementation');
+  console.log('  /sdd-validate [feature]          # Validate compliance');
+  console.log('');
+  console.log('Claude Code Skills (25 specialized skills):');
+  console.log('  @orchestrator, @steering, @requirements-analyst, @system-architect,');
+  console.log('  @software-developer, @test-engineer, @code-reviewer, and 18 more...');
+  console.log('');
+  console.log('Note: Skills API is Claude Code exclusive. Other agents use commands/prompts.');
+  console.log('');
+});
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}