musubi-sdd 0.6.1 → 0.8.0

package/README.ja.md

@@ -13,9 +13,14 @@ MUSUBIは、6つの主要フレームワークのベスト機能を統合した
   - GitHub Copilot & Cursor: AGENTS.md（公式サポート）
   - その他4エージェント: AGENTS.md（互換形式）
 - 📋 **憲法ガバナンス** - 9つの不変条項 + フェーズ-1ゲートによる品質保証
-- 📝 **EARS要件形式** - 完全なトレーサビリティを持つ明確な要件
+- 📝 **EARS要件ジェネレーター** - 5つのEARSパターンで明確な要件を作成（v0.8.0）
 - 🔄 **差分仕様** - ブラウンフィールドおよびグリーンフィールドプロジェクト対応
 - 🧭 **自動更新プロジェクトメモリ** - ステアリングシステムがアーキテクチャ、技術スタック、製品コンテキストを維持
+- 🚀 **自動オンボーディング** - `musubi-onboard` が既存プロジェクトを分析し、ステアリングドキュメントを生成（2-5分）
+- 🔄 **自動同期** - `musubi-sync` がコードベースの変更を検出し、ステアリングドキュメントを最新に保つ
+- 🔍 **インテリジェントコード分析** - `musubi-analyze` が品質メトリクス、複雑度分析、技術的負債検出を提供
+- 🤝 **チーム連携** - `musubi-share` がメモリ共有、インポート/エクスポート、マルチプラットフォーム同期を実現（v0.6.0）
+- ✅ **憲法バリデーション** - `musubi-validate` が9つの不変ガバナンス条項とフェーズ-1ゲートを強制（v0.7.0）
 - ✅ **完全なトレーサビリティ** - 要件 → 設計 → コード → テストのマッピング
 - 🌐 **バイリンガルドキュメント** - すべてのエージェント生成ドキュメントは英語と日本語の両方で作成
 
@@ -72,6 +77,40 @@ npx musubi-sdd init --windsurf
 # またはグローバルインストール
 npm install -g musubi-sdd
 musubi init --claude    # または --copilot、--cursorなど
