@su-record/vibe 0.1.3 → 0.1.7

package/templates/feature-template.md

@@ -0,0 +1,259 @@
+# Feature: {기능명}
+
+**Generated from**: `specs/{기능명}.md`
+**Language**: {ko | en}
+**Priority**: {HIGH | MEDIUM | LOW}
+
+---
+
+## Feature Description
+
+**As a** {사용자 역할}
+**I want** {원하는 기능}
+**So that** {이유/가치}
+
+---
+
+## Background (Optional)
+
+```gherkin
+Background:
+  Given {공통 전제 조건 1}
+  And {공통 전제 조건 2}
+```
+
+---
+
+## Scenarios
+
+### Scenario 1: {시나리오 제목}
+
+**Mapped to**: REQ-001 in SPEC
+
+```gherkin
+Scenario: {시나리오 제목}
+  Given {전제 조건}
+  And {추가 전제 조건}
+  When {사용자 행동}
+  And {추가 행동}
+  Then {예상 결과}
+  And {추가 검증}
+```
+
+**Acceptance Criteria**:
+- [ ] {SPEC의 Acceptance Criteria 1}
+- [ ] {SPEC의 Acceptance Criteria 2}
+
+**Test Data**:
+```json
+{
+  "input": {...},
+  "expected_output": {...}
+}
+```
+
+---
+
+### Scenario 2: {에러 케이스 제목}
+
+```gherkin
+Scenario: {에러 케이스 제목}
+  Given {전제 조건}
+  When {잘못된 입력}
+  Then {에러 응답}
+  And {에러 메시지 검증}
+```
+
+---
+
+### Scenario Outline: {파라미터화된 시나리오}
+
+```gherkin
+Scenario Outline: {시나리오 제목}
+  Given {전제 조건}
+  When I {행동} with "<parameter>"
+  Then I should see "<result>"
+
+Examples:
+  | parameter | result |
+  | value1    | result1 |
+  | value2    | result2 |
+  | value3    | result3 |
+```
+
+---
+
+## Implementation Guide
+
+### Backend Tests (Python + Pytest-BDD)
+
+**File**: `tests/features/{기능명}.feature`
+
+```python
+# tests/step_defs/test_{기능명}.py
+import pytest
+from pytest_bdd import scenarios, given, when, then, parsers
+
+# Load scenarios
+scenarios('features/{기능명}.feature')
+
+@given(parsers.parse('사용자가 {role}로 로그인되어 있다'))
+def user_logged_in(context, role):
+    context.user = create_user(role)
+    context.token = authenticate(context.user)
+
+@when(parsers.parse('{action}을 실행한다'))
+def execute_action(context, action):
+    context.response = api_call(action, context.token)
+
+@then(parsers.parse('응답 코드는 {status_code:d}이어야 한다'))
+def check_status_code(context, status_code):
+    assert context.response.status_code == status_code
+```
+
+**Run**:
+```bash
+pytest tests/features/{기능명}.feature --verbose
+```
+
+---
+
+### Frontend Tests (Flutter + Gherkin)
+
+**File**: `integration_test/features/{기능명}.feature`
+
+```dart
+// integration_test/step_definitions/{기능명}_test.dart
+import 'package:flutter_gherkin/flutter_gherkin.dart';
+
+class UserLoggedInStep extends Given1WithWorld<String, FlutterWorld> {
+  @override
+  Future<void> executeStep(String role) async {
+    await world.appDriver.waitForAppToSettle();
+    // Login logic
+  }
+
+  @override
+  RegExp get pattern => RegExp(r'사용자가 {string}로 로그인되어 있다');
+}
+```
+
+**Run**:
+```bash
+flutter test integration_test/{기능명}_test.dart
+```
+
+---
+
+### Frontend Tests (React + Cucumber)
+
+**File**: `tests/features/{기능명}.feature`
+
+```javascript
+// tests/step_definitions/{기능명}.steps.js
+const { Given, When, Then } = require('@cucumber/cucumber');
+const { render, screen, fireEvent } = require('@testing-library/react');
+
+Given('사용자가 {string}로 로그인되어 있다', async function (role) {
+  this.user = await createUser(role);
+  this.token = await authenticate(this.user);
+});
+
+When('{string}을 실행한다', async function (action) {
+  this.response = await apiCall(action, this.token);
+});
+
+Then('응답 코드는 {int}이어야 한다', function (statusCode) {
+  expect(this.response.status).toBe(statusCode);
+});
+```
+
+**Run**:
+```bash
+npm test -- --features tests/features/{기능명}.feature
+```
+
+---
+
+## Tags
+
+```gherkin
+@priority-high
+@smoke
+@regression
+@backend
+@frontend
+```
+
+**Run by tag**:
+```bash
+# Python
+pytest -m "priority-high"
+
+# JavaScript
+npm test -- --tags "@smoke"
+```
+
+---
+
+## Coverage Mapping
+
+| Scenario | SPEC REQ | Acceptance Criteria | Status |
+|----------|----------|---------------------|--------|
+| Scenario 1 | REQ-001 | AC-1, AC-2, AC-3 | ⬜ |
+| Scenario 2 | REQ-002 | AC-4, AC-5 | ⬜ |
+| Scenario 3 | REQ-003 | AC-6, AC-7 | ⬜ |
+
+**Coverage**: 0 / {총 시나리오 수} (0%)
+
+---
+
+## Test Execution Report
+
+**Last Run**: {날짜 시간}
+**Environment**: {dev | staging | production}
+
+| Scenario | Status | Duration | Error |
+|----------|--------|----------|-------|
+| Scenario 1 | ⬜ PENDING | - | - |
+| Scenario 2 | ⬜ PENDING | - | - |
+
+**Total**: 0 passed, 0 failed, {총 수} pending
+
+---
+
+## Next Steps
+
+1. **구현 전 테스트 작성** (Test-First):
+   ```bash
+   # Create feature file first
+   vibe feature "{기능명}"
+
+   # Then implement
+   vibe run "Task 1-1"
+   ```
+
+2. **구현 중 테스트 실행**:
+   ```bash
+   vibe test "{기능명}" --watch
+   ```
+
+3. **완료 후 검증**:
+   ```bash
+   vibe verify "{기능명}"
+   ```
+
+---
+
+## Notes
+
+- ✅ **Given**: 테스트 전제 조건 (상태 설정)
+- ✅ **When**: 사용자 행동 (액션 실행)
+- ✅ **Then**: 예상 결과 (검증)
+- ✅ **And/But**: 추가 조건/검증
+
+**Best Practices**:
+- 시나리오는 비즈니스 언어로 작성
+- 구현 세부사항은 Step Definitions에
+- 각 시나리오는 독립적으로 실행 가능해야 함
+- Background는 중복 제거용으로만 사용

