claude-symphony 0.0.1 → 0.0.2

package/template/.claude/commands/validate.md

@@ -1,174 +1,174 @@
 # /validate - Output Validation Command
 
-현재 스테이지의 산출물을 검증합니다.
+Validate the outputs of the current stage.
 
-## 사용법
+## Usage
 
 ```bash
 /validate [options]
 ```
 
-## 옵션
+## Options
 
-| 옵션 | 설명 | 기본값 |
-|------|------|--------|
-| `--stage` | 검증할 스테이지 ID | 현재 스테이지 |
-| `--verbose` | 상세 출력 | false |
-| `--fix` | 자동 수정 제안 | false |
-| `--skip-commands` | 명령어 검증 건너뛰기 | false |
-| `--force` | 실패해도 통과 처리 | false |
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--stage` | Stage ID to validate | Current stage |
+| `--verbose` | Detailed output | false |
+| `--fix` | Auto-fix suggestions | false |
+| `--skip-commands` | Skip command validation | false |
+| `--force` | Pass even on failure | false |
 
-## 검증 항목
+## Validation Items
 
-### 1. 필수 파일 존재
+### 1. Required File Existence
 ```bash
 /validate
-# → ideas.md ✅, requirements_analysis.md ❌ (누락)
+# → ideas.md ✅, requirements_analysis.md ❌ (missing)
 ```
 
-### 2. 파일 내용 검증
+### 2. File Content Validation
 ```bash
 /validate --verbose
-# → ideas.md: 8개 아이디어 (최소 5개) ✅
-# → 필수 섹션: 기능 요구사항 ✅, 비기능 요구사항 ❌
+# → ideas.md: 8 ideas (minimum 5) ✅
+# → Required sections: Functional Requirements ✅, Non-Functional Requirements ❌
 ```
 
-### 3. 명령어 검증
+### 3. Command Validation
 ```bash
 /validate
 # → npm run lint ✅
 # → npm run typecheck ✅
-# → npm run test ❌ (3개 실패)
+# → npm run test ❌ (3 failures)
 ```
 
-### 4. 품질 점수
+### 4. Quality Score
 ```bash
 /validate
-# → 종합 점수: 0.85/1.0
+# → Overall score: 0.85/1.0
 ```
 
-## 출력 형식
+## Output Format
 
-### 간단 출력
+### Simple Output
 ```
-✅ 검증 통과: 06-implementation (점수: 0.95)
+✅ Validation passed: 06-implementation (score: 0.95)
 ```
 
-### 실패 시
+### On Failure
 ```
-❌ 검증 실패: 06-implementation
+❌ Validation failed: 06-implementation
 
-실패 항목:
-1. 테스트 실패 (3개)
-2. 커버리지 미달 (75% < 80%)
+Failed items:
+1. Test failures (3)
+2. Coverage below target (75% < 80%)
 
-수정 필요:
-- [ ] tests/auth.test.ts:45 수정
-- [ ] 테스트 커버리지 5% 향상
+Fixes needed:
+- [ ] Fix tests/auth.test.ts:45
+- [ ] Improve test coverage by 5%
 ```
 
-### 상세 출력 (--verbose)
+### Verbose Output (--verbose)
 ```markdown
-# 산출물 검증 리포트
+# Output Validation Report
 
-## 스테이지: 06-implementation
-## 상태: ⚠️ 부분 통과
-## 점수: 0.85
+## Stage: 06-implementation
+## Status: ⚠️ Partial Pass
+## Score: 0.85
 
-### 파일 검증
-| 파일 | 상태 | 상세 |
-|------|------|------|
-| source_code/ | ✅ | 디렉토리 존재 |
-| implementation_log.md | ✅ | 필수 형식 충족 |
+### File Validation
+| File | Status | Details |
+|------|--------|---------|
+| source_code/ | ✅ | Directory exists |
+| implementation_log.md | ✅ | Required format met |
 
-### 명령어 검증
-| 명령 | 결과 | 시간 |
-|------|------|------|
+### Command Validation
+| Command | Result | Time |
+|---------|--------|------|
 | lint | ✅ | 2.3s |
 | typecheck | ✅ | 4.1s |
 | test | ❌ | 15.2s |
 
-### 품질 메트릭
-| 메트릭 | 현재 | 목표 | 상태 |
-|--------|------|------|------|
+### Quality Metrics
+| Metric | Current | Target | Status |
+|--------|---------|--------|--------|
 | Lint | 0.95 | 0.90 | ✅ |
 | Coverage | 0.75 | 0.80 | ❌ |
 ```
 
-## 자동 수정 제안
+## Auto-Fix Suggestions
 
 ```bash
 /validate --fix
 ```
 
 ```markdown
