binary-agents 1.0.1 → 1.0.3

package/README.md

@@ -1,10 +1,10 @@
 # Binary Agents
 
-Claude Code 서브에이전트 컬렉션 및 동기화 도구
+Claude Code 서브에이전트 및 슬래시 명령어 컬렉션 + 동기화 도구
 
 ## 소개
 
-`binary-agents`는 Claude Code의 강력한 서브에이전트들을 모아놓은 모노레포입니다. 코드 리뷰, 리팩토링 분석, 주니어 개발자 친화성 체크 등 다양한 서브에이전트와 이를 프로젝트에 쉽게 설치할 수 있는 CLI 도구를 제공합니다.
+`binary-agents`는 Claude Code의 강력한 서브에이전트와 슬래시 명령어를 모아놓은 모노레포입니다. 코드 리뷰, 리팩토링 분석, 주니어 개발자 친화성 체크 등 다양한 서브에이전트와 자동 커밋 등의 슬래시 명령어를 제공하며, 이를 프로젝트에 쉽게 설치할 수 있는 CLI 도구를 포함합니다.
 
 ## 설치
 
@@ -32,39 +32,48 @@ npx binary-agents sync
 
 ## 사용법
 
-### 로컬 프로젝트에 설치 (기본)
+### 기본 동기화
 
-현재 프로젝트의 `.claude/agents/` 디렉토리에 설치:
+현재 프로젝트의 `.claude/` 디렉토리에 agents와 commands 모두 설치:
 
 ```bash
-# 모든 서브에이전트 동기화
 npx binary-agents sync
+```
+
+### 선택적 동기화
+
+```bash
+# 서브에이전트만 동기화
+npx binary-agents sync --agents
+
+# 슬래시 명령어만 동기화
+npx binary-agents sync --commands
 
-# 기본 버전만 (Haiku 모델)
-npx binary-agents sync --basic
+# 기본 서브에이전트만 (Haiku 모델)
+npx binary-agents sync --agents --basic
 
-# 고급 버전만 (Sonnet 모델)
-npx binary-agents sync --advanced
+# 고급 서브에이전트만 (Opus 모델)
+npx binary-agents sync --agents --advanced
 ```
 
 ### 전역 설치
 
-홈 디렉토리의 `~/.claude/agents/`에 설치 (모든 프로젝트에서 사용 가능):
+홈 디렉토리의 `~/.claude/`에 설치 (모든 프로젝트에서 사용 가능):
 
 ```bash
-# 전역으로 모든 서브에이전트 설치
+# 전역으로 모두 설치
 npx binary-agents sync --global
 # 또는
 npx binary-agents sync -g
 
-# 전역 + 기본 버전만
-npx binary-agents sync --global --basic
+# 전역 + 서브에이전트만
+npx binary-agents sync -g --agents
 
-# 전역 + 고급 버전만
-npx binary-agents sync --global --advanced
+# 전역 + 슬래시 명령어만
+npx binary-agents sync -g --commands
 ```
 