package/templates/spec-template.md

@@ -117,26 +117,83 @@ Response: {...}
 
 ---
 
-## 7. Out of Scope
+## 7. 테스트 전략
+
+### BDD 시나리오 (Gherkin)
+
+**생성 명령어**: `vibe feature "{기능명}"`
+
+```gherkin
+Scenario: {시나리오 제목}
+  Given {전제 조건}
+  When {사용자 행동}
+  Then {예상 결과}
+```
+
+**매핑**:
+- REQ-001 → Scenario 1, 2
+- REQ-002 → Scenario 3
+
+### Contract Tests (API 스키마)
+
+**생성 명령어**: `vibe contract "{기능명}"`
+
+**Backend Contract**:
+```json
+{
+  "request": {
+    "method": "POST",
+    "path": "/api/v1/{resource}",
+    "schema": {JSON Schema}
+  },
+  "response": {
+    "status": 201,
+    "schema": {JSON Schema}
+  }
+}
+```
+
+**Frontend Contract**:
+- Mock 서버로 독립 테스트
+- 응답 스키마 검증 (Zod, JSON Schema)
+
+### 테스트 커버리지 목표
+
+- [ ] BDD: 모든 Acceptance Criteria 커버
+- [ ] Contract: 모든 API 엔드포인트 커버
+- [ ] Unit: 70%+ 커버리지
+- [ ] Integration: 핵심 경로 커버
+
+---
+
+## 8. Out of Scope
 
 - ❌ {제외 항목 1}
 - ❌ {제외 항목 2}
 
 ---
 
-## 8. 검증 체크리스트
+## 9. 검증 체크리스트
 
+### 요구사항
 - [ ] 모든 요구사항이 테스트 가능한가?
 - [ ] SHALL/SHOULD/MAY가 명확한가?
 - [ ] Acceptance Criteria가 구체적인가?
 - [ ] 성능 목표가 측정 가능한가?
 
+### 테스팅
+- [ ] BDD Feature 파일 생성 완료?
+- [ ] Contract 테스트 정의 완료?
+- [ ] Step Definitions 작성 완료?
+- [ ] 테스트 커버리지 목표 달성?
+
 ---
 
-## 9. 승인
+## 10. 승인
 
 - [ ] 사용자 승인
 - [ ] 기술 리뷰 완료
+- [ ] 테스트 계획 승인
 
 승인일: ____________
 승인자: ____________

package/mcp/dist/__tests__/complexity.test.js

