Merge pull request #26 from QwenLM/sync-0.3.0

chore: Update the Qwen Code docs to v0.3.0

Author: pomelo-nwu

website/content/de/cli/commands.md

@@ -0,0 +1,71 @@
+# Language Command
+
+Der Befehl `/language` ermöglicht es dir, die Spracheinstellungen sowohl für das Qwen Code User Interface (UI) als auch für die Ausgabesprache des Language Models (LLM) anzupassen. Dieser Befehl unterstützt zwei verschiedene Funktionen:
+
+1. Festlegen der UI-Sprache für das Qwen Code-Interface  
+2. Festlegen der Ausgabesprache für das Language Model (LLM)
+
+## UI-Spracheinstellungen
+
+Um die UI-Sprache von Qwen Code zu ändern, verwende den `ui`-Unterbefehl:
+
+```
+/language ui [zh-CN|en-US]
+```
+
+### Verfügbare UI-Sprachen
+
+- **zh-CN**: Vereinfachtes Chinesisch (简体中文)  
+- **en-US**: Englisch
+
+### Beispiele
+
+```
+/language ui zh-CN    # UI-Sprache auf Vereinfachtes Chinesisch setzen
+/language ui en-US    # UI-Sprache auf Englisch setzen
+```
+
+### UI-Sprache Unterbefehle
+
+Für mehr Komfort kannst du auch direkte Unterbefehle verwenden:
+
+- `/language ui zh-CN` oder `/language ui zh` oder `/language ui 中文`  
+- `/language ui en-US` oder `/language ui en` oder `/language ui english`
+
+## LLM Output Language Settings
+
+Um die Sprache für die Responses des Language Models festzulegen, verwendest du den `output` Subcommand:
+
+```
+/language output <language>
+```
+
+Dieser Befehl generiert eine Sprachregel-Datei, die dem LLM anweist, in der angegebenen Sprache zu antworten. Die Regel-Datei wird unter `~/.qwen/output-language.md` gespeichert.
+
+### Beispiele
+
+```
+/language output 中文      # Setzt die LLM-Ausgabesprache auf Chinesisch
+/language output English   # Setzt die LLM-Ausgabesprache auf Englisch
+/language output 日本語    # Setzt die LLM-Ausgabesprache auf Japanisch
+```
+
+## Aktuelle Einstellungen anzeigen
+
+Wenn der `/language` Befehl ohne Argumente verwendet wird, zeigt er die aktuellen Spracheinstellungen an:
+
+```
+/language
+```
+
+Es werden folgende Informationen angezeigt:
+
+- Aktuelle UI-Sprache
+- Aktuelle LLM-Ausgabesprache (falls gesetzt)
+- Verfügbare Subcommands
+
+## Hinweise
+
+- Änderungen der UI-Sprache werden sofort übernommen und alle Befehlsbeschreibungen neu geladen
+- Die Einstellungen für die LLM-Ausgabesprache werden in einer Regel-Datei gespeichert, die automatisch im Kontext des Modells eingebunden wird
+- Um zusätzliche UI-Sprachpakete anzufordern, öffne bitte ein Issue auf GitHub

website/content/de/cli/configuration-v1.md

@@ -2,74 +2,78 @@
 
 Der Qwen Code Core (`packages/core`) bietet ein robustes System zum Definieren, Registrieren und Ausführen von Tools. Diese Tools erweitern die Fähigkeiten des Modells, sodass es mit der lokalen Umgebung interagieren, Webinhalte abrufen und verschiedene Aktionen jenseits der einfachen Textgenerierung durchführen kann.
 
-## Core Concepts
+## Kernkonzepte
 
 - **Tool (`tools.ts`)**: Ein Interface und eine Basisklasse (`BaseTool`), die den Vertrag für alle Tools definiert. Jedes Tool muss folgende Eigenschaften haben:
   - `name`: Ein eindeutiger interner Name (wird in API-Aufrufen an das Modell verwendet).
   - `displayName`: Ein benutzerfreundlicher Name.
   - `description`: Eine klare Erklärung dessen, was das Tool tut – diese wird dem Modell zur Verfügung gestellt.
