musubix 1.0.1 → 1.0.2

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-code-generation/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: musubix-code-generation
+description: Guide for generating code from design specifications using MUSUBIX. Use this when asked to generate code, implement features, or create components following design documents.
+license: MIT
+---
+
+# MUSUBIX Code Generation Skill
+
+This skill guides you through generating code from design specifications following MUSUBIX methodology.
+
+## Prerequisites
+
+Before generating code:
+
+1. Verify design document exists (`DES-*`)
+2. Verify requirements are traceable (`REQ-*`)
+3. Check `steering/tech.ja.md` for technology stack
+
+## Supported Languages
+
+| Language | Extension | Features |
+|----------|-----------|----------|
+| TypeScript | `.ts` | Full support with types |
+| JavaScript | `.js` | ES6+ modules |
+| Python | `.py` | Type hints support |
+| Java | `.java` | Interface/Class generation |
+| Go | `.go` | Struct/Interface generation |
+| Rust | `.rs` | Trait/Struct generation |
+| C# | `.cs` | Interface/Class generation |
+
+## Code Generation Workflow
+
+### Step 1: Read Design Document
+
+```bash
+# Generate code from design
+npx musubix codegen generate <design-file>
+```
+
+### Step 2: Generate with Traceability
+
+Always include requirement references:
+
+```typescript
+/**
+ * UserService - Handles user operations
+ * 
+ * @see REQ-INT-001 - Neuro-Symbolic Integration
+ * @see DES-INT-001 - Integration Layer Design
+ */
+export class UserService {
+  // Implementation
+}
+```
+
+### Step 3: Follow Test-First (Article III)
+
+1. **Write test first**:
+```typescript
+describe('UserService', () => {
+  it('should create user', async () => {
+    const service = new UserService();
+    const user = await service.create({ name: 'Test' });
+    expect(user.id).toBeDefined();
+  });
+});
+```
+
+2. **Implement minimal code**:
+```typescript
+export class UserService {
+  async create(data: CreateUserDto): Promise<User> {
+    return { id: generateId(), ...data };
+  }
+}
+```
+
+3. **Refactor**
+
+## Design Pattern Templates
+
+### Singleton Pattern
+```typescript
+/**
+ * @see REQ-DES-001 - Pattern Detection
+ * @pattern Singleton
+ */
+export class ConfigManager {
+  private static instance: ConfigManager;
+  
+  private constructor() {}
+  
+  static getInstance(): ConfigManager {
+    if (!ConfigManager.instance) {
+      ConfigManager.instance = new ConfigManager();
+    }
+    return ConfigManager.instance;
+  }
+}
+```
+
+### Factory Pattern
+```typescript
+/**
+ * @see REQ-DES-001 - Pattern Detection
+ * @pattern Factory
+ */
+export interface ServiceFactory {
+  create(type: string): Service;
+}
+
+export class DefaultServiceFactory implements ServiceFactory {
+  create(type: string): Service {
+    switch (type) {
+      case 'auth': return new AuthService();
+      case 'user': return new UserService();
+      default: throw new Error(`Unknown service: ${type}`);
+    }
+  }
+}
+```
+
+### Repository Pattern
+```typescript
+/**
+ * @see REQ-COD-001 - Code Generation
+ * @pattern Repository
+ */
+export interface Repository<T> {
+  findById(id: string): Promise<T | null>;
+  findAll(): Promise<T[]>;
+  save(entity: T): Promise<T>;
+  delete(id: string): Promise<void>;
+}
+
+export class UserRepository implements Repository<User> {
+  async findById(id: string): Promise<User | null> {
+    // Implementation
+  }
+  // ... other methods
+}
+```
+
+## CLI Commands
+
+```bash
+# Generate code from design
+npx musubix codegen generate <design-file>
+
+# Analyze existing code
+npx musubix codegen analyze <file>
+
+# Security scan
+npx musubix codegen security <path>
+```
+
+## Quality Checks (Article IX)
+
+Before committing code:
+
+- [ ] **Type Safety**: No `any` types (TypeScript)
+- [ ] **Traceability**: All classes/functions have `@see` references
+- [ ] **Tests**: Test coverage ≥ 80%
+- [ ] **Linting**: `npm run lint` passes
+- [ ] **Build**: `npm run build` succeeds
+
+## Neuro-Symbolic Integration (REQ-INT-002)
+
+When generating code that involves decision-making:
+
+```typescript
+/**
+ * @see REQ-INT-002 - Confidence Evaluation
+ */
+async function integrateResults(
+  neuralResult: NeuralResult,
+  symbolicResult: SymbolicResult
+): Promise<FinalResult> {
+  // Decision rules from REQ-INT-002
+  if (symbolicResult.status === 'invalid') {
+    return rejectNeural(neuralResult);
+  }
+  
+  if (neuralResult.confidence >= 0.8) {
+    return adoptNeural(neuralResult);
+  }
+  
+  return prioritizeSymbolic(symbolicResult);
+}
+```
+
+## File Structure Convention
+
+```
+packages/
+├── core/
+│   └── src/
+│       ├── [feature]/
+│       │   ├── index.ts        # Public exports
+│       │   ├── [feature].ts    # Main implementation
+│       │   ├── types.ts        # Type definitions
+│       │   └── __tests__/      # Tests
+│       └── index.ts            # Package exports
+```
+
+## Error Handling Pattern
+
+```typescript
+/**
+ * @see REQ-ERR-001 - Graceful Degradation
+ */
+export class MuSubixError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public recoverable: boolean = true
+  ) {
+    super(message);
+    this.name = 'MuSubixError';
+  }
+}
+
+// Usage
+throw new MuSubixError(
+  'Failed to connect to YATA',
+  'YATA_CONNECTION_ERROR',
+  true // Can retry
+);
+```

