musubix 3.3.10 → 3.4.0

package/.github/prompts/sdd-validate.prompt.md

@@ -0,0 +1,304 @@
+# MUSUBIX Validate Command
+
+Validate constitutional compliance and requirements coverage.
+
+---
+
+## Instructions for AI Agent
+
+You are executing the `musubix validate [feature-name]` command to validate constitutional compliance.
+
+### Command Format
+
+```bash
+npx musubix validate authentication
+npx musubix trace validate
+npx musubix trace matrix
+```
+
+### Your Task
+
+Perform comprehensive validation of the feature implementation against:
+
+1. 9 Constitutional Articles
+2. Requirements coverage (100% traceability)
+3. Code quality standards
+4. Test coverage
+
+---
+
+## Process
+
+### 1. Read All Documentation
+
+```bash
+# Requirements and Design
+storage/specs/REQ-{{FEATURE}}-001.md
+storage/specs/DES-{{FEATURE}}-001.md
+storage/specs/TSK-{{FEATURE}}-001.md
+
+# Steering Context
+steering/structure.ja.md
+steering/tech.ja.md
+steering/rules/constitution.md
+
+# Source Code
+packages/core/src/{{feature}}/**/*.ts
+packages/core/__tests__/**/*.test.ts
+packages/mcp-server/src/tools/**/*.ts
+```
+
+---
+
+### 2. Constitutional Validation
+
+Validate each of the 9 Constitutional Articles:
+
+#### Article I: Library-First Principle
+
+**Requirement**: Features as independent packages
+
+**Validation**:
+- [ ] Feature in `packages/` directory
+- [ ] Has `package.json` (monorepo workspace)
+- [ ] Exports public API via `index.ts`
+- [ ] No circular dependencies
+
+```markdown
+### Article I: Library-First Principle
+
+**Status**: ✅ PASS / ❌ FAIL
+
+**Evidence**:
+- Location: `packages/core/src/{{feature}}/`
+- Public API: `packages/core/src/{{feature}}/index.ts`
+- Exports: {{Feature}}Service, {{Feature}}Options
+```
+
+---
+
+#### Article II: CLI Interface Mandate
+
+**Requirement**: CLI interface for all libraries
+
+**Validation**:
+- [ ] CLI command exists in `packages/core/src/cli/commands/`
+- [ ] `--help` flag works
+- [ ] Documented in CLI help
+
+```markdown
+### Article II: CLI Interface Mandate
+
+**Status**: ✅ PASS / ❌ FAIL
+
+**Evidence**:
+- CLI: `npx musubix {{feature}}`
+- Help: `npx musubix {{feature}} --help`
+- Registered: packages/core/src/cli/index.ts
+```
+
+---
+
+#### Article III: Test-First Imperative
+
+**Requirement**: Tests before implementation (Red-Green-Blue)
+
+**Validation**:
+- [ ] Tests in `packages/core/__tests__/unit/`
+- [ ] Tests cover all requirements
+- [ ] Coverage ≥ 80%
+
+```bash
+npm run test:coverage
+```
+
+```markdown
+### Article III: Test-First Imperative
+
+**Status**: ✅ PASS / ❌ FAIL
+
+**Coverage**: XX%
+**Test Files**:
+- packages/core/__tests__/unit/{{feature}}.test.ts
+- packages/core/__tests__/integration/{{feature}}.integration.test.ts
+```
+
+---
+
+#### Article IV: EARS Requirements Format
+
+**Requirement**: All requirements in EARS format
+
+**Validation**:
+- [ ] All requirements use EARS patterns
+- [ ] Each has unique ID (REQ-XXX-NNN)
+- [ ] Each has acceptance criteria
+
+```markdown
+### Article IV: EARS Requirements Format
+
+**Status**: ✅ PASS / ❌ FAIL
+
+**Requirements Checked**: X
+**EARS Patterns Used**:
+- Ubiquitous: X
+- Event-driven: X
+- State-driven: X
+- Unwanted: X
+- Optional: X
+```
+
+---
+
+#### Article V: Traceability Mandate
+
+**Requirement**: 100% traceability REQ↔DES↔TSK↔CODE↔TEST
+
+**Validation**:
+
+```markdown
+### Article V: Traceability Mandate
+
+**Status**: ✅ PASS / ❌ FAIL
+
+**Traceability Matrix**:
+
+| Requirement | Design | Task | Code | Test |
+|-------------|--------|------|------|------|
+| REQ-XXX-001 | DES-XXX-001 | TSK-XXX-001 | {{feature}}/service.ts | {{feature}}.test.ts |
+
+**Coverage**: 100%
+**Unmapped Requirements**: None
+```
+
+---
+
+#### Article VI: Project Memory (Steering)
+
+**Requirement**: Consult steering before decisions
+
+**Validation**:
+- [ ] Design references steering files
+- [ ] Tech stack matches `steering/tech.ja.md`
+- [ ] Architecture matches `steering/structure.ja.md`
+
+---
+
+#### Article VII: Design Patterns
+
+**Requirement**: Document pattern applications
+
+**Validation**:
+- [ ] Patterns documented in design
+- [ ] ADRs created for decisions
+
+---
+
+#### Article VIII: Decision Records
+
+**Requirement**: All decisions as ADRs
+
+**Validation**:
+- [ ] ADRs in design document
+- [ ] Each ADR has: Status, Context, Decision, Consequences
+
+---
+
+#### Article IX: Quality Gates
+
+**Requirement**: Validate before phase transitions
+
+**Validation**:
+- [ ] Requirements validated before design
+- [ ] Design validated before implementation
+- [ ] Tests pass before deployment
+
+---
+
+### 3. Generate Validation Report
+
+```markdown
+# Validation Report: {{FEATURE_NAME}}
+
+**Date**: {{DATE}}
+**Validator**: AI Agent
+
+## Summary
+
+| Article | Status | Score |
+|---------|--------|-------|
+| I. Library-First | ✅ | 100% |
+| II. CLI Interface | ✅ | 100% |
+| III. Test-First | ✅ | 85% |
+| IV. EARS Format | ✅ | 100% |
+| V. Traceability | ✅ | 100% |
+| VI. Project Memory | ✅ | 100% |
+| VII. Design Patterns | ✅ | 100% |
+| VIII. Decision Records | ✅ | 100% |
+| IX. Quality Gates | ✅ | 100% |
+
+**Overall Compliance**: ✅ PASS (97%)
+
+## Test Coverage
+
+- Unit Tests: XX%
+- Integration Tests: XX%
+- Total: XX%
+
+## Traceability Coverage
+
+- Requirements → Design: 100%
+- Design → Tasks: 100%
+- Tasks → Code: 100%
+- Code → Tests: 100%
+
+## Issues Found
+
+### Critical (P0)
+None
+
+### High (P1)
+None
+
+### Medium (P2)
+- [Issue description]
+
+## Recommendations
+
+1. [Recommendation 1]
+2. [Recommendation 2]
+```
+
+---
+
+### 4. MCP Tool Integration
+
+Use MUSUBIX MCP tools:
+
+```
+sdd_validate_constitution - Validate constitutional compliance
+sdd_validate_traceability - Validate traceability matrix
+```
+
+---
+
+### 5. Validation Commands
+
+```bash
+# Run all validations
+npm test
+npm run typecheck
+npm run lint
+
+# Check coverage
+npm run test:coverage
+
+# Traceability
+npx musubix trace matrix
+npx musubix trace validate
+```
+
+---
+
+**MUSUBIX**: https://github.com/nahisaho/MUSUBIX
+**Version**: 1.0.0