-  - `parameterSchema`: Ein JSON-Schema, das die Parameter definiert, die das Tool akzeptiert. Dies ist entscheidend, damit das Modell weiß, wie es das Tool korrekt aufrufen kann.
+  - `parameterSchema`: Ein JSON-Schema, das die Parameter beschreibt, die das Tool akzeptiert. Dies ist entscheidend dafür, dass das Modell weiß, wie es das Tool korrekt aufrufen kann.
   - `validateToolParams()`: Eine Methode zur Validierung eingehender Parameter.
-  - `getDescription()`: Eine Methode, die eine menschenlesbare Beschreibung liefert, was das Tool mit bestimmten Parametern vor der Ausführung tun wird.
+  - `getDescription()`: Eine Methode, um eine menschenlesbare Beschreibung dessen bereitzustellen, was das Tool mit bestimmten Parametern tun wird – vor der Ausführung.
   - `shouldConfirmExecute()`: Eine Methode, um festzustellen, ob eine Bestätigung durch den Benutzer vor der Ausführung erforderlich ist (z. B. bei potenziell destruktiven Operationen).
   - `execute()`: Die Kernmethode, die die Aktion des Tools ausführt und ein `ToolResult` zurückgibt.
 
 - **`ToolResult` (`tools.ts`)**: Ein Interface, das die Struktur des Ergebnisses einer Toolausführung definiert:
-  - `llmContent`: Der faktische Inhalt, der in den Verlauf aufgenommen wird, der an das LLM zurückgesendet wird, um Kontext bereitzustellen. Dies kann ein einfacher String oder ein `PartListUnion` (ein Array aus `Part`-Objekten und Strings) für Rich Content sein.
-  - `returnDisplay`: Ein benutzerfreundlicher String (häufig Markdown) oder ein spezielles Objekt (wie `FileDiff`) zur Anzeige in der CLI.
+  - `llmContent`: Der faktische Inhalt, der in den Verlauf aufgenommen wird, der an das LLM zurückgesendet wird, um Kontext zu liefern. Kann ein einfacher String oder ein `PartListUnion` (ein Array aus `Part`-Objekten und Strings) für Rich Content sein.
+  - `returnDisplay`: Ein benutzerfreundlicher String (häufig Markdown) oder ein spezielles Objekt (wie `FileDiff`) zur Darstellung in der CLI.
 
-- **Rich Content zurückgeben**: Tools sind nicht darauf beschränkt, einfachen Text zurückzugeben. Der `llmContent` kann ein `PartListUnion` sein – also ein Array, das sowohl `Part`-Objekte (für Bilder, Audio usw.) als auch `string`s enthalten kann. Dadurch kann eine einzelne Toolausführung mehrere Rich Content-Elemente zurückgeben.
+- **Rückgabe von Rich Content**: Tools sind nicht darauf beschränkt, einfachen Text zurückzugeben. Der `llmContent` kann ein `PartListUnion` sein – also ein Array, das sowohl `Part`-Objekte (für Bilder, Audio usw.) als auch `string`s enthalten kann. Dadurch kann eine einzelne Toolausführung mehrere Rich-Content-Elemente zurückgeben.
 
 - **Tool Registry (`tool-registry.ts`)**: Eine Klasse (`ToolRegistry`), die folgende Aufgaben übernimmt:
