@neurocode-ai/web 1.18.8

package/src/content/docs/de/models.mdx

@@ -0,0 +1,223 @@
+---
+title: Modelle
+description: Konfigurieren eines LLM-Anbieters und -Modells.
+---
+
+OpenCode verwendet [AI SDK](https://ai-sdk.dev/) und [Models.dev](https://models.dev) zur Unterstützung von **75+ LLM-Anbietern** und unterstützt die Ausführung lokaler Modelle.
+
+---
+
+## Anbieter
+
+Die meisten gängigen Anbieter sind standardmäßig vorinstalliert. Wenn Sie die Anmeldeinformationen für einen Anbieter über den Befehl `/connect` hinzugefügt haben, sind diese verfügbar, wenn Sie OpenCode starten.
+
+Erfahren Sie mehr über [providers](/docs/providers).
+
+---
+
+## Modell auswählen
+
+Sobald Sie Ihren Anbieter konfiguriert haben, können Sie das gewünschte Modell auswählen, indem Sie Folgendes eingeben:
+
+```bash frame="none"
+/models
+```
+
+---
+
+## Empfohlene Modelle
+
+Es gibt viele Modelle da draußen und jede Woche kommen neue Modelle heraus.
+
+:::tip
+Erwägen Sie die Verwendung eines der von uns empfohlenen Modelle.
+:::
+
+Allerdings gibt es nur wenige von ihnen, die sowohl gut darin sind, Code zu generieren als auch Tools aufzurufen.
+
+Hier sind mehrere Modelle, die gut mit OpenCode funktionieren, in keiner bestimmten Reihenfolge. (Dies ist weder eine vollständige noch eine unbedingt aktuelle Liste):
+
+- GPT 5.2
+- GPT 5.1 Kodex
+- Claude Opus 4.5
+- Claude Sonett 4.5
+- Minimax M2.1
+- Gemini 3 Pro
+
+---
+
+## Standard festlegen
+
+Um eines davon als Standardmodell festzulegen, können Sie den Schlüssel `model` in Ihrem festlegen
+OpenCode config.
+
+```json title="opencode.json" {3}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "lmstudio/google/gemma-3n-e4b"
+}
+```
+
+Hier ist der vollständige ID `provider_id/model_id`. Wenn Sie beispielsweise [OpenCode Zen](/docs/zen) verwenden, würden Sie `opencode/gpt-5.1-codex` für GPT 5.1 Codex verwenden.
+
+Wenn Sie einen [custom provider](/docs/providers#custom) konfiguriert haben, ist `provider_id` der Schlüssel aus dem `provider`-Teil Ihrer Konfiguration und `model_id` der Schlüssel aus `provider.models`.
+
+---
+
+## Modelle konfigurieren
+
+Sie können die Optionen eines Modells global über die Konfiguration konfigurieren.
+
+```jsonc title="opencode.jsonc" {7-12,19-24}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "openai": {
+      "models": {
+        "gpt-5": {
+          "options": {
+            "reasoningEffort": "high",
+            "textVerbosity": "low",
+            "reasoningSummary": "auto",
+            "include": ["reasoning.encrypted_content"],
+          },
+        },
+      },
+    },
+    "anthropic": {
+      "models": {
+        "claude-sonnet-4-5-20250929": {
+          "options": {
+            "thinking": {
+              "type": "enabled",
+              "budgetTokens": 16000,
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+Hier konfigurieren wir globale Einstellungen für zwei integrierte Modelle: `gpt-5` bei Zugriff über den `openai`-Anbieter und `claude-sonnet-4-20250514` bei Zugriff über den `anthropic`-Anbieter.
+Die integrierten Anbieter- und Modellnamen finden Sie unter [Models.dev](https://models.dev).
+
+Sie können diese Optionen auch für alle von Ihnen verwendeten Agenten konfigurieren. Die Agentenkonfiguration beschreibt hier alle globalen Optionen. [Learn more](/docs/agents/#additional).
+
+Sie können auch benutzerdefinierte Varianten definieren, die integrierte Varianten erweitern. Mit Varianten können Sie unterschiedliche Einstellungen für dasselbe Modell konfigurieren, ohne doppelte Einträge zu erstellen:
+
+```jsonc title="opencode.jsonc" {6-21}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "opencode": {
+      "models": {
+        "gpt-5": {
+          "variants": {
+            "high": {
+              "reasoningEffort": "high",
+              "textVerbosity": "low",
+              "reasoningSummary": "auto",
+            },
+            "low": {
+              "reasoningEffort": "low",
+              "textVerbosity": "low",
+              "reasoningSummary": "auto",
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+---
+
+## Varianten
+
+Viele Modelle unterstützen mehrere Varianten mit unterschiedlichen Konfigurationen. OpenCode wird mit integrierten Standardvarianten für beliebte Anbieter ausgeliefert.
+
+### Integrierte Varianten
+
+OpenCode wird für viele Anbieter mit Standardvarianten ausgeliefert:
+
+**Anthropic**:
+
+- `high` – Budget für hohes Denken (Standard)
+- `max` – Maximales Denkbudget
+
+**OpenAI**:
+
+Variiert je nach Modell, aber ungefähr:
+
+- `none` – Keine Begründung
+- `minimal` – Minimaler Argumentationsaufwand
+- `low` – Geringer Denkaufwand
+- `medium` – Mittlerer Denkaufwand
+- `high` – Hoher Denkaufwand
+- `xhigh` – Extra hoher Argumentationsaufwand
+
+**Google**:
+
+- `low` – Beliebtestes effort/token-Budget
+- `high` – Höheres effort/token-Budget
+
+:::tip
+Diese Liste ist nicht vollständig. Viele andere Anbieter verfügen ebenfalls über integrierte Standardeinstellungen.
+:::
+
+### Benutzerdefinierte Varianten
+
+Sie können vorhandene Varianten überschreiben oder eigene hinzufügen:
+
+```jsonc title="opencode.jsonc" {7-18}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "provider": {
+    "openai": {
+      "models": {
+        "gpt-5": {
+          "variants": {
+            "thinking": {
+              "reasoningEffort": "high",
+              "textVerbosity": "low",
+            },
+            "fast": {
+              "disabled": true,
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+### Varianten durchwechseln
+
+Verwenden Sie die Tastenkombination `variant_cycle`, um schnell zwischen Varianten zu wechseln. [Learn more](/docs/keybinds).
+
+---
+
+## Laden von Modellen
+
+Wenn OpenCode startet, sucht es nach Modellen in der folgenden Prioritätsreihenfolge:
+
+1. Das Befehlszeilenflag `--model` oder `-m`. Das Format ist das gleiche wie in der Konfigurationsdatei: `provider_id/model_id`.
+
+2. Die Modellliste in der OpenCode-Konfiguration.
+
+   ```json title="opencode.json"
+   {
+     "$schema": "https://opencode.ai/config.json",
+     "model": "anthropic/claude-sonnet-4-20250514"
+   }
+   ```
+
+   Das Format hier ist `provider/model`.
+
+3. Das zuletzt verwendete Modell.
+
+4. Das erste Modell, das eine interne Priorität verwendet.

package/src/content/docs/de/network.mdx

@@ -0,0 +1,57 @@
+---
+title: Netzwerk
+description: Konfigurieren Sie Proxys und benutzerdefinierte Zertifikate.
+---
+
+OpenCode unterstützt Standard-Proxy-Umgebungsvariablen und benutzerdefinierte Zertifikate für Unternehmensnetzwerkumgebungen.
+
+---
+
+## Proxy
+
+OpenCode respektiert Standard-Proxy-Umgebungsvariablen.
+
+```bash
+# HTTPS proxy (recommended)
+export HTTPS_PROXY=https://proxy.example.com:8080
+
+# HTTP proxy (if HTTPS not available)
+export HTTP_PROXY=http://proxy.example.com:8080
+
+# Bypass proxy for local server (required)
+export NO_PROXY=localhost,127.0.0.1
+```
+
+:::caution
+Der TUI kommuniziert mit einem lokalen HTTP-Server. Sie müssen den Proxy für diese Verbindung umgehen, um Routing-Schleifen zu verhindern.
+:::
+
+Sie können den Port und den Hostnamen des Servers mit [CLI flags](/docs/cli#run) konfigurieren.
+
+---
+
+### Authentifizierung
+
+Wenn Ihr Proxy eine Basisauthentifizierung erfordert, geben Sie Anmeldeinformationen in URL ein.
+
+```bash
+export HTTPS_PROXY=http://username:password@proxy.example.com:8080
+```
+
+:::caution
+Vermeiden Sie hartkodierte Passwörter. Verwenden Sie Umgebungsvariablen oder einen sicheren Speicher für Anmeldeinformationen.
+:::
+
+Für Proxys, die eine erweiterte Authentifizierung wie NTLM oder Kerberos erfordern, sollten Sie die Verwendung eines LLM-Gateways in Betracht ziehen, das Ihre Authentifizierungsmethode unterstützt.
+
+---
+
+## Benutzerdefinierte Zertifikate
+
+Wenn Ihr Unternehmen benutzerdefinierte Zertifizierungsstellen für HTTPS-Verbindungen verwendet, konfigurieren Sie OpenCode so, dass es ihnen vertraut.
+
+```bash
+export NODE_EXTRA_CA_CERTS=/path/to/ca-cert.pem
+```
+
+Dies funktioniert sowohl für Proxy-Verbindungen als auch für den direkten API-Zugriff.

package/src/content/docs/de/permissions.mdx

@@ -0,0 +1,235 @@
+---
+title: Berechtigungen
+description: Steuern Sie, für welche Aktionen eine Genehmigung erforderlich ist.
+---
+
+OpenCode verwendet die `permission`-Konfiguration, um zu entscheiden, ob eine bestimmte Aktion automatisch ausgeführt werden soll, Sie dazu auffordern oder blockiert werden soll.
+
+Ab `v1.1.1` ist die alte boolesche Konfiguration `tools` veraltet und wurde in `permission` zusammengeführt. Die alte `tools`-Konfiguration wird aus Gründen der Abwärtskompatibilität weiterhin unterstützt.
+
+---
+
+## Aktionen
+
+Jede Berechtigungsregel wird zu einem der folgenden aufgelöst:
+
+- `"allow"` – ohne Genehmigung ausführen
+- `"ask"` — um Genehmigung bitten
+- `"deny"` – Aktion blockieren
+
+---
+
+## Konfiguration
+
+Sie können Berechtigungen global festlegen (mit `*`) und bestimmte Tools überschreiben.
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "*": "ask",
+    "bash": "allow",
+    "edit": "deny"
+  }
+}
+```
+
+Sie können auch alle Berechtigungen auf einmal festlegen:
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": "allow"
+}
+```
+
+---
+
+## Granulare Regeln (Objektsyntax)
+
+Bei den meisten Berechtigungen können Sie ein Objekt verwenden, um basierend auf der Werkzeugeingabe verschiedene Aktionen anzuwenden.
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "bash": {
+      "*": "ask",
+      "git *": "allow",
+      "npm *": "allow",
+      "rm *": "deny",
+      "grep *": "allow"
+    },
+    "edit": {
+      "*": "deny",
+      "packages/web/src/content/docs/*.mdx": "allow"
+    }
+  }
+}
+```
+
+Regeln werden nach Musterübereinstimmung ausgewertet, wobei die **letzte übereinstimmende Regel gewinnt**. Ein gängiges Muster besteht darin, zuerst die Catch-All-Regel `"*"` und danach spezifischere Regeln zu platzieren.
+
+### Platzhalter
+
+Berechtigungsmuster verwenden einen einfachen Platzhalterabgleich:
+
+- `*` matches zero or more of any character
+- `?` matches exactly one character
+- Alle anderen Zeichen stimmen wörtlich überein
+
+### Erweiterung des Home-Verzeichnisses
+
+Sie können `~` oder `$HOME` am Anfang eines Musters verwenden, um auf Ihr Home-Verzeichnis zu verweisen. Dies ist besonders nützlich für [`external_directory`](#external-directories)-Regeln.
+
+- `~/projects/*` -> `/Users/username/projects/*`
+- `$HOME/projects/*` -> `/Users/username/projects/*`
+- `~` -> `/Users/username`
+
+### Externe Verzeichnisse
+
+Verwenden Sie `external_directory`, um Toolaufrufe zuzulassen, die Pfade außerhalb des Arbeitsverzeichnisses berühren, in dem OpenCode gestartet wurde. Dies gilt für jedes Werkzeug, das einen Pfad als Eingabe verwendet (z. B. `read`, `edit`, `glob`, `grep` und viele `bash`-Befehle).
+
+Die Home-Erweiterung (wie `~/...`) wirkt sich nur darauf aus, wie ein Muster geschrieben wird. Dadurch wird ein externer Pfad nicht zum Teil des aktuellen Arbeitsbereichs, daher müssen Pfade außerhalb des Arbeitsverzeichnisses weiterhin über `external_directory` zulässig sein.
+
+Dies ermöglicht beispielsweise den Zugriff auf alles unter `~/projects/personal/`:
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "external_directory": {
+      "~/projects/personal/**": "allow"
+    }
+  }
+}
+```
+
+Jedes hier zulässige Verzeichnis erbt dieselben Standardeinstellungen wie der aktuelle Arbeitsbereich. Seit [`read` defaults to `allow`](#defaults) sind Lesevorgänge auch für Einträge unter `external_directory` zulässig, sofern sie nicht überschrieben werden. Fügen Sie explizite Regeln hinzu, wenn ein Tool in diesen Pfaden eingeschränkt werden soll, z. B. das Blockieren von Bearbeitungen, während Lesevorgänge beibehalten werden:
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "external_directory": {
+      "~/projects/personal/**": "allow"
+    },
+    "edit": {
+      "~/projects/personal/**": "deny"
+    }
+  }
+}
+```
+
+Konzentrieren Sie sich in der Liste auf vertrauenswürdige Pfade und fügen Sie bei Bedarf zusätzliche Zulassungs- oder Ablehnungsregeln für andere Tools hinzu (z. B. `bash`).
+
+---
+
+## Verfügbare Berechtigungen
+
+OpenCode-Berechtigungen basieren auf Tool-Namen sowie einigen Sicherheitsvorkehrungen:
+
+- `read` – eine Datei lesen (entspricht dem Dateipfad)
+- `edit` – alle Dateiänderungen (umfasst `edit`, `write`, `patch`)
+- `glob` – Datei-Globbing (entspricht dem Glob-Muster)
+- `grep` – Inhaltssuche (entspricht dem Regex-Muster)
+- `bash` – Ausführen von Shell-Befehlen (entspricht analysierten Befehlen wie `git status --porcelain`)
+- `task` – Subagenten starten (entspricht dem Subagententyp)
+- `skill` – Laden einer Fertigkeit (entspricht dem Fertigkeitsnamen)
+- `lsp` – Ausführen von LSP-Abfragen (derzeit nicht granular)
+- `webfetch` – Abrufen eines URL (entspricht dem URL)
+- `websearch` – Websuche (entspricht der Abfrage)
+- `external_directory` – wird ausgelöst, wenn ein Tool Pfade außerhalb des Projektarbeitsverzeichnisses berührt
+- `doom_loop` – wird ausgelöst, wenn derselbe Werkzeugaufruf dreimal mit identischer Eingabe wiederholt wird
+
+---
+
+## Standardwerte
+
+Wenn Sie nichts angeben, beginnt OpenCode mit zulässigen Standardeinstellungen:
+
+- Die meisten Berechtigungen sind standardmäßig auf `"allow"` eingestellt.
+- `doom_loop` und `external_directory` sind standardmäßig `"ask"`.
+- `read` ist `"allow"`, aber `.env`-Dateien werden standardmäßig verweigert:
+
+```json title="opencode.json"
+{
+  "permission": {
+    "read": {
+      "*": "allow",
+      "*.env": "deny",
+      "*.env.*": "deny",
+      "*.env.example": "allow"
+    }
+  }
+}
+```
+
+---
+
+## Was „Fragen“ bewirkt
+
+Wenn OpenCode zur Genehmigung auffordert, bietet UI drei Ergebnisse:
+
+- `once` – nur diese Anfrage genehmigen
+- `always` – zukünftige Anfragen genehmigen, die den vorgeschlagenen Mustern entsprechen (für den Rest der aktuellen OpenCode-Sitzung)
+- `reject` – die Anfrage ablehnen
+
+Der Satz von Mustern, die `always` genehmigen würde, wird vom Tool bereitgestellt (Beispiel: Bash-Genehmigungen setzen normalerweise ein sicheres Befehlspräfix wie `git status*` auf die Whitelist).
+
+---
+
+## Agenten
+
+Sie können Berechtigungen pro Agent überschreiben. Agentenberechtigungen werden mit der globalen Konfiguration zusammengeführt und Agentenregeln haben Vorrang. [Learn more](/docs/agents#permissions) über Agentenberechtigungen.
+
+:::note
+Ausführlichere Mustervergleichsbeispiele finden Sie oben im Abschnitt [Granular Rules (Object Syntax)](#granular-rules-object-syntax).
+:::
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "bash": {
+      "*": "ask",
+      "git *": "allow",
+      "git commit *": "deny",
+      "git push *": "deny",
+      "grep *": "allow"
+    }
+  },
+  "agent": {
+    "build": {
+      "permission": {
+        "bash": {
+          "*": "ask",
+          "git *": "allow",
+          "git commit *": "ask",
+          "git push *": "deny",
+          "grep *": "allow"
+        }
+      }
+    }
+  }
+}
+```
+
+Sie können Agentenberechtigungen auch in Markdown konfigurieren:
+
+```markdown title="~/.config/opencode/agents/review.md"
+---
+description: Code review without edits
+mode: subagent
+permission:
+  edit: deny
+  bash: ask
+  webfetch: deny
+---
+
+Only analyze code and suggest changes.
+```
+
+:::tip
+Verwenden Sie den Mustervergleich für Befehle mit Argumenten. `"grep *"` erlaubt `grep pattern file.txt`, während `"grep"` allein es blockieren würde. Befehle wie `git status` funktionieren für das Standardverhalten, erfordern jedoch eine explizite Erlaubnis (wie `"git status *"`), wenn Argumente übergeben werden.
+:::