musubix 2.3.7 → 2.4.1

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

@@ -0,0 +1,212 @@
+---
+name: musubix-test-generation
+description: Guide for generating test code from designs and requirements. Use this when asked to create unit tests, integration tests, or test coverage analysis following TDD/BDD practices.
+license: MIT
+---
+
+# MUSUBIX Test Generation Skill
+
+This skill guides you through generating comprehensive test suites that maintain traceability.
+
+## Overview
+
+MUSUBIX follows **Article III - Test-First**: Red-Green-Blue TDD cycle.
+
+```mermaid
+flowchart LR
+    RED[🔴 Red<br/>Failing Test] --> GREEN[🟢 Green<br/>Minimal Code]
+    GREEN --> BLUE[🔵 Blue<br/>Refactor]
+    BLUE --> RED
+```
+
+## Test Structure
+
+### Unit Test Template
+
+```typescript
+/**
+ * @requirement REQ-XXX-NNN
+ * @design DES-XXX-NNN
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { XxxService } from './xxx-service.js';
+import { resetXxxCounter } from './xxx-entity.js';
+
+describe('XxxService', () => {
+  let service: XxxService;
+  let repository: MockXxxRepository;
+
+  beforeEach(() => {
+    // BP-TEST-001: Reset counters before each test
+    resetXxxCounter();
+    repository = new MockXxxRepository();
+    service = new XxxService(repository);
+  });
+
+  describe('create', () => {
+    it('should create entity with valid input', async () => {
+      // Arrange
+      const input = { name: 'Test', value: 100 };
+      
+      // Act
+      const result = await service.create(input);
+      
+      // Assert
+      expect(result.isOk()).toBe(true);
+      if (result.isOk()) {
+        expect(result.value.name).toBe('Test');
+      }
+    });
+
+    it('should return error for invalid input', async () => {
+      // Arrange
+      const input = { name: '', value: -1 };
+      
+      // Act
+      const result = await service.create(input);
+      
+      // Assert
+      expect(result.isErr()).toBe(true);
+    });
+  });
+});
+```
+
+### Integration Test Template
+
+```typescript
+/**
+ * @requirement REQ-XXX-NNN
+ * @design DES-XXX-NNN
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+
+describe('XxxService Integration', () => {
+  beforeAll(async () => {
+    // Setup test environment
+  });
+
+  afterAll(async () => {
+    // Cleanup
+  });
+
+  it('should complete full workflow', async () => {
+    // Test full user journey
+  });
+});
+```
+
+## Best Practices for Testing
+
+### BP-TEST-001: Test Counter Reset
+
+```typescript
+beforeEach(() => {
+  resetPetCounter();  // Reset ID counters
+  resetReservationCounter();
+});
+```
+
+### BP-TEST-002: Verify API Before Test
+
+```typescript
+// ✅ Check actual API signature first
+const service = new PetService(repository);
+// Verify method exists and parameters match
+```
+
+### BP-TEST-004: Result Type Test Pattern
+
+```typescript
+// ✅ Test both success and failure cases
+it('should handle success', async () => {
+  const result = await service.create(validInput);
+  expect(result.isOk()).toBe(true);
+  if (result.isOk()) {
+    expect(result.value.id).toBeDefined();
+  }
+});
+
+it('should handle failure', async () => {
+  const result = await service.create(invalidInput);
+  expect(result.isErr()).toBe(true);
+  if (result.isErr()) {
+    expect(result.error.message).toContain('validation');
+  }
+});
+```
+
+### BP-TEST-005: Status Transition Testing
+
+```typescript
+describe('status transitions', () => {
+  // Valid transitions
+  it('should allow draft -> active', () => {
+    const result = workflow.transition('draft', 'activate');
+    expect(result).toBe('active');
+  });
+
+  // Invalid transitions
+  it('should reject completed -> draft', () => {
+    expect(() => workflow.transition('completed', 'revert'))
+      .toThrow('Invalid transition');
+  });
+});
+```
+
+## Test Categories
+
+| Category | Purpose | Location |
+|----------|---------|----------|
+| Unit | Single component | `__tests__/unit/` |
+| Integration | Multiple components | `__tests__/integration/` |
+| E2E | Full user flows | `__tests__/e2e/` |
+
+## CLI Commands
+
+```bash
+# Generate tests from design
+npx musubix test generate storage/design/DES-XXX.md
+
+# Run all tests
+npm test
+
+# Coverage report
+npx musubix test coverage src/
+
+# Run specific test file
+npm test -- xxx.test.ts
+```
+
+## Vitest Configuration
+
+```typescript
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+    },
+  },
+});
+```
+
+## Coverage Targets
+
+| Metric | Target |
+|--------|--------|
+| Line Coverage | ≥80% |
+| Branch Coverage | ≥75% |
+| Function Coverage | ≥90% |
+
+## Related Skills
+
+- `musubix-sdd-workflow` - Full SDD workflow with TDD
+- `musubix-code-generation` - Generate code to test
+- `musubix-traceability` - Link tests to requirements