-  - **Tools registrieren**: Hält eine Sammlung aller verfügbaren Built-in-Tools (z. B. `ReadFileTool`, `ShellTool`).
-  - **Tools entdecken**: Kann auch dynamisch Tools entdecken:
-    - **Befehlsbasierte Entdeckung**: Wenn `tools.toolDiscoveryCommand` in den Einstellungen konfiguriert ist, wird dieser Befehl ausgeführt. Es wird erwartet, dass er JSON ausgibt, das benutzerdefinierte Tools beschreibt, die dann als `DiscoveredTool`-Instanzen registriert werden.
-    - **MCP-basierte Entdeckung**: Wenn `mcp.mcpServerCommand` konfiguriert ist, kann die Registry sich mit einem Model Context Protocol (MCP)-Server verbinden, um Tools aufzulisten und zu registrieren (`DiscoveredMCPTool`).
-  - **Schemas bereitstellen**: Stellt die `FunctionDeclaration`-Schemas aller registrierten Tools für das Modell bereit, damit es weiß, welche Tools verfügbar sind und wie sie verwendet werden.
-  - **Tools abrufen**: Ermöglicht es dem Core, ein bestimmtes Tool anhand des Namens zur Ausführung abzurufen.
+  - **Registrierung von Tools**: Hält eine Sammlung aller verfügbaren Built-in-Tools (z. B. `ListFiles`, `ReadFile`).
+  - **Entdecken von Tools**: Kann auch dynamisch Tools entdecken:
+    - **Befehlsbasierte Entdeckung**: Wenn `tools.toolDiscoveryCommand` in den Einstellungen konfiguriert ist, wird dieser Befehl ausgeführt. Es wird erwartet, dass er JSON ausgibt, das benutzerdefinierte Tools beschreibt – diese werden dann als `DiscoveredTool`-Instanzen registriert.
+    - **MCP-basierte Entdeckung**: Wenn `mcp.mcpServerCommand` konfiguriert ist, kann sich die Registry mit einem Model Context Protocol (MCP)-Server verbinden, um Tools abzurufen und zu registrieren (`DiscoveredMCPTool`).
+  - **Bereitstellung von Schemas**: Stellt die `FunctionDeclaration`-Schemas aller registrierten Tools für das Modell bereit, damit es weiß, welche Tools verfügbar sind und wie sie verwendet werden.
+  - **Abrufen von Tools**: Ermöglicht es dem Kernsystem, ein bestimmtes Tool anhand seines Namens zur Ausführung abzurufen.
 
-## Built-in Tools
+## Integrierte Tools
 
-Der Core enthält eine Sammlung vordefinierter Tools, die sich typischerweise in `packages/core/src/tools/` befinden. Dazu gehören:
+Der Core enthält eine Sammlung vordefinierter Tools, die sich üblicherweise in `packages/core/src/tools/` befinden. Dazu gehören:
 
 - **File System Tools:**
-  - `LSTool` (`ls.ts`): Listet den Inhalt eines Verzeichnisses auf.
-  - `ReadFileTool` (`read-file.ts`): Liest den Inhalt einer einzelnen Datei. Akzeptiert einen `absolute_path`-Parameter, der ein absoluter Pfad sein muss.
-  - `WriteFileTool` (`write-file.ts`): Schreibt Inhalte in eine Datei.
-  - `GrepTool` (`grep.ts`): Sucht nach Mustern in Dateien.
-  - `GlobTool` (`glob.ts`): Findet Dateien anhand von Glob-Patterns.
-  - `EditTool` (`edit.ts`): Führt Änderungen direkt in Dateien durch (oft mit Bestätigungsabfrage).
-  - `ReadManyFilesTool` (`read-many-files.ts`): Liest und verknüpft Inhalte aus mehreren Dateien oder Glob-Patterns (verwendet vom `@`-Befehl in der CLI).
+  - `ListFiles` (`ls.ts`): Listet den Inhalt eines Verzeichnisses auf.
+  - `ReadFile` (`read-file.ts`): Liest den Inhalt einer einzelnen Datei. Akzeptiert einen `absolute_path` Parameter, der ein absoluter Pfad sein muss.
+  - `WriteFile` (`write-file.ts`): Schreibt Inhalte in eine Datei.
+  - `ReadManyFiles` (`read-many-files.ts`): Liest und verknüpft Inhalte aus mehreren Dateien oder Glob-Patterns (verwendet vom `@` Befehl in der CLI).
+  - `Grep` (`grep.ts`): Sucht nach Mustern in Dateien.
+  - `Glob` (`glob.ts`): Findet Dateien anhand von Glob-Patterns.
+  - `Edit` (`edit.ts`): Führt Änderungen direkt in Dateien durch (benötigt oft eine Bestätigung).
 - **Execution Tools:**