-## 자동 수정 제안
+## Auto-Fix Suggestions
 
-### 1. 누락된 섹션 추가
-**파일**: requirements_analysis.md
-**제안**: "비기능 요구사항" 섹션 추가
+### 1. Add Missing Section
+**File**: requirements_analysis.md
+**Suggestion**: Add "Non-Functional Requirements" section
 
-### 2. 테스트 수정
-**파일**: tests/auth.test.ts:45
-**원인**: 반환 타입 불일치
-**수정안**:
+### 2. Fix Test
+**File**: tests/auth.test.ts:45
+**Cause**: Return type mismatch
+**Fix**:
 ```typescript
 expect(result).toHaveProperty('token');
-// 변경 →
+// Change to →
 expect(result.data).toHaveProperty('token');
 ```
 
-자동 수정을 적용하시겠습니까? (y/n)
+Apply auto-fixes? (y/n)
 ```
 
-## 강제 통과
+## Force Pass
 
 ```bash
 /validate --force
 ```
 
 ```
-⚠️ 검증 실패 항목이 있습니다.
-강제로 통과 처리하시겠습니까?
+⚠️ There are failed validation items.
+Force pass anyway?
 
-이유를 입력하세요:
-> 테스트 환경 문제로 일시적 실패, 로컬에서 통과 확인됨
+Enter reason:
+> Temporary failure due to test environment issue, verified locally
 
-✅ 강제 통과 처리됨 (이유 기록됨)
+✅ Force passed (reason recorded)
 ```
 
-## 예시
+## Examples
 
 ```bash
-# 현재 스테이지 검증
+# Validate current stage
 /validate
 
-# 특정 스테이지 상세 검증
+# Validate specific stage with details
 /validate --stage 06 --verbose
 
-# 자동 수정 제안 포함
+# Include auto-fix suggestions
 /validate --fix
 