package/.github/skills/musubix-traceability/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: musubix-traceability
+description: Guide for managing traceability between requirements, designs, code, and tests. Use this when asked to verify traceability, create traceability matrices, or perform impact analysis.
+license: MIT
+---
+
+# MUSUBIX Traceability Skill
+
+This skill guides you through maintaining full traceability across the development lifecycle.
+
+## Overview
+
+MUSUBIX enforces **Article V - Traceability**: Complete bidirectional tracing between:
+
+```
+Requirements (REQ-*) ↔ Design (DES-*) ↔ Tasks (TSK-*) ↔ Code ↔ Tests
+```
+
+## Traceability Matrix
+
+### Creating a Traceability Matrix
+
+```markdown
+# Traceability Matrix
+
+| 要件ID | 設計ID | タスクID | コード | テスト |
+|--------|--------|---------|--------|--------|
+| REQ-AUTH-001 | DES-AUTH-001 | TSK-001 | src/auth/auth-service.ts | auth.test.ts |
+| REQ-AUTH-002 | DES-AUTH-001 | TSK-002 | src/auth/token-manager.ts | token.test.ts |
+```
+
+### CLI Commands
+
+```bash
+# Generate traceability matrix
+npx musubix trace matrix
+
+# Impact analysis for a specific requirement
+npx musubix trace impact REQ-AUTH-001
+
+# Validate all traceability links
+npx musubix trace validate
+```
+
+## Traceability in Code
+
+### Adding Traceability Comments
+
+```typescript
+/**
+ * AuthService - 認証サービス
+ * @requirement REQ-AUTH-001
+ * @design DES-AUTH-001
+ * @task TSK-001
+ */
+export class AuthService {
+  /**
+   * ユーザー認証
+   * @requirement REQ-AUTH-001
+   */
+  async authenticate(credentials: Credentials): Promise<Result<Token, AuthError>> {
+    // Implementation
+  }
+}
+```
+
+### Test Traceability
+
+```typescript
+/**
+ * @requirement REQ-AUTH-001
+ * @design DES-AUTH-001
+ */
+describe('AuthService', () => {
+  describe('authenticate', () => {
+    it('should return token for valid credentials', async () => {
+      // Test implementation
+    });
+  });
+});
+```
+
+## Impact Analysis
+
+When a requirement changes, identify all affected artifacts:
+
+```mermaid
+flowchart LR
+    REQ[REQ-AUTH-001<br/>変更] --> DES[DES-AUTH-001<br/>設計]
+    DES --> TSK1[TSK-001<br/>タスク]
+    DES --> TSK2[TSK-002<br/>タスク]
+    TSK1 --> CODE1[auth-service.ts]
+    TSK2 --> CODE2[token-manager.ts]
+    CODE1 --> TEST1[auth.test.ts]
+    CODE2 --> TEST2[token.test.ts]
+```
+
+### Impact Analysis Steps
+
+1. Identify changed requirement (REQ-*)
+2. Find linked designs (DES-*)
+3. Find linked tasks (TSK-*)
+4. Locate affected code files
+5. Identify tests to update
+6. Update all artifacts
+
+## Traceability Storage
+
+```
+storage/traceability/
+├── matrix.json           # Full traceability matrix
+├── requirements-map.json # REQ -> DES mappings
+├── design-map.json       # DES -> TSK mappings
+└── code-map.json         # TSK -> Code mappings
+```
+
+## Verification Checklist
+
+Before completing any feature:
+
+- [ ] All requirements have linked designs
+- [ ] All designs have linked tasks
+- [ ] All tasks have linked code
+- [ ] All code has linked tests
+- [ ] Traceability comments in code
+- [ ] Matrix updated
+
+## MCP Tool
+
+Use MCP tool for automated validation:
+
+```
+Tool: sdd_validate_traceability
+Description: Validates bidirectional traceability across all artifacts
+```
+
+## Related Skills
+
+- `musubix-sdd-workflow` - Full SDD workflow
+- `musubix-ears-validation` - Requirements validation
+- `musubix-test-generation` - Generate tests with traceability