package/.github/skills/musubix-adr-generation/SKILL.md

@@ -0,0 +1,209 @@
+---
+name: musubix-adr-generation
+description: Guide for creating Architecture Decision Records (ADRs). Use this when asked to document architecture decisions, technology choices, or design trade-offs.
+license: MIT
+---
+
+# MUSUBIX ADR Generation Skill
+
+This skill guides you through creating Architecture Decision Records following **Article VIII - Decision Records**.
+
+## Overview
+
+An **ADR (Architecture Decision Record)** documents significant architectural decisions with their context and consequences.
+
+## ADR Template
+
+```markdown
+# ADR-[NUMBER]: [Decision Title]
+
+## ステータス
+[Proposed | Accepted | Deprecated | Superseded by ADR-XXX]
+
+## コンテキスト
+[What is the issue that we're seeing that is motivating this decision?]
+
+## 決定
+[What is the change that we're proposing and/or doing?]
+
+## 選択肢
+
+### Option 1: [Name]
+**メリット:**
+- [Advantage 1]
+- [Advantage 2]
+
+**デメリット:**
+- [Disadvantage 1]
+- [Disadvantage 2]
+
+### Option 2: [Name]
+**メリット:**
+- [Advantage 1]
+
+**デメリット:**
+- [Disadvantage 1]
+
+## 結果
+[What becomes easier or more difficult to do because of this change?]
+
+## トレーサビリティ
+- 関連要件: REQ-XXX-NNN
+- 関連設計: DES-XXX-NNN
+```
+
+## Common ADR Topics
+
+### 1. Technology Selection
+
+```markdown
+# ADR-001: Use TypeScript for Backend
+
+## コンテキスト
+We need to choose a programming language for the backend API.
+
+## 決定
+We will use TypeScript with Node.js.
+
+## 選択肢
+
+### Option 1: TypeScript + Node.js
+**メリット:**
+- Type safety reduces runtime errors
+- Same language as frontend (code sharing)
+- Large ecosystem (npm)
+- Strong async/await support
+
+**デメリット:**
+- Slower than compiled languages
+- Type definitions not always available
+
+### Option 2: Go
+**メリット:**
+- High performance
+- Strong concurrency support
+
+**デメリット:**
+- Different language from frontend
+- Smaller ecosystem for web
+
+## 結果
+- Frontend/backend code sharing enabled
+- Need to maintain TypeScript configuration
+- Team can use consistent tooling
+```
+
+### 2. Architecture Pattern
+
+```markdown
+# ADR-002: Layered Architecture with DDD
+
+## コンテキスト
+We need to define the overall architecture pattern.
+
+## 決定
+We will use Layered Architecture with Domain-Driven Design principles.
+
+## 選択肢
+
+### Option 1: Layered Architecture
+- Presentation → Application → Domain → Infrastructure
+
+### Option 2: Hexagonal Architecture
+- Ports and Adapters pattern
+
+## 結果
+- Clear separation of concerns
+- Domain logic isolated from infrastructure
+- Easier testing with dependency injection
+```
+
+### 3. Database Selection
+
+```markdown
+# ADR-003: Use PostgreSQL for Primary Database
+
+## コンテキスト
+We need a primary data store for the application.
+
+## 決定
+PostgreSQL will be our primary database.
+
+## 選択肢
+
+### Option 1: PostgreSQL
+**メリット:**
+- ACID compliance
+- JSON support
+- Strong ecosystem
+- Free and open source
+
+### Option 2: MongoDB
+**メリット:**
+- Schema flexibility
+- Horizontal scaling
+
+**デメリット:**
+- Eventual consistency concerns
+- Complex transactions
+
+## 結果
+- Reliable transactional data storage
+- Need to manage schema migrations
+- Can use JSON columns for flexibility
+```
+
+## CLI Commands
+
+```bash
+# Generate ADR from decision description
+npx musubix design adr "Use React for frontend"
+
+# List all ADRs
+ls storage/design/adr/
+
+# Generate ADR interactively
+npx musubix design adr --interactive
+```
+
+## ADR Numbering
+
+ADRs are numbered sequentially:
+- ADR-001, ADR-002, ADR-003...
+
+Never renumber existing ADRs. If an ADR is superseded, mark it as such and reference the new ADR.
+
+## Storage Location
+
+```
+storage/design/adr/
+├── ADR-001-typescript-backend.md
+├── ADR-002-layered-architecture.md
+├── ADR-003-postgresql-database.md
+└── index.md  # ADR index
+```
+
+## ADR Index Template
+
+```markdown
+# Architecture Decision Records
+
+| ADR | Title | Status | Date |
+|-----|-------|--------|------|
+| [ADR-001](./ADR-001-typescript-backend.md) | Use TypeScript for Backend | Accepted | 2026-01-04 |
+| [ADR-002](./ADR-002-layered-architecture.md) | Layered Architecture | Accepted | 2026-01-04 |
+```
+
+## When to Write an ADR
+
+- Technology selection (language, framework, database)
+- Architecture patterns (layered, hexagonal, microservices)
+- External integrations (APIs, services)
+- Security decisions (authentication, authorization)
+- Performance trade-offs (caching, scaling)
+
+## Related Skills
+
+- `musubix-c4-design` - Architecture diagrams
+- `musubix-sdd-workflow` - Full development workflow
+- `musubix-traceability` - Link ADRs to requirements