@neurocode-ai/web 1.18.8

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

@@ -0,0 +1,222 @@
+---
+title: Modèles
+description: Configuration d'un fournisseur et d'un modèle LLM.
+---
+
+OpenCode utilise [AI SDK](https://ai-sdk.dev/) et [Models.dev](https://models.dev) pour prendre en charge **75+ fournisseurs LLM** et prend en charge l'exécution de modèles locaux.
+
+---
+
+## Fournisseurs
+
+Les fournisseurs les plus populaires sont préchargés par défaut. Si vous avez ajouté les informations d'identification d'un fournisseur via la commande `/connect`, elles seront disponibles lorsque vous démarrerez OpenCode.
+
+En savoir plus sur [fournisseurs](/docs/providers).
+
+---
+
+## Sélection d'un modèle
+
+Une fois que vous avez configuré votre fournisseur, vous pouvez sélectionner le modèle souhaité en tapant :
+
+```bash frame="none"
+/models
+```
+
+---
+
+## Modèles recommandés
+
+Il existe de nombreux modèles et de nouveaux modèles sortent chaque semaine.
+
+:::tip
+Pensez à utiliser l’un des modèles que nous recommandons.
+:::
+
+Cependant, seuls quelques-uns d’entre eux savent à la fois générer du code et appeler des outils.
+
+Voici plusieurs modèles qui fonctionnent bien avec OpenCode, sans ordre particulier. (Cette liste n’est pas exhaustive et n’est pas nécessairement à jour) :
+
+- GPT 5.2
+- Codex GPT 5.1
+- Claude Opus 4.5
+- Claude Sonnet 4.5
+- Minimax M2.1
+- Gemini 3 Pro
+
+---
+
+## Définir une valeur par défaut
+
+Pour définir l'un d'entre eux comme modèle par défaut, vous pouvez définir la clé `model` dans votre configuration OpenCode.
+
+```json title="opencode.json" {3}
+{
+  "$schema": "https://opencode.ai/config.json",
+  "model": "lmstudio/google/gemma-3n-e4b"
+}
+```
+
+Ici, l'identifiant complet est `provider_id/model_id`. Par exemple, si vous utilisez [OpenCode Zen](/docs/zen), vous utiliserez `opencode/gpt-5.1-codex` pour GPT 5.1 Codex.
+
+Si vous avez configuré un [fournisseur personnalisé](/docs/providers#custom), le `provider_id` est la clé de la partie `provider` de votre configuration et le `model_id` est la clé de `provider.models`.
+
+---
+
+## Configuration des modèles
+
+Vous pouvez configurer globalement les options d'un modèle via le fichier config.
+
+```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,
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+Ici, nous configurons les paramètres globaux pour deux modèles intégrés : `gpt-5` lorsqu'il est accessible via le fournisseur `openai` et `claude-sonnet-4-20250514` lorsqu'il est accessible via le fournisseur `anthropic`.
+Les noms du fournisseur intégré et des modèles peuvent être trouvés sur [Models.dev](https://models.dev).
+
+Vous pouvez également configurer ces options pour tous les agents que vous utilisez. La configuration de l'agent remplace ici toutes les options globales. [En savoir plus](/docs/agents/#additional).
+
+Vous pouvez également définir des variantes personnalisées qui étendent celles intégrées. Les variantes vous permettent de configurer différents paramètres pour le même modèle sans créer d'entrées en double :
+
+```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",
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+---
+
+## Variantes
+
+De nombreux modèles prennent en charge plusieurs variantes avec différentes configurations. OpenCode est livré avec des variantes par défaut intégrées pour les fournisseurs populaires.
+
+### Variantes intégrées
+
+OpenCode est livré avec des variantes par défaut pour de nombreux fournisseurs :
+
+**Anthropic** :
+
+- `high` - Budget de réflexion élevé (par défaut)
+- `max` - Budget de réflexion maximum
+
+**OpenAI** :
+
+Varie selon le modèle mais en gros :
+
+- `none` - Aucun raisonnement
+- `minimal` - Effort de raisonnement minimal
+- `low` - Faible effort de raisonnement
+- `medium` - Effort de raisonnement moyen
+- `high` – Effort de raisonnement élevé
+- `xhigh` - Effort de raisonnement très élevé
+
+**Google**:
+
+- `low` – Budget d'effort/jetons réduit
+- `high` – Budget d'effort/de jetons plus élevé
+
+:::tip
+Cette liste n'est pas exhaustive. De nombreux autres fournisseurs ont également des paramètres par défaut intégrés.
+:::
+
+### Variantes personnalisées
+
+Vous pouvez remplacer les variantes existantes ou ajouter les vôtres :
+
+```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,
+            },
+          },
+        },
+      },
+    },
+  },
+}
+```
+
+### Cycle des variantes
+
+Utilisez le raccourci clavier `variant_cycle` pour basculer rapidement entre les variantes. [En savoir plus](/docs/keybinds).
+
+---
+
+## Chargement des modèles
+
+Lorsque OpenCode démarre, il recherche les modèles dans l'ordre de priorité suivant :
+
+1. Le flag de ligne de commande `--model` ou `-m`. Le format est le même que dans le fichier de configuration : `provider_id/model_id`.
+
+2. La liste des modèles dans la configuration OpenCode.
+
+   ```json title="opencode.json"
+   {
+     "$schema": "https://opencode.ai/config.json",
+     "model": "anthropic/claude-sonnet-4-20250514"
+   }
+   ```
+
+Le format ici est `provider/model`.
+
+3. Le dernier modèle utilisé.
+
+4. Le premier modèle utilisant une priorité interne.

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

@@ -0,0 +1,57 @@
+---
+title: Réseau
+description: Configurez les proxys et les certificats personnalisés.
+---
+
+OpenCode prend en charge les variables d'environnement proxy standard et les certificats personnalisés pour les environnements réseau d'entreprise.
+
+---
+
+## Proxy
+
+OpenCode respecte les variables d'environnement proxy standard.
+
+```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
+Le TUI communique avec un serveur HTTP local. Vous devez contourner le proxy pour cette connexion afin d'éviter les boucles de routage.
+:::
+
+Vous pouvez configurer le port et le nom d'hôte du serveur à l'aide de [CLI flags](/docs/cli#run).
+
+---
+
+### Authentification
+
+Si votre proxy nécessite une authentification de base, incluez les informations d'identification dans l'URL.
+
+```bash
+export HTTPS_PROXY=http://username:password@proxy.example.com:8080
+```
+
+:::caution
+Évitez de coder en dur les mots de passe. Utilisez des variables d’environnement ou un stockage sécurisé des informations d’identification.
+:::
+
+Pour les proxys nécessitant une authentification avancée comme NTLM ou Kerberos, envisagez d'utiliser une passerelle LLM qui prend en charge votre méthode d'authentification.
+
+---
+
+## Certificats personnalisés
+
+Si votre entreprise utilise des autorités de certification personnalisées pour les connexions HTTPS, configurez OpenCode pour leur faire confiance.
+
+```bash
+export NODE_EXTRA_CA_CERTS=/path/to/ca-cert.pem
+```
+
+Cela fonctionne à la fois pour les connexions proxy et pour l'accès direct à l'API.

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

@@ -0,0 +1,235 @@
+---
+title: Autorisations
+description: Contrôlez quelles actions nécessitent une approbation pour être exécutées.
+---
+
+OpenCode utilise la configuration `permission` pour décider si une action donnée doit s'exécuter automatiquement, vous inviter ou être bloquée.
+
+Depuis `v1.1.1`, l'ancienne configuration booléenne `tools` est obsolète et a été fusionnée dans `permission`. L'ancienne configuration `tools` est toujours prise en charge pour des raisons de compatibilité ascendante.
+
+---
+
+## Actions
+
+Chaque règle d'autorisation se résout en l'une des suivantes :
+
+- `"allow"` – exécuter sans approbation
+- `"ask"` – demande d'approbation
+- `"deny"` — bloque l'action
+
+---
+
+## Configuration
+
+Vous pouvez définir des autorisations globalement (avec `*`) et remplacer des outils spécifiques.
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "*": "ask",
+    "bash": "allow",
+    "edit": "deny"
+  }
+}
+```
+
+Vous pouvez également définir toutes les autorisations en même temps :
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": "allow"
+}
+```
+
+---
+
+## Règles granulaires (syntaxe d'objet)
+
+Pour la plupart des autorisations, vous pouvez utiliser un objet pour appliquer différentes actions en fonction de l'entrée de l'outil.
+
+```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"
+    }
+  }
+}
+```
+
+Les règles sont évaluées par correspondance de modèle, la **dernière règle correspondante étant gagnante**. Un modèle courant consiste à placer la règle fourre-tout `"*"` en premier, et les règles plus spécifiques après.
+
+### Caractères génériques
+
+Les modèles d'autorisation utilisent une simple correspondance de caractères génériques :
+
+- `*` correspond à zéro ou plusieurs caractères
+- `?` correspond exactement à un caractère
+- Tous les autres caractères correspondent littéralement
+
+### Extension du répertoire personnel
+
+Vous pouvez utiliser `~` ou `$HOME` au début d'un modèle pour référencer votre répertoire personnel. Ceci est particulièrement utile pour les règles [`external_directory`](#external-directories).
+
+- `~/projects/*` -> `/Users/username/projects/*`
+- `$HOME/projects/*` -> `/Users/username/projects/*`
+- `~` -> `/Users/username`
+
+### Répertoires externes
+
+Utilisez `external_directory` pour autoriser les appels d'outils qui touchent des chemins en dehors du répertoire de travail où OpenCode a été démarré. Cela s'applique à tout outil qui prend un chemin en entrée (par exemple `read`, `edit`, `glob`, `grep` et de nombreuses commandes `bash`).
+
+L'expansion du répertoire personnel (comme `~/...`) n'affecte que la façon dont un modèle est écrit. Cela n'intègre pas un chemin externe à l'espace de travail actuel, donc les chemins en dehors du répertoire de travail doivent toujours être autorisés via `external_directory`.
+
+Par exemple, cela permet d'accéder à tout ce qui se trouve sous `~/projects/personal/` :
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "external_directory": {
+      "~/projects/personal/**": "allow"
+    }
+  }
+}
+```
+
+Tout répertoire autorisé ici hérite des mêmes valeurs par défaut que l'espace de travail actuel. Étant donné que [`read` est par défaut `allow`](#defaults), les lectures sont également autorisées pour les entrées sous `external_directory`, sauf dérogation. Ajoutez des règles explicites lorsqu'un outil doit être restreint dans ces chemins, comme bloquer les modifications tout en conservant les lectures :
+
+```json title="opencode.json"
+{
+  "$schema": "https://opencode.ai/config.json",
+  "permission": {
+    "external_directory": {
+      "~/projects/personal/**": "allow"
+    },
+    "edit": {
+      "~/projects/personal/**": "deny"
+    }
+  }
+}
+```
+
+Gardez la liste centrée sur les chemins approuvés et superposez des règles d'autorisation ou de refus supplémentaires selon les besoins pour d'autres outils (par exemple `bash`).
+
+---
+
+## Autorisations disponibles
+
+Les autorisations OpenCode sont classées par nom d'outil, plus quelques garde-fous de sécurité :
+
+- `read` — lecture d'un fichier (correspond au chemin du fichier)
+- `edit` — toutes les modifications de fichiers (couvre `edit`, `write`, `patch`)
+- `glob` — globalisation de fichiers (correspond au modèle global)
+- `grep` — recherche de contenu (correspond au modèle regex)
+- `bash` - exécution de commandes shell (correspond aux commandes analysées comme `git status --porcelain`)
+- `task` — lancement de sous-agents (correspond au type de sous-agent)
+- `skill` — chargement d'une compétence (correspond au nom de la compétence)
+- `lsp` — exécution de requêtes LSP (actuellement non granulaires)
+- `webfetch` — récupérer une URL (correspond à l'URL)
+- `websearch` — recherche Web (correspond à la requête)
+- `external_directory` - déclenché lorsqu'un outil touche des chemins en dehors du répertoire de travail du projet
+- `doom_loop` — déclenché lorsque le même appel d'outil se répète 3 fois avec une entrée identique
+
+---
+
+## Valeurs par défaut
+
+Si vous ne spécifiez rien, OpenCode démarre avec les valeurs par défaut permissives :
+
+- La plupart des autorisations sont par défaut `"allow"`.
+- `doom_loop` et `external_directory` sont par défaut `"ask"`.
+- `read` est `"allow"`, mais les fichiers `.env` sont refusés par défaut :
+
+```json title="opencode.json"
+{
+  "permission": {
+    "read": {
+      "*": "allow",
+      "*.env": "deny",
+      "*.env.*": "deny",
+      "*.env.example": "allow"
+    }
+  }
+}
+```
+
+---
+
+## Que fait « Demander » ?
+
+Lorsque OpenCode demande l'approbation, l'interface utilisateur propose trois résultats :
+
+- `once` — approuve uniquement cette demande
+- `always` — approuve les futures demandes correspondant aux modèles suggérés (pour le reste de la session OpenCode en cours)
+- `reject` — refuser la demande
+
+L'ensemble des modèles que `always` approuverait est fourni par l'outil (par exemple, les approbations bash mettent généralement sur liste blanche un préfixe de commande sûr comme `git status*`).
+
+---
+
+## Agents
+
+Vous pouvez remplacer les autorisations par agent. Les autorisations des agents sont fusionnées avec la configuration globale et les règles des agents sont prioritaires. [En savoir plus](/docs/agents#permissions) sur les autorisations des agents.
+
+:::note
+Reportez-vous à la section [Règles granulaires (syntaxe d'objet)](#granular-rules-object-syntax) ci-dessus pour des exemples de correspondance de modèles plus détaillés.
+:::
+
+```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"
+        }
+      }
+    }
+  }
+}
+```
+
+Vous pouvez également configurer les autorisations des agents dans Markdown :
+
+```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
+Utilisez la correspondance de modèles pour les commandes avec des arguments. `"grep *"` autorise `grep pattern file.txt`, tandis que `"grep"` seul le bloquerait. Les commandes comme `git status` fonctionnent pour le comportement par défaut mais nécessitent une autorisation explicite (comme `"git status *"`) lorsque des arguments sont passés.
+:::