binary-agents 1.0.2 → 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
 
-# 기본 버전만 (Haiku 모델)
-npx binary-agents sync --basic
+# 슬래시 명령어만 동기화
+npx binary-agents sync --commands
 
-# 고급 버전만 (Sonnet 모델)
-npx binary-agents sync --advanced
+# 기본 서브에이전트만 (Haiku 모델)
+npx binary-agents sync --agents --basic
+
+# 고급 서브에이전트만 (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,17 +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.md` - 고급 코드 리뷰어
-- `advanced-refactor-analyzer.md` - 고급 리팩토링 분석기
-- `advanced-junior-checker.md` - 고급 주니어 친화성 체커
-- `react-performance-optimizer.md` - React 성능 최적화
-- `toss-cohesion-analyzer.md` - Toss 응집도 분석기
-- `subagent-builder.md` - 서브에이전트 빌더
+| 이름 | 설명 |
+|------|------|
+| `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
+```
+
+Claude가 자동으로:
+1. 최근 커밋 로그에서 컨벤션 분석
+2. staged changes 확인
+3. 컨벤션에 맞는 커밋 메시지 생성
+4. 커밋 실행
 
 ## 저장소 구조
 
@@ -99,6 +134,8 @@ binary-agents/
 │   ├── toss-cohesion-analyzer.md
 │   ├── react-performance-optimizer.md
 │   └── subagent-builder.md
+├── commands/            # 슬래시 명령어 MD 파일들
+│   └── commit.md
 ├── bin/                 # CLI 실행 파일
 ├── src/                 # CLI 소스 코드
 ├── docs/                # 문서
@@ -110,9 +147,9 @@ binary-agents/
 
 ## 작동 원리
 
-1. 로컬 `agents/` 디렉토리에서 서브에이전트 파일 목록 읽기
+1. 로컬 `agents/`, `commands/` 디렉토리에서 파일 목록 읽기
 2. YAML frontmatter 검증
-3. 사용자 프로젝트의 `.claude/agents/` 디렉토리로 복사
+3. 사용자 프로젝트의 `.claude/agents/`, `.claude/commands/` 디렉토리로 복사
 
 ## 요구사항
 
@@ -126,23 +163,24 @@ MIT
 
 이슈 및 PR을 환영합니다!
 
-## 서브에이전트 직접 사용하기
+## 직접 사용하기
+
+NPM 패키지를 설치하지 않고 이 저장소의 파일을 직접 사용할 수도 있습니다:
 
-NPM 패키지를 설치하지 않고 이 저장소의 서브에이전트를 직접 사용할 수도 있습니다:
+```bash
+# 저장소 클론
+git clone https://github.com/01-binary/binary-agents.git
 
-1. 저장소 클론:
-   ```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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "binary-agents",
-  "version": "1.0.2",
-  "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('');
 }