musubi-sdd 0.1.0

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "musubi-sdd",
+  "version": "0.1.0",
+  "description": "Ultimate Specification Driven Development Tool with 25 Claude Code Skills",
+  "main": "src/index.js",
+  "bin": {
+    "musubi": "bin/musubi.js",
+    "musubi-init": "bin/musubi-init.js"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint bin/ src/ tests/",
+    "lint:fix": "eslint bin/ src/ tests/ --fix",
+    "format": "prettier --write bin/ src/ tests/"
+  },
+  "keywords": [
+    "specification-driven-development",
+    "sdd",
+    "claude-code",
+    "claude-skills",
+    "requirements",
+    "ears-format",
+    "constitutional-governance",
+    "traceability",
+    "musubi"
+  ],
+  "author": "MUSUBI Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nahisaho/musubi.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.0.0",
+    "fs-extra": "^11.0.0",
+    "inquirer": "^9.0.0"
+  },
+  "devDependencies": {
+    "eslint": "^8.50.0",
+    "jest": "^29.0.0",
+    "prettier": "^3.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/agents/registry.js

@@ -0,0 +1,242 @@
+/**
+ * MUSUBI Agent Registry
+ *
+ * Defines supported AI coding agents and their installation configurations.
+ * Inspired by cc-sdd multi-agent architecture.
+ */
+
+const agentDefinitions = {
+  'claude-code': {
+    label: 'Claude Code',
+    description: 'Installs MUSUBI skills in `.claude/skills/`, commands in `.claude/commands/`, and steering in `steering/`',
+    aliasFlags: ['--claude-code', '--claude'],
+    recommendedModels: ['Claude Sonnet 4.5 or newer'],
+    layout: {
+      skillsDir: '.claude/skills',      // MUSUBI-specific: 25 skills
+      commandsDir: '.claude/commands',
+      agentDir: '.claude',
+      docFile: 'CLAUDE.md',
+    },
+    commands: {
+      steering: '/sdd-steering',
+      requirements: '/sdd-requirements <feature>',
+      design: '/sdd-design <feature>',
+      tasks: '/sdd-tasks <feature>',
+      implement: '/sdd-implement <feature>',
+      validate: '/sdd-validate <feature>',
+    },
+    features: {
+      hasSkills: true,      // Claude Code supports Skills API
+      hasCommands: true,
+      commandPrefix: '/',
+    },
+  },
+  'github-copilot': {
+    label: 'GitHub Copilot',
+    description: 'Installs MUSUBI prompts in `.github/prompts/` and steering in `steering/`',
+    aliasFlags: ['--copilot', '--github-copilot'],
+    recommendedModels: ['Claude Sonnet 4.5 or newer', 'GPT-4'],
+    layout: {
+      commandsDir: '.github/prompts',
+      agentDir: '.github',
+      docFile: 'AGENTS.md',
+    },
+    commands: {
+      steering: '#sdd-steering',
+      requirements: '#sdd-requirements <feature>',
+      design: '#sdd-design <feature>',
+      tasks: '#sdd-tasks <feature>',
+      implement: '#sdd-implement <feature>',
+      validate: '#sdd-validate <feature>',
+    },
+    features: {
+      hasSkills: false,     // Copilot doesn't support Skills API
+      hasCommands: true,
+      commandPrefix: '#',
+    },
+  },
+  'cursor': {
+    label: 'Cursor IDE',
+    description: 'Installs MUSUBI commands in `.cursor/commands/` and steering in `steering/`',
+    aliasFlags: ['--cursor'],
+    recommendedModels: ['Claude Sonnet 4.5 or newer', 'GPT-4'],
+    layout: {
+      commandsDir: '.cursor/commands',
+      agentDir: '.cursor',
+      docFile: 'AGENTS.md',
+    },
+    commands: {
+      steering: '/sdd-steering',
+      requirements: '/sdd-requirements <feature>',
+      design: '/sdd-design <feature>',
+      tasks: '/sdd-tasks <feature>',
+      implement: '/sdd-implement <feature>',
+      validate: '/sdd-validate <feature>',
+    },
+    features: {
+      hasSkills: false,
+      hasCommands: true,
+      commandPrefix: '/',
+    },
+  },
+  'gemini-cli': {
+    label: 'Gemini CLI',
+    description: 'Installs MUSUBI commands in `.gemini/commands/` (TOML format) and steering in `steering/`',
+    aliasFlags: ['--gemini-cli', '--gemini'],
+    recommendedModels: ['Gemini 2.0 Flash or newer'],
+    layout: {
+      commandsDir: '.gemini/commands',
+      agentDir: '.gemini',
+      docFile: 'GEMINI.md',
+    },
+    commands: {
+      steering: '/sdd-steering',
+      requirements: '/sdd-requirements <feature>',
+      design: '/sdd-design <feature>',
+      tasks: '/sdd-tasks <feature>',
+      implement: '/sdd-implement <feature>',
+      validate: '/sdd-validate <feature>',
+    },
+    features: {
+      hasSkills: false,
+      hasCommands: true,
+      commandPrefix: '/',
+      commandFormat: 'toml',  // Unique: Gemini uses TOML instead of Markdown
+    },
+  },
+  'codex': {
+    label: 'Codex CLI',
+    description: 'Installs MUSUBI prompts in `.codex/prompts/` and steering in `steering/`',
+    aliasFlags: ['--codex', '--codex-cli'],
+    recommendedModels: ['GPT-4 or newer'],
+    layout: {
+      commandsDir: '.codex/prompts',
+      agentDir: '.codex',
+      docFile: 'AGENTS.md',
+    },
+    commands: {
+      steering: '/prompts:sdd-steering',
+      requirements: '/prompts:sdd-requirements <feature>',
+      design: '/prompts:sdd-design <feature>',
+      tasks: '/prompts:sdd-tasks <feature>',
+      implement: '/prompts:sdd-implement <feature>',
+      validate: '/prompts:sdd-validate <feature>',
+    },
+    features: {
+      hasSkills: false,
+      hasCommands: true,
+      commandPrefix: '/prompts:',
+    },
+  },
+  'qwen-code': {
+    label: 'Qwen Code',
+    description: 'Installs MUSUBI commands in `.qwen/commands/` and steering in `steering/`',
+    aliasFlags: ['--qwen-code', '--qwen'],
+    recommendedModels: ['Qwen 2.5 Coder or newer'],
+    layout: {
+      commandsDir: '.qwen/commands',
+      agentDir: '.qwen',
+      docFile: 'QWEN.md',
+    },
+    commands: {
+      steering: '/sdd-steering',
+      requirements: '/sdd-requirements <feature>',
+      design: '/sdd-design <feature>',
+      tasks: '/sdd-tasks <feature>',
+      implement: '/sdd-implement <feature>',
+      validate: '/sdd-validate <feature>',
+    },
+    features: {
+      hasSkills: false,
+      hasCommands: true,
+      commandPrefix: '/',
+    },
+  },
+  'windsurf': {
+    label: 'Windsurf IDE',
+    description: 'Installs MUSUBI workflows in `.windsurf/workflows/` and steering in `steering/`',
+    aliasFlags: ['--windsurf'],
+    recommendedModels: ['Claude Sonnet 4.5 or newer', 'GPT-4'],
+    layout: {
+      commandsDir: '.windsurf/workflows',
+      agentDir: '.windsurf',
+      docFile: 'AGENTS.md',
+    },
+    commands: {
+      steering: '/sdd-steering',
+      requirements: '/sdd-requirements <feature>',
+      design: '/sdd-design <feature>',
+      tasks: '/sdd-tasks <feature>',
+      implement: '/sdd-implement <feature>',
+      validate: '/sdd-validate <feature>',
+    },
+    features: {
+      hasSkills: false,
+      hasCommands: true,
+      commandPrefix: '/',
+    },
+  },
+};
+
+/**
+ * Get agent definition by key
+ * @param {string} agentKey - Agent key (e.g., 'claude-code', 'cursor')
+ * @returns {object} Agent definition
+ */
+function getAgentDefinition(agentKey) {
+  const definition = agentDefinitions[agentKey];
+  if (!definition) {
+    throw new Error(`Unknown agent: ${agentKey}`);
+  }
+  return definition;
+}
+
+/**
+ * Detect agent from CLI flags
+ * @param {object} options - CLI options object
+ * @returns {string} Agent key
+ */
+function detectAgentFromFlags(options) {
+  // Check each agent's alias flags
+  for (const [agentKey, definition] of Object.entries(agentDefinitions)) {
+    for (const flag of definition.aliasFlags) {
+      const flagName = flag.replace(/^--/, '');
+      if (options[flagName]) {
+        return agentKey;
+      }
+    }
+  }
+
+  // Default to Claude Code
+  return 'claude-code';
+}
+
+/**
+ * Get list of all supported agents
+ * @returns {string[]} Array of agent keys
+ */
+function getAgentList() {
+  return Object.keys(agentDefinitions);
+}
+
+/**
+ * Get all alias flags for CLI option parsing
+ * @returns {string[]} Array of flag names (without --)
+ */
+function getAllAliasFlags() {
+  const flags = new Set();
+  for (const definition of Object.values(agentDefinitions)) {
+    for (const flag of definition.aliasFlags) {
+      flags.add(flag.replace(/^--/, ''));
+    }
+  }
+  return Array.from(flags);
+}
+
+module.exports = {
+  agentDefinitions,
+  getAgentDefinition,
+  detectAgentFromFlags,
+  getAgentList,
+  getAllAliasFlags,
+};

package/src/templates/agents/claude-code/CLAUDE.md

@@ -0,0 +1,232 @@
+# MUSUBI for Claude Code
+
+**Ultimate Specification Driven Development with 25 Specialized Skills**
+
+This project uses **MUSUBI** (Ultimate Specification Driven Development) configured for Claude Code.
+
+## Features
+
+- 🎯 **25 Specialized Skills** - Orchestrator, Steering, Requirements, Architecture, Development, Quality, Security, Infrastructure
+- 📋 **Constitutional Governance** - 9 immutable articles + Phase -1 Gates
+- 📝 **EARS Requirements Format** - Unambiguous requirements with complete traceability
+- 🧭 **Auto-Updating Project Memory** - Steering system maintains architecture, tech stack, and product context
+- 🌐 **Bilingual Documentation** - All documents created in both English and Japanese
+
+## 25 Skills Overview
+
+### Orchestration & Management (3)
+- **@orchestrator** - Master coordinator for multi-skill workflows
+- **@steering** - Project memory manager (auto-updating context)
+- **@constitution-enforcer** - Governance validation (9 Articles + Phase -1 Gates)
+
+### Requirements & Planning (3)
+- **@requirements-analyst** - EARS format requirements generation
+- **@project-manager** - Project planning, scheduling, risk management
+- **@change-impact-analyzer** - Brownfield change analysis
+
+### Architecture & Design (4)
+- **@system-architect** - C4 model + ADR architecture design
+- **@api-designer** - REST/GraphQL/gRPC API design
+- **@database-schema-designer** - Database design, ER diagrams, DDL
+- **@ui-ux-designer** - UI/UX design, wireframes, prototypes
+
+### Development (1)
+- **@software-developer** - Multi-language code implementation
+
+### Quality & Review (5)
+- **@test-engineer** - Unit, integration, E2E testing with EARS mapping
+- **@code-reviewer** - Code review, SOLID principles
+- **@bug-hunter** - Bug investigation, root cause analysis
+- **@quality-assurance** - QA strategy, test planning
+- **@traceability-auditor** - Requirements ↔ Code ↔ Test coverage validation
+
+### Security & Performance (2)
+- **@security-auditor** - OWASP Top 10, vulnerability detection
+- **@performance-optimizer** - Performance analysis, optimization
+
+### Infrastructure & Operations (5)
+- **@devops-engineer** - CI/CD pipelines, Docker/Kubernetes
+- **@cloud-architect** - AWS/Azure/GCP, IaC (Terraform/Bicep)
+- **@database-administrator** - Database operations, tuning
+- **@site-reliability-engineer** - Production monitoring, SLO/SLI
+- **@release-coordinator** - Multi-component release management
+
+### Documentation & Specialized (2)
+- **@technical-writer** - Technical documentation, API docs
+- **@ai-ml-engineer** - ML model development, MLOps
+
+## Slash Commands
+
+```bash
+# Generate project memory
+/sdd-steering
+
+# Create requirements
+/sdd-requirements <feature>
+
+# Design architecture
+/sdd-design <feature>
+
+# Break down into tasks
+/sdd-tasks <feature>
+
+# Implement feature
+/sdd-implement <feature>
+
+# Validate constitutional compliance
+/sdd-validate <feature>
+```
+
+## Project Memory (Steering System)
+
+**IMPORTANT**: Before starting any task, check if steering files exist in `steering/` directory:
+
+- `steering/structure.md` - Architecture patterns, directory organization, naming conventions
+- `steering/tech.md` - Technology stack, frameworks, development tools
+- `steering/product.md` - Business context, product purpose, users
+
+If these files exist, ALWAYS read them first to understand project context.
+
+## SDD Workflow (8 Stages)
+
+```
+Research → Requirements → Design → Tasks → Implementation → Testing → Deployment → Monitoring
+```
+
+Each stage has:
+- Dedicated skills
+- Quality gates
+- Traceability requirements
+- Constitutional validation
+
+## EARS Requirements Format
+
+All requirements must use EARS patterns:
+
+```markdown
+### Requirement: User Login
+
+WHEN user provides valid credentials,
+THEN the system SHALL authenticate the user
+AND the system SHALL create a session.
+
+#### Scenario: Successful login
+- WHEN user enters correct email and password
+- THEN system SHALL verify credentials
+- AND system SHALL redirect to dashboard
+```
+
+## Constitutional Governance
+
+MUSUBI enforces 9 immutable constitutional articles:
+
+1. **Library-First Principle** - Features start as libraries
+2. **CLI Interface Mandate** - All libraries expose CLI
+3. **Test-First Imperative** - Tests before code (Red-Green-Blue)
+4. **EARS Requirements Format** - Unambiguous requirements
+5. **Traceability Mandate** - 100% coverage required
+6. **Project Memory** - All skills check steering first
+7. **Simplicity Gate** - Maximum 3 projects initially
+8. **Anti-Abstraction Gate** - Use framework features directly
+9. **Integration-First Testing** - Real services over mocks
+
+## Bilingual Documentation
+
+**All agent-generated documents are created in both English and Japanese.**
+
+### Language Policy
+
+- **English**: Reference/source documents (`.md`)
+- **Japanese**: Translations (`.ja.md`)
+- **Skills**: Always read English versions for work
+- **Code References**: Requirement IDs, technical terms stay in English
+
+### Files Generated Bilingually
+
+**Steering Context**:
+- `steering/structure.md` + `steering/structure.ja.md`
+- `steering/tech.md` + `steering/tech.ja.md`
+- `steering/product.md` + `steering/product.ja.md`
+
+**Specifications**:
+- `storage/specs/[feature]-requirements.md` + `.ja.md`
+- `storage/specs/[feature]-design.md` + `.ja.md`
+- `storage/specs/[feature]-tasks.md` + `.ja.md`
+
+## Quick Start
+
+### First Time Setup
+
+1. Generate project memory:
+   ```
+   /sdd-steering
+   ```
+
+2. Review steering context in `steering/` directory
+
+3. Start development with skills
+
+### For Complex Projects
+
+```
+@orchestrator [describe your complete task]
+```
+
+### For Specific Tasks
+
+```
+@requirements-analyst Create requirements for authentication
+@system-architect Design architecture based on requirements.md
+@software-developer Implement UserService following design.md
+@test-engineer Generate tests from requirements.md
+```
+
+## Example Usage
+
+### Greenfield Project (0→1)
+
+```bash
+# 1. Generate steering
+/sdd-steering
+
+# 2. Create requirements
+/sdd-requirements user-authentication
+
+# 3. Design architecture
+/sdd-design user-authentication
+
+# 4. Break into tasks
+/sdd-tasks user-authentication
+
+# 5. Implement
+/sdd-implement user-authentication
+```
+
+### Brownfield Project (1→n)
+
+```bash
+# 1. Generate steering from existing code
+/sdd-steering
+
+# 2. Create change proposal
+/sdd-change-init add-2fa
+
+# 3. Impact analysis (automatic via change-impact-analyzer skill)
+
+# 4. Implement change
+/sdd-change-apply add-2fa
+
+# 5. Archive change
+/sdd-change-archive add-2fa
+```
+
+## Learn More
+
+- [MUSUBI Documentation](https://github.com/your-org/musubi)
+- [Constitutional Governance](steering/rules/constitution.md)
+- [8-Stage SDD Workflow](steering/rules/workflow.md)
+- [EARS Format Guide](steering/rules/ears-format.md)
+
+---
+
+**MUSUBI for Claude Code** - むすび - Bringing specifications, design, and code together.