Slash Commands dans le SDK
Apprenez à utiliser les slash commands pour contrôler les sessions Claude Code via le SDK
Les slash commands offrent un moyen de contrôler les sessions Claude Code avec des commandes spéciales commençant par /. Ces commandes peuvent être envoyées via le SDK pour effectuer des actions comme compacter le contexte, lister l'utilisation du contexte ou invoquer des commandes personnalisées. Seules les commandes qui fonctionnent sans terminal interactif peuvent être envoyées via le SDK ; le message system/init liste celles disponibles dans votre session.
Découvrir les Slash Commands Disponibles
Le Claude Agent SDK fournit des informations sur les slash commands disponibles dans le message d'initialisation du système. Accédez à ces informations au démarrage de votre session :
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", ...]
}
}
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())
Envoyer des Slash Commands
Envoyez des slash commands en les incluant dans votre chaîne de prompt, comme du texte ordinaire. Les commandes qui agissent sur l'historique de la conversation, telles que /compact, ont besoin de messages antérieurs pour fonctionner, donc les exemples ci-dessous posent d'abord une question, puis envoient la commande comme suivi à la même conversation :
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
}
}
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())
Commandes Slash Courantes
`/compact` - Compacter l'historique de conversation
La commande /compact réduit la taille de votre historique de conversation en résumant les messages plus anciens tout en préservant le contexte important. La compaction nécessite une conversation existante avec au moins deux échanges antérieurs à résumer. Cet exemple a d'abord une conversation, puis la compacte et lit le message système compact_boundary qui rapporte le résultat :
import { query } from "@anthropic-ai/claude-agent-sdk";
// Compaction needs existing history, so have a conversation first
try {
for await (const message of query({
prompt: "Explain what this project does",
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}`);
}
// Compact the same conversation
for await (const message of query({
prompt: "/compact",
options: { continue: true, maxTurns: 1 }
})) {
if (message.type === "system" && message.subtype === "compact_boundary") {
console.log("Compaction completed");
console.log("Pre-compaction tokens:", message.compact_metadata.pre_tokens);
console.log("Trigger:", message.compact_metadata.trigger);
// Example output:
// Compaction completed
// Pre-compaction tokens: 1842
// Trigger: manual
}
}
import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage, SystemMessage
async def main():
# Compaction needs existing history, so have a conversation first
try:
async for message in query(
prompt="Explain what this project does",
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}")
# Compact the same conversation
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("Compaction completed")
print("Pre-compaction tokens:", message.data["compact_metadata"]["pre_tokens"])
print("Trigger:", message.data["compact_metadata"]["trigger"])
# Example output:
# Compaction completed
# Pre-compaction tokens: 1842
# Trigger: manual
asyncio.run(main())
`/clear` - Réinitialiser le contexte de conversation
La commande /clear réinitialise la conversation à un contexte vide, de sorte que les invites suivantes commencent sans aucun historique de conversation antérieur. La conversation précédente reste sur le disque et peut être reprise en passant son ID de session à l'option resume.
Ceci est utile en mode d'entrée en continu, où vous envoyez plusieurs invites sur une seule connexion. Pour les appels query() ponctuels, chaque appel démarre déjà avec un contexte vide, donc envoyer /clear n'a aucun effet pratique ; démarrez plutôt un nouveau query().
Créer des Slash Commands Personnalisés
En plus d'utiliser les slash commands intégrés, vous pouvez créer vos propres commandes personnalisées disponibles via le SDK. Les commandes personnalisées sont définies comme des fichiers markdown dans des répertoires spécifiques, de la même manière que les subagents sont configurés.
Emplacements des Fichiers
Les slash commands personnalisés sont stockés dans des répertoires désignés selon leur portée :
- Commandes de projet :
.claude/commands/- Disponibles uniquement dans le projet actuel (hérité ; préférez.claude/skills/) - Commandes personnelles :
~/.claude/commands/- Disponibles dans tous vos projets (hérité ; préférez~/.claude/skills/)
Format du Fichier
Chaque commande personnalisée est un fichier markdown où :
- Le nom du fichier (sans extension
.md) devient le nom de la commande - Le contenu du fichier définit ce que la commande fait
- Un frontmatter YAML optionnel fournit la configuration
Exemple Basique
Créez le répertoire .claude/commands dans votre projet s'il n'existe pas, puis créez .claude/commands/refactor.md :
Refactor the selected code to improve readability and maintainability.
Focus on clean code principles and best practices.
Cela crée la commande /refactor que vous pouvez utiliser via le SDK.
Avec Frontmatter
Créez .claude/commands/security-check.md :
---
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
Utiliser des Commandes Personnalisées dans le SDK
Une fois définies dans le système de fichiers, les commandes personnalisées sont automatiquement disponibles via le SDK :
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", ...]
}
}
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())
Fonctionnalités Avancées
Arguments et Placeholders
Les commandes personnalisées supportent les arguments dynamiques en utilisant des placeholders :
Créez .claude/commands/fix-issue.md :
---
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.
Utilisez dans le SDK :
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);
}
}
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())
Exécution de Commandes Bash
Les commandes personnalisées peuvent exécuter des commandes bash et inclure leur sortie :
Créez .claude/commands/git-commit.md :
---
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.
Références de Fichiers
Incluez le contenu des fichiers en utilisant le préfixe @ :
Créez .claude/commands/review-config.md :
---
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.
Organisation avec Namespacing
Organisez les commandes dans des sous-répertoires pour une meilleure structure :
.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)
Le sous-répertoire apparaît dans la description de la commande mais n'affecte pas le nom de la commande lui-même.
Exemples Pratiques
Commande de Révision de Pull Request
Créez .claude/commands/review-pr.md :
---
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.
Commande Test Runner
Créez .claude/commands/test.md :
---
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
Utilisez ces commandes via le SDK :
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
}
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())
Voir Aussi
- Slash Commands - Documentation complète des slash commands
- Subagents dans le SDK - Configuration similaire basée sur le système de fichiers pour les subagents
- Référence TypeScript SDK - Documentation complète de l'API
- Aperçu du SDK - Concepts généraux du SDK
- Référence CLI - Interface de ligne de commande