> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Slash Commands dalam SDK

> Pelajari cara menggunakan slash commands untuk mengontrol sesi Claude Code melalui SDK

Slash commands menyediakan cara untuk mengontrol sesi Claude Code dengan perintah khusus yang dimulai dengan `/`. Perintah-perintah ini dapat dikirim melalui SDK untuk melakukan tindakan seperti memadatkan konteks, mencantumkan penggunaan konteks, atau memanggil perintah khusus. Hanya perintah yang bekerja tanpa terminal interaktif yang dapat dikirim melalui SDK; pesan `system/init` mencantumkan yang tersedia di sesi Anda.

<h2 id="discovering-available-slash-commands">
  Menemukan Slash Commands yang Tersedia
</h2>

Claude Agent SDK menyediakan informasi tentang slash commands yang tersedia dalam pesan inisialisasi sistem. Akses informasi ini ketika sesi Anda dimulai:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  for await (const message of query({
    prompt: "Hello Claude",
    options: { maxTurns: 1 }
  })) {
    if (message.type === "system" && message.subtype === "init") {
      console.log("Available slash commands:", message.slash_commands);
      // Includes built-in commands plus bundled skills, for example:
      // ["clear", "compact", "context", "usage", "code-review", "verify", ...]
    }
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions, SystemMessage


  async def main():
      async for message in query(prompt="Hello Claude", options=ClaudeAgentOptions(max_turns=1)):
          if isinstance(message, SystemMessage) and message.subtype == "init":
              print("Available slash commands:", message.data["slash_commands"])
              # Includes built-in commands plus bundled skills, for example:
              # ["clear", "compact", "context", "usage", "code-review", "verify", ...]


  asyncio.run(main())
  ```
</CodeGroup>

<h2 id="sending-slash-commands">
  Mengirim Slash Commands
</h2>

Kirim slash commands dengan memasukkannya dalam string prompt Anda, seperti teks biasa. Perintah yang bertindak pada riwayat percakapan, seperti `/compact`, memerlukan pesan sebelumnya untuk bekerja, jadi contoh di bawah ini mengajukan pertanyaan terlebih dahulu dan kemudian mengirim perintah sebagai tindak lanjut ke percakapan yang sama:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  // Build up conversation history first
  try {
    for await (const message of query({
      prompt: "What does the README in this directory cover?",
      options: { maxTurns: 2 }
    })) {
      if (message.type === "result" && message.subtype === "success") {
        console.log(message.result);
      }
    }
  } catch (error) {
    // A single-shot query() throws after yielding an error result,
    // so the follow-up query below still runs.
    console.error(`Session ended with an error: ${error}`);
  }

  // Send a slash command as a follow-up to the same conversation
  for await (const message of query({
    prompt: "/compact",
    options: { continue: true, maxTurns: 1 }
  })) {
    if (message.type === "result") {
      console.log("Command executed, result subtype:", message.subtype);
      // Example output: Command executed, result subtype: success
    }
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage


  async def main():
      # Build up conversation history first
      try:
          async for message in query(
              prompt="What does the README in this directory cover?",
              options=ClaudeAgentOptions(max_turns=2),
          ):
              if isinstance(message, ResultMessage) and message.subtype == "success":
                  print(message.result)
      except Exception as error:
          # A single-shot query() raises after yielding an error result,
          # so the follow-up query below still runs.
          print(f"Session ended with an error: {error}")

      # Send a slash command as a follow-up to the same conversation
      async for message in query(
          prompt="/compact",
          options=ClaudeAgentOptions(continue_conversation=True, max_turns=1),
      ):
          if isinstance(message, ResultMessage):
              print("Command executed, result subtype:", message.subtype)
              # Example output: Command executed, result subtype: success


  asyncio.run(main())
  ```
</CodeGroup>

<Note>
  Kueri dapat berakhir dengan hasil kesalahan, misalnya ketika batas `maxTurns` / `max_turns` tercapai sebelum pekerjaan selesai. Pesan hasil akhir kemudian memiliki `is_error: true` dan subtipe kesalahan seperti `error_max_turns` alih-alih `success`.

  Setelah menghasilkan pesan hasil akhir tersebut, SDK melempar kesalahan, karena proses CLI keluar dengan kode non-nol.

  Bungkus loop dalam `try`/`catch` di TypeScript atau `try`/`except` di Python jika perintah Anda mungkin mencapai batas, seperti yang ditunjukkan dalam [Single Message Input](/id/agent-sdk/streaming-vs-single-mode#single-message-input), atau atur `maxTurns` cukup tinggi agar pekerjaan dapat selesai. Di Python, tangkap `Exception`: SDK menampilkan hasil kesalahan sebagai `Exception` biasa.
</Note>

<h2 id="common-slash-commands">
  Slash Commands Umum
</h2>

<h3 id="/compact-compact-conversation-history">
  `/compact` - Memadatkan Riwayat Percakapan
</h3>

Perintah `/compact` mengurangi ukuran riwayat percakapan Anda dengan merangkum pesan yang lebih lama sambil mempertahankan konteks penting. Pemadatan memerlukan percakapan yang sudah ada dengan setidaknya dua pertukaran sebelumnya untuk dirangkum. Contoh ini memiliki percakapan terlebih dahulu, kemudian memadatkannya dan membaca pesan sistem `compact_boundary` yang melaporkan hasilnya:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  // Pemadatan memerlukan riwayat yang sudah ada, jadi mulai dengan percakapan terlebih dahulu
  try {
    for await (const message of query({
      prompt: "Jelaskan apa yang dilakukan proyek ini",
      options: { maxTurns: 2 }
    })) {
      if (message.type === "result" && message.subtype === "success") {
        console.log(message.result);
      }
    }
  } catch (error) {
    // Satu query() sekali jalan melempar setelah menghasilkan hasil kesalahan,
    // jadi query tindak lanjut di bawah masih berjalan.
    console.error(`Sesi berakhir dengan kesalahan: ${error}`);
  }

  // Padatkan percakapan yang sama
  for await (const message of query({
    prompt: "/compact",
    options: { continue: true, maxTurns: 1 }
  })) {
    if (message.type === "system" && message.subtype === "compact_boundary") {
      console.log("Pemadatan selesai");
      console.log("Token sebelum pemadatan:", message.compact_metadata.pre_tokens);
      console.log("Pemicu:", message.compact_metadata.trigger);
      // Contoh output:
      // Pemadatan selesai
      // Token sebelum pemadatan: 1842
      // Pemicu: manual
    }
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage, SystemMessage


  async def main():
      # Pemadatan memerlukan riwayat yang sudah ada, jadi mulai dengan percakapan terlebih dahulu
      try:
          async for message in query(
              prompt="Jelaskan apa yang dilakukan proyek ini",
              options=ClaudeAgentOptions(max_turns=2),
          ):
              if isinstance(message, ResultMessage) and message.subtype == "success":
                  print(message.result)
      except Exception as error:
          # Satu query() sekali jalan menaikkan setelah menghasilkan hasil kesalahan,
          # jadi query tindak lanjut di bawah masih berjalan.
          print(f"Sesi berakhir dengan kesalahan: {error}")

      # Padatkan percakapan yang sama
      async for message in query(
          prompt="/compact",
          options=ClaudeAgentOptions(continue_conversation=True, max_turns=1),
      ):
          if isinstance(message, SystemMessage) and message.subtype == "compact_boundary":
              print("Pemadatan selesai")
              print("Token sebelum pemadatan:", message.data["compact_metadata"]["pre_tokens"])
              print("Pemicu:", message.data["compact_metadata"]["trigger"])
              # Contoh output:
              # Pemadatan selesai
              # Token sebelum pemadatan: 1842
              # Pemicu: manual


  asyncio.run(main())
  ```
</CodeGroup>

<Note>
  Pesan `compact_boundary` hanya tiba ketika pemadatan berjalan. Tanpa ada yang dirangkum, `/compact` melaporkan alasannya sebagai gantinya dari menaikkan: jalannya masih berakhir dengan hasil `success`, tidak ada pesan `compact_boundary` yang dipancarkan, dan teks hasil membawa pesan, misalnya `Tidak cukup pesan untuk dipadatkan.` setelah satu pertukaran pendek. Panggilan `query()` sekali jalan yang segar dimulai dengan konteks kosong, jadi gunakan pola ini dalam sesi dengan putaran sebelumnya, misalnya dalam [mode input streaming](/id/agent-sdk/streaming-vs-single-mode) atau ketika melanjutkan sesi.
</Note>

<h3 id="/clear-reset-conversation-context">
  `/clear` - Atur Ulang Konteks Percakapan
</h3>

Perintah `/clear` mengatur ulang percakapan ke konteks kosong, sehingga prompt berikutnya dimulai tanpa riwayat percakapan sebelumnya. Percakapan sebelumnya tetap tersimpan di disk dan dapat dikembalikan dengan melewatkan ID sesinya ke [opsi `resume`](/id/agent-sdk/sessions#resume-by-id).

Ini berguna dalam [mode input streaming](/id/agent-sdk/streaming-vs-single-mode), di mana Anda mengirim beberapa prompt melalui satu koneksi. Untuk panggilan `query()` sekali jalan, setiap panggilan sudah dimulai dengan konteks kosong, jadi mengirim `/clear` tidak memiliki efek praktis; mulai `query()` baru sebagai gantinya.

<Note>
  `/clear` di SDK memerlukan Claude Code v2.1.117 atau lebih baru. Dalam versi sebelumnya, ini dihilangkan dari `slash_commands`.
</Note>

<h2 id="creating-custom-slash-commands">
  Membuat Slash Commands Khusus
</h2>

Selain menggunakan slash commands bawaan, Anda dapat membuat perintah khusus Anda sendiri yang tersedia melalui SDK. Perintah khusus didefinisikan sebagai file markdown di direktori tertentu, mirip dengan cara subagents dikonfigurasi.

<Note>
  Direktori `.claude/commands/` adalah format warisan. Format yang direkomendasikan adalah `.claude/skills/<name>/SKILL.md`, yang mendukung invokasi slash-command yang sama (`/name`) ditambah invokasi otonom oleh Claude. Lihat [Skills](/id/agent-sdk/skills) untuk format saat ini. CLI terus mendukung kedua format, dan contoh di bawah tetap akurat untuk `.claude/commands/`.
</Note>

<h3 id="file-locations">
  Lokasi File
</h3>

Slash commands khusus disimpan di direktori yang ditentukan berdasarkan cakupan mereka:

* **Perintah proyek**: `.claude/commands/` - Tersedia hanya di proyek saat ini (warisan; lebih suka `.claude/skills/`)
* **Perintah pribadi**: `~/.claude/commands/` - Tersedia di semua proyek Anda (warisan; lebih suka `~/.claude/skills/`)

<h3 id="file-format">
  Format File
</h3>

Setiap perintah khusus adalah file markdown di mana:

* Nama file (tanpa ekstensi `.md`) menjadi nama perintah
* Konten file mendefinisikan apa yang dilakukan perintah
* Frontmatter YAML opsional menyediakan konfigurasi

<h4 id="basic-example">
  Contoh Dasar
</h4>

Buat direktori `.claude/commands` di proyek Anda jika belum ada, kemudian buat `.claude/commands/refactor.md`:

```markdown theme={null}
Refactor the selected code to improve readability and maintainability.
Focus on clean code principles and best practices.
```

Ini membuat perintah `/refactor` yang dapat Anda gunakan melalui SDK.

<h4 id="with-frontmatter">
  Dengan Frontmatter
</h4>

Buat `.claude/commands/security-check.md`:

```markdown theme={null}
---
allowed-tools: Read, Grep, Glob
description: Run security vulnerability scan
model: claude-opus-4-8
---

Analyze the codebase for security vulnerabilities including:
- SQL injection risks
- XSS vulnerabilities
- Exposed credentials
- Insecure configurations
```

<h3 id="using-custom-commands-in-the-sdk">
  Menggunakan Custom Commands di SDK
</h3>

Setelah didefinisikan di sistem file, perintah khusus secara otomatis tersedia melalui SDK:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  // Use a custom command
  try {
    for await (const message of query({
      prompt: "/refactor src/auth/login.ts",
      options: { maxTurns: 3 }
    })) {
      if (message.type === "assistant") {
        console.log("Refactoring suggestions:", message.message);
      }
    }
  } catch (error) {
    // A single-shot query() throws after yielding an error result,
    // so the second query below still runs.
    console.error(`Session ended with an error: ${error}`);
  }

  // Custom commands appear in the slash_commands list
  for await (const message of query({
    prompt: "Hello",
    options: { maxTurns: 1 }
  })) {
    if (message.type === "system" && message.subtype === "init") {
      console.log("Available commands:", message.slash_commands);
      // Includes built-in commands plus bundled skills and your custom commands, for example:
      // ["clear", "compact", "context", "usage", "code-review", "verify", "refactor", "security-check", ...]
    }
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, SystemMessage


  async def main():
      # Use a custom command
      try:
          async for message in query(
              prompt="/refactor src/auth/login.py", options=ClaudeAgentOptions(max_turns=3)
          ):
              if isinstance(message, AssistantMessage):
                  for block in message.content:
                      if hasattr(block, "text"):
                          print("Refactoring suggestions:", block.text)
      except Exception as error:
          # A single-shot query() raises after yielding an error result,
          # so the second query below still runs.
          print(f"Session ended with an error: {error}")

      # Custom commands appear in the slash_commands list
      async for message in query(prompt="Hello", options=ClaudeAgentOptions(max_turns=1)):
          if isinstance(message, SystemMessage) and message.subtype == "init":
              print("Available commands:", message.data["slash_commands"])
              # Includes built-in commands plus bundled skills and your custom commands, for example:
              # ["clear", "compact", "context", "usage", "code-review", "verify", "refactor", "security-check", ...]


  asyncio.run(main())
  ```
</CodeGroup>

<h3 id="advanced-features">
  Fitur Lanjutan
</h3>

<h4 id="arguments-and-placeholders">
  Argumen dan Placeholder
</h4>

Perintah khusus mendukung argumen dinamis menggunakan placeholder:

Buat `.claude/commands/fix-issue.md`:

```markdown theme={null}
---
argument-hint: [issue-number] [priority]
description: Fix a GitHub issue
---

Fix issue #$0 with priority $1.
Check the issue description and implement the necessary changes.
```

Gunakan di SDK:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  // Pass arguments to custom command
  for await (const message of query({
    prompt: "/fix-issue 123 high",
    options: { maxTurns: 5 }
  })) {
    // Command will process with $0="123" and $1="high"
    if (message.type === "result" && message.subtype === "success") {
      console.log("Issue fixed:", message.result);
    }
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage


  async def main():
      # Pass arguments to custom command
      async for message in query(prompt="/fix-issue 123 high", options=ClaudeAgentOptions(max_turns=5)):
          # Command will process with $0="123" and $1="high"
          if isinstance(message, ResultMessage):
              print("Issue fixed:", message.result)


  asyncio.run(main())
  ```
</CodeGroup>

<h4 id="bash-command-execution">
  Eksekusi Perintah Bash
</h4>

Perintah khusus dapat mengeksekusi perintah bash dan menyertakan output mereka:

Buat `.claude/commands/git-commit.md`:

```markdown theme={null}
---
allowed-tools: Bash(git add *), Bash(git status *), Bash(git commit *)
description: Create a git commit
---

## Context

- Current status: !`git status`
- Current diff: !`git diff HEAD`

## Task

Create a git commit with appropriate message based on the changes.
```

<h4 id="file-references">
  Referensi File
</h4>

Sertakan konten file menggunakan awalan `@`:

Buat `.claude/commands/review-config.md`:

```markdown theme={null}
---
description: Review configuration files
---

Review the following configuration files for issues:
- Package config: @package.json
- TypeScript config: @tsconfig.json
- Environment config: @.env

Check for security issues, outdated dependencies, and misconfigurations.
```

<h3 id="organization-with-namespacing">
  Organisasi dengan Namespacing
</h3>

Organisir perintah dalam subdirektori untuk struktur yang lebih baik:

```bash theme={null}
.claude/commands/
├── frontend/
│   ├── component.md      # Creates /component (project:frontend)
│   └── style-check.md     # Creates /style-check (project:frontend)
├── backend/
│   ├── api-test.md        # Creates /api-test (project:backend)
│   └── db-migrate.md      # Creates /db-migrate (project:backend)
└── review.md              # Creates /review (project)
```

Subdirektori muncul dalam deskripsi perintah tetapi tidak mempengaruhi nama perintah itu sendiri.

<h3 id="practical-examples">
  Contoh Praktis
</h3>

<h4 id="pull-request-review-command">
  Perintah Pull Request Review
</h4>

Buat `.claude/commands/review-pr.md`:

```markdown theme={null}
---
allowed-tools: Read, Grep, Glob, Bash(git diff *)
description: Comprehensive code review
---

## Changed Files
!`git diff --name-only HEAD~1`

## Detailed Changes
!`git diff HEAD~1`

## Review Checklist

Review the above changes for:
1. Code quality and readability
2. Security vulnerabilities
3. Performance implications
4. Test coverage
5. Documentation completeness

Provide specific, actionable feedback organized by priority.
```

<Note>
  Claude Code mencakup skills `code-review` dan `verify` yang disertakan. Jika Anda memberi nama perintah khusus setelah salah satunya, misalnya `.claude/commands/code-review.md`, perintah Anda menimpa skill yang disertakan dan `slash_commands` mencantumkan nama sekali.
</Note>

<h4 id="test-runner-command">
  Perintah Test Runner
</h4>

Buat `.claude/commands/test.md`:

```markdown theme={null}
---
allowed-tools: Bash, Read, Edit
argument-hint: [test-pattern]
description: Run tests with optional pattern
---

Run tests matching pattern: $ARGUMENTS

1. Detect the test framework (Jest, pytest, etc.)
2. Run tests with the provided pattern
3. If tests fail, analyze and fix them
4. Re-run to verify fixes
```

Gunakan perintah-perintah ini melalui SDK:

<CodeGroup>
  ```typescript TypeScript theme={null}
  import { query } from "@anthropic-ai/claude-agent-sdk";

  // Run code review
  try {
    for await (const message of query({
      prompt: "/review-pr",
      options: { maxTurns: 3 }
    })) {
      // Process review feedback
    }
  } catch (error) {
    // A single-shot query() throws after yielding an error result,
    // so the second query below still runs.
    console.error(`Session ended with an error: ${error}`);
  }

  // Run specific tests
  for await (const message of query({
    prompt: "/test auth",
    options: { maxTurns: 5 }
  })) {
    // Handle test results
  }
  ```

  ```python Python theme={null}
  import asyncio
  from claude_agent_sdk import query, ClaudeAgentOptions


  async def main():
      # Run code review
      try:
          async for message in query(prompt="/review-pr", options=ClaudeAgentOptions(max_turns=3)):
              # Process review feedback
              pass
      except Exception as error:
          # A single-shot query() raises after yielding an error result,
          # so the second query below still runs.
          print(f"Session ended with an error: {error}")

      # Run specific tests
      async for message in query(prompt="/test auth", options=ClaudeAgentOptions(max_turns=5)):
          # Handle test results
          pass


  asyncio.run(main())
  ```
</CodeGroup>

<h2 id="see-also">
  Lihat Juga
</h2>

* [Slash Commands](/id/skills) - Dokumentasi slash command lengkap
* [Subagents dalam SDK](/id/agent-sdk/subagents) - Konfigurasi berbasis sistem file serupa untuk subagents
* [Referensi TypeScript SDK](/id/agent-sdk/typescript) - Dokumentasi API lengkap
* [Gambaran umum SDK](/id/agent-sdk/overview) - Konsep SDK umum
* [Referensi CLI](/id/cli-reference) - Antarmuka baris perintah