package/.github/skills/musubix-ears-validation/SKILL.md

@@ -0,0 +1,161 @@
+---
+name: musubix-ears-validation
+description: Guide for validating and creating EARS-format requirements. Use this when asked to write requirements, validate requirement syntax, or convert natural language to EARS format.
+license: MIT
+---
+
+# MUSUBIX EARS Validation Skill
+
+This skill helps you create and validate requirements using EARS (Easy Approach to Requirements Syntax) format.
+
+## EARS Pattern Reference
+
+### 1. Ubiquitous Pattern
+**Use for**: Requirements that must always be satisfied.
+
+**Syntax**:
+```
+THE [system name] SHALL [requirement]
+```
+
+**Example**:
+```markdown
+THE AuthService SHALL authenticate users with valid credentials.
+```
+
+### 2. Event-Driven Pattern
+**Use for**: Requirements triggered by specific events.
+
+**Syntax**:
+```
+WHEN [trigger event], THE [system name] SHALL [response]
+```
+
+**Example**:
+```markdown
+WHEN a user submits login credentials, THE AuthService SHALL validate the credentials within 2 seconds.
+```
+
+### 3. State-Driven Pattern
+**Use for**: Requirements that apply while in a specific state.
+
+**Syntax**:
+```
+WHILE [system state], THE [system name] SHALL [behavior]
+```
+
+**Example**:
+```markdown
+WHILE the system is in maintenance mode, THE API SHALL return 503 Service Unavailable.
+```
+
+### 4. Unwanted Behavior Pattern
+**Use for**: Behaviors that must be prevented.
+
+**Syntax**:
+```
+THE [system name] SHALL NOT [unwanted behavior]
+```
+
+**Example**:
+```markdown
+THE AuthService SHALL NOT store passwords in plain text.
+```
+
+### 5. Optional Pattern
+**Use for**: Conditional requirements.
+
+**Syntax**:
+```
+IF [condition], THEN THE [system name] SHALL [response]
+```
+
+**Example**:
+```markdown
+IF two-factor authentication is enabled, THEN THE AuthService SHALL require a verification code.
+```
+
+## Validation Checklist
+
+When validating EARS requirements, check:
+
+- [ ] **Pattern Compliance**: Does it follow one of the 5 EARS patterns?
+- [ ] **System Name**: Is the system/component clearly identified?
+- [ ] **SHALL Keyword**: Is "SHALL" used for mandatory requirements?
+- [ ] **Measurable**: Is the requirement testable and measurable?
+- [ ] **Atomic**: Does it describe a single requirement?
+- [ ] **No Ambiguity**: Is the language clear and unambiguous?
+
+## CLI Commands
+
+```bash
+# Validate EARS syntax
+npx musubix requirements validate <file>
+
+# Convert natural language to EARS
+npx musubix requirements analyze <file>
+
+# Map to ontology
+npx musubix requirements map <file>
+```
+
+## Conversion Examples
+
+### Natural Language → EARS
+
+**Input**: "Users should be able to login"
+
+**Output**:
+```markdown
+THE AuthenticationModule SHALL authenticate users with valid credentials.
+```
+
+**Input**: "Show error when password is wrong"
+
+**Output**:
+```markdown
+WHEN invalid credentials are provided, THE AuthenticationModule SHALL display an error message.
+```
+
+**Input**: "Don't allow SQL injection"
+
+**Output**:
+```markdown
+THE InputValidator SHALL NOT accept input containing SQL injection patterns.
+```
+
+## Priority Levels
+
+| Priority | Description | Usage |
+|----------|-------------|-------|
+| **P0** | 必須 (Must Have) | Release blocker |
+| **P1** | 重要 (Should Have) | Implement if possible |
+| **P2** | 任意 (Nice to Have) | Time permitting |
+
+## Requirement Document Template
+
+```markdown
+### REQ-[CATEGORY]-[NUMBER]: [Title]
+
+**種別**: [UBIQUITOUS|EVENT-DRIVEN|STATE-DRIVEN|UNWANTED|OPTIONAL]
+**優先度**: [P0|P1|P2]
+
+**要件**:
+[EARS形式の要件文]
+
+**検証方法**: [Unit Test|Integration Test|E2E Test|Manual]
+**受入基準**:
+- [ ] Criterion 1
+- [ ] Criterion 2
+
+**トレーサビリティ**: DES-XXX, TEST-XXX
+**憲法準拠**: Article IV (EARS Format)
+```
+
+## Common Mistakes to Avoid
+
+1. ❌ Using "should" instead of "SHALL"
+2. ❌ Combining multiple requirements in one statement
+3. ❌ Vague or unmeasurable criteria
+4. ❌ Missing system name
+5. ❌ Using implementation details in requirements