-### 사용 가능한 서브에이전트 목록 보기
+### 목록 보기
 
 ```bash
 npx binary-agents list
@@ -73,14 +82,43 @@ npx binary-agents list
 ## 서브에이전트 종류
 
 ### 기본 버전 (Haiku 모델)
-- `code-reviewer.md` - 코드 리뷰어
-- `refactor-analyzer.md` - 리팩토링 분석기
-- `junior-friendly-checker.md` - 주니어 친화성 체커
+| 이름 | 설명 |
+|------|------|
+| `code-reviewer` | 코드 리뷰어 |
+| `refactor-analyzer` | 리팩토링 분석기 |
+| `junior-friendly-checker` | 주니어 친화성 체커 |
+
+### 고급 버전 (Opus 모델)
+| 이름 | 설명 |
+|------|------|
+| `advanced-code-reviewer` | 고급 코드 리뷰어 (웹 검색 포함) |
+| `advanced-refactor-analyzer` | 고급 리팩토링 분석기 (웹 검색 포함) |
+| `advanced-junior-checker` | 고급 주니어 친화성 체커 (웹 검색 포함) |
+| `react-performance-optimizer` | React 성능 최적화 |
+| `toss-cohesion-analyzer` | Toss 팀 원칙 기반 응집도 분석기 |
+| `subagent-builder` | 커스텀 서브에이전트 빌더 |
+
+## 슬래시 명령어
+
+| 명령어 | 설명 |
+|--------|------|
+| `/commit` | git log 분석 후 컨벤션에 맞는 커밋 메시지 자동 생성 및 커밋 |
+
+### /commit 사용법
+
+```bash
+# 1. 변경 사항 스테이징
+git add .
+
+# 2. Claude Code에서 /commit 실행
+/commit
+```
 
-### 고급 버전 (Sonnet 모델)
-- `advanced-code-reviewer.md` - 고급 코드 리뷰어
-- `advanced-refactor-analyzer.md` - 고급 리팩토링 분석기
-- `advanced-junior-checker.md` - 고급 주니어 친화성 체커
+Claude가 자동으로:
+1. 최근 커밋 로그에서 컨벤션 분석
+2. staged changes 확인
+3. 컨벤션에 맞는 커밋 메시지 생성
+4. 커밋 실행
 
 ## 저장소 구조
 
@@ -93,7 +131,11 @@ binary-agents/
 │   ├── advanced-refactor-analyzer.md
 │   ├── junior-friendly-checker.md
 │   ├── advanced-junior-checker.md
+│   ├── toss-cohesion-analyzer.md
+│   ├── react-performance-optimizer.md
 │   └── subagent-builder.md
+├── commands/            # 슬래시 명령어 MD 파일들
+│   └── commit.md
 ├── bin/                 # CLI 실행 파일
 ├── src/                 # CLI 소스 코드
 ├── docs/                # 문서
@@ -105,9 +147,9 @@ binary-agents/
 
 ## 작동 원리
 
-1. 로컬 `agents/` 디렉토리에서 서브에이전트 파일 목록 읽기
+1. 로컬 `agents/`, `commands/` 디렉토리에서 파일 목록 읽기
 2. YAML frontmatter 검증
-3. 사용자 프로젝트의 `.claude/agents/` 디렉토리로 복사
+3. 사용자 프로젝트의 `.claude/agents/`, `.claude/commands/` 디렉토리로 복사
 
 ## 요구사항
 
@@ -121,23 +163,24 @@ MIT
 
 이슈 및 PR을 환영합니다!
 
-## 서브에이전트 직접 사용하기
+## 직접 사용하기
 
-NPM 패키지를 설치하지 않고 이 저장소의 서브에이전트를 직접 사용할 수도 있습니다:
+NPM 패키지를 설치하지 않고 이 저장소의 파일을 직접 사용할 수도 있습니다:
 
-1. 저장소 클론:
-   ```bash
-   git clone https://github.com/01-binary/binary-agents.git
-   ```
+```bash
+# 저장소 클론
+git clone https://github.com/01-binary/binary-agents.git
+
+# 서브에이전트 복사
+cp binary-agents/agents/*.md your-project/.claude/agents/
 
-2. 원하는 서브에이전트 파일을 프로젝트의 `.claude/agents/` 디렉토리로 복사:
-   ```bash
-   cp binary-agents/agents/*.md your-project/.claude/agents/
-   ```
+# 슬래시 명령어 복사
+cp binary-agents/commands/*.md your-project/.claude/commands/
+```
 
 ## 관련 링크
 
-- [Claude Code Documentation](https://docs.claude.com/en/docs/claude-code)
+- [Claude Code Documentation](https://docs.anthropic.com/en/docs/claude-code)
 - [서브에이전트 상세 가이드](docs/SUBAGENTS.md)
 - [Basic vs Advanced 비교](docs/COMPARISON.md)
 - [커스텀 서브에이전트 제작](docs/BUILDER_GUIDE.md)

package/agents/advanced-code-reviewer.md

@@ -1,8 +1,8 @@
 ---
 name: advanced-code-reviewer
-description: Deep code analysis with architectural insights and web-based best practices research. Uses Sonnet for superior reasoning and WebFetch/WebSearch for up-to-date patterns and recommendations.
+description: Deep code analysis with architectural insights and web-based best practices research. Uses Opus for superior reasoning and WebFetch/WebSearch for up-to-date patterns and recommendations.
 tools: Read, Glob, Grep, WebFetch, WebSearch
-model: sonnet
+model: opus
 ---
 
 # Advanced Code Quality Reviewer

package/agents/advanced-junior-checker.md

@@ -1,8 +1,8 @@
 ---
 name: advanced-junior-checker
-description: Evaluates code readability from a junior developer perspective with research-backed recommendations. Uses Sonnet for empathetic analysis and web tools to find learning resources and onboarding best practices.
+description: Evaluates code readability from a junior developer perspective with research-backed recommendations. Uses Opus for empathetic analysis and web tools to find learning resources and onboarding best practices.
 tools: Read, Glob, Grep, WebFetch, WebSearch
-model: sonnet
+model: opus
 ---
 
 # Advanced Junior Developer Readability Checker

package/agents/advanced-refactor-analyzer.md

@@ -1,8 +1,8 @@
 ---
 name: advanced-refactor-analyzer
-description: Deep refactoring analysis with industry pattern research and architectural recommendations. Uses Sonnet for sophisticated reasoning and web tools to compare against modern refactoring strategies and design patterns.
+description: Deep refactoring analysis with industry pattern research and architectural recommendations. Uses Opus for sophisticated reasoning and web tools to compare against modern refactoring strategies and design patterns.
 tools: Read, Glob, Grep, WebFetch, WebSearch
-model: sonnet
+model: opus
 ---
 
 # Advanced Refactoring Opportunity Analyzer

package/agents/react-performance-optimizer.md

@@ -2,7 +2,7 @@
 name: react-performance-optimizer
 description: Analyzes React applications for performance bottlenecks including re-render optimization, context splitting, hook dependencies, memoization opportunities, and React 19+ patterns. Provides measurable performance improvement recommendations.
 tools: Read, Glob, Grep, WebFetch, WebSearch
-model: sonnet
+model: opus
 ---
 
 # React Performance Optimizer

package/agents/subagent-builder.md

@@ -2,7 +2,7 @@
 name: subagent-builder
 description: Creates, modifies, and customizes Claude subagents based on user requirements. Analyzes existing subagents, generates new ones, and adapts them for specific project needs.
 tools: Read, Glob, Grep, Write, Edit, WebFetch, WebSearch
-model: sonnet
+model: opus
 ---
 
 # Subagent Builder & Manager

package/agents/toss-cohesion-analyzer.md

@@ -2,7 +2,7 @@
 name: toss-cohesion-analyzer
 description: Analyzes React/TypeScript code using Toss team's cohesion and coupling principles. Evaluates code organization, readability patterns, context switching, consistency, and practical duplication strategies based on Toss frontend fundamentals.
 tools: Read, Glob, Grep
-model: haiku
+model: opus
 ---
 
 # Toss Cohesion & Coupling Analyzer

package/bin/cli.js

@@ -13,10 +13,12 @@ program
 
 program
   .command('sync')
-  .description('Sync subagent files to .claude/agents/ (local) or ~/.claude/agents (global)')
+  .description('Sync agents and commands to .claude/ (local) or ~/.claude/ (global)')
   .option('--basic', 'Sync only basic (Haiku) subagents')
-  .option('--advanced', 'Sync only advanced (Sonnet) subagents')
-  .option('-g, --global', 'Install to ~/.claude/agents instead of current directory')
+  .option('--advanced', 'Sync only advanced (Opus) subagents')
+  .option('-g, --global', 'Install to ~/.claude/ instead of current directory')
+  .option('--agents', 'Sync only agents (subagents)')
+  .option('--commands', 'Sync only commands (slash commands)')
   .action(async (options) => {
     let filter = null;
 
@@ -26,9 +28,15 @@ program
       filter = 'advanced';
     }
 
+    // --agents 또는 --commands가 명시되지 않으면 둘 다 동기화
+    const syncAgents = options.agents || (!options.agents && !options.commands);
+    const syncCommands = options.commands || (!options.agents && !options.commands);
+
     const result = await syncSubagents({
       filter,
-      global: options.global || false
+      global: options.global || false,
+      agents: syncAgents,
+      commands: syncCommands
     });
 
     if (!result.success) {
@@ -38,7 +46,7 @@ program
 
 program
   .command('list')
-  .description('List available subagents')
+  .description('List available agents and commands')
   .action(async () => {
     await listSubagents();
   });

package/commands/commit.md

@@ -0,0 +1,53 @@
+---
+description: Analyze staged changes and recent commits to generate a conventional commit
+allowed-tools: Bash(git status:*), Bash(git diff:*), Bash(git log:*), Bash(git commit:*)
+---
+
+# Auto Commit Generator
+
+You are a commit message generator that analyzes the project's commit conventions and staged changes to create appropriate commit messages.
+
+## Context Information
+
+**Recent commit history (for convention analysis):**
+!`git log --oneline -20`
+
+**Staged changes summary:**
+!`git diff --cached --stat`
+
+**Staged changes detail:**
+!`git diff --cached`
+
+**Unstaged files (for reference):**
+!`git status --short`
+
+## Your Task
+
+1. **Analyze the commit convention** from the recent commit history above
+   - Identify the pattern (e.g., `type: message`, `type(scope): message`, `[type] message`, emoji usage, etc.)
+   - Note the language used (English/Korean/etc.)
+   - Observe the message style (imperative, past tense, etc.)
+
+2. **Understand the staged changes**
+   - What files were modified/added/deleted?
+   - What is the main purpose of these changes?
+   - Are there multiple logical changes that should be separate commits?
+
+3. **Generate the commit message**
+   - Follow the detected convention exactly
+   - Keep the subject line concise (50 chars recommended, 72 max)
+   - If the changes are complex, suggest a body with bullet points
+
+4. **Execute the commit**
+   - Run `git commit -m "message"` with the generated message
+   - If a body is needed, use the multi-line format
+
+## Output Format
+
+First, briefly explain:
+- Detected convention pattern
+- Summary of changes
+
+Then execute the commit command directly.
+
+If there are no staged changes, inform the user and suggest using `git add` first.

package/docs/COMPARISON.md

@@ -4,8 +4,8 @@
 
 | 항목 | 기본 버전 (Basic) | 고급 버전 (Advanced) |
 |------|------------------|---------------------|
-| **모델** | Haiku | Sonnet |
-| **토큰 비용** | ~$0.25 per 1M input | ~$3.00 per 1M input |
+| **모델** | Haiku | Opus |
+| **토큰 비용** | ~$0.25 per 1M input | ~$15.00 per 1M input |
 | **추론 능력** | 패턴 매칭, 규칙 기반 | 심층 추론, 컨텍스트 이해 |
 | **도구** | Read, Glob, Grep | Read, Glob, Grep, WebFetch, WebSearch |
 | **실행 시간** | 5-10분 | 15-20분 |
@@ -60,7 +60,7 @@ tools: Read, Glob, Grep
 
 ```yaml
 name: advanced-code-reviewer
-model: sonnet
+model: opus
 tools: Read, Glob, Grep, WebFetch, WebSearch
 ```
 
@@ -185,7 +185,7 @@ export function validateEmail(email: string): boolean {
 
 ```yaml
 name: advanced-refactor-analyzer
-model: sonnet
+model: opus
 tools: Read, Glob, Grep, WebFetch, WebSearch
 ```
 
@@ -353,7 +353,7 @@ tools: Read, Glob, Grep
 
 ```yaml
 name: advanced-junior-checker
-model: sonnet
+model: opus
 tools: Read, Glob, Grep, WebFetch, WebSearch
 ```
 
@@ -567,7 +567,7 @@ Claude는 **파일 이름**으로 서브에이전트를 선택합니다.
 ```
 "advanced-code-reviewer를 사용해서 최신 베스트 프랙티스와 비교해줘"
 ```
-→ `advanced-code-reviewer.md`가 실행됨 (Sonnet, 웹 리서치)
+→ `advanced-code-reviewer.md`가 실행됨 (Opus, 웹 리서치)
 
 #### 3. 암묵적 사용 (추천!)
 상황에 맞게 요청하면 Claude가 적절한 에이전트 선택:
@@ -584,7 +584,7 @@ Claude는 **파일 이름**으로 서브에이전트를 선택합니다.
 최신 문서와 비교해서 분석하고, 부족한 부분에 대한
 학습 자료도 찾아줘"
 ```
-→ Claude가 `advanced-code-reviewer` 선택 (Sonnet + 웹)
+→ Claude가 `advanced-code-reviewer` 선택 (Opus + 웹)
 
 ---
 
@@ -659,7 +659,7 @@ Claude: [advanced-junior-checker 사용]
 - 업계 표준 궁금
 - 왜 문제인지 깊은 이해 필요
 
-### 고급 버전 (Sonnet) 사용
+### 고급 버전 (Opus) 사용
 ✅ **이럴 때 사용:**
 - 아키텍처 리뷰
 - 최신 2025 패턴 확인

package/docs/SUBAGENTS.md

@@ -8,7 +8,7 @@ React/TypeScript 코드베이스 분석을 위한 Claude 서브에이전트 모
 
 | 특징 | 기본 버전 | 고급 버전 |
 |------|----------|----------|
-| **모델** | Haiku (빠름, 저렴) | Sonnet (강력, 심층 분석) |
+| **모델** | Haiku (빠름, 저렴) | Opus (최강, 심층 분석) |
 | **도구** | Read, Glob, Grep | Read, Glob, Grep, WebFetch, WebSearch |
 | **속도** | ⚡⚡⚡ 매우 빠름 | ⚡⚡ 빠름 |
 | **비용** | 💰 저렴 | 💰💰 보통 |
@@ -24,7 +24,7 @@ React/TypeScript 코드베이스 분석을 위한 Claude 서브에이전트 모
 
 #### [subagent-builder.md](subagent-builder.md) - 메타 에이전트 ⭐⭐⭐
 ```yaml
-모델: sonnet
+모델: opus
 도구: Read, Glob, Grep, Write, Edit, WebFetch, WebSearch
 설명: 서브에이전트를 생성, 수정, 커스터마이징하는 메타 에이전트
 ```
@@ -81,7 +81,7 @@ React/TypeScript 코드베이스 분석을 위한 Claude 서브에이전트 모
 
 #### [toss-cohesion-analyzer.md](../agents/toss-cohesion-analyzer.md) - Toss 원칙 특화 ⭐⭐⭐
 ```yaml
-모델: haiku
+모델: opus
 도구: Read, Glob, Grep
 설명: 토스 팀의 16가지 코드 품질 원칙을 기반으로 응집도, 결합도, 가독성 분석
 ```
@@ -142,7 +142,52 @@ React/TypeScript 코드베이스 분석을 위한 Claude 서브에이전트 모
 
 ---
 
-### 2. Code Quality Reviewers (코드 품질 리뷰어)
+### 2. React Performance Optimizer (React 성능 최적화) 🆕 **SPECIAL**
+
+#### [react-performance-optimizer.md](../agents/react-performance-optimizer.md) - 성능 분석 특화 ⭐⭐⭐
+```yaml
+모델: opus
+도구: Read, Glob, Grep, WebFetch, WebSearch
+설명: React 앱의 성능 병목점 분석 - 리렌더 최적화, 컨텍스트 분할, 훅 의존성, 메모이제이션, React 19+ 패턴
+```
+
+**주요 기능:**
+- 🔄 리렌더 최적화 (React.memo, useMemo, useCallback)
+- 📦 컨텍스트 최적화 (State/Dispatch/Config 분리 패턴)
+- 🎣 훅 의존성 검증 (stale closure, ESLint disable 탐지)
+- ⚡ 모던 React 패턴 (useSyncExternalStore, useTransition)
+- 📊 번들 사이즈 & 코드 스플리팅 분석
+
+**평가 항목 (5개):**
+- 🔄 Re-render Optimization (30%)
+- 📦 Context Optimization (25%)
+- 🎣 Hook Dependencies (20%)
+- ⚡ Modern React Patterns (15%)
+- 📊 Bundle Size (10%)
+
+**언제 사용하나요?**
+- ✅ React 앱이 느리게 느껴질 때
+- ✅ 불필요한 리렌더를 줄이고 싶을 때
+- ✅ Context 구조를 최적화하고 싶을 때
+- ✅ React 19+ 최신 패턴을 적용하고 싶을 때
+
+**사용 예시:**
+```bash
+"react-performance-optimizer로 이 프로젝트 분석해줘"
+"리렌더가 너무 많이 발생하는 것 같아"
+"Context 구조를 최적화하고 싶어"
+```
+
+**출력물:**
+- 📊 Performance Score (100점 만점)
+- 🔥 High Priority (Quick Wins)
+- ⚠️ Medium Priority
+- 📈 Impact Metrics (렌더 횟수 감소율)
+- 🛣️ Implementation Roadmap
+
+---
+
+### 4. Code Quality Reviewers (코드 품질 리뷰어)
 
 #### [code-reviewer.md](code-reviewer.md) - 기본 버전
 ```yaml
@@ -167,7 +212,7 @@ React/TypeScript 코드베이스 분석을 위한 Claude 서브에이전트 모
 
 #### [advanced-code-reviewer.md](advanced-code-reviewer.md) - 고급 버전 ⭐
 ```yaml
-모델: sonnet
+모델: opus
 도구: Read, Glob, Grep, WebFetch, WebSearch
 설명: 심층 아키텍처 분석 + 웹 기반 베스트 프랙티스 리서치
 ```
@@ -195,7 +240,7 @@ React/TypeScript 코드베이스 분석을 위한 Claude 서브에이전트 모
 
 ---
 
-### 3. Refactoring Analyzers (리팩토링 분석기)
+### 5. Refactoring Analyzers (리팩토링 분석기)
 
 #### [refactor-analyzer.md](refactor-analyzer.md) - 기본 버전
 ```yaml
@@ -220,7 +265,7 @@ React/TypeScript 코드베이스 분석을 위한 Claude 서브에이전트 모
 
 #### [advanced-refactor-analyzer.md](advanced-refactor-analyzer.md) - 고급 버전 ⭐
 ```yaml
-모델: sonnet
+모델: opus
 도구: Read, Glob, Grep, WebFetch, WebSearch
 설명: 심층 리팩토링 분석 + 업계 패턴 리서치 + 아키텍처 권장사항
 ```
@@ -254,7 +299,7 @@ React/TypeScript 코드베이스 분석을 위한 Claude 서브에이전트 모
 
 ---
 
-### 4. Junior Developer Readability Checkers (주니어 친화성 검사기)
+### 6. Junior Developer Readability Checkers (주니어 친화성 검사기)
 
 #### [junior-friendly-checker.md](junior-friendly-checker.md) - 기본 버전
 ```yaml
@@ -284,7 +329,7 @@ React/TypeScript 코드베이스 분석을 위한 Claude 서브에이전트 모
 
 #### [advanced-junior-checker.md](advanced-junior-checker.md) - 고급 버전 ⭐
 ```yaml
-모델: sonnet
+모델: opus
 도구: Read, Glob, Grep, WebFetch, WebSearch
 설명: 리서치 기반 권장사항 + 학습 리소스 큐레이션
 ```
@@ -327,7 +372,7 @@ React/TypeScript 코드베이스 분석을 위한 Claude 서브에이전트 모
 - ✅ 명확한 패턴 기반 분석
 - ✅ CI/CD 파이프라인 자동화
 
-### 고급 버전 (Sonnet) 선택
+### 고급 버전 (Opus) 선택
 - ⭐ 아키텍처 리뷰가 필요할 때
 - ⭐ 최신 베스트 프랙티스 확인
 - ⭐ 학습 리소스가 필요할 때
@@ -351,7 +396,7 @@ Claude는 **명시적으로 요청**해야 해당 서브에이전트를 실행
 → code-reviewer.md 실행 (Haiku, 빠름)
 
 "advanced-code-reviewer를 사용해서 최신 패턴과 비교해줘"
-→ advanced-code-reviewer.md 실행 (Sonnet, 웹 리서치)
+→ advanced-code-reviewer.md 실행 (Opus, 웹 리서치)
 ```
 
 #### 방법 2: 상황 설명 (추천)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "binary-agents",
-  "version": "1.0.1",
-  "description": "Claude Code subagents collection with sync CLI tool",
+  "version": "1.0.3",
+  "description": "Claude Code subagents and slash commands collection with sync CLI tool",
   "type": "module",
   "main": "src/sync.js",
   "bin": {
@@ -16,6 +16,7 @@
     "claude",
     "claude-code",
     "subagents",
+    "slash-commands",
     "sync",
     "cli",
     "code-review",
@@ -29,6 +30,7 @@
   },
   "files": [
     "agents",
+    "commands",
     "bin",
     "src",
     "docs",

package/src/sync.js

@@ -7,8 +7,9 @@ import ora from 'ora';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// 모노레포의 agents 디렉토리 경로
+// 모노레포의 agents, commands 디렉토리 경로
 const REPO_AGENTS_DIR = path.join(__dirname, '..', 'agents');
+const REPO_COMMANDS_DIR = path.join(__dirname, '..', 'commands');
 
 /**
  * 로컬 agents 디렉토리에서 서브에이전트 파일 목록 가져오기
@@ -29,6 +30,22 @@ async function fetchSubagentFiles() {
   }
 }
 
+/**
+ * 로컬 commands 디렉토리에서 슬래시 명령어 파일 목록 가져오기
+ */
+async function fetchCommandFiles() {
+  try {
+    const files = await fs.readdir(REPO_COMMANDS_DIR);
+
+    // .md 파일만 필터링
+    const commandFiles = files.filter(file => file.endsWith('.md'));
+
+    return commandFiles;
+  } catch (error) {
+    throw new Error(`Failed to read commands directory: ${error.message}`);
+  }
+}
+
 /**
  * YAML frontmatter가 있는지 검증
  */