-  - `ShellTool` (`shell.ts`): Führt beliebige Shell-Befehle aus (erfordert sorgfältige Sandbox-Konfiguration und Nutzerbestätigung).
+  - `Shell` (`shell.ts`): Führt beliebige Shell-Befehle aus (erfordert sorgfältiges Sandboxing und Nutzerbestätigung).
 - **Web Tools:**
-  - `WebFetchTool` (`web-fetch.ts`): Ruft Inhalte von einer URL ab.
-  - `WebSearchTool` (`web-search.ts`): Führt eine Websuche durch.
+  - `WebFetch` (`web-fetch.ts`): Ruft Inhalte von einer URL ab.
+  - `WebSearch` (`web-search.ts`): Führt eine Websuche durch.
 - **Memory Tools:**
-  - `MemoryTool` (`memoryTool.ts`): Interagiert mit dem Gedächtnis des KI-Modells.
+  - `SaveMemory` (`memoryTool.ts`): Interagiert mit dem Gedächtnis des KI-Modells.
+- **Planning Tools:**
+  - `Task` (`task.ts`): Delegiert Aufgaben an spezialisierte Subagenten.
+  - `TodoWrite` (`todoWrite.ts`): Erstellt und verwaltet eine strukturierte To-do-Liste.
+  - `ExitPlanMode` (`exitPlanMode.ts`): Beendet den Planungsmodus und kehrt zum Normalbetrieb zurück.
 
 Jedes dieser Tools erweitert `BaseTool` und implementiert die erforderlichen Methoden für seine jeweilige Funktionalität.
 
-## Tool Execution Flow
+## Ablauf der Tool-Ausführung
 
-1.  **Model Request:** Das Modell entscheidet auf Basis des User-Prompts und der bereitgestellten Tool-Schemas, ein Tool zu verwenden, und gibt einen `FunctionCall`-Teil in seiner Response zurück, der den Tool-Namen und die Argumente angibt.
-2.  **Core empfängt Request:** Das Core parsed diesen `FunctionCall`.
-3.  **Tool-Abruf:** Es sucht das angeforderte Tool in der `ToolRegistry`.
-4.  **Parameter-Validierung:** Die `validateToolParams()`-Methode des Tools wird aufgerufen.
-5.  **Bestätigung (falls nötig):**
-    - Die `shouldConfirmExecute()`-Methode des Tools wird aufgerufen.
-    - Falls diese Details zur Bestätigung zurückgibt, kommuniziert das Core dies zurück an die CLI, welche den User dann zur Eingabe auffordert.
-    - Die Entscheidung des Users (z. B. fortfahren, abbrechen) wird an das Core zurückgesendet.
-6.  **Ausführung:** Falls validiert und bestätigt (oder keine Bestätigung nötig), ruft das Core die `execute()`-Methode des Tools mit den übergebenen Argumenten und einem `AbortSignal` (für mögliche Abbrüche) auf.
-7.  **Ergebnisverarbeitung:** Das `ToolResult` aus `execute()` wird vom Core entgegengenommen.
-8.  **Antwort an das Modell:** Der `llmContent` aus dem `ToolResult` wird als `FunctionResponse` verpackt und an das Modell gesendet, damit es mit der Generierung einer nutzerseitigen Antwort fortfahren kann.
-9.  **Anzeige für den User:** Das `returnDisplay` aus dem `ToolResult` wird an die CLI gesendet, um dem User anzuzeigen, was das Tool ausgeführt hat.
+1.  **Modell-Anfrage:** Das Modell entscheidet auf Basis des Benutzerprompts und der bereitgestellten Tool-Schemas, ein Tool zu verwenden, und gibt einen `FunctionCall`-Teil in seiner Antwort zurück, der den Tool-Namen und die Argumente angibt.
+2.  **Core erhält Anfrage:** Der Core parst diesen `FunctionCall`.
+3.  **Tool-Abruf:** Er sucht das angeforderte Tool in der `ToolRegistry`.
+4.  **Parameter-Validierung:** Die Methode `validateToolParams()` des Tools wird aufgerufen.
+5.  **Bestätigung (falls erforderlich):**
+    - Die Methode `shouldConfirmExecute()` des Tools wird aufgerufen.
+    - Falls diese Details zur Bestätigung zurückgibt, kommuniziert der Core dies an die CLI zurück, welche den Benutzer dann zur Eingabe auffordert.
+    - Die Entscheidung des Benutzers (z. B. fortfahren, abbrechen) wird an den Core gesendet.
+6.  **Ausführung:** Wenn validiert und bestätigt (oder keine Bestätigung nötig), ruft der Core die Methode `execute()` des Tools mit den übergebenen Argumenten sowie einem `AbortSignal` (für mögliche Abbrüche) auf.
+7.  **Ergebnisverarbeitung:** Der `ToolResult` aus `execute()` wird vom Core entgegengenommen.
+8.  **Antwort an das Modell:** Der `llmContent` aus dem `ToolResult` wird als `FunctionResponse` verpackt und an das Modell gesendet, damit es seine benutzerseitige Antwort fortsetzen kann.
+9.  **Anzeige für den Benutzer:** Der `returnDisplay` aus dem `ToolResult` wird an die CLI gesendet, um dem Benutzer anzuzeigen, was das Tool ausgeführt hat.
 
