agent-sdk/slash-commands.md +0 −594 deleted
File Deleted View Diff
1> ## Documentation Index
2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
3> Use this file to discover all available pages before exploring further.
4
5# Slash Commands im SDK
6
7> Erfahren Sie, wie Sie Slash Commands verwenden, um Claude Code-Sitzungen über das SDK zu steuern
8
9Slash Commands bieten eine Möglichkeit, Claude Code-Sitzungen mit speziellen Befehlen zu steuern, die mit `/` beginnen. Diese Befehle können über das SDK gesendet werden, um Aktionen wie das Komprimieren von Kontext, das Auflisten der Kontextnutzung oder das Aufrufen benutzerdefinierter Befehle auszuführen. Nur Befehle, die ohne ein interaktives Terminal funktionieren, können über das SDK versendet werden; die `system/init`-Nachricht listet die in Ihrer Sitzung verfügbaren auf.
10
11<h2 id="discovering-available-slash-commands">
12 Verfügbare Slash Commands entdecken
13</h2>
14
15Das Claude Agent SDK stellt Informationen über verfügbare Slash Commands in der Systeminitalisierungsnachricht bereit. Greifen Sie auf diese Informationen zu, wenn Ihre Sitzung startet:
16
17<CodeGroup>
18 ```typescript TypeScript theme={null}
19 import { query } from "@anthropic-ai/claude-agent-sdk";
20
21 for await (const message of query({
22 prompt: "Hello Claude",
23 options: { maxTurns: 1 }
24 })) {
25 if (message.type === "system" && message.subtype === "init") {
26 console.log("Available slash commands:", message.slash_commands);
27 // Includes built-in commands plus bundled skills, for example:
28 // ["clear", "compact", "context", "usage", "code-review", "verify", ...]
29 }
30 }
31 ```
32
33 ```python Python theme={null}
34 import asyncio
35 from claude_agent_sdk import query, ClaudeAgentOptions, SystemMessage
36
37
38 async def main():
39 async for message in query(prompt="Hello Claude", options=ClaudeAgentOptions(max_turns=1)):
40 if isinstance(message, SystemMessage) and message.subtype == "init":
41 print("Available slash commands:", message.data["slash_commands"])
42 # Includes built-in commands plus bundled skills, for example:
43 # ["clear", "compact", "context", "usage", "code-review", "verify", ...]
44
45
46 asyncio.run(main())
47 ```
48</CodeGroup>
49
50<h2 id="sending-slash-commands">
51 Slash Commands senden
52</h2>
53
54Senden Sie Slash Commands, indem Sie sie in Ihre Eingabeaufforderung einbeziehen, genau wie normalen Text. Befehle, die auf der Konversationsverlauf wirken, wie `/compact`, benötigen vorherige Nachrichten zum Arbeiten, daher fragen die folgenden Beispiele zunächst eine Frage und senden dann den Befehl als Folgemaßnahme zur gleichen Konversation:
55
56<CodeGroup>
57 ```typescript TypeScript theme={null}
58 import { query } from "@anthropic-ai/claude-agent-sdk";
59
60 // Build up conversation history first
61 try {
62 for await (const message of query({
63 prompt: "What does the README in this directory cover?",
64 options: { maxTurns: 2 }
65 })) {
66 if (message.type === "result" && message.subtype === "success") {
67 console.log(message.result);
68 }
69 }
70 } catch (error) {
71 // A single-shot query() throws after yielding an error result,
72 // so the follow-up query below still runs.
73 console.error(`Session ended with an error: ${error}`);
74 }
75
76 // Send a slash command as a follow-up to the same conversation
77 for await (const message of query({
78 prompt: "/compact",
79 options: { continue: true, maxTurns: 1 }
80 })) {
81 if (message.type === "result") {
82 console.log("Command executed, result subtype:", message.subtype);
83 // Example output: Command executed, result subtype: success
84 }
85 }
86 ```
87
88 ```python Python theme={null}
89 import asyncio
90 from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage
91
92
93 async def main():
94 # Build up conversation history first
95 try:
96 async for message in query(
97 prompt="What does the README in this directory cover?",
98 options=ClaudeAgentOptions(max_turns=2),
99 ):
100 if isinstance(message, ResultMessage) and message.subtype == "success":
101 print(message.result)
102 except Exception as error:
103 # A single-shot query() raises after yielding an error result,
104 # so the follow-up query below still runs.
105 print(f"Session ended with an error: {error}")
106
107 # Send a slash command as a follow-up to the same conversation
108 async for message in query(
109 prompt="/compact",
110 options=ClaudeAgentOptions(continue_conversation=True, max_turns=1),
111 ):
112 if isinstance(message, ResultMessage):
113 print("Command executed, result subtype:", message.subtype)
114 # Example output: Command executed, result subtype: success
115
116
117 asyncio.run(main())
118 ```
119</CodeGroup>
120
121<Note>
122 Eine Abfrage kann mit einem Fehler-Ergebnis enden, beispielsweise wenn das Limit `maxTurns` / `max_turns` erreicht wird, bevor die Arbeit abgeschlossen ist. Die endgültige Ergebnisnachricht hat dann `is_error: true` und einen Fehler-Subtyp wie `error_max_turns` statt `success`.
123
124 Nach dem Ausgeben dieser endgültigen Ergebnisnachricht wirft das SDK einen Fehler, da der CLI-Prozess mit einem Nicht-Null-Code beendet wird.
125
126 Umhüllen Sie die Schleife in einem `try`/`catch` in TypeScript oder `try`/`except` in Python, wenn Ihr Befehl das Limit erreichen könnte, wie in [Single Message Input](/de/agent-sdk/streaming-vs-single-mode#single-message-input) gezeigt, oder setzen Sie `maxTurns` hoch genug, damit die Arbeit abgeschlossen wird. In Python fangen Sie `Exception`: Das SDK zeigt Fehler-Ergebnisse als einfache `Exception`.
127</Note>
128
129<h2 id="common-slash-commands">
130 Häufige Slash Commands
131</h2>
132
133<h3 id="/compact-compact-conversation-history">
134 `/compact` - Konversationsverlauf komprimieren
135</h3>
136
137Der `/compact`-Befehl reduziert die Größe Ihres Konversationsverlaufs, indem er ältere Nachrichten zusammenfasst und dabei wichtigen Kontext bewahrt. Die Komprimierung benötigt eine vorhandene Konversation mit mindestens zwei vorherigen Austauschvorgängen zum Zusammenfassen. Dieses Beispiel zeigt zunächst eine Konversation, komprimiert sie dann und liest die `compact_boundary`-Systemnachricht, die das Ergebnis meldet:
138
139<CodeGroup>
140 ```typescript TypeScript theme={null}
141 import { query } from "@anthropic-ai/claude-agent-sdk";
142
143 // Compaction needs existing history, so have a conversation first
144 try {
145 for await (const message of query({
146 prompt: "Explain what this project does",
147 options: { maxTurns: 2 }
148 })) {
149 if (message.type === "result" && message.subtype === "success") {
150 console.log(message.result);
151 }
152 }
153 } catch (error) {
154 // A single-shot query() throws after yielding an error result,
155 // so the follow-up query below still runs.
156 console.error(`Session ended with an error: ${error}`);
157 }
158
159 // Compact the same conversation
160 for await (const message of query({
161 prompt: "/compact",
162 options: { continue: true, maxTurns: 1 }
163 })) {
164 if (message.type === "system" && message.subtype === "compact_boundary") {
165 console.log("Compaction completed");
166 console.log("Pre-compaction tokens:", message.compact_metadata.pre_tokens);
167 console.log("Trigger:", message.compact_metadata.trigger);
168 // Example output:
169 // Compaction completed
170 // Pre-compaction tokens: 1842
171 // Trigger: manual
172 }
173 }
174 ```
175
176 ```python Python theme={null}
177 import asyncio
178 from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage, SystemMessage
179
180
181 async def main():
182 # Compaction needs existing history, so have a conversation first
183 try:
184 async for message in query(
185 prompt="Explain what this project does",
186 options=ClaudeAgentOptions(max_turns=2),
187 ):
188 if isinstance(message, ResultMessage) and message.subtype == "success":
189 print(message.result)
190 except Exception as error:
191 # A single-shot query() raises after yielding an error result,
192 # so the follow-up query below still runs.
193 print(f"Session ended with an error: {error}")
194
195 # Compact the same conversation
196 async for message in query(
197 prompt="/compact",
198 options=ClaudeAgentOptions(continue_conversation=True, max_turns=1),
199 ):
200 if isinstance(message, SystemMessage) and message.subtype == "compact_boundary":
201 print("Compaction completed")
202 print("Pre-compaction tokens:", message.data["compact_metadata"]["pre_tokens"])
203 print("Trigger:", message.data["compact_metadata"]["trigger"])
204 # Example output:
205 # Compaction completed
206 # Pre-compaction tokens: 1842
207 # Trigger: manual
208
209
210 asyncio.run(main())
211 ```
212</CodeGroup>
213
214<Note>
215 Eine `compact_boundary`-Nachricht kommt nur an, wenn die Komprimierung ausgeführt wurde. Wenn es nichts zu zusammenfassen gibt, meldet `/compact` stattdessen den Grund: Der Durchlauf endet immer noch mit einem `success`-Ergebnis, es wird keine `compact_boundary`-Nachricht ausgegeben, und der Ergebnistext enthält die Nachricht, zum Beispiel `Not enough messages to compact.` nach einem einzelnen kurzen Austausch. Ein neuer einmaliger `query()`-Aufruf startet mit leerem Kontext, daher verwenden Sie dieses Muster in einer Sitzung mit vorherigen Durchläufen, zum Beispiel im [Streaming-Eingabemodus](/de/agent-sdk/streaming-vs-single-mode) oder beim Fortsetzen einer Sitzung.
216</Note>
217
218<h3 id="/clear-reset-conversation-context">
219 `/clear` - Konversationskontext zurücksetzen
220</h3>
221
222Der `/clear`-Befehl setzt die Konversation auf einen leeren Kontext zurück, sodass nachfolgende Eingabeaufforderungen ohne vorherigen Konversationsverlauf starten. Die vorherige Konversation bleibt auf der Festplatte gespeichert und kann durch Übergabe ihrer Sitzungs-ID an die [`resume`-Option](/de/agent-sdk/sessions#resume-by-id) wieder aufgerufen werden.
223
224Dies ist nützlich im [Streaming-Eingabemodus](/de/agent-sdk/streaming-vs-single-mode), in dem Sie mehrere Eingabeaufforderungen über eine einzelne Verbindung senden. Für einmalige `query()`-Aufrufe startet jeder Aufruf bereits mit leerem Kontext, daher hat das Senden von `/clear` keine praktische Auswirkung; starten Sie stattdessen eine neue `query()`.
225
226<Note>
227 `/clear` im SDK erfordert Claude Code v2.1.117 oder später. In früheren Versionen wird es aus `slash_commands` weggelassen.
228</Note>
229
230<h2 id="creating-custom-slash-commands">
231 Benutzerdefinierte Slash Commands erstellen
232</h2>
233
234Zusätzlich zur Verwendung integrierter Slash Commands können Sie Ihre eigenen benutzerdefinierten Befehle erstellen, die über das SDK verfügbar sind. Benutzerdefinierte Befehle werden als Markdown-Dateien in bestimmten Verzeichnissen definiert, ähnlich wie Subagenten konfiguriert werden.
235
236<Note>
237 Das `.claude/commands/`-Verzeichnis ist das Legacy-Format. Das empfohlene Format ist `.claude/skills/<name>/SKILL.md`, das die gleiche Slash-Command-Aufrufe (`/name`) plus autonome Aufrufe durch Claude unterstützt. Siehe [Skills](/de/agent-sdk/skills) für das aktuelle Format. Die CLI unterstützt weiterhin beide Formate, und die folgenden Beispiele bleiben für `.claude/commands/` genau.
238</Note>
239
240<h3 id="file-locations">
241 Dateispeicherorte
242</h3>
243
244Benutzerdefinierte Slash Commands werden in bestimmten Verzeichnissen basierend auf ihrem Umfang gespeichert:
245
246* **Projektbefehle**: `.claude/commands/` - Nur im aktuellen Projekt verfügbar (Legacy; bevorzugen Sie `.claude/skills/`)
247* **Persönliche Befehle**: `~/.claude/commands/` - Verfügbar in allen Ihren Projekten (Legacy; bevorzugen Sie `~/.claude/skills/`)
248
249<h3 id="file-format">
250 Dateiformat
251</h3>
252
253Jeder benutzerdefinierte Befehl ist eine Markdown-Datei, bei der:
254
255* Der Dateiname (ohne `.md`-Erweiterung) zum Befehlsnamen wird
256* Der Dateiinhalt definiert, was der Befehl tut
257* Optionale YAML-Frontmatter bietet Konfiguration
258
259<h4 id="basic-example">
260 Grundlegendes Beispiel
261</h4>
262
263Erstellen Sie das `.claude/commands`-Verzeichnis in Ihrem Projekt, falls es nicht vorhanden ist, und erstellen Sie dann `.claude/commands/refactor.md`:
264
265```markdown theme={null}
266Refactor the selected code to improve readability and maintainability.
267Focus on clean code principles and best practices.
268```
269
270Dies erstellt den `/refactor`-Befehl, den Sie über das SDK verwenden können.
271
272<h4 id="with-frontmatter">
273 Mit Frontmatter
274</h4>
275
276Erstellen Sie `.claude/commands/security-check.md`:
277
278```markdown theme={null}
279allowed-tools: Read, Grep, Glob
280description: Run security vulnerability scan
281model: claude-opus-4-8
282
283Analyze the codebase for security vulnerabilities including:
284- SQL injection risks
285- XSS vulnerabilities
286- Exposed credentials
287- Insecure configurations
288```
289
290<h3 id="using-custom-commands-in-the-sdk">
291 Benutzerdefinierte Commands im SDK verwenden
292</h3>
293
294Sobald sie im Dateisystem definiert sind, sind benutzerdefinierte Befehle automatisch über das SDK verfügbar:
295
296<CodeGroup>
297 ```typescript TypeScript theme={null}
298 import { query } from "@anthropic-ai/claude-agent-sdk";
299
300 // Use a custom command
301 try {
302 for await (const message of query({
303 prompt: "/refactor src/auth/login.ts",
304 options: { maxTurns: 3 }
305 })) {
306 if (message.type === "assistant") {
307 console.log("Refactoring suggestions:", message.message);
308 }
309 }
310 } catch (error) {
311 // A single-shot query() throws after yielding an error result,
312 // so the second query below still runs.
313 console.error(`Session ended with an error: ${error}`);
314 }
315
316 // Custom commands appear in the slash_commands list
317 for await (const message of query({
318 prompt: "Hello",
319 options: { maxTurns: 1 }
320 })) {
321 if (message.type === "system" && message.subtype === "init") {
322 console.log("Available commands:", message.slash_commands);
323 // Includes built-in commands plus bundled skills and your custom commands, for example:
324 // ["clear", "compact", "context", "usage", "code-review", "verify", "refactor", "security-check", ...]
325 }
326 }
327 ```
328
329 ```python Python theme={null}
330 import asyncio
331 from claude_agent_sdk import query, ClaudeAgentOptions, AssistantMessage, SystemMessage
332
333
334 async def main():
335 # Use a custom command
336 try:
337 async for message in query(
338 prompt="/refactor src/auth/login.py", options=ClaudeAgentOptions(max_turns=3)
339 ):
340 if isinstance(message, AssistantMessage):
341 for block in message.content:
342 if hasattr(block, "text"):
343 print("Refactoring suggestions:", block.text)
344 except Exception as error:
345 # A single-shot query() raises after yielding an error result,
346 # so the second query below still runs.
347 print(f"Session ended with an error: {error}")
348
349 # Custom commands appear in the slash_commands list
350 async for message in query(prompt="Hello", options=ClaudeAgentOptions(max_turns=1)):
351 if isinstance(message, SystemMessage) and message.subtype == "init":
352 print("Available commands:", message.data["slash_commands"])
353 # Includes built-in commands plus bundled skills and your custom commands, for example:
354 # ["clear", "compact", "context", "usage", "code-review", "verify", "refactor", "security-check", ...]
355
356
357 asyncio.run(main())
358 ```
359</CodeGroup>
360
361<h3 id="advanced-features">
362 Erweiterte Funktionen
363</h3>
364
365<h4 id="arguments-and-placeholders">
366 Argumente und Platzhalter
367</h4>
368
369Benutzerdefinierte Befehle unterstützen dynamische Argumente mit Platzhaltern:
370
371Erstellen Sie `.claude/commands/fix-issue.md`:
372
373```markdown theme={null}
374argument-hint: [issue-number] [priority]
375description: Fix a GitHub issue
376
377Fix issue #$0 with priority $1.
378Check the issue description and implement the necessary changes.
379```
380
381Verwendung im SDK:
382
383<CodeGroup>
384 ```typescript TypeScript theme={null}
385 import { query } from "@anthropic-ai/claude-agent-sdk";
386
387 // Pass arguments to custom command
388 for await (const message of query({
389 prompt: "/fix-issue 123 high",
390 options: { maxTurns: 5 }
391 })) {
392 // Command will process with $0="123" and $1="high"
393 if (message.type === "result" && message.subtype === "success") {
394 console.log("Issue fixed:", message.result);
395 }
396 }
397 ```
398
399 ```python Python theme={null}
400 import asyncio
401 from claude_agent_sdk import query, ClaudeAgentOptions, ResultMessage
402
403
404 async def main():
405 # Pass arguments to custom command
406 async for message in query(prompt="/fix-issue 123 high", options=ClaudeAgentOptions(max_turns=5)):
407 # Command will process with $0="123" and $1="high"
408 if isinstance(message, ResultMessage):
409 print("Issue fixed:", message.result)
410
411
412 asyncio.run(main())
413 ```
414</CodeGroup>
415
416<h4 id="bash-command-execution">
417 Bash-Befehlsausführung
418</h4>
419
420Benutzerdefinierte Befehle können Bash-Befehle ausführen und deren Ausgabe einbeziehen:
421
422Erstellen Sie `.claude/commands/git-commit.md`:
423
424```markdown theme={null}
425allowed-tools: Bash(git add *), Bash(git status *), Bash(git commit *)
426description: Create a git commit
427
428## Context
429
430- Current status: !`git status`
431- Current diff: !`git diff HEAD`
432
433## Task
434
435Create a git commit with appropriate message based on the changes.
436```
437
438<h4 id="file-references">
439 Dateireferenzen
440</h4>
441
442Beziehen Sie Dateiinhalte mit dem `@`-Präfix ein:
443
444Erstellen Sie `.claude/commands/review-config.md`:
445
446```markdown theme={null}
447description: Review configuration files
448
449Review the following configuration files for issues:
450- Package config: @package.json
451- TypeScript config: @tsconfig.json
452- Environment config: @.env
453
454Check for security issues, outdated dependencies, and misconfigurations.
455```
456
457<h3 id="organization-with-namespacing">
458 Organisation mit Namensräumen
459</h3>
460
461Organisieren Sie Befehle in Unterverzeichnissen für bessere Struktur:
462
463```bash theme={null}
464.claude/commands/
465├── frontend/
466│ ├── component.md # Creates /component (project:frontend)
467│ └── style-check.md # Creates /style-check (project:frontend)
468├── backend/
469│ ├── api-test.md # Creates /api-test (project:backend)
470│ └── db-migrate.md # Creates /db-migrate (project:backend)
471└── review.md # Creates /review (project)
472```
473
474Das Unterverzeichnis wird in der Befehlsbeschreibung angezeigt, beeinflusst aber nicht den Befehlsnamen selbst.
475
476<h3 id="practical-examples">
477 Praktische Beispiele
478</h3>
479
480<h4 id="pull-request-review-command">
481 Pull-Request-Review-Befehl
482</h4>
483
484Erstellen Sie `.claude/commands/review-pr.md`:
485
486```markdown theme={null}
487allowed-tools: Read, Grep, Glob, Bash(git diff *)
488description: Comprehensive code review
489
490## Changed Files
491!`git diff --name-only HEAD~1`
492
493## Detailed Changes
494!`git diff HEAD~1`
495
496## Review Checklist
497
498Review the above changes for:
4991. Code quality and readability
5002. Security vulnerabilities
5013. Performance implications
5024. Test coverage
5035. Documentation completeness
504
505Provide specific, actionable feedback organized by priority.
506```
507
508<Note>
509 Claude Code enthält gebündelte `code-review`- und `verify`-Skills. Wenn Sie einen benutzerdefinierten Befehl nach einem von ihnen benennen, z. B. `.claude/commands/code-review.md`, überschattet Ihr Befehl den gebündelten Skill und `slash_commands` listet den Namen einmal auf.
510</Note>
511
512<h4 id="test-runner-command">
513 Test Runner-Befehl
514</h4>
515
516Erstellen Sie `.claude/commands/test.md`:
517
518```markdown theme={null}
519allowed-tools: Bash, Read, Edit
520argument-hint: [test-pattern]
521description: Run tests with optional pattern
522
523Run tests matching pattern: $ARGUMENTS
524
5251. Detect the test framework (Jest, pytest, etc.)
5262. Run tests with the provided pattern
5273. If tests fail, analyze and fix them
5284. Re-run to verify fixes
529```
530
531Verwenden Sie diese Befehle über das SDK:
532
533<CodeGroup>
534 ```typescript TypeScript theme={null}
535 import { query } from "@anthropic-ai/claude-agent-sdk";
536
537 // Run code review
538 try {
539 for await (const message of query({
540 prompt: "/review-pr",
541 options: { maxTurns: 3 }
542 })) {
543 // Process review feedback
544 }
545 } catch (error) {
546 // A single-shot query() throws after yielding an error result,
547 // so the second query below still runs.
548 console.error(`Session ended with an error: ${error}`);
549 }
550
551 // Run specific tests
552 for await (const message of query({
553 prompt: "/test auth",
554 options: { maxTurns: 5 }
555 })) {
556 // Handle test results
557 }
558 ```
559
560 ```python Python theme={null}
561 import asyncio
562 from claude_agent_sdk import query, ClaudeAgentOptions
563
564
565 async def main():
566 # Run code review
567 try:
568 async for message in query(prompt="/review-pr", options=ClaudeAgentOptions(max_turns=3)):
569 # Process review feedback
570 pass
571 except Exception as error:
572 # A single-shot query() raises after yielding an error result,
573 # so the second query below still runs.
574 print(f"Session ended with an error: {error}")
575
576 # Run specific tests
577 async for message in query(prompt="/test auth", options=ClaudeAgentOptions(max_turns=5)):
578 # Handle test results
579 pass
580
581
582 asyncio.run(main())
583 ```
584</CodeGroup>
585
586<h2 id="see-also">
587 Siehe auch
588</h2>
589
590* [Slash Commands](/de/skills) - Vollständige Dokumentation zu Slash Commands
591* [Subagenten im SDK](/de/agent-sdk/subagents) - Ähnliche dateisystembasierte Konfiguration für Subagenten
592* [TypeScript SDK-Referenz](/de/agent-sdk/typescript) - Vollständige API-Dokumentation
593* [SDK-Übersicht](/de/agent-sdk/overview) - Allgemeine SDK-Konzepte
594* [CLI-Referenz](/de/cli-reference) - Befehlszeilenschnittstelle