@@ -1,126 +0,0 @@
-import { describe, test, expect } from 'vitest';
-import { analyzeComplexity, analyzeComplexityDefinition } from '../tools/convention/analyzeComplexity.js';
-describe('Code Complexity Analysis', () => {
-    describe('analyzeComplexity', () => {
-        test('should analyze simple function with low complexity', async () => {
-            const simpleCode = `
-        function add(a, b) {
-          return a + b;
-        }
-      `;
-            const result = await analyzeComplexity({ code: simpleCode, metrics: 'all' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.status).toBe('success');
-            expect(parsed.results.cyclomaticComplexity).toBeDefined();
-            expect(parsed.results.cognitiveComplexity).toBeDefined();
-            expect(parsed.results.halsteadMetrics).toBeDefined();
-            expect(parsed.results.cyclomaticComplexity.status).toBe('pass');
-        });
-        test('should detect high cyclomatic complexity', async () => {
-            const complexCode = `
-        function complexFunction(x) {
-          if (x > 0) {
-            if (x < 10) {
-              for (let i = 0; i < x; i++) {
-                if (i % 2 === 0) {
-                  while (i < 5) {
-                    if (i === 3) {
-                      return i;
-                    }
-                    i++;
-                  }
-                }
-              }
-            }
-          }
-          return x;
-        }
-      `;
-            const result = await analyzeComplexity({ code: complexCode, metrics: 'all' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.results.cyclomaticComplexity.value).toBeGreaterThan(5);
-            expect(parsed.issues.length).toBeGreaterThan(0);
-        });
-        test('should calculate AST-based complexity', async () => {
-            const code = `
-        function test() {
-          if (true) return 1;
-          for (let i = 0; i < 10; i++) {
-            console.log(i);
-          }
-        }
-      `;
-            const result = await analyzeComplexity({ code, metrics: 'cyclomatic' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.results.astCyclomaticComplexity).toBeDefined();
-            expect(parsed.results.astCyclomaticComplexity.value).toBeGreaterThan(1);
-        });
-        test('should calculate cognitive complexity with nesting', async () => {
-            const code = `
-        function nested() {
-          if (a) {
-            if (b) {
-              if (c) {
-                return true;
-              }
-            }
-          }
-        }
-      `;
-            const result = await analyzeComplexity({ code, metrics: 'cognitive' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.results.cognitiveComplexity.value).toBeGreaterThan(0);
-        });
-        test('should calculate Halstead metrics', async () => {
-            const code = `
-        function calculate(x, y) {
-          const sum = x + y;
-          const product = x * y;
-          return sum + product;
-        }
-      `;
-            const result = await analyzeComplexity({ code, metrics: 'halstead' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.results.halsteadMetrics).toBeDefined();
-            expect(parsed.results.halsteadMetrics.vocabulary).toBeGreaterThan(0);
-            expect(parsed.results.halsteadMetrics.difficulty).toBeGreaterThan(0);
-        });
-        test('should provide recommendations for complex code', async () => {
-            const veryComplexCode = `
-        function veryComplex(a, b, c, d, e) {
-          if (a) {
-            if (b) {
-              for (let i = 0; i < 10; i++) {
-                if (c) {
-                  while (d) {
-                    if (e) {
-                      return true;
-                    }
-                  }
-                }
-              }
-            }
-          }
-          return false;
-        }
-      `;
-            const result = await analyzeComplexity({ code: veryComplexCode, metrics: 'all' });
-            const parsed = JSON.parse(result.content[0].text.replace('Complexity Analysis:\n', ''));
-            expect(parsed.recommendations).toBeDefined();
-            expect(parsed.recommendations.length).toBeGreaterThan(0);
-            expect(parsed.overallScore).toBeLessThan(100);
-        });
-    });
-    describe('Tool Definition', () => {
-        test('should have correct definition', () => {
-            expect(analyzeComplexityDefinition.name).toBe('analyze_complexity');
-            expect(analyzeComplexityDefinition.description).toContain('IMPORTANT');
-            expect(analyzeComplexityDefinition.inputSchema.required).toContain('code');
-        });
-        test('should include keyword triggers', () => {
-            const desc = analyzeComplexityDefinition.description;
-            expect(desc).toContain('복잡도');
-            expect(desc).toContain('complexity');
-        });
-    });
-});

package/mcp/dist/__tests__/memory.test.js

@@ -1,120 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'vitest';
-import { saveMemory, saveMemoryDefinition } from '../tools/memory/saveMemory.js';
-import { recallMemory } from '../tools/memory/recallMemory.js';
-import { listMemories } from '../tools/memory/listMemories.js';
-import { deleteMemory } from '../tools/memory/deleteMemory.js';
-import { memoryDB } from '../tools/memory/database.js';
-import { clearAllMemories } from '../tools/memory/memorySQLite.js';
-import { promises as fs } from 'fs';
-import path from 'path';
-const TEST_MEMORY_DIR = path.join(process.cwd(), 'memories');
-describe('Memory Management Tools', () => {
-    beforeEach(async () => {
-        // Ensure fresh database for each test
-        try {
-            // Close existing connection if any
-            memoryDB.close();
-        }
-        catch (error) {
-            // Ignore
-        }
-        // Clean up test files
-        try {
-            await fs.rm(TEST_MEMORY_DIR, { recursive: true, force: true });
-        }
-        catch (error) {
-            // Ignore
-        }
-        // Clear all memories (this will recreate DB if needed)
-        try {
-            clearAllMemories();
-        }
-        catch (error) {
-            // Database might not exist yet, will be created on first use
-        }
-    });
-    afterEach(async () => {
-        // Close database connection
-        try {
-            memoryDB.close();
-        }
-        catch (error) {
-            // Ignore
-        }
-    });
-    describe('saveMemory', () => {
-        test('should save memory successfully', async () => {
-            const result = await saveMemory({
-                key: 'test-key',
-                value: 'test-value',
-                category: 'project'
-            });
-            expect(result.content[0].text).toContain('success');
-            expect(result.content[0].text).toContain('test-key');
-        });
-        test('should create memory database if not exists', async () => {
-            await saveMemory({ key: 'test-key', value: 'test-value' });
-            // Check if database file exists
-            const dbPath = path.join(TEST_MEMORY_DIR, 'memories.db');
-            const dbExists = await fs.access(dbPath).then(() => true).catch(() => false);
-            expect(dbExists).toBe(true);
-        });
-    });
-    describe('recallMemory', () => {
-        test('should recall saved memory', async () => {
-            await saveMemory({ key: 'recall-test', value: 'recall-value' });
-            const result = await recallMemory({ key: 'recall-test' });
-            const parsedResult = JSON.parse(result.content[0].text.replace('Memory recalled:\n', ''));
-            expect(parsedResult.value).toBe('recall-value');
-            expect(parsedResult.key).toBe('recall-test');
-        });
-        test('should return not found for non-existent key', async () => {
-            const result = await recallMemory({ key: 'non-existent' });
-            expect(result.content[0].text).toContain('not found');
-        });
-    });
-    describe('listMemories', () => {
-        test('should list all memories', async () => {
-            await saveMemory({ key: 'key1', value: 'value1', category: 'project' });
-            await saveMemory({ key: 'key2', value: 'value2', category: 'code' });
-            const result = await listMemories({ summary: false });
-            const parsed = JSON.parse(result.content[0].text.replace('Memory list:\n', ''));
-            expect(parsed.memories.length).toBe(2);
-            expect(parsed.total).toBe(2);
-        });
-        test('should filter memories by category', async () => {
-            await saveMemory({ key: 'project1', value: 'val1', category: 'project' });
-            await saveMemory({ key: 'code1', value: 'val2', category: 'code' });
-            const result = await listMemories({ category: 'project', summary: false });
-            const parsed = JSON.parse(result.content[0].text.replace('Memory list:\n', ''));
-            expect(parsed.total).toBe(1);
-            expect(parsed.memories[0].key).toBe('project1');
-        });
-        test('should return empty array when no memories exist', async () => {
-            const result = await listMemories({ summary: false });
-            const parsed = JSON.parse(result.content[0].text.replace('Memory list:\n', ''));
-            expect(parsed.memories).toEqual([]);
-            expect(parsed.total).toBe(0);
-        });
-    });
-    describe('deleteMemory', () => {
-        test('should delete existing memory', async () => {
-            await saveMemory({ key: 'delete-me', value: 'temporary' });
-            const deleteResult = await deleteMemory({ key: 'delete-me' });
-            expect(deleteResult.content[0].text).toContain('success');
-            const recallResult = await recallMemory({ key: 'delete-me' });
-            expect(recallResult.content[0].text).toContain('not found');
-        });
-    });
-    describe('Tool Definition', () => {
-        test('should have correct structure', () => {
-            expect(saveMemoryDefinition.name).toBe('save_memory');
-            expect(saveMemoryDefinition.description).toContain('IMPORTANT');
-            expect(saveMemoryDefinition.inputSchema.required).toContain('key');
-        });
-        test('should include keyword triggers', () => {
-            expect(saveMemoryDefinition.description).toContain('기억해');
-            expect(saveMemoryDefinition.description).toContain('remember');
-        });
-    });
-});