-## Erweitern mit Custom Tools
+## Erweitern mit benutzerdefinierten Tools
 
-Auch wenn die direkte programmatische Registrierung neuer Tools durch Benutzer nicht explizit als primärer Workflow in den bereitgestellten Dateien für typische Endnutzer beschrieben ist, unterstützt die Architektur die Erweiterung durch:
+Auch wenn die direkte programmatische Registrierung neuer Tools durch Benutzer nicht explizit als primärer Workflow in den bereitgestellten Dateien für typische Endbenutzer beschrieben ist, unterstützt die Architektur Erweiterungen über:
 
-- **Command-basierte Discovery:** Fortgeschrittene Benutzer oder Projektadministratoren können einen `tools.toolDiscoveryCommand` in der `settings.json` definieren. Dieser Befehl sollte bei Ausführung durch den Core ein JSON-Array von `FunctionDeclaration`-Objekten ausgeben. Der Core stellt diese dann als `DiscoveredTool`-Instanzen zur Verfügung. Der entsprechende `tools.toolCallCommand` ist dann dafür verantwortlich, diese Custom Tools tatsächlich auszuführen.
-- **MCP Server:** Für komplexere Szenarien können ein oder mehrere MCP-Server eingerichtet und über die `mcpServers`-Einstellung in der `settings.json` konfiguriert werden. Der Core kann dann Tools erkennen und nutzen, die von diesen Servern bereitgestellt werden. Wie bereits erwähnt: Wenn mehrere MCP-Server verwendet werden, werden die Tool-Namen mit dem Server-Alias aus der Konfiguration vorangestellt (z. B. `serverAlias__actualToolName`).
+- **Befehlsbasierte Erkennung:** Fortgeschrittene Benutzer oder Projektadministratoren können einen `tools.toolDiscoveryCommand` in der `settings.json` definieren. Dieser Befehl sollte bei Ausführung durch den Core ein JSON-Array von `FunctionDeclaration`-Objekten ausgeben. Der Core stellt diese dann als `DiscoveredTool`-Instanzen zur Verfügung. Der entsprechende `tools.toolCallCommand` ist dann dafür verantwortlich, diese benutzerdefinierten Tools tatsächlich auszuführen.
+- **MCP Server:** Für komplexere Szenarien können ein oder mehrere MCP-Server eingerichtet und über die Einstellung `mcpServers` in der `settings.json` konfiguriert werden. Der Core kann dann Tools erkennen und nutzen, die von diesen Servern bereitgestellt werden. Wie bereits erwähnt: Wenn Sie mehrere MCP-Server verwenden, werden die Tool-Namen mit dem Servernamen aus Ihrer Konfiguration vorangestellt (z. B. `serverAlias__actualToolName`).
 
 Dieses Tool-System bietet eine flexible und leistungsstarke Möglichkeit, die Fähigkeiten des Modells zu erweitern und macht Qwen Code zu einem vielseitigen Assistenten für eine breite Palette von Aufgaben.