claude-symphony 0.0.1 → 0.0.2

package/README.md

@@ -1,5 +1,9 @@
 # claude-symphony
 
+<p align="center">
+  <img src="./assets/claude_symphony.webp" alt="Claude Symphony Logo" width="400">
+</p>
+
 Multi-AI Orchestration Framework for Software Development
 
 [![CI](https://github.com/znehraks/claude-symphony/actions/workflows/ci.yml/badge.svg)](https://github.com/znehraks/claude-symphony/actions/workflows/ci.yml)
@@ -107,22 +111,22 @@ cd my-saas-app
 Edit `stages/01-brainstorm/inputs/project_brief.md`:
 
 ```markdown
-## 프로젝트 이름
+## Project Name
 my-saas-app
 
-## 한 줄 설명
-[프로젝트를 한 줄로 설명해주세요]
+## One-line Description
+[Describe your project in one line]
 
-## 문제 정의
-[해결하려는 문제는 무엇인가요?]
+## Problem Definition
+[What problem are you trying to solve?]
 
-## 타겟 사용자
-[주요 사용자는 누구인가요?]
+## Target Users
+[Who are the main users?]
 
-## 핵심 기능 (초안)
-1. [기능 1]
-2. [기능 2]
-3. [기능 3]
+## Core Features (Draft)
+1. [Feature 1]
+2. [Feature 2]
+3. [Feature 3]
 ```
 
 ## Packages
@@ -212,7 +216,7 @@ context:
   task_save_frequency: 5
 
 git:
-  commit_language: "Korean"
+  commit_language: "English"
   auto_commit: true
 ```
 

package/bin/create.js

@@ -8,7 +8,7 @@ import { input } from '@inquirer/prompts';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// 색상 코드
+// Color codes
 const colors = {
   reset: '\x1b[0m',
   green: '\x1b[32m',
@@ -22,6 +22,14 @@ function log(message, color = 'reset') {
   console.log(`${colors[color]}${message}${colors.reset}`);
 }
 
+function displayAsciiBanner() {
+  const bannerPath = path.join(__dirname, '..', 'assets', 'claude_symphony_ascii.txt');
+  if (fs.existsSync(bannerPath)) {
+    const banner = fs.readFileSync(bannerPath, 'utf8');
+    console.log(colors.cyan + banner + colors.reset);
+  }
+}
+
 function copyRecursiveSync(src, dest) {
   const exists = fs.existsSync(src);
   const stats = exists && fs.statSync(src);
@@ -44,24 +52,24 @@ function copyRecursiveSync(src, dest) {
 
 async function collectBriefInfo() {
   console.log('');
-  log('📝 프로젝트 브리프를 작성합니다. (Enter만 누르면 건너뜁니다)', 'yellow');
+  log('📜 Creating project brief. (Press Enter to skip)', 'yellow');
   console.log('');
 
   const info = {};
 
-  // 순차적으로 질문 (각 input()이 완료되어야 다음으로 진행)
-  info.description = await input({ message: '한 줄 설명:' });
-  info.problem = await input({ message: '문제 정의 (해결하려는 문제):' });
-  info.targetUser = await input({ message: '타겟 사용자:' });
-  info.successCriteria = await input({ message: '성공 기준:' });
-  info.constraintSchedule = await input({ message: '제약조건 - 일정:' });
-  info.constraintBudget = await input({ message: '제약조건 - 예산:' });
-  info.constraintTech = await input({ message: '제약조건 - 기술:' });
-  info.references = await input({ message: '참고 자료 (URL 또는 문서):' });
-
-  // 핵심 기능 - 여러 개 입력 (별도 루프)
+  // Sequential questions (each input() must complete before proceeding)
+  info.description = await input({ message: '📝 One-line description:' });
+  info.problem = await input({ message: '🔍 Problem definition (problem to solve):' });
+  info.targetUser = await input({ message: '🎯 Target users:' });
+  info.successCriteria = await input({ message: '🏆 Success criteria:' });
+  info.constraintSchedule = await input({ message: '⏰ Constraints - Schedule:' });
+  info.constraintBudget = await input({ message: '💰 Constraints - Budget:' });
+  info.constraintTech = await input({ message: '⚙️ Constraints - Technology:' });
+  info.references = await input({ message: '🔗 References (URL or documents):' });
+
+  // Core features - multiple inputs (separate loop)
   console.log('');
-  log('핵심 기능 (빈 입력 시 종료):', 'reset');
+  log('🎺 Core features (empty input to finish):', 'reset');
   info.features = [];
   let featureNum = 1;
   while (true) {
@@ -75,68 +83,68 @@ async function collectBriefInfo() {
 }
 
 function generateBriefContent(projectName, info) {
-  // 핵심 기능 포맷팅
+  // Core features formatting
   let featuresContent;
   if (info.features && info.features.length > 0) {
     featuresContent = info.features.map((f, i) => `${i + 1}. ${f}`).join('\n');
   } else {
-    featuresContent = '1. [기능 1]\n2. [기능 2]\n3. [기능 3]';
+    featuresContent = '1. [Feature 1]\n2. [Feature 2]\n3. [Feature 3]';
   }
 
   return `# Project Brief
 
-## 프로젝트 이름
+## Project Name
 ${projectName}
 
-## 한 줄 설명
-${info.description || '[프로젝트를 한 줄로 설명해주세요]'}
+## One-line Description
+${info.description || '[Describe your project in one line]'}
 
-## 문제 정의
-${info.problem || '[해결하려는 문제는 무엇인가요?]'}
+## Problem Definition
+${info.problem || '[What problem are you trying to solve?]'}
 
-## 타겟 사용자
-${info.targetUser || '[주요 사용자는 누구인가요?]'}
+## Target Users
+${info.targetUser || '[Who are the main users?]'}
 
-## 핵심 기능 (초안)
+## Core Features (Draft)
 ${featuresContent}
 
-## 성공 기준
-${info.successCriteria || '[프로젝트가 성공했다고 판단하는 기준은?]'}
+## Success Criteria
+${info.successCriteria || '[What criteria define project success?]'}
 
-## 제약조건
-- 일정: ${info.constraintSchedule || ''}
-- 예산: ${info.constraintBudget || ''}
-- 기술: ${info.constraintTech || ''}
+## Constraints
+- Schedule: ${info.constraintSchedule || ''}
+- Budget: ${info.constraintBudget || ''}
+- Technology: ${info.constraintTech || ''}
 
-## 참고 자료
-- ${info.references || '[URL 또는 문서]'}
+## References
+- ${info.references || '[URL or documents]'}
 `;
 }
 
 async function main() {
   const args = process.argv.slice(2);
 
-  // 도움말 체크 (가장 먼저 처리)
+  // Help check (process first)
   if (args.includes('--help') || args.includes('-h')) {
     console.log(`
-${colors.cyan}claude-symphony${colors.reset} - Multi-AI Orchestration Framework 프로젝트 생성
+${colors.cyan}claude-symphony${colors.reset} - Multi-AI Orchestration Framework project creation
 
-${colors.yellow}사용법:${colors.reset}
+${colors.yellow}Usage:${colors.reset}
   npx claude-symphony <project-name>
-  npx claude-symphony .  (현재 디렉토리에 생성)
+  npx claude-symphony .  (create in current directory)
 
-${colors.yellow}옵션:${colors.reset}
-  --yes, -y    프롬프트 없이 기본값으로 생성
+${colors.yellow}Options:${colors.reset}
+  --yes, -y    Create with defaults (no prompts)
 
-${colors.yellow}예시:${colors.reset}
+${colors.yellow}Examples:${colors.reset}
   npx claude-symphony my-saas-app
   npx claude-symphony my-game
   npx claude-symphony my-project --yes
 
-${colors.yellow}생성 후:${colors.reset}
+${colors.yellow}After creation:${colors.reset}
   1. cd <project-name>
-  2. stages/01-brainstorm/inputs/project_brief.md 작성
-  3. /run-stage 01-brainstorm 실행
+  2. Edit stages/01-brainstorm/inputs/project_brief.md
+  3. Run /run-stage 01-brainstorm
 `);
     process.exit(0);
   }
@@ -144,9 +152,9 @@ ${colors.yellow}생성 후:${colors.reset}
   const skipPrompts = args.includes('--yes') || args.includes('-y');
   const projectName = args.find(arg => !arg.startsWith('-')) || '.';
 
-  // 프로젝트 이름 검증
+  // Project name validation
   if (projectName !== '.' && !/^[a-z0-9-]+$/.test(projectName)) {
-    log('오류: 프로젝트 이름은 영문 소문자, 숫자, 하이픈만 허용됩니다.', 'red');
+    log('Error: Project name must contain only lowercase letters, numbers, and hyphens.', 'red');
     process.exit(1);
   }
 
@@ -154,45 +162,48 @@ ${colors.yellow}생성 후:${colors.reset}
   const targetDir = path.resolve(projectName);
   const actualProjectName = projectName === '.' ? path.basename(targetDir) : projectName;
 
-  // 템플릿 존재 확인
+  // Template existence check
   if (!fs.existsSync(templateDir)) {
-    log(`오류: 템플릿 디렉토리를 찾을 수 없습니다: ${templateDir}`, 'red');
+    log(`Error: Template directory not found: ${templateDir}`, 'red');
     process.exit(1);
   }
 
-  // 대상 디렉토리 확인
+  // Target directory check
   if (projectName !== '.' && fs.existsSync(targetDir)) {
     const files = fs.readdirSync(targetDir);
     if (files.length > 0) {
-      log(`오류: 디렉토리가 비어있지 않습니다: ${targetDir}`, 'red');
+      log(`Error: Directory is not empty: ${targetDir}`, 'red');
       process.exit(1);
     }
   }
 
+  // Display ASCII banner
+  displayAsciiBanner();
+
   console.log('');
   log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'cyan');
-  log(`🎼 claude-symphony 프로젝트 생성: ${actualProjectName}`, 'cyan');
+  log(`🎼 Creating claude-symphony project: ${actualProjectName}`, 'cyan');
   log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'cyan');
   console.log('');
 
-  // 1. 대상 디렉토리 생성
+  // 1. Create target directory
   if (!fs.existsSync(targetDir)) {
     fs.mkdirSync(targetDir, { recursive: true });
   }
-  log(`✓ 프로젝트 디렉토리: ${targetDir}`, 'green');
+  log(`✓ Project directory: ${targetDir}`, 'green');
 
-  // 2. 프로젝트 브리프 정보 수집 (--yes 플래그가 없을 때만)
+  // 2. Collect project brief info (only when --yes flag is not present)
   let briefInfo = {};
   if (!skipPrompts) {
     briefInfo = await collectBriefInfo();
   }
 
-  // 3. 템플릿 복사
-  log('  템플릿 복사 중...', 'blue');
+  // 3. Copy template
+  log('  Copying template...', 'blue');
   copyRecursiveSync(templateDir, targetDir);
-  log('✓ 템플릿 복사 완료', 'green');
+  log('✓ Template copy complete', 'green');
 
-  // 4. progress.json 초기화
+  // 4. Initialize progress.json
   const progressTemplatePath = path.join(targetDir, 'state', 'progress.json.template');
   const progressPath = path.join(targetDir, 'state', 'progress.json');
 
@@ -205,11 +216,11 @@ ${colors.yellow}생성 후:${colors.reset}
       .replace('{{STARTED_AT}}', timestamp);
 
     fs.writeFileSync(progressPath, progressContent);
-    fs.unlinkSync(progressTemplatePath); // 템플릿 파일 삭제
-    log('✓ progress.json 초기화 완료', 'green');
+    fs.unlinkSync(progressTemplatePath); // Delete template file
+    log('✓ progress.json initialized', 'green');
   }
 
-  // 5. project_brief.md 생성
+  // 5. Create project_brief.md
   const briefPath = path.join(targetDir, 'stages', '01-brainstorm', 'inputs', 'project_brief.md');
   const briefDir = path.dirname(briefPath);
 
@@ -219,25 +230,25 @@ ${colors.yellow}생성 후:${colors.reset}
 
   const briefContent = generateBriefContent(actualProjectName, briefInfo);
   fs.writeFileSync(briefPath, briefContent);
-  log('✓ project_brief.md 생성 완료', 'green');
+  log('✓ project_brief.md created', 'green');
 
-  // 6. 완료 메시지
+  // 6. Completion message
   console.log('');
   log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'green');
-  log(`✓ 프로젝트 '${actualProjectName}' 생성 완료!`, 'green');
+  log(`✓ Project '${actualProjectName}' created successfully!`, 'green');
   log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━', 'green');
   console.log('');
-  log('다음 단계:', 'yellow');
+  log('Next steps:', 'yellow');
   if (projectName !== '.') {
     console.log(`  1. cd ${projectName}`);
-    console.log('  2. stages/01-brainstorm/inputs/project_brief.md 작성');
-    console.log('  3. /run-stage 01-brainstorm 실행');
+    console.log('  2. Edit stages/01-brainstorm/inputs/project_brief.md');
+    console.log('  3. Run /run-stage 01-brainstorm');
   } else {
-    console.log('  1. stages/01-brainstorm/inputs/project_brief.md 작성');
-    console.log('  2. /run-stage 01-brainstorm 실행');
+    console.log('  1. Edit stages/01-brainstorm/inputs/project_brief.md');
+    console.log('  2. Run /run-stage 01-brainstorm');
   }
   console.log('');
-  log('파이프라인 스테이지:', 'cyan');
+  log('Pipeline stages:', 'cyan');
   console.log('  01-brainstorm → 02-research → 03-planning → 04-ui-ux');
   console.log('  → 05-task-management → 06-implementation → 07-refactoring');
   console.log('  → 08-qa → 09-testing → 10-deployment');
@@ -245,6 +256,6 @@ ${colors.yellow}생성 후:${colors.reset}
 }
 
 main().catch(err => {
-  log(`오류: ${err.message}`, 'red');
+  log(`Error: ${err.message}`, 'red');
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-symphony",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Multi-AI Orchestration Framework - Create new projects with 10-stage development workflow",
   "type": "module",
   "bin": {

package/template/.claude/commands/benchmark.md

@@ -1,44 +1,44 @@
 # /benchmark - AI Model Benchmarking Command
 
-AI 모델 성능을 비교하고 최적 모델을 선택합니다.
+Compare AI model performance and select the optimal model.
 
-## 사용법
+## Usage
 
 ```bash
 /benchmark [options]
 ```
 
-## 옵션
+## Options
 
-| 옵션 | 설명 | 기본값 |
-|------|------|--------|
-| `--task` | 벤치마크할 태스크 유형 | code_generation |
-| `--models` | 비교할 모델 (쉼표 구분) | claude,codex |
-| `--samples` | 샘플 태스크 수 | 3 |
-| `--metrics` | 측정 메트릭 | correctness,performance |
-| `--verbose` | 상세 출력 | false |
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--task` | Task type to benchmark | code_generation |
+| `--models` | Models to compare (comma-separated) | claude,codex |
+| `--samples` | Number of sample tasks | 3 |
+| `--metrics` | Metrics to measure | correctness,performance |
+| `--verbose` | Verbose output | false |
 
-## 벤치마크 태스크 유형
+## Benchmark Task Types
 
 ### code_generation
 ```bash
 /benchmark --task code_generation --models "claude,codex"
 ```
-- 메트릭: correctness, performance, style_compliance, readability
+- Metrics: correctness, performance, style_compliance, readability
 
 ### refactoring
 ```bash
 /benchmark --task refactoring --models "codex,claude"
 ```
-- 메트릭: complexity_reduction, test_coverage, maintainability
+- Metrics: complexity_reduction, test_coverage, maintainability
 
 ### test_generation
 ```bash
 /benchmark --task test_generation --models "codex,claude"
 ```
-- 메트릭: coverage, edge_cases, quality
+- Metrics: coverage, edge_cases, quality
 
-## 출력 형식
+## Output Format
 
 ```markdown
 # AI Benchmark Results
@@ -61,43 +61,43 @@ AI 모델 성능을 비교하고 최적 모델을 선택합니다.
 | Readability | 0.2 | 0.85 | 0.75 |
 
 ### Recommendation
-현재 태스크에 **Claude** 사용 권장
+**Claude** recommended for this task
 ```
 
-## 예시
+## Examples
 
 ```bash
-# 코드 생성 벤치마크
+# Code generation benchmark
 /benchmark --task code_generation
 
-# 상세 결과 출력
+# Detailed results output
 /benchmark --task refactoring --verbose
 
-# 특정 모델만 비교
+# Compare specific models only
 /benchmark --task test_generation --models "codex"
 ```
 
-## 결과 저장
+## Result Storage
 
-- 결과: `state/ai_benchmarks/`
-- 리포트: `state/ai_benchmarks/reports/`
+- Results: `state/ai_benchmarks/`
+- Reports: `state/ai_benchmarks/reports/`
 
-## 히스토리 조회
+## View History
 
 ```bash
-# 최근 벤치마크 결과 확인
+# Check latest benchmark results
 cat state/ai_benchmarks/latest.json
 
-# 주간 트렌드 확인
+# Check weekly trends
 scripts/ai-benchmark.sh --history weekly
 ```
 
-## 설정
+## Configuration
 
-`config/ai_benchmarking.yaml` 참조
+See `config/ai_benchmarking.yaml`
 
-## 관련 커맨드
+## Related Commands
 
-- `/collaborate` - AI 협업
-- `/gemini` - Gemini 직접 호출
-- `/codex` - Codex 직접 호출
+- `/collaborate` - AI collaboration
+- `/gemini` - Direct Gemini call
+- `/codex` - Direct Codex call

package/template/.claude/commands/brainstorm.md

@@ -1,67 +1,67 @@
 # /brainstorm
 
-01-brainstorm 스테이지를 바로 시작합니다.
+Start the 01-brainstorm stage directly.
 
-## 사용법
+## Usage
 ```
 /brainstorm [topic]
 ```
 
-## 스테이지 정보
+## Stage Information
 
-| 항목 | 값 |
-|------|-----|
-| 스테이지 | 01-brainstorm |
-| AI 모델 | Gemini + ClaudeCode |
-| 실행 모드 | YOLO (Container) |
-| 체크포인트 | 선택 |
+| Item | Value |
+|------|-------|
+| Stage | 01-brainstorm |
+| AI Model | Gemini + ClaudeCode |
+| Execution Mode | YOLO (Container) |
+| Checkpoint | Optional |
 
-## 동작
+## Actions
 
-1. **전제 조건 확인**
-   - 프로젝트 초기화 여부 (progress.json)
+1. **Prerequisite Check**
+   - Project initialization status (progress.json)
 
-2. **스테이지 시작**
-   - Gemini CLI 호출 (창의적 아이디어)
-   - ClaudeCode 병렬 실행 (기술 검토)
+2. **Stage Start**
+   - Gemini CLI call (creative ideas)
+   - ClaudeCode parallel execution (technical review)
 
-3. **산출물 생성**
-   - ideas.md - 브레인스토밍 아이디어
-   - decisions.md - 핵심 결정사항
+3. **Output Generation**
+   - ideas.md - Brainstorming ideas
+   - decisions.md - Key decisions
 
-## 실행
+## Execution
 
 ```bash
-# /run-stage 01과 동일
+# Same as /run-stage 01
 scripts/run-stage.sh 01-brainstorm "$ARGUMENTS"
 ```
 
-## 출력 예시
+## Output Example
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 🧠 Stage 01: Brainstorm
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-AI: Gemini + ClaudeCode (병렬)
+AI: Gemini + ClaudeCode (parallel)
 Mode: YOLO (Container)
 
-주제: $ARGUMENTS
+Topic: $ARGUMENTS
 
-[Gemini] 창의적 아이디어 생성 중...
-[ClaudeCode] 기술 검토 중...
+[Gemini] Generating creative ideas...
+[ClaudeCode] Technical review in progress...
 
-완료 후: /next 또는 /research
+After completion: /next or /research
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ```
 
-## 관련 명령어
+## Related Commands
 
-- `/run-stage 01` - 전제조건 확인 후 시작
-- `/next` - 다음 스테이지 (02-research)
-- `/gemini` - Gemini CLI 직접 호출
+- `/run-stage 01` - Start after prerequisite check
+- `/next` - Next stage (02-research)
+- `/gemini` - Direct Gemini CLI call
 
 ## Tips
 
-- YOLO 모드: 실패해도 괜찮음, 창의성 우선
-- 여러 아이디어를 자유롭게 탐색
-- decisions.md에 최종 선택 기록
+- YOLO mode: Failure is okay, creativity first
+- Freely explore multiple ideas
+- Record final selections in decisions.md