+
+# 既存プロジェクトのオンボーディング（自動分析）
+musubi-onboard
+
+# コードベースとステアリングドキュメントの同期
+musubi-sync
+musubi-sync --dry-run        # 変更のプレビュー
+musubi-sync --auto-approve   # 自動適用（CI/CD）
+
+# コード品質分析（v0.5.0）
+musubi-analyze                      # 完全分析
+musubi-analyze --type=quality       # 品質メトリクスのみ
+musubi-analyze --type=dependencies  # 依存関係のみ
+musubi-analyze --type=security      # セキュリティ監査
+musubi-analyze --output=report.md   # レポート保存
+
+# チームとプロジェクトメモリを共有（v0.6.0）
+musubi-share export                 # メモリをJSONにエクスポート
+musubi-share import memories.json   # チームメイトからインポート
+musubi-share sync --platform=copilot # 特定プラットフォームに同期
+
+# 憲法準拠の検証（v0.7.0）
+musubi-validate constitution        # 全9条項を検証
+musubi-validate article 3           # テストファースト原則を検証
+musubi-validate gates               # フェーズ-1ゲートを検証
+musubi-validate complexity          # 複雑度制限をチェック
+musubi-validate all -v              # 詳細付き完全検証
+
+# EARS要件の作成（v0.8.0）
+musubi-requirements init "ユーザー認証"  # 要件ドキュメント初期化
+musubi-requirements add                 # インタラクティブに要件追加
+musubi-requirements list                # 全要件リスト表示
+musubi-requirements validate            # EARS形式検証
+musubi-requirements trace               # トレーサビリティマトリクス表示
 ```
 
 ### プロジェクトタイプ

package/README.md

@@ -17,13 +17,14 @@ MUSUBI is a comprehensive SDD (Specification Driven Development) framework that
   - GitHub Copilot & Cursor: AGENTS.md (official support)
   - Other 4 agents: AGENTS.md (compatible format)
 - 📋 **Constitutional Governance** - 9 immutable articles + Phase -1 Gates for quality enforcement
-- 📝 **EARS Requirements Format** - Unambiguous requirements with complete traceability
+- 📝 **EARS Requirements Generator** - Create unambiguous requirements with 5 EARS patterns (v0.8.0)
 - 🔄 **Delta Specifications** - Brownfield and greenfield project support
 - 🧭 **Auto-Updating Project Memory** - Steering system maintains architecture, tech stack, and product context
 - 🚀 **Automatic Onboarding** - `musubi-onboard` analyzes existing projects and generates steering docs (2-5 minutes)
 - 🔄 **Auto-Sync** - `musubi-sync` detects codebase changes and keeps steering docs current
 - 🔍 **Intelligent Code Analysis** - `musubi-analyze` provides quality metrics, complexity analysis, and technical debt detection
 - 🤝 **Team Collaboration** - `musubi-share` enables memory sharing, import/export, and multi-platform sync (v0.6.0)
+- ✅ **Constitutional Validation** - `musubi-validate` enforces 9 immutable governance articles with Phase -1 Gates (v0.7.0)
 - ✅ **Complete Traceability** - Requirements → Design → Code → Tests mapping
 - 🌐 **Bilingual Documentation** - All agent-generated documents created in both English and Japanese
 
@@ -99,8 +100,21 @@ musubi-analyze --output=report.md   # Save report
 # Share project memories with team (v0.6.0)
 musubi-share export                 # Export memories to JSON
 musubi-share import memories.json   # Import from teammate
-musubi-share sync                   # Sync across AI platforms
-musubi-share status                 # Show sharing status
+musubi-share sync --platform=copilot # Sync to specific platform
+
+# Validate constitutional compliance (v0.7.0)
+musubi-validate constitution        # Validate all 9 articles
+musubi-validate article 3           # Validate Test-First Imperative
+musubi-validate gates               # Validate Phase -1 Gates
+musubi-validate complexity          # Check complexity limits
+musubi-validate all -v              # Full validation with details
+
+# Create EARS requirements (v0.8.0)
+musubi-requirements init "User Authentication"  # Initialize requirements doc
+musubi-requirements add                         # Add requirement interactively
+musubi-requirements list                        # List all requirements
+musubi-requirements validate                    # Validate EARS format
+musubi-requirements trace                       # Show traceability matrix
 ```
 
 ### Project Types