-# 빠른 검증 (명령어 건너뛰기)
+# Quick validation (skip commands)
 /validate --skip-commands
 ```
 
-## 검증 결과 저장
+## Validation Results Storage
 
-- 결과: `state/validations/{stage}_{timestamp}.json`
-- 리포트: `state/validations/{stage}_{timestamp}.md`
+- Results: `state/validations/{stage}_{timestamp}.json`
+- Report: `state/validations/{stage}_{timestamp}.md`
 
-## 설정
+## Configuration
 
-`config/output_validation.yaml` 참조
+See `config/output_validation.yaml`
 
-## 스테이지 전환 시 자동 실행
+## Auto-Run on Stage Transition
 
-`/next` 명령어 실행 시 자동으로 검증이 수행됩니다.
-검증 실패 시 스테이지 전환이 차단됩니다.
+Validation runs automatically when executing `/next` command.
+Stage transition is blocked if validation fails.
 
-## 관련 커맨드
+## Related Commands
 
-- `/next` - 다음 스테이지 전환
-- `/status` - 파이프라인 상태
-- `/stages` - 스테이지 목록
+- `/next` - Next stage transition
+- `/status` - Pipeline status
+- `/stages` - Stage list

package/template/.claude/hooks/ai-selector.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # claude-symphony AI Selector Hook
-# 동적 AI 모델 선택
+# Dynamic AI model selection
 
 set -e
 
@@ -10,18 +10,18 @@ CONFIG_FILE="$PROJECT_ROOT/config/models.yaml"
 BENCHMARKS_DIR="$PROJECT_ROOT/state/ai_benchmarks"
 PROGRESS_FILE="$PROJECT_ROOT/state/progress.json"
 
-# 색상 정의
+# Color definitions
 BLUE='\033[0;34m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 NC='\033[0m'
 
-# 로그 함수
+# Log functions
 log_info() { echo -e "${BLUE}[AI-SELECT]${NC} $1"; }
 log_success() { echo -e "${GREEN}[AI-SELECT]${NC} $1"; }
 log_suggest() { echo -e "${YELLOW}[AI-SELECT]${NC} $1"; }
 
-# 현재 스테이지 확인
+# Get current stage
 get_current_stage() {
     if [ -f "$PROGRESS_FILE" ]; then
         cat "$PROGRESS_FILE" 2>/dev/null | grep -o '"current_stage"[[:space:]]*:[[:space:]]*"[^"]*"' | cut -d'"' -f4
@@ -30,7 +30,7 @@ get_current_stage() {
     fi
 }
 
-# 스테이지 기반 모델 선택
+# Stage-based model selection
 get_stage_model() {
     local stage="$1"
 
@@ -56,7 +56,7 @@ get_stage_model() {
     esac
 }
 
-# 태스크 유형 기반 모델 선택
+# Task type-based model selection
 get_task_model() {
     local task_type="$1"
 
@@ -79,13 +79,13 @@ get_task_model() {
     esac
 }
 
-# 이전 성능 기반 모델 선택
+# Performance-based model selection
 get_performance_model() {
     local task_type="$1"
     local benchmark_file="$BENCHMARKS_DIR/latest.json"
 
     if [ -f "$benchmark_file" ]; then
-        # 최근 벤치마크 결과에서 최고 성능 모델 추출
+        # Extract best performing model from recent benchmark results
         local best_model=$(cat "$benchmark_file" 2>/dev/null | grep -o '"best_model"[[:space:]]*:[[:space:]]*"[^"]*"' | cut -d'"' -f4)
 
         if [ -n "$best_model" ]; then
@@ -94,23 +94,23 @@ get_performance_model() {
         fi
     fi
 
-    # 벤치마크 없으면 기본값
+    # Default if no benchmark available
     echo "claudecode"
 }
 
-# 복잡도 기반 모델 선택
+# Complexity-based model selection
 get_complexity_model() {
     local complexity="$1"
 
     case "$complexity" in
         "simple"|"low")
-            echo "claudecode"  # 빠른 응답
+            echo "claudecode"  # Fast response
             ;;
         "moderate"|"medium")
             echo "claudecode"
             ;;
         "complex"|"high")
-            echo "claudecode"  # 복잡한 로직 처리
+            echo "claudecode"  # Complex logic handling
             ;;
         *)
             echo "claudecode"
@@ -118,59 +118,59 @@ get_complexity_model() {
     esac
 }
 
-# 최적 모델 선택 (종합)
+# Select best model (comprehensive)
 select_best_model() {
     local stage="$1"
     local task_type="$2"
     local complexity="$3"
 
-    # 가중치
+    # Weights
     local stage_weight=0.4
     local task_weight=0.3
     local perf_weight=0.2
     local complexity_weight=0.1
 
-    # 각 기준별 모델
+    # Models per criterion
     local stage_model=$(get_stage_model "$stage")
     local task_model=$(get_task_model "$task_type")
     local perf_model=$(get_performance_model "$task_type")
     local comp_model=$(get_complexity_model "$complexity")
 
-    log_info "모델 선택 분석:"
-    log_info "  스테이지 기반: $stage_model (가중치: $stage_weight)"
-    log_info "  태스크 기반: $task_model (가중치: $task_weight)"
-    log_info "  성능 기반: $perf_model (가중치: $perf_weight)"
-    log_info "  복잡도 기반: $comp_model (가중치: $complexity_weight)"
+    log_info "Model selection analysis:"
+    log_info "  Stage-based: $stage_model (weight: $stage_weight)"
+    log_info "  Task-based: $task_model (weight: $task_weight)"
+    log_info "  Performance-based: $perf_model (weight: $perf_weight)"
+    log_info "  Complexity-based: $comp_model (weight: $complexity_weight)"
 
-    # 스테이지 기반이 가장 높은 가중치이므로 우선 선택
-    # 실제 구현에서는 점수 계산 필요
+    # Stage-based has highest weight, so prioritize it
+    # In actual implementation, score calculation needed
     local selected_model="$stage_model"
 
-    log_success "선택된 모델: $selected_model"
+    log_success "Selected model: $selected_model"
     echo "$selected_model"
 }
 
-# 모델 정보 출력
+# Print model info
 print_model_info() {
     local model="$1"
 
     case "$model" in
         "claudecode")
-            echo "Claude Code - 정확한 코드 생성, 복잡한 로직 분석"
+            echo "Claude Code - Accurate code generation, complex logic analysis"
             ;;
         "claude")
-            echo "Claude - 심층 리서치, 문서 분석 및 요약"
+            echo "Claude - Deep research, document analysis and summarization"
             ;;
         "gemini")
-            echo "Gemini - 창의적 아이디어, 다양한 관점 탐색"
+            echo "Gemini - Creative ideas, diverse perspective exploration"
             ;;
         "codex")
-            echo "Codex - 코드 분석, 리팩토링, 테스트 생성"
+            echo "Codex - Code analysis, refactoring, test generation"
             ;;
     esac
 }
 
-# 메인 실행
+# Main execution
 main() {
     local action="$1"
     shift
@@ -199,25 +199,25 @@ main() {
         "current")
             local stage=$(get_current_stage)
             local model=$(get_stage_model "$stage")
-            log_info "현재 스테이지: $stage"
-            log_info "권장 모델: $model"
+            log_info "Current stage: $stage"
+            log_info "Recommended model: $model"
             print_model_info "$model"
             ;;
         *)
-            echo "사용법: $0 {stage|task|select|info|current} [args]"
+            echo "Usage: $0 {stage|task|select|info|current} [args]"
             echo ""
-            echo "명령어:"
-            echo "  stage [stage_id]     - 스테이지 기반 모델 선택"
-            echo "  task [task_type]     - 태스크 유형 기반 모델 선택"
-            echo "  select [stage] [task] [complexity] - 종합 모델 선택"
-            echo "  info [model]         - 모델 정보 출력"
-            echo "  current              - 현재 스테이지 권장 모델"
+            echo "Commands:"
+            echo "  stage [stage_id]     - Stage-based model selection"
+            echo "  task [task_type]     - Task type-based model selection"
+            echo "  select [stage] [task] [complexity] - Comprehensive model selection"
+            echo "  info [model]         - Print model info"
+            echo "  current              - Recommended model for current stage"
             exit 1
             ;;
     esac
 }
 
-# 직접 실행 시에만 main 호출
+# Call main only when executed directly
 if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
     main "$@"
 fi

package/template/.claude/hooks/auto-checkpoint.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 # claude-symphony Auto-Checkpoint Hook
-# 자동 체크포인트 트리거 감지 및 생성
+# Auto-checkpoint trigger detection and creation
 
 set -e
 
@@ -10,25 +10,25 @@ CONFIG_FILE="$PROJECT_ROOT/config/auto_checkpoint.yaml"
 CHECKPOINTS_DIR="$PROJECT_ROOT/state/checkpoints"
 PROGRESS_FILE="$PROJECT_ROOT/state/progress.json"
 
-# 색상 정의
+# Color definitions
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
 BLUE='\033[0;34m'
 NC='\033[0m'
 
-# 로그 함수
+# Log functions
 log_info() { echo -e "${BLUE}[INFO]${NC} $1"; }
 log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
 log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
 log_error() { echo -e "${RED}[ERROR]${NC} $1"; }
 
-# 체크포인트 디렉토리 확인
+# Ensure checkpoint directory
 ensure_checkpoint_dir() {
     mkdir -p "$CHECKPOINTS_DIR"
 }
 
-# 현재 스테이지 확인
+# Get current stage
 get_current_stage() {
     if [ -f "$PROGRESS_FILE" ]; then
         cat "$PROGRESS_FILE" 2>/dev/null | grep -o '"current_stage"[[:space:]]*:[[:space:]]*"[^"]*"' | cut -d'"' -f4
@@ -37,7 +37,7 @@ get_current_stage() {
     fi
 }
 
-# 변경된 라인 수 계산
+# Calculate changed lines
 get_changed_lines() {
     if git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
         git diff --stat 2>/dev/null | tail -1 | grep -oE '[0-9]+ insertion|[0-9]+ deletion' | grep -oE '[0-9]+' | paste -sd+ | bc 2>/dev/null || echo "0"
@@ -46,7 +46,7 @@ get_changed_lines() {
     fi
 }
 
-# 체크포인트 생성
+# Create checkpoint
 create_checkpoint() {
     local trigger_reason="$1"
     local checkpoint_name="$2"
@@ -62,38 +62,38 @@ create_checkpoint() {
 
     local checkpoint_path="$CHECKPOINTS_DIR/$checkpoint_name"
 
-    log_info "체크포인트 생성 중: $checkpoint_name"
+    log_info "Creating checkpoint: $checkpoint_name"
 
-    # 체크포인트 디렉토리 생성
+    # Create checkpoint directory
     mkdir -p "$checkpoint_path"
 
-    # 소스 코드 복사 (node_modules 제외)
+    # Copy source code (exclude node_modules)
     if [ -d "$PROJECT_ROOT/src" ]; then
         rsync -a --exclude='node_modules' --exclude='.git' --exclude='state/checkpoints' \
             "$PROJECT_ROOT/src" "$checkpoint_path/" 2>/dev/null || true
     fi
 
-    # 설정 파일 복사
+    # Copy config files
     if [ -d "$PROJECT_ROOT/config" ]; then
         cp -r "$PROJECT_ROOT/config" "$checkpoint_path/" 2>/dev/null || true
     fi
 
-    # 상태 파일 복사
+    # Copy state files
     if [ -d "$PROJECT_ROOT/state" ]; then
         mkdir -p "$checkpoint_path/state"
         cp "$PROJECT_ROOT/state/progress.json" "$checkpoint_path/state/" 2>/dev/null || true
     fi
 
-    # 스테이지 outputs 복사
+    # Copy stage outputs
     if [ -d "$PROJECT_ROOT/stages" ]; then
         mkdir -p "$checkpoint_path/stages"
         find "$PROJECT_ROOT/stages" -name "outputs" -type d -exec cp -r {} "$checkpoint_path/stages/" \; 2>/dev/null || true
     fi
 
-    # HANDOFF 복사
+    # Copy HANDOFF
     find "$PROJECT_ROOT/stages" -name "HANDOFF.md" -exec cp {} "$checkpoint_path/" \; 2>/dev/null || true
 
-    # 메타데이터 생성
+    # Create metadata
     cat > "$checkpoint_path/metadata.json" << EOF
 {
     "name": "$checkpoint_name",
@@ -105,49 +105,49 @@ create_checkpoint() {
 }
 EOF
 
-    log_success "체크포인트 생성 완료: $checkpoint_name"
+    log_success "Checkpoint created: $checkpoint_name"
 
-    # Git 태그 생성 (옵션)
+    # Create Git tag (optional)
     if git rev-parse --is-inside-work-tree > /dev/null 2>&1; then
         git tag -a "checkpoint/$checkpoint_name" -m "Auto-checkpoint: $trigger_reason" 2>/dev/null || true
     fi
 
-    # 오래된 체크포인트 정리
+    # Cleanup old checkpoints
     cleanup_old_checkpoints
 
     echo "$checkpoint_name"
 }
 
-# 오래된 체크포인트 정리
+# Cleanup old checkpoints
 cleanup_old_checkpoints() {
     local max_checkpoints=20
     local checkpoint_count=$(ls -1 "$CHECKPOINTS_DIR" 2>/dev/null | wc -l)
 
     if [ "$checkpoint_count" -gt "$max_checkpoints" ]; then
         local to_delete=$((checkpoint_count - max_checkpoints))
-        log_info "오래된 체크포인트 정리: ${to_delete}개"
+        log_info "Cleaning up old checkpoints: ${to_delete}"
 
-        # 가장 오래된 것부터 삭제 (milestone 제외)
+        # Delete oldest first (exclude milestones)
         ls -1t "$CHECKPOINTS_DIR" | tail -n "$to_delete" | while read -r checkpoint; do
-            # milestone 체크포인트는 보존
+            # Preserve milestone checkpoints
             if [[ ! "$checkpoint" =~ (stage_complete|pre_destructive|manual) ]]; then
                 rm -rf "$CHECKPOINTS_DIR/$checkpoint"
-                log_info "삭제됨: $checkpoint"
+                log_info "Deleted: $checkpoint"
             fi
         done
     fi
 }
 
-# 파괴적 작업 감지
+# Detect destructive action
 check_destructive_action() {
     local command="$1"
 
-    # 파괴적 패턴
+    # Destructive patterns
     local patterns=("rm -rf" "git reset --hard" "drop table" "DELETE FROM" "truncate")
 
     for pattern in "${patterns[@]}"; do
         if [[ "$command" == *"$pattern"* ]]; then
-            log_warning "파괴적 작업 감지: $pattern"
+            log_warning "Destructive action detected: $pattern"
             create_checkpoint "pre_destructive" ""
             return 0
         fi
@@ -156,7 +156,7 @@ check_destructive_action() {
     return 1
 }
 
-# 메인 실행
+# Main execution
 main() {
     local action="$1"
     shift
@@ -172,16 +172,16 @@ main() {
             cleanup_old_checkpoints
             ;;
         "list")
-            ls -1t "$CHECKPOINTS_DIR" 2>/dev/null || echo "체크포인트 없음"
+            ls -1t "$CHECKPOINTS_DIR" 2>/dev/null || echo "No checkpoints"
             ;;
         *)
-            echo "사용법: $0 {create|check-destructive|cleanup|list} [args]"
+            echo "Usage: $0 {create|check-destructive|cleanup|list} [args]"
             exit 1
             ;;
     esac
 }
 
-# 직접 실행 시에만 main 호출
+# Call main only when executed directly
 if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
     main "$@"
 fi