# Référence du système d'outils (/fr/docs/verdent-for-vscode/advanced-features/tool-reference)
> Référence complète du système d'outils de Verdent
### Ce que vous allez apprendre [#ce-que-vous-allez-apprendre]
Référence complète du système d'outils intégré de Verdent, incluant les opérations sur les fichiers, les capacités de recherche, l'exécution de commandes et les outils d'intégration.
***
## Vue d'ensemble des outils disponibles [#vue-densemble-des-outils-disponibles]
Verdent for VS Code fournit une boîte à outils complète pour la manipulation de code, la navigation et l'interaction externe.
| Outil | Objectif | Capacités clés |
| ------------ | ------------------------------- | --------------------------------------------------------------------------------------------------- |
| `file_read` | Lire le contenu d'un fichier | Prend en charge les plages de lignes pour les gros fichiers, fonctionne avec tous les formats texte |
| `file_edit` | Modifications ciblées | Remplace des correspondances de texte exactes, remplacements multiples, préserve le formatage |
| `file_write` | Créer ou remplacer des fichiers | Création/remplacement complet de fichier, gère le contenu texte |
| Outil | Objectif | Capacités clés |
| -------------- | ---------------------------------- | ----------------------------------------------------------------------------- |
| `glob` | Recherche de fichiers par motif | Motifs glob (`**/*.ts`), motifs d'exclusion, limitation des résultats |
| `grep_content` | Recherche de contenu avec contexte | Prise en charge des regex, lignes de contexte, options insensibles à la casse |
| `grep_file` | Lister les fichiers correspondants | Identifie rapidement les fichiers avant d'en lire le contenu |
| `list_dir` | Structure des répertoires | Affiche la hiérarchie, motifs d'exclusion, contrôle de la profondeur |
| Outil | Objectif | Capacités clés |
| ---------------- | -------------------------------- | ------------------------------------------------------------------------------------- |
| `bash` | Exécution de commandes shell | Configuration du délai d'expiration, descriptions résumées, enchaînement de commandes |
| `spawn_subagent` | Déléguer à des spécialistes | Lance des sous-agents general, explorer, verifier ou code-reviewer |
| `todo_update` | Suivre la progression des tâches | Gère les listes de tâches, met à jour le statut, suit la progression |
| Outil | Objectif | Capacités clés |
| ------------ | ------------------------------- | ------------------------------------------------------------------------------ |
| `web_search` | Recherche sur internet | Exécution de requêtes, contrôle du nombre de résultats, filtrage par fraîcheur |
| `web_fetch` | Récupérer et analyser des pages | Récupère du contenu, extrait des informations à partir de requêtes |
***
## Capacités des outils et cas d'usage [#capacités-des-outils-et-cas-dusage]
### file\_read [#file_read]
**Capacités :**
* Lit le contenu complet d'un fichier ou des plages de lignes spécifiques
* Essentiel pour comprendre le code avant toute modification
* Gestion efficace des gros fichiers grâce à la spécification de plages
**Cas d'usage :**
* Lire des fichiers de configuration avant de les modifier
* Comprendre les schémas d'implémentation existants
* Examiner des fichiers de test pour comprendre la couverture
**Exemple :**
```bash
# Read entire file
file_read("src/components/Button.tsx")
# Read specific range for large files
file_read("package-lock.json", start_line=1, max_lines=50)
```
***
### file\_edit [#file_edit]
**Capacités :**
* Remplacement précis de texte par correspondance exacte de chaîne
* Opérations de remplacement multiples avec l'indicateur `multiple`
* Préserve la structure et le formatage du fichier
**Cas d'usage :**
* Mettre à jour des implémentations de fonctions
* Modifier des valeurs de configuration
* Renommer des variables dans plusieurs fichiers
**Bonne pratique :** À utiliser pour des changements ciblés. Pour des réécritures complètes, utilisez plutôt `file_write`.
***
### file\_write [#file_write]
**Capacités :**
* Créer de nouveaux fichiers depuis zéro
* Remplacer entièrement le contenu de fichiers existants
* Gérer tout format basé sur du texte
**Cas d'usage :**
* Générer de nouveaux composants ou modules
* Créer des fichiers de configuration
* Écrire des fichiers de test
**Avertissement :** Remplace entièrement les fichiers existants. Utilisez `file_edit` pour des modifications partielles.
### glob [#glob]
**Capacités :**
* Trouve des fichiers correspondant à des motifs : `**/*.ts`, `src/**/*.js`
* Filtre par chemin de répertoire
* Motifs d'exclusion pour affiner les résultats
* Contrôle du nombre de résultats
**Cas d'usage :**
* Trouver tous les composants d'un projet
* Localiser des fichiers de test
* Identifier des fichiers de configuration dans plusieurs répertoires
**Exemples de motifs :**
```bash
**/*.tsx # All TypeScript React files
src/**/*.test.js # All test files in src
**/config.* # All config files anywhere
```
***
### grep\_content [#grep_content]
**Capacités :**
* Recherche dans le contenu des fichiers à l'aide de motifs regex
* Affiche des lignes de contexte avant/après les correspondances (indicateurs `-B`, `-A`)
* Recherche insensible à la casse
* Filtrage par type de fichier via des motifs glob
**Cas d'usage :**
* Trouver des définitions de fonctions
* Localiser des implémentations de points de terminaison API
* Rechercher des messages d'erreur spécifiques
* Identifier des schémas de sécurité
**Exemple :**
```bash
# Find authentication-related code
grep_content("auth.*login", glob="**/*.ts")
# Search with context
grep_content("TODO", glob="src/**", context_before=2, context_after=2)
```
***
### grep\_file [#grep_file]
**Capacités :**
* Liste les fichiers contenant des correspondances de motif
* Plus rapide que `grep_content` lorsque vous avez seulement besoin de l'emplacement des fichiers
* Prise en charge des motifs regex
* Filtrage glob par type de fichier
**Cas d'usage :**
* Identifier les fichiers à refactoriser
* Trouver les fichiers qui importent des modules spécifiques
* Localiser les fichiers contenant des schémas obsolètes
**Bonne pratique :** Utilisez d'abord `grep_file` pour identifier les fichiers pertinents, puis `file_read` pour un examen détaillé.
***
### list\_dir [#list_dir]
**Capacités :**
* Affiche la hiérarchie des répertoires
* Contrôle de la profondeur avec le paramètre `max_depth`
* Motifs d'exclusion pour filtrer la sortie
**Cas d'usage :**
* Comprendre la structure d'un projet
* Vérifier l'organisation des répertoires
* Trouver des sous-répertoires spécifiques
### bash [#bash]
**Capacités :**
* Exécute des commandes shell
* Délai d'expiration maximal : 120 secondes (2 minutes, limite stricte)
* Enchaîne les commandes avec `&&` pour gérer les dépendances
* Fournit des résumés descriptifs pour plus de clarté
**Cas d'usage :**
* Exécuter des tests
* Construire des projets
* Installer des dépendances
* Opérations Git
* Migrations de base de données
**Exemple :**
```bash
# Run tests
bash("npm test", timeout=60000, summary="Run Jest test suite")
# Chain dependent commands
bash("npm install && npm run build", timeout=120000)
```
**Sécurité :** Les commandes s'exécutent avec les permissions de l'utilisateur. Vérifiez les commandes dans Manual Accept Mode.
***
### spawn\_subagent [#spawn_subagent]
**Capacités :**
* Lance des sous-agents spécialisés avec des contextes isolés
* Types : `explorer`, `verifier`, `code-reviewer`
* Délègue des tâches complexes sans polluer le contexte principal
* Exécution parallèle de sous-agents pour plus d'efficacité
**Cas d'usage :**
* **explorer :** Rechercher des motifs dans de grandes bases de code
* **verifier :** Valider la logique d'implémentation
* **code-reviewer :** Évaluation de la sécurité et de la qualité
**Bonne pratique :** Déléguez les recherches exploratoires au sous-agent Explorer pour préserver le contexte de la conversation principale.
***
### todo\_update [#todo_update]
**Capacités :**
* Créer et gérer des listes de tâches
* Mettre à jour le statut des tâches (pending, in\_progress, completed)
* Suivre la progression au fil d'implémentations complexes
**Cas d'usage :**
* Décomposer des fonctionnalités multi-étapes
* Suivre la progression d'une refactorisation
* Gérer des tâches de migration
### web\_search [#web_search]
**Capacités :**
* Interroge des moteurs de recherche internet
* Contrôle du nombre de résultats
* Filtrage par fraîcheur (jours récents)
**Cas d'usage :**
* Trouver la documentation de APIs peu familiers
* Rechercher des messages d'erreur
* Vérifier les bonnes pratiques actuelles
***
### web\_fetch [#web_fetch]
**Capacités :**
* Récupère le contenu de pages web
* Analyse le contenu à l'aide de requêtes spécifiques
* Extrait des informations structurées
**Cas d'usage :**
* Lire des pages de documentation
* Analyser la documentation API
* Extraire des exemples depuis des tutoriels
***
## Prise en charge des formats de fichiers [#prise-en-charge-des-formats-de-fichiers]
Verdent fonctionne avec tous les formats de fichiers basés sur du texte grâce à ses outils d'opération sur les fichiers.
| Catégorie | Langages/Extensions |
| --------------- | --------------------------------------------------- |
| **Web** | JavaScript, TypeScript, HTML, CSS, SCSS, LESS |
| **Backend** | Python, Java, Go, Rust, C, C++, C#, Ruby, PHP, Perl |
| **Mobile** | Swift, Kotlin, Dart (Flutter), Objective-C |
| **Fonctionnel** | Haskell, Scala, Elixir, Clojure, F# |
| **Scripting** | Bash, PowerShell, Zsh, Fish |
| **Données** | SQL, R, Julia, MATLAB |
| Format | Exemples courants |
| -------- | ------------------------------------------------------------- |
| **JSON** | package.json, tsconfig.json, settings.json |
| **YAML** | docker-compose.yml, GitHub Actions, configurations Kubernetes |
| **TOML** | Cargo.toml, pyproject.toml |
| **XML** | pom.xml, web.xml, fichiers de configuration |
| **INI** | .gitconfig, .editorconfig |
| **ENV** | fichiers .env, configuration d'environnement |
| **HCL** | Configuration Terraform |
| Format | Cas d'usage |
| -------------------- | --------------------------------------------- |
| **Markdown** | README.md, fichiers de documentation |
| **HTML** | Modèles, pages web |
| **LaTeX** | Documents scientifiques, articles académiques |
| **reStructuredText** | Documentation Python |
| **AsciiDoc** | Documentation technique |
### Formats de données [#formats-de-données]
| Format | Description |
| ------------------------------- | ------------------------------------ |
| **CSV/TSV** | Fichiers de données tabulaires |
| **Données basées sur du texte** | Fichiers de logs, exports de données |
| **JSON/YAML** | Échange de données structurées |
### Fichiers de build et de package [#fichiers-de-build-et-de-package]
| Fichier | Objectif |
| -------------------- | ----------------------- |
| **Makefile** | Automatisation du build |
| **package.json** | Dépendances Node.js |
| **requirements.txt** | Paquets Python |
| **Gemfile** | Gems Ruby |
| **Cargo.toml** | Paquets Rust |
| **build.gradle** | Builds Gradle |
| Type de format | Exemples | Modifiable |
| -------------------------- | ---------------------------- | -------------------------- |
| **Images** | PNG, JPG, GIF, SVG (binaire) | Non modifiable directement |
| **Vidéos** | MP4, AVI, MOV | Non modifiable directement |
| **Binaires compilés** | EXE, DLL, SO | Non modifiable directement |
| **Archives** | ZIP, TAR, GZ | Non modifiable directement |
| **Documents bureautiques** | DOCX, XLSX, PPTX | Non modifiable directement |
| **PDF** | Fichiers PDF | Non modifiable directement |
Les fichiers binaires peuvent être référencés dans le code mais ne peuvent pas être modifiés via les outils de fichiers.
***
## Prise en charge des langages de programmation [#prise-en-charge-des-langages-de-programmation]
Verdent offre une prise en charge complète de tous les langages de programmation et frameworks basés sur du texte.
| Langage/Framework | Niveau de prise en charge | Cas d'usage courants |
| ----------------- | ------------------------- | -------------------------------------------------------------------- |
| JavaScript | Excellent | Logique frontend, backends Node.js, outillage |
| TypeScript | Excellent | Applications web sûres au niveau des types, projets à grande échelle |
| React | Excellent | Interfaces basées sur des composants, hooks, gestion d'état |
| Vue | Excellent | Applications web progressives, composants monofichiers |
| Angular | Excellent | Applications d'entreprise, intégration TypeScript |
| Svelte | Très bon | Composants compilés, programmation réactive |
| HTML/CSS | Excellent | Balisage, style, design responsive |
| SCSS/LESS | Excellent | Style avancé, variables, mixins |
| Langage/Framework | Niveau de prise en charge | Cas d'usage courants |
| -------------------- | ------------------------- | --------------------------------------------------- |
| Python | Excellent | APIs, traitement de données, automatisation |
| Django/Flask/FastAPI | Excellent | Frameworks web, APIs REST |
| Node.js/Express | Excellent | Backends JavaScript, microservices |
| Java/Spring | Excellent | Applications d'entreprise, Spring Boot |
| Go | Excellent | Services haute performance, CLI |
| Rust | Très bon | Programmation système, code critique en performance |
| C/C++ | Très bon | Systèmes, embarqué, moteurs de jeu |
| C# / .NET | Excellent | Applications Windows, services web, Unity |
| Ruby/Rails | Très bon | Applications web, développement rapide |
| PHP | Bon | WordPress, Laravel, applications héritées |
| Langage/Framework | Niveau de prise en charge | Cas d'usage courants |
| ----------------- | ------------------------- | ------------------------------------------ |
| Swift | Excellent | Applications natives iOS/macOS |
| Kotlin | Excellent | Applications natives Android |
| Dart/Flutter | Excellent | Applications mobiles multiplateformes |
| React Native | Excellent | Applications mobiles basées sur JavaScript |
| Objective-C | Bon | Applications iOS/macOS héritées |
| Langage | Niveau de prise en charge | Cas d'usage courants |
| ------- | ------------------------- | -------------------------------------------------- |
| Python | Excellent | NumPy, Pandas, scikit-learn, TensorFlow |
| R | Très bon | Analyse statistique, visualisation de données |
| SQL | Excellent | Requêtes de base de données, conception de schémas |
| Julia | Bon | Calcul scientifique, analyse numérique |
| Langage | Niveau de prise en charge | Cas d'usage courants |
| ---------- | ------------------------- | ------------------------------------- |
| C | Très bon | Programmation système, embarqué |
| C++ | Très bon | Applications critiques en performance |
| Rust | Très bon | Programmation système sûre en mémoire |
| Go | Excellent | Systèmes concurrents, services cloud |
| Assembleur | Bon | Optimisation bas niveau, débogage |
**Qualité de la prise en charge :** Les langages courants (JavaScript, Python, TypeScript) bénéficient d'une prise en charge renforcée grâce à un volume important de données d'entraînement. Les langages moins courants ou spécifiques à un domaine peuvent offrir une qualité de prise en charge réduite tout en restant fonctionnels.
***
## Limites d'utilisation et bonnes pratiques [#limites-dutilisation-et-bonnes-pratiques]
### Efficacité de file\_read [#efficacité-de-file_read]
**Bonnes pratiques :**
* Utilisez des plages de lignes pour les fichiers de plus de 500 lignes afin d'éviter une surcharge du contexte
* Ne lisez que les sections pertinentes nécessaires à la tâche
* Pour les gros fichiers, utilisez d'abord `grep_content` pour identifier les numéros de lignes pertinents
```bash
# Good: Read specific section
file_read("large-config.json", start_line=100, max_lines=50)
# Less efficient: Read entire large file
file_read("large-config.json") # May consume excessive context
```
***
### Précision de file\_edit [#précision-de-file_edit]
**Bonnes pratiques :**
* Assurez des correspondances exactes de chaîne pour éviter les échecs de modification
* Pour des changements multiples similaires, utilisez l'indicateur `multiple=true`
* Vérifiez les chemins de fichiers avant de les modifier
***
### Sécurité de file\_write [#sécurité-de-file_write]
**Bonnes pratiques :**
* Vérifiez soigneusement les chemins pour éviter des remplacements accidentels
* À utiliser uniquement pour de nouveaux fichiers ou des réécritures complètes
* Pour des modifications, privilégiez `file_edit` par sécurité
### Spécificité des motifs glob [#spécificité-des-motifs-glob]
**Bonnes pratiques :**
* Utilisez des motifs spécifiques pour restreindre la portée : `src/**/*.ts` plutôt que `**/*`
* Excluez des répertoires avec des motifs d'exclusion : `!**/node_modules/**`
* Limitez les résultats pour éviter une sortie excessive
```bash
# Good: Specific scope
glob("src/components/**/*.tsx", max_results=50)
# Less efficient: Too broad
glob("**/*") # Returns thousands of results
```
***
### Stratégie grep [#stratégie-grep]
**Flux de travail recommandé :**
1. Utilisez `grep_file` pour identifier les fichiers pertinents
2. Lisez les fichiers spécifiques avec `file_read`
3. Utilisez `grep_content` lorsque vous avez besoin du contexte environnant
**Conseils de performance :**
* Les motifs regex peuvent être plus lents que les chaînes littérales
* Les recherches insensibles à la casse sont plus lentes
* Limitez les lignes de contexte (`-A`, `-B`) au nécessaire
### Bonnes pratiques pour bash [#bonnes-pratiques-pour-bash]
**Exécution sécurisée des commandes :**
* Fournissez des résumés clairs pour décrire les commandes
* Définissez des délais d'expiration appropriés pour les opérations longues
* Enchaînez les commandes dépendantes avec `&&`
* Examinez attentivement les commandes destructrices (rm, drop, truncate)
```bash
# Good: Clear summary, reasonable timeout
bash("npm run build", timeout=120000, summary="Build production bundle")
# Good: Chained dependencies
bash("npm install && npm run test", timeout=180000)
```
***
### Considérations de sécurité [#considérations-de-sécurité]
**Règles de sécurité critiques :**
* Les commandes s'exécutent avec les permissions de l'utilisateur
* Ne jamais exécuter de commandes non fiables
* Utilisez Manual Accept Mode pour la revue dans des bases de code partagées
* Évitez les commandes qui exposent des identifiants ou des données sensibles
Vérifiez toujours les commandes bash dans Manual Accept Mode lorsque vous travaillez dans des bases de code partagées ou des environnements de production.
### Efficacité de la délégation aux sous-agents [#efficacité-de-la-délégation-aux-sous-agents]
**Quand utiliser des sous-agents :**
* **Explorer :** Recherches dans la base de code, questions d'architecture (préserve le contexte principal)
* **Verifier :** Vérifications rapides (validation isolée)
* **Code-reviewer :** Revues de sécurité et de qualité (analyse détaillée)
* **General :** Tâches complexes multi-étapes (exécution parallèle)
**Bonne pratique :**
Déléguez les tâches exploratoires et de recherche à des sous-agents pour préserver le contexte de la conversation principale pour le travail de développement actif.
***
### Gestion du contexte [#gestion-du-contexte]
**Utilisation stratégique des outils :**
* Lisez les fichiers de manière stratégique - uniquement ce qui est nécessaire
* Utilisez des sous-agents pour la recherche en arrière-plan
* Surveillez la consommation de contexte lors de sessions longues
* Décomposez les opérations complexes en étapes avec todo\_update
**Flux de travail efficaces :**
1. **Planification :** Utilisez glob/grep pour identifier la portée
2. **Lecture :** Lisez uniquement les fichiers/sections pertinents
3. **Exécution :** Déléguez à des sous-agents lorsque c'est pertinent
4. **Vérification :** Vérifications rapides avec le sous-agent Verifier
### Limites de taille de fichier [#limites-de-taille-de-fichier]
**Gestion des gros fichiers :**
Les fichiers très volumineux (>10 000 lignes) doivent être lus par sections pour éviter :
* L'épuisement de la fenêtre de contexte
* Des temps de réponse lents
* Des problèmes de mémoire
Pour les fichiers de plus de 500 lignes, utilisez toujours des plages de lignes avec `file_read` pour maintenir des performances optimales.
***
### Délais d'expiration par défaut des outils [#délais-dexpiration-par-défaut-des-outils]
**Limites des outils :**
* **Délai d'expiration de Bash :** 120 secondes (2 minutes) maximum
* **Opérations sur les fichiers :** Aucune limite de taille (les gros fichiers sont automatiquement lus par lots)
* **Gestion des gros fichiers :** Les fichiers >256 Ko ne renvoient que les 256 premiers Ko de contenu
* **Résultats de recherche :** Aucune limite sur les résultats de `glob` ou `grep_content`
* **Sous-agents concurrents :** Aucune limite sur l'exécution parallèle
**Configuration des délais d'expiration :**
* Définissez des délais d'expiration explicites pour les opérations longues
* Surveillez les processus bloqués
* Les commandes dépassant le délai de 2 minutes seront interrompues
***
### Opérations concurrentes [#opérations-concurrentes]
**Exécution parallèle :**
Plusieurs sous-agents peuvent s'exécuter en parallèle pour accélérer les opérations complexes. L'agent principal gère automatiquement la coordination.
**Avantages en performance :**
* Réduction du temps d'exécution total pour les tâches multi-étapes
* Utilisation efficace des ressources
* Orchestration automatique des tâches
* Aucune limite sur le nombre de sous-agents concurrents
***
## Voir aussi [#voir-aussi]
Découvrez les agents spécialisés
Contrôlez l'exécution des outils avec les modes