@@ -38,7 +55,7 @@ function validateYamlFrontmatter(content) {
 }
 
 /**
- * 로컬에서 파일 읽기
+ * 로컬에서 에이전트 파일 읽기
  */
 async function readAgentFile(filename) {
   const filePath = path.join(REPO_AGENTS_DIR, filename);
@@ -53,28 +70,44 @@ async function readAgentFile(filename) {
 }
 
 /**
- * .claude/agents 디렉토리 생성
- * @param {boolean} isGlobal - true면 ~/.claude/agents, false면 현재 디렉토리의 .claude/agents
+ * 로컬에서 커맨드 파일 읽기
  */
-async function ensureAgentsDirectory(isGlobal = false) {
-  let agentsDir;
+async function readCommandFile(filename) {
+  const filePath = path.join(REPO_COMMANDS_DIR, filename);
+  const content = await fs.readFile(filePath, 'utf-8');
+
+  // YAML frontmatter 검증
+  if (!validateYamlFrontmatter(content)) {
+    throw new Error(`Invalid YAML frontmatter in ${filename}`);
+  }
+
+  return content;
+}
+
+/**
+ * .claude 하위 디렉토리 생성
+ * @param {string} subdir - 하위 디렉토리 이름 ('agents' 또는 'commands')
+ * @param {boolean} isGlobal - true면 ~/.claude/{subdir}, false면 현재 디렉토리의 .claude/{subdir}
+ */
+async function ensureClaudeDirectory(subdir, isGlobal = false) {
+  let targetDir;
 
   if (isGlobal) {
-    // 전역 설치: ~/.claude/agents
+    // 전역 설치: ~/.claude/{subdir}
     const homeDir = process.env.HOME || process.env.USERPROFILE;
-    agentsDir = path.join(homeDir, '.claude', 'agents');
+    targetDir = path.join(homeDir, '.claude', subdir);
   } else {
-    // 로컬 설치: 현재 디렉토리의 .claude/agents
-    agentsDir = path.join(process.cwd(), '.claude', 'agents');
+    // 로컬 설치: 현재 디렉토리의 .claude/{subdir}
+    targetDir = path.join(process.cwd(), '.claude', subdir);
   }
 
   try {
-    await fs.access(agentsDir);
+    await fs.access(targetDir);
   } catch {
-    await fs.mkdir(agentsDir, { recursive: true });
+    await fs.mkdir(targetDir, { recursive: true });
   }
 
-  return agentsDir;
+  return targetDir;
 }
 
 /**
@@ -87,19 +120,15 @@ async function saveFile(agentsDir, filename, content) {
 }
 
 /**
- * 서브에이전트 동기화 메인 함수
+ * 서브에이전트 동기화
  */
-export async function syncSubagents(options = {}) {
-  const { filter = null, global = false } = options;
+async function syncAgentsOnly(options = {}) {
+  const { filter = null, global: isGlobal = false } = options;
 
-  console.log(chalk.blue.bold('\n🤖 Binary Agents Sync\n'));
-
-  if (global) {
-    console.log(chalk.cyan('📍 Global mode: Installing to ~/.claude/agents\n'));
-  }
+  console.log(chalk.yellow.bold('\n📦 Syncing Agents...\n'));
 
   // 로컬 agents 디렉토리에서 파일 목록 가져오기
-  const fetchSpinner = ora('Reading subagent files from local repository...').start();
+  const fetchSpinner = ora('Reading subagent files...').start();
   let allFiles;
 
   try {
@@ -107,7 +136,7 @@ export async function syncSubagents(options = {}) {
     fetchSpinner.succeed(chalk.green(`Found ${allFiles.length} subagent files`));
   } catch (error) {
     fetchSpinner.fail(chalk.red(`Failed to read file list: ${error.message}`));
-    return { success: false, error: error.message };
+    return { success: false, error: error.message, type: 'agents' };
   }
 
   // 필터링된 파일 목록
@@ -122,17 +151,17 @@ export async function syncSubagents(options = {}) {
   }
 
   // .claude/agents 디렉토리 생성
-  const dirMessage = global ? 'Creating ~/.claude/agents directory...' : 'Creating .claude/agents directory...';
+  const dirMessage = isGlobal ? 'Creating ~/.claude/agents directory...' : 'Creating .claude/agents directory...';
   const dirSpinner = ora(dirMessage).start();
   let agentsDir;
 
   try {
-    agentsDir = await ensureAgentsDirectory(global);
-    const successMessage = global ? 'Created ~/.claude/agents directory' : 'Created .claude/agents directory';
+    agentsDir = await ensureClaudeDirectory('agents', isGlobal);
+    const successMessage = isGlobal ? 'Created ~/.claude/agents directory' : 'Created .claude/agents directory';
     dirSpinner.succeed(chalk.green(successMessage));
   } catch (error) {
     dirSpinner.fail(chalk.red(`Failed to create directory: ${error.message}`));
-    return { success: false, error: error.message };
+    return { success: false, error: error.message, type: 'agents' };
   }
 
   // 각 파일 복사
@@ -145,12 +174,71 @@ export async function syncSubagents(options = {}) {
     const fileSpinner = ora(`Copying ${filename}...`).start();
 
     try {
-      // 로컬 파일 읽기
       const content = await readAgentFile(filename);
+      await saveFile(agentsDir, filename, content);
+      fileSpinner.succeed(chalk.green(`✓ ${filename}`));
+      results.success.push(filename);
+    } catch (error) {
+      fileSpinner.fail(chalk.red(`✗ ${filename}: ${error.message}`));
+      results.failed.push({ filename, error: error.message });
+    }
+  }
+
+  return {
+    success: results.failed.length === 0,
+    results,
+    type: 'agents',
+    dir: agentsDir,
+    total: filesToSync.length
+  };
+}
+
+/**
+ * 슬래시 명령어 동기화
+ */
+async function syncCommandsOnly(options = {}) {
+  const { global: isGlobal = false } = options;
+
+  console.log(chalk.yellow.bold('\n⚡ Syncing Commands...\n'));
+
+  // 로컬 commands 디렉토리에서 파일 목록 가져오기
+  const fetchSpinner = ora('Reading command files...').start();
+  let allFiles;
+
+  try {
+    allFiles = await fetchCommandFiles();
+    fetchSpinner.succeed(chalk.green(`Found ${allFiles.length} command files`));
+  } catch (error) {
+    fetchSpinner.fail(chalk.red(`Failed to read file list: ${error.message}`));
+    return { success: false, error: error.message, type: 'commands' };
+  }
 
-      // 저장
-      const filePath = await saveFile(agentsDir, filename, content);
+  // .claude/commands 디렉토리 생성
+  const dirMessage = isGlobal ? 'Creating ~/.claude/commands directory...' : 'Creating .claude/commands directory...';
+  const dirSpinner = ora(dirMessage).start();
+  let commandsDir;
+
+  try {
+    commandsDir = await ensureClaudeDirectory('commands', isGlobal);
+    const successMessage = isGlobal ? 'Created ~/.claude/commands directory' : 'Created .claude/commands directory';
+    dirSpinner.succeed(chalk.green(successMessage));
+  } catch (error) {
+    dirSpinner.fail(chalk.red(`Failed to create directory: ${error.message}`));
+    return { success: false, error: error.message, type: 'commands' };
+  }
 
+  // 각 파일 복사
+  const results = {
+    success: [],
+    failed: []
+  };
+
+  for (const filename of allFiles) {
+    const fileSpinner = ora(`Copying ${filename}...`).start();
+
+    try {
+      const content = await readCommandFile(filename);
+      await saveFile(commandsDir, filename, content);
       fileSpinner.succeed(chalk.green(`✓ ${filename}`));
       results.success.push(filename);
     } catch (error) {
@@ -159,49 +247,108 @@ export async function syncSubagents(options = {}) {
     }
   }
 
+  return {
+    success: results.failed.length === 0,
+    results,
+    type: 'commands',
+    dir: commandsDir,
+    total: allFiles.length
+  };
+}
+
+/**
+ * 메인 동기화 함수
+ */
+export async function syncSubagents(options = {}) {
+  const { filter = null, global: isGlobal = false, agents = true, commands = true } = options;
+
+  console.log(chalk.blue.bold('\n🤖 Binary Agents Sync\n'));
+
+  if (isGlobal) {
+    console.log(chalk.cyan('📍 Global mode: Installing to ~/.claude/\n'));
+  }
+
+  const syncResults = [];
+
+  // Agents 동기화
+  if (agents) {
+    const agentResult = await syncAgentsOnly({ filter, global: isGlobal });
+    syncResults.push(agentResult);
+  }
+
+  // Commands 동기화
+  if (commands) {
+    const commandResult = await syncCommandsOnly({ global: isGlobal });
+    syncResults.push(commandResult);
+  }
+
   // 결과 요약
   console.log(chalk.blue.bold('\n📊 Sync Summary\n'));
-  console.log(chalk.green(`✓ Successful: ${results.success.length}/${filesToSync.length}`));
 
-  if (results.failed.length > 0) {
-    console.log(chalk.red(`✗ Failed: ${results.failed.length}/${filesToSync.length}`));
-    console.log(chalk.red('\nFailed files:'));
-    results.failed.forEach(({ filename, error }) => {
-      console.log(chalk.red(`  - ${filename}: ${error}`));
-    });
+  for (const result of syncResults) {
+    if (result.error) {
+      console.log(chalk.red(`✗ ${result.type}: Failed - ${result.error}`));
+    } else {
+      const icon = result.type === 'agents' ? '🤖' : '⚡';
+      console.log(chalk.green(`${icon} ${result.type}: ${result.results.success.length}/${result.total} successful`));
+
+      if (result.results.failed.length > 0) {
+        console.log(chalk.red(`   Failed files:`));
+        result.results.failed.forEach(({ filename, error }) => {
+          console.log(chalk.red(`     - ${filename}: ${error}`));
+        });
+      }
+
+      console.log(chalk.cyan(`   📁 Location: ${result.dir}`));
+    }
   }
 
-  console.log(chalk.cyan(`\n📁 Location: ${agentsDir}\n`));
+  console.log('');
 
+  const allSuccess = syncResults.every(r => r.success);
   return {
-    success: results.failed.length === 0,
-    results
+    success: allSuccess,
+    results: syncResults
   };
 }
 
 /**
- * 사용 가능한 서브에이전트 목록 표시
+ * 사용 가능한 서브에이전트 및 명령어 목록 표시
  */
 export async function listSubagents() {
-  console.log(chalk.blue.bold('\n🤖 Available Subagents\n'));
+  console.log(chalk.blue.bold('\n🤖 Binary Agents - Available Items\n'));
 
-  const spinner = ora('Reading subagent files from local repository...').start();
+  // Agents 목록
+  const agentSpinner = ora('Reading subagent files...').start();
 
   try {
-    const files = await fetchSubagentFiles();
-    spinner.succeed(chalk.green('Found subagent files'));
+    const agentFiles = await fetchSubagentFiles();
+    agentSpinner.succeed(chalk.green(`Found ${agentFiles.length} subagent files`));
 
-    const basic = files.filter(f => !f.startsWith('advanced-'));
-    const advanced = files.filter(f => f.startsWith('advanced-'));
+    const basic = agentFiles.filter(f => !f.startsWith('advanced-'));
+    const advanced = agentFiles.filter(f => f.startsWith('advanced-'));
 
-    console.log(chalk.yellow('\nBasic (Haiku model):'));
-    basic.forEach(f => console.log(chalk.white(`  • ${f}`)));
+    console.log(chalk.yellow('\n📦 Agents - Basic (Haiku model):'));
+    basic.forEach(f => console.log(chalk.white(`  • ${f.replace('.md', '')}`)));
 
-    console.log(chalk.yellow('\nAdvanced (Sonnet model):'));
-    advanced.forEach(f => console.log(chalk.white(`  • ${f}`)));
+    console.log(chalk.yellow('\n📦 Agents - Advanced (Opus model):'));
+    advanced.forEach(f => console.log(chalk.white(`  • ${f.replace('.md', '')}`)));
+  } catch (error) {
+    agentSpinner.fail(chalk.red(`Failed to read agents: ${error.message}`));
+  }
+
+  // Commands 목록
+  const commandSpinner = ora('Reading command files...').start();
 
-    console.log(chalk.cyan(`\nTotal: ${files.length} subagents\n`));
+  try {
+    const commandFiles = await fetchCommandFiles();
+    commandSpinner.succeed(chalk.green(`Found ${commandFiles.length} command files`));
+
+    console.log(chalk.yellow('\n⚡ Commands (Slash commands):'));
+    commandFiles.forEach(f => console.log(chalk.white(`  • /${f.replace('.md', '')}`)));
   } catch (error) {
-    spinner.fail(chalk.red(`Failed to read file list: ${error.message}`));
+    commandSpinner.fail(chalk.red(`Failed to read commands: ${error.message}`));
   }
+
+  console.log('');
 }