package/bin/musubi-requirements.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+
+/**
+ * MUSUBI Requirements Generator CLI
+ * 
+ * Generates EARS (Easy Approach to Requirements Syntax) formatted requirements
+ * Supports 5 EARS patterns for unambiguous specification
+ * 
+ * Usage:
+ *   musubi-requirements init <feature>          # Initialize requirements document
+ *   musubi-requirements add <pattern> <title>   # Add requirement with EARS pattern
+ *   musubi-requirements list                    # List all requirements
+ *   musubi-requirements validate                # Validate EARS format compliance
+ *   musubi-requirements trace                   # Show traceability matrix
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const RequirementsGenerator = require('../src/generators/requirements');
+
+const program = new Command();
+
+program
+  .name('musubi-requirements')
+  .description('EARS Requirements Generator - Create unambiguous specifications')
+  .version('0.8.0');
+
+// Initialize requirements document
+program
+  .command('init <feature>')
+  .description('Initialize requirements document for a feature')
+  .option('-o, --output <path>', 'Output directory', 'docs/requirements')
+  .option('-a, --author <name>', 'Author name')
+  .option('--project <name>', 'Project name')
+  .action(async (feature, options) => {
+    try {
+      console.log(chalk.bold(`\n📋 Initializing requirements for: ${feature}\n`));
+      
+      const generator = new RequirementsGenerator(process.cwd());
+      const result = await generator.init(feature, options);
+      
+      console.log(chalk.green('✓ Requirements document created'));
+      console.log(chalk.dim(`  ${result.path}`));
+      console.log();
+      console.log(chalk.bold('Next steps:'));
+      console.log(chalk.dim(`  1. Edit ${result.path}`));
+      console.log(chalk.dim('  2. Add requirements: musubi-requirements add <pattern> <title>'));
+      console.log(chalk.dim('  3. Validate: musubi-requirements validate'));
+      console.log();
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Add requirement with EARS pattern
+program
+  .command('add')
+  .description('Add requirement with EARS pattern (interactive)')
+  .option('-f, --file <path>', 'Requirements file path')
+  .option('-p, --pattern <type>', 'EARS pattern (ubiquitous|event|state|unwanted|optional)')
+  .option('-t, --title <text>', 'Requirement title')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n📝 Add EARS Requirement\n'));
+      
+      const generator = new RequirementsGenerator(process.cwd());
+      
+      // Find requirements file
+      let reqFile = options.file;
+      if (!reqFile) {
+        const files = await generator.findRequirementsFiles();
+        if (files.length === 0) {
+          console.error(chalk.red('✗ No requirements files found'));
+          console.log(chalk.dim('  Run: musubi-requirements init <feature>'));
+          process.exit(1);
+        }
+        
+        if (files.length === 1) {
+          reqFile = files[0];
+        } else {
+          const answer = await inquirer.prompt([{
+            type: 'list',
+            name: 'file',
+            message: 'Select requirements file:',
+            choices: files
+          }]);
+          reqFile = answer.file;
+        }
+      }
+      
+      // Interactive prompts if not provided
+      let pattern = options.pattern;
+      let title = options.title;
+      
+      if (!pattern || !title) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'pattern',
+            message: 'Select EARS pattern:',
+            choices: [
+              { name: 'Ubiquitous - The [system] SHALL [requirement]', value: 'ubiquitous' },
+              { name: 'Event-Driven - WHEN [event], THEN [system] SHALL [response]', value: 'event' },
+              { name: 'State-Driven - WHILE [state], [system] SHALL [response]', value: 'state' },
+              { name: 'Unwanted Behavior - IF [error], THEN [system] SHALL [response]', value: 'unwanted' },
+              { name: 'Optional Feature - WHERE [feature], [system] SHALL [response]', value: 'optional' }
+            ],
+            when: () => !pattern
+          },
+          {
+            type: 'input',
+            name: 'title',
+            message: 'Requirement title:',
+            when: () => !title,
+            validate: (input) => input.length > 0 || 'Title is required'
+          },
+          {
+            type: 'input',
+            name: 'system',
+            message: 'System/component name:',
+            default: 'system'
+          },
+          {
+            type: 'input',
+            name: 'statement',
+            message: (answers) => {
+              const prompts = {
+                ubiquitous: 'What SHALL the system do?',
+                event: 'What event triggers this? (WHEN...)',
+                state: 'What state/condition? (WHILE...)',
+                unwanted: 'What error/unwanted condition? (IF...)',
+                optional: 'What optional feature? (WHERE...)'
+              };
+              return prompts[answers.pattern || pattern];
+            },
+            validate: (input) => input.length > 0 || 'Statement is required'
+          },
+          {
+            type: 'input',
+            name: 'response',
+            message: 'What SHALL the system do? (response)',
+            validate: (input) => input.length > 0 || 'Response is required'
+          },
+          {
+            type: 'input',
+            name: 'criteria',
+            message: 'Acceptance criteria (comma-separated):',
+            filter: (input) => input.split(',').map(s => s.trim()).filter(s => s.length > 0)
+          }
+        ]);
+        
+        pattern = pattern || answers.pattern;
+        title = title || answers.title;
+        
+        const requirement = {
+          pattern,
+          title,
+          system: answers.system,
+          statement: answers.statement,
+          response: answers.response,
+          criteria: answers.criteria
+        };
+        
+        const result = await generator.addRequirement(reqFile, requirement);
+        
+        console.log(chalk.green('\n✓ Requirement added:'));
+        console.log(chalk.dim(`  ${result.id}: ${title}`));
+        console.log(chalk.bold('\n📄 EARS Statement:'));
+        console.log(chalk.cyan(result.statement));
+        console.log();
+        
+        process.exit(0);
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// List all requirements
+program
+  .command('list')
+  .description('List all requirements in the project')
+  .option('-f, --file <path>', 'Specific requirements file')
+  .option('--format <type>', 'Output format (table|json|markdown)', 'table')
+  .action(async (options) => {
+    try {
+      const generator = new RequirementsGenerator(process.cwd());
+      const requirements = await generator.listRequirements(options.file);
+      
+      if (requirements.length === 0) {
+        console.log(chalk.yellow('No requirements found'));
+        process.exit(0);
+      }
+      
+      console.log(chalk.bold(`\n📋 Requirements (${requirements.length} total)\n`));
+      
+      if (options.format === 'json') {
+        console.log(JSON.stringify(requirements, null, 2));
+      } else if (options.format === 'markdown') {
+        requirements.forEach(req => {
+          console.log(`## ${req.id}: ${req.title}`);
+          console.log();
+          console.log(`**Pattern**: ${req.pattern}`);
+          console.log();
+          console.log(req.statement);
+          console.log();
+        });
+      } else {
+        // Table format
+        requirements.forEach(req => {
+          console.log(chalk.bold(`${req.id}: ${req.title}`));
+          console.log(chalk.dim(`  Pattern: ${req.pattern}`));
+          console.log(chalk.cyan(`  ${req.statement.substring(0, 100)}...`));
+          console.log();
+        });
+      }
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Validate EARS format compliance
+program
+  .command('validate')
+  .description('Validate requirements against EARS format')
+  .option('-f, --file <path>', 'Specific requirements file')
+  .option('-v, --verbose', 'Show detailed validation results')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n🔍 Validating EARS Requirements\n'));
+      
+      const generator = new RequirementsGenerator(process.cwd());
+      const results = await generator.validate(options.file);
+      
+      if (results.passed) {
+        console.log(chalk.green('✓ All requirements valid\n'));
+      } else {
+        console.log(chalk.red('✗ Validation failed\n'));
+      }
+      
+      console.log(chalk.bold('Summary:'));
+      console.log(chalk.dim(`  Total: ${results.total}`));
+      console.log(chalk.green(`  Valid: ${results.valid}`));
+      console.log(chalk.red(`  Invalid: ${results.invalid}`));
+      console.log();
+      
+      if (results.violations.length > 0) {
+        console.log(chalk.bold.red('Violations:'));
+        results.violations.forEach(v => {
+          console.log(chalk.red(`  • ${v}`));
+        });
+        console.log();
+      }
+      
+      if (options.verbose && results.details) {
+        console.log(chalk.bold('Details:'));
+        results.details.forEach(d => {
+          const icon = d.valid ? chalk.green('✓') : chalk.red('✗');
+          console.log(`  ${icon} ${d.id}: ${d.message}`);
+        });
+        console.log();
+      }
+      
+      process.exit(results.passed ? 0 : 1);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Show traceability matrix
+program
+  .command('trace')
+  .description('Show requirements traceability matrix')
+  .option('-f, --file <path>', 'Specific requirements file')
+  .option('--format <type>', 'Output format (table|json|markdown)', 'table')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n📊 Requirements Traceability Matrix\n'));
+      
+      const generator = new RequirementsGenerator(process.cwd());
+      const matrix = await generator.generateTraceabilityMatrix(options.file);
+      
+      if (options.format === 'json') {
+        console.log(JSON.stringify(matrix, null, 2));
+      } else {
+        console.log(chalk.bold('| Requirement | Design | Code | Tests | Status |'));
+        console.log('|-------------|--------|------|-------|--------|');
+        
+        matrix.forEach(row => {
+          const design = row.design ? '✓' : '-';
+          const code = row.code ? '✓' : '-';
+          const tests = row.tests ? '✓' : '-';
+          const status = row.complete ? chalk.green('Complete') : chalk.yellow('Incomplete');
+          
+          console.log(`| ${row.id} | ${design} | ${code} | ${tests} | ${status} |`);
+        });
+        console.log();
+        
+        const complete = matrix.filter(r => r.complete).length;
+        const total = matrix.length;
+        const percentage = total > 0 ? Math.round((complete / total) * 100) : 0;
+        
+        console.log(chalk.bold('Coverage:'));
+        console.log(chalk.dim(`  ${complete}/${total} requirements traced (${percentage}%)`));
+        console.log();
+      }
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}