plugins.md +0 −527 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# Créer des plugins
6
7> Créez des plugins personnalisés pour étendre Claude Code avec des skills, des agents, des hooks et des serveurs MCP.
8
9Les plugins vous permettent d'étendre Claude Code avec des fonctionnalités personnalisées qui peuvent être partagées entre les projets et les équipes. Ce guide couvre la création de vos propres plugins avec des skills, des agents, des hooks et des serveurs MCP.
10
11Vous cherchez à installer des plugins existants ? Consultez [Découvrir et installer des plugins](/docs/fr/discover-plugins). Pour les spécifications techniques complètes, consultez [Référence des plugins](/docs/fr/plugins-reference).
12
13<h2 id="when-to-use-plugins-vs-standalone-configuration">
14 Quand utiliser les plugins par rapport à la configuration autonome
15</h2>
16
17Claude Code prend en charge deux façons d'ajouter des skills, des agents et des hooks personnalisés :
18
19| Approche | Noms des skills | Idéal pour |
20| :------------------------------------------------------------------------------------------------- | :------------------- | :------------------------------------------------------------------------------------------------------------ |
21| **Autonome** (répertoire `.claude/`) | `/hello` | Flux de travail personnels, personnalisations spécifiques au projet, expériences rapides |
22| **Plugins** (répertoires avec skills, agents, hooks, ou un manifeste `.claude-plugin/plugin.json`) | `/plugin-name:hello` | Partage avec les coéquipiers, distribution à la communauté, versions publiées, réutilisable entre les projets |
23
24<Tip>
25 Commencez par la configuration autonome dans `.claude/` pour une itération rapide, puis [convertissez en plugin](#convert-existing-configurations-to-plugins) quand vous êtes prêt à partager.
26</Tip>
27
28<h2 id="quickstart">
29 Démarrage rapide
30</h2>
31
32Ce démarrage rapide vous guide dans la création d'un plugin avec un skill personnalisé. Vous allez créer un manifeste (le fichier de configuration qui définit votre plugin), ajouter un skill et le tester localement en utilisant le drapeau `--plugin-dir`.
33
34<h3 id="prerequisites">
35 Prérequis
36</h3>
37
38* Claude Code [installé et authentifié](/docs/fr/quickstart#step-1-install-claude-code)
39
40<h3 id="create-your-first-plugin">
41 Créez votre premier plugin
42</h3>
43
44<Steps>
45 <Step title="Créez le répertoire du plugin">
46 Chaque plugin se trouve dans son propre répertoire contenant vos skills, agents ou hooks, optionnellement aux côtés d'un manifeste `.claude-plugin/plugin.json`. L'emplacement n'a pas d'importance pour ce démarrage rapide car vous pointerez Claude Code vers le répertoire avec `--plugin-dir` à l'étape de test. Créez-le n'importe où, par exemple dans un dossier de travail ou un répertoire de projets :
47
48 ```bash theme={null}
49 mkdir my-first-plugin
50 ```
51
52 Les étapes restantes s'exécutent à partir du répertoire parent et font référence à des chemins comme `my-first-plugin/...` relatifs à celui-ci.
53 </Step>
54
55 <Step title="Créez le manifeste du plugin">
56 Le fichier manifeste à `.claude-plugin/plugin.json` définit l'identité de votre plugin : son nom, sa description et sa version. Claude Code utilise ces métadonnées pour afficher votre plugin dans le gestionnaire de plugins.
57
58 Créez le répertoire `.claude-plugin` à l'intérieur de votre dossier de plugin :
59
60 ```bash theme={null}
61 mkdir my-first-plugin/.claude-plugin
62 ```
63
64 Ensuite, créez `my-first-plugin/.claude-plugin/plugin.json` avec ce contenu :
65
66 ```json my-first-plugin/.claude-plugin/plugin.json theme={null}
67 {
68 "name": "my-first-plugin",
69 "description": "A greeting plugin to learn the basics",
70 "version": "1.0.0",
71 "author": {
72 "name": "Your Name"
73 }
74 }
75 ```
76
77 | Champ | Objectif |
78 | :------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
79 | `name` | Identifiant unique et espace de noms du skill. Les skills sont préfixés avec ceci (par exemple, `/my-first-plugin:hello`). |
80 | `description` | Affiché dans le gestionnaire de plugins lors de la navigation ou de l'installation de plugins. |
81 | `version` | Optionnel. S'il est défini, les utilisateurs ne reçoivent les mises à jour que lorsque vous augmentez ce champ, sauf pour une [source `command`](/docs/fr/plugin-marketplaces#command-sources) ou un plugin [chargé sur place](/docs/fr/plugins-reference#plugin-caching-and-file-resolution) ; consultez [gestion des versions](/docs/fr/plugins-reference#version-management). S'il est omis, la version provient de la source suivante dans [gestion des versions](/docs/fr/plugins-reference#version-management). |
82 | `author` | Optionnel. Utile pour l'attribution. |
83
84 Pour les champs supplémentaires comme `homepage`, `repository` et `license`, consultez le [schéma manifeste complet](/docs/fr/plugins-reference#plugin-manifest-schema).
85 </Step>
86
87 <Step title="Ajoutez un skill">
88 Les skills se trouvent dans le répertoire `skills/`. Chaque skill est un dossier contenant un fichier `SKILL.md`. Le nom du dossier devient le nom du skill, préfixé par l'espace de noms du plugin (`hello/` dans un plugin nommé `my-first-plugin` crée `/my-first-plugin:hello`).
89
90 Créez un répertoire de skill dans votre dossier de plugin :
91
92 ```bash theme={null}
93 mkdir -p my-first-plugin/skills/hello
94 ```
95
96 Ensuite, créez `my-first-plugin/skills/hello/SKILL.md` avec ce contenu :
97
98 ```markdown my-first-plugin/skills/hello/SKILL.md theme={null}
99 ---
100 description: Greet the user with a friendly message
101 disable-model-invocation: true
102 ---
103
104 Greet the user warmly and ask how you can help them today.
105 ```
106 </Step>
107
108 <Step title="Testez votre plugin">
109 Exécutez Claude Code avec le drapeau `--plugin-dir` pour charger votre plugin :
110
111 ```bash theme={null}
112 claude --plugin-dir ./my-first-plugin
113 ```
114
115 Une fois Claude Code démarré, essayez votre nouveau skill :
116
117 ```shell theme={null}
118 /my-first-plugin:hello
119 ```
120
121 Vous verrez Claude répondre avec un salut. Exécutez `/help` et ouvrez l'onglet **Commandes personnalisées** pour voir votre skill listé sous l'espace de noms du plugin.
122
123 <Note>
124 **Pourquoi l'espace de noms ?** Les skills des plugins sont toujours avec espace de noms (comme `/my-first-plugin:hello`) pour prévenir les conflits quand plusieurs plugins ont des skills avec le même nom.
125
126 Pour changer le préfixe d'espace de noms, mettez à jour le champ `name` dans `plugin.json`.
127 </Note>
128 </Step>
129
130 <Step title="Ajoutez des arguments au skill">
131 Rendez votre skill dynamique en acceptant l'entrée de l'utilisateur. L'espace réservé `$ARGUMENTS` capture tout texte que l'utilisateur fournit après le nom du skill.
132
133 Mettez à jour votre fichier `SKILL.md` :
134
135 ```markdown my-first-plugin/skills/hello/SKILL.md theme={null}
136 ---
137 description: Greet the user with a personalized message
138 ---
139
140 # Hello Skill
141
142 Greet the user named "$ARGUMENTS" warmly and ask how you can help them today. Make the greeting personal and encouraging.
143 ```
144
145 Exécutez `/reload-plugins` pour récupérer les modifications. Ensuite, essayez le skill avec votre nom :
146
147 ```shell theme={null}
148 /my-first-plugin:hello Alex
149 ```
150
151 Claude vous saluera par votre nom. Pour plus d'informations sur la transmission d'arguments aux skills, consultez [Skills](/docs/fr/skills#pass-arguments-to-skills).
152 </Step>
153</Steps>
154
155<Tip>
156 Le drapeau `--plugin-dir` est utile pour le développement et les tests. Quand vous êtes prêt à partager votre plugin avec d'autres, consultez [Créer et distribuer une marketplace de plugins](/docs/fr/plugin-marketplaces).
157</Tip>
158
159<h2 id="develop-a-plugin-in-your-skills-directory">
160 Développez un plugin dans votre répertoire de skills
161</h2>
162
163Au lieu de passer `--plugin-dir` à chaque lancement, vous pouvez garder un plugin dans votre répertoire de skills et faire en sorte que Claude Code le charge automatiquement. `claude plugin init` en crée un :
164
165```bash theme={null}
166claude plugin init my-tool
167```
168
169Cela crée `~/.claude/skills/my-tool/` avec un manifeste `.claude-plugin/plugin.json` et un `SKILL.md` de démarrage. À la session suivante, il se charge en tant que `my-tool@skills-dir` sans étape de marketplace ou d'installation.
170
171Pour les règles de chargement automatique, la portée personnelle par rapport à la portée du projet, l'exigence de confiance de l'espace de travail et comment mettre à jour ou supprimer un, consultez [Plugins du répertoire de skills](/docs/fr/plugins-reference#skills-directory-plugins).
172
173<h2 id="plugin-structure-overview">
174 Aperçu de la structure du plugin
175</h2>
176
177Vous avez créé un plugin avec un skill, mais les plugins peuvent inclure beaucoup plus : des agents personnalisés, des hooks, des serveurs MCP, des serveurs LSP et des moniteurs en arrière-plan.
178
179<Warning>
180 **Erreur courante** : Ne mettez pas `commands/`, `agents/`, `skills/` ou `hooks/` à l'intérieur du répertoire `.claude-plugin/`. Seul `plugin.json` va à l'intérieur de `.claude-plugin/`. Tous les autres répertoires doivent être au niveau racine du plugin.
181
182 La racine du plugin est le répertoire propre du plugin individuel, tel que `my-first-plugin/` du [démarrage rapide](#quickstart). Ce n'est jamais `~/.claude/`. Par exemple, Claude Code ne lit pas un `.mcp.json` placé à `~/.claude/.mcp.json`.
183</Warning>
184
185| Répertoire | Emplacement | Objectif |
186| :---------------- | :--------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
187| `.claude-plugin/` | Racine du plugin | Contient le manifeste `plugin.json` (optionnel si les composants utilisent les emplacements par défaut) |
188| `skills/` | Racine du plugin | Skills en tant que répertoires `<name>/SKILL.md` |
189| `commands/` | Racine du plugin | Skills en tant que fichiers Markdown plats. Utilisez `skills/` pour les nouveaux plugins |
190| `agents/` | Racine du plugin | Définitions d'agents personnalisés |
191| `hooks/` | Racine du plugin | Gestionnaires d'événements dans `hooks.json` |
192| `.mcp.json` | Racine du plugin | Configurations du serveur MCP |
193| `.lsp.json` | Racine du plugin | Configurations du serveur LSP pour l'intelligence du code |
194| `monitors/` | Racine du plugin | Configurations du moniteur en arrière-plan dans `monitors.json` |
195| `bin/` | Racine du plugin | Exécutables ajoutés au `PATH` de l'outil Bash tandis que le plugin est activé. Vous ne pouvez pas inclure ce répertoire dans un plugin que vous [distribuez via les paramètres d'organisation claude.ai](/docs/fr/plugin-marketplaces#keep-executables-out-of-the-top-level-bin-directory) |
196| `settings.json` | Racine du plugin | [Paramètres](/docs/fr/settings) par défaut appliqués quand le plugin est activé |
197
198Un plugin qui fournit exactement un skill peut placer `SKILL.md` directement à la racine du plugin au lieu de créer un répertoire `skills/`. Claude Code le charge en tant que skill unique et utilise le champ `name` du frontmatter pour le nom d'invocation. Utilisez la disposition `skills/` pour les plugins qui pourraient croître pour avoir plus d'un skill.
199
200<h2 id="develop-more-complex-plugins">
201 Développer des plugins plus complexes
202</h2>
203
204Une fois que vous êtes à l'aise avec les plugins de base, vous pouvez créer des extensions plus sophistiquées.
205
206<h3 id="add-skills-to-your-plugin">
207 Ajoutez des Skills à votre plugin
208</h3>
209
210Les plugins peuvent inclure des [Agent Skills](/docs/fr/skills) pour étendre les capacités de Claude. Les skills sont invoqués par le modèle : Claude les utilise automatiquement en fonction du contexte de la tâche.
211
212Ajoutez un répertoire `skills/` à la racine de votre plugin avec des dossiers de Skill contenant des fichiers `SKILL.md` :
213
214```text theme={null}
215my-plugin/
216├── .claude-plugin/
217│ └── plugin.json
218└── skills/
219 └── code-review/
220 └── SKILL.md
221```
222
223Chaque `SKILL.md` contient un frontmatter YAML et des instructions. Incluez une `description` pour que Claude sache quand utiliser le skill :
224
225```yaml theme={null}
226description: Reviews code for best practices and potential issues. Use when reviewing code, checking PRs, or analyzing code quality.
227
228When reviewing code, check for:
2291. Code organization and structure
2302. Error handling
2313. Security concerns
2324. Test coverage
233```
234
235Après l'installation du plugin, vérifiez le résumé d'installation : s'il signale `Run /reload-plugins to activate.`, consultez [Appliquer les modifications du plugin sans redémarrer](/docs/fr/discover-plugins#apply-plugin-changes-without-restarting) pour charger les Skills dans votre session actuelle. Pour des conseils complets sur la création de Skills incluant la divulgation progressive et les restrictions d'outils, consultez [Agent Skills](/docs/fr/skills).
236
237<h3 id="add-lsp-servers-to-your-plugin">
238 Ajoutez des serveurs LSP à votre plugin
239</h3>
240
241<Tip>
242 Pour les langages courants comme TypeScript, Python et Rust, installez les plugins LSP pré-construits à partir de la marketplace officielle. Créez des plugins LSP personnalisés uniquement quand vous avez besoin de support pour des langages non encore couverts.
243</Tip>
244
245Les plugins LSP (Language Server Protocol) donnent à Claude l'intelligence du code en temps réel. Si vous avez besoin de supporter un langage qui n'a pas de plugin LSP officiel, vous pouvez en créer un en ajoutant un fichier `.lsp.json` à votre plugin :
246
247```json .lsp.json theme={null}
248{
249 "go": {
250 "command": "gopls",
251 "args": ["serve"],
252 "extensionToLanguage": {
253 ".go": "go"
254 }
255 }
256}
257```
258
259Les utilisateurs qui installent votre plugin doivent avoir le binaire du serveur de langage installé sur leur machine.
260
261Pour confirmer que le serveur démarre, lancez Claude Code avec le plugin activé et vérifiez l'onglet Erreurs de `/plugin` : un serveur de langage qui échoue au démarrage apparaît là, par exemple avec `Executable not found in $PATH` quand le binaire n'est pas installé. Une entrée avec une configuration invalide est ignorée à la place ; exécutez `claude --debug` pour voir pourquoi.
262
263Pour les options de configuration LSP complètes, consultez [Serveurs LSP](/docs/fr/plugins-reference#lsp-servers).
264
265<h3 id="add-background-monitors-to-your-plugin">
266 Ajoutez des moniteurs en arrière-plan à votre plugin
267</h3>
268
269Les moniteurs en arrière-plan permettent à votre plugin de surveiller les journaux, les fichiers ou l'état externe en arrière-plan et de notifier Claude à mesure que les événements arrivent. Claude Code démarre automatiquement chaque moniteur quand le plugin est actif, donc vous n'avez pas besoin d'instruire Claude pour démarrer la surveillance.
270
271Ajoutez un fichier `monitors/monitors.json` à la racine du plugin avec un tableau d'entrées de moniteur :
272
273```json monitors/monitors.json theme={null}
274[
275 {
276 "name": "error-log",
277 "command": "tail -F ./logs/error.log",
278 "description": "Application error log"
279 }
280]
281```
282
283Chaque ligne stdout de `command` est livrée à Claude en tant que notification pendant la session. Pour le schéma complet, incluant le déclencheur `when` et la substitution de variables, consultez [Moniteurs](/docs/fr/plugins-reference#monitors).
284
285<h3 id="ship-default-settings-with-your-plugin">
286 Livrez les paramètres par défaut avec votre plugin
287</h3>
288
289Les plugins peuvent inclure un fichier `settings.json` à la racine du plugin pour appliquer la configuration par défaut quand le plugin est activé. Actuellement, seules les clés `agent` et `subagentStatusLine` sont supportées.
290
291Définir `agent` active l'un des [agents personnalisés](/docs/fr/sub-agents) du plugin en tant que thread principal, en appliquant son invite système, ses restrictions d'outils et son modèle. Cela permet à un plugin de changer le comportement par défaut de Claude Code quand il est activé.
292
293```json settings.json theme={null}
294{
295 "agent": "security-reviewer"
296}
297```
298
299Cet exemple active l'agent `security-reviewer` défini dans le répertoire `agents/` du plugin. Les paramètres de `settings.json` ont priorité sur les `settings` déclarés dans `plugin.json`. Les clés inconnues sont silencieusement ignorées.
300
301<h3 id="organize-complex-plugins">
302 Organisez les plugins complexes
303</h3>
304
305Pour les plugins avec de nombreux composants, organisez votre structure de répertoires par fonctionnalité. Pour les dispositions de répertoires complètes et les modèles d'organisation, consultez [Structure du répertoire du plugin](/docs/fr/plugins-reference#plugin-directory-structure).
306
307<h3 id="test-your-plugins-locally">
308 Testez vos plugins localement
309</h3>
310
311Utilisez le drapeau `--plugin-dir` pour tester les plugins pendant le développement. Cela charge votre plugin directement sans nécessiter d'installation.
312
313```bash theme={null}
314claude --plugin-dir ./my-plugin
315```
316
317Le drapeau accepte également une archive `.zip` du répertoire du plugin.
318
319```bash theme={null}
320claude --plugin-dir ./my-plugin.zip
321```
322
323Quand un plugin `--plugin-dir` a le même nom qu'un plugin marketplace installé, la copie locale prend la priorité pour cette session. Cela vous permet de tester les modifications d'un plugin que vous avez déjà installé sans le désinstaller d'abord. L'exception concerne les plugins dont les paramètres gérés forcent l'activation ou la désactivation : `--plugin-dir` ne peut pas les remplacer.
324
325À mesure que vous apportez des modifications à votre plugin, exécutez `/reload-plugins` pour récupérer les mises à jour sans redémarrer. Cela recharge les plugins, les skills, les agents, les hooks, les serveurs MCP du plugin et les serveurs LSP du plugin ; dans une session sans terminal interactif, les modifications du serveur MCP du plugin [attendent votre prochaine session](/docs/fr/discover-plugins#apply-plugin-changes-without-restarting). Testez vos composants de plugin :
326
327* Essayez vos skills avec `/plugin-name:skill-name`
328* Vérifiez que les agents apparaissent dans `/context` sous Agents personnalisés, ou mentionnez-en un avec le symbole @ par son nom délimité
329* Déclenchez l'événement que chaque hook correspond, comme demander à Claude d'éditer un fichier pour un hook `PostToolUse`, et confirmez son effet. Claude Code enregistre quels hooks ont correspondu, leurs codes de sortie et leur sortie dans le [journal de débogage](/docs/fr/hooks#debug-hooks)
330
331<Tip>
332 Vous pouvez charger plusieurs plugins à la fois en spécifiant le drapeau plusieurs fois :
333
334 ```bash theme={null}
335 claude --plugin-dir ./plugin-one --plugin-dir ./plugin-two
336 ```
337
338 Pour tester un plugin avec un plugin dont il dépend, consultez [Testez un plugin et sa dépendance localement](/docs/fr/plugin-dependencies#test-a-plugin-and-its-dependency-locally).
339</Tip>
340
341Pour charger les plugins dans une session où vous ne pouvez pas ajouter le drapeau, listez leurs chemins absolus dans la variable d'environnement [`CLAUDE_CODE_PLUGIN_DIRS`](/docs/fr/env-vars#variables) à la place. Claude Code charge chaque chemin comme il charge un chemin `--plugin-dir`. Ces plugins se chargent en plus de ceux que vous passez avec `--plugin-dir`. [Les paramètres de projet et locaux ne peuvent pas définir cette variable](/docs/fr/settings-reference#variables-claude-code-ignores-in-env). `CLAUDE_CODE_PLUGIN_DIRS` nécessite Claude Code v2.1.280 ou ultérieur.
342
343Essayer le plugin avec `--plugin-dir` vous indique qu'il peut fonctionner. Pour savoir à quelle fréquence Claude y recourt réellement et obtient le bon résultat, exécutez-le sur un ensemble de prompts de test avec [`claude plugin eval`](/docs/fr/plugin-evals). Chaque prompt s'exécute plusieurs fois avec et sans le plugin chargé, afin que vous puissiez voir ce que le plugin contribue et détecter les régressions quand vous le modifiez ou qu'un nouveau modèle est lancé.
344
345Pour charger plusieurs plugins à partir d'un seul endroit, passez un dossier qui les contient, comme `--plugin-dir ./plugins`. Le chargement d'un dossier de plugins nécessite Claude Code v2.1.265 ou ultérieur. Claude Code lit le niveau supérieur du dossier pour décider quels plugins charger, et dans une session interactive, il surveille également le dossier pour les modifications ultérieures :
346
347* **Ce qui se charge** : si le dossier n'a pas de manifeste ou de composants de plugin à son niveau supérieur, Claude Code le traite comme un dossier de plugins. Chaque sous-dossier immédiat qui a un manifeste `.claude-plugin/plugin.json` se charge en tant que plugin séparé. Claude Code ignore tout le reste dans le dossier sans signaler d'erreur, y compris les plugins qui n'ont pas de manifeste.
348* **Modifications pendant une session interactive** : un sous-dossier que vous ajoutez se charge en tant que nouveau plugin une fois que son manifeste est en place, et quand vous supprimez un sous-dossier, son plugin se décharge. Claude Code affiche une ligne dans la session pour chaque modification. Si l'application d'une modification en milieu de conversation [invaliderait le cache d'invite](/docs/fr/prompt-caching#enabling-or-disabling-a-plugin), Claude Code la retient, et la ligne dit d'exécuter `/reload-plugins` pour l'appliquer.
349
350Pour tester un plugin qui est déjà empaqueté en tant qu'archive `.zip` et hébergé à une URL, comme un artefact de build CI, utilisez `--plugin-url` à la place. Claude Code récupère l'archive au démarrage et la charge pour cette session uniquement. Si Claude Code ne peut pas récupérer l'archive, ou que l'archive est invalide, il démarre sans le plugin et enregistre une erreur de chargement de plugin que vous pouvez examiner dans l'onglet **Erreurs** du gestionnaire `/plugin`. Les mêmes [considérations de confiance](/docs/fr/discover-plugins#security) s'appliquent que pour toute source de plugin : pointez uniquement ce drapeau vers des archives que vous contrôlez ou en lesquelles vous avez confiance.
351
352Pour charger plusieurs plugins, répétez le drapeau pour chaque URL :
353
354```bash theme={null}
355claude --plugin-url https://example.com/my-plugin.zip --plugin-url https://example.com/other.zip
356```
357
358Ou passez des URL séparées par des espaces en tant qu'un seul argument entre guillemets :
359
360```bash theme={null}
361claude --plugin-url "https://example.com/my-plugin.zip https://example.com/other.zip"
362```
363
364<h3 id="debug-plugin-issues">
365 Déboguez les problèmes de plugin
366</h3>
367
368Si votre plugin ne fonctionne pas comme prévu :
369
3701. **Vérifiez la structure** : Assurez-vous que vos répertoires sont à la racine du plugin, pas à l'intérieur de `.claude-plugin/`
3712. **Testez les composants individuellement** : Vérifiez chaque skill, agent et hook séparément
3723. **Utilisez les outils de validation et de débogage** : Consultez [Outils de débogage et de développement](/docs/fr/plugins-reference#debugging-and-development-tools) pour les commandes CLI et les techniques de dépannage
373
374<h3 id="share-your-plugins">
375 Partagez vos plugins
376</h3>
377
378Quand votre plugin est prêt à être partagé :
379
3801. **Ajoutez de la documentation** : Incluez un `README.md` avec les instructions d'installation et d'utilisation
3812. **Choisissez une stratégie de versioning** : Décidez si vous allez définir une `version` explicite ou vous fier au fallback décrit dans [gestion des versions](/docs/fr/plugins-reference#version-management).
3823. **Créez ou utilisez une marketplace** : Distribuez via des [marketplaces de plugins](/docs/fr/plugin-marketplaces) pour l'installation
3834. **Testez avec d'autres** : Faites tester le plugin par les membres de l'équipe avant une distribution plus large
384
385Une fois que votre plugin est dans une marketplace, d'autres peuvent l'installer en utilisant les instructions dans [Découvrir et installer des plugins](/docs/fr/discover-plugins). Pour garder un plugin interne à votre équipe, hébergez la marketplace dans un [référentiel privé](/docs/fr/plugin-marketplaces#private-repositories).
386
387<h3 id="submit-your-plugin-to-the-community-marketplace">
388 Soumettez votre plugin à la marketplace communautaire
389</h3>
390
391Anthropic maintient deux marketplaces publiques pour les plugins Claude Code :
392
393* **`claude-plugins-official`** : un ensemble organisé de plugins maintenus par Anthropic. Claude Code l'enregistre automatiquement la première fois que vous démarrez Claude Code de manière interactive. Si vous exécutez Claude Code de manière non-interactive avant ce premier lancement interactif, ou si une [politique de marketplace](/docs/fr/plugin-marketplaces#managed-marketplace-restrictions) a bloqué une tentative antérieure, enregistrez-le vous-même avec `claude plugin marketplace add anthropics/claude-plugins-official`.
394* **`claude-community`** : la marketplace communautaire publique où les soumissions tierces arrivent après examen. Les utilisateurs l'ajoutent avec `/plugin marketplace add anthropics/claude-plugins-community` et l'installent en tant que `@claude-community`.
395
396Pour soumettre votre plugin pour examen de la marketplace communautaire, utilisez l'un des formulaires dans l'application :
397
398* **claude.ai** : [claude.ai/admin-settings/directory/submissions/plugins/new](https://claude.ai/admin-settings/directory/submissions/plugins/new)
399* **Console** : [platform.claude.com/plugins/submit](https://platform.claude.com/plugins/submit)
400
401Le formulaire claude.ai nécessite une organisation Team ou Enterprise et un accès à la gestion du répertoire ; les propriétaires d'organisation ont cet accès par défaut. Les auteurs individuels qui ne font pas partie d'une organisation Team ou Enterprise peuvent utiliser le formulaire Console à la place.
402
403Exécutez `claude plugin validate ./your-plugin` localement avant de soumettre, en remplaçant `./your-plugin` par le chemin vers votre répertoire de plugin. Le pipeline d'examen exécute la même vérification sur chaque soumission, ainsi qu'un dépistage de sécurité automatisé. Quand la validation réussit, Claude Code affiche `✔ Validation passed`, ou `✔ Validation passed with warnings` s'il y a des avertissements. Les avertissements ne font pas échouer la validation ; ajoutez `--strict` pour les traiter comme des erreurs.
404
405Les plugins approuvés sont épinglés à un SHA de commit spécifique dans le catalogue [`anthropics/claude-plugins-community`](https://github.com/anthropics/claude-plugins-community), et CI augmente automatiquement l'épingle à mesure que vous poussez de nouveaux commits vers votre référentiel. Le catalogue public se synchronise chaque nuit à partir du pipeline d'examen, il peut donc y avoir un délai entre l'approbation et l'apparition de votre plugin dans `marketplace.json`. Pour vérifier si votre plugin est installable, recherchez son nom dans le [catalogue communautaire](https://github.com/anthropics/claude-plugins-community/blob/main/.claude-plugin/marketplace.json).
406
407La marketplace officielle, `claude-plugins-official`, est organisée séparément. Anthropic décide quels plugins inclure à sa discrétion. Il n'y a pas de processus de candidature, et le formulaire de soumission n'ajoute pas de plugins à la marketplace officielle.
408
409Si Anthropic liste votre plugin dans la marketplace officielle, votre CLI peut inviter les utilisateurs de Claude Code à l'installer. Consultez [Recommander votre plugin à partir de votre CLI](/docs/fr/plugin-hints).
410
411<h2 id="convert-existing-configurations-to-plugins">
412 Convertir les configurations existantes en plugins
413</h2>
414
415Si vous avez déjà des skills ou des hooks dans votre répertoire `.claude/`, vous pouvez les convertir en plugin pour un partage et une distribution plus faciles.
416
417<h3 id="migration-steps">
418 Étapes de migration
419</h3>
420
421<Steps>
422 <Step title="Créez la structure du plugin">
423 Créez un nouveau répertoire de plugin dans la racine de votre projet, à côté du dossier `.claude/` existant, afin que les chemins `cp` relatifs à l'étape suivante se résolvent :
424
425 ```bash theme={null}
426 mkdir -p my-plugin/.claude-plugin
427 ```
428
429 Créez le fichier manifeste à `my-plugin/.claude-plugin/plugin.json` :
430
431 ```json my-plugin/.claude-plugin/plugin.json theme={null}
432 {
433 "name": "my-plugin",
434 "description": "Migrated from standalone configuration",
435 "version": "1.0.0"
436 }
437 ```
438 </Step>
439
440 <Step title="Copiez vos fichiers existants">
441 Copiez chaque répertoire de configuration que vous avez dans la racine du plugin. Vous n'avez peut-être pas les trois : si un répertoire n'existe pas, `cp` affiche `No such file or directory` et ne copie rien, donc ignorez cette commande ou ignorez l'erreur.
442
443 ```bash theme={null}
444 cp -r .claude/commands my-plugin/
445
446 cp -r .claude/agents my-plugin/
447
448 cp -r .claude/skills my-plugin/
449 ```
450
451 Votre plugin contient maintenant des copies des répertoires que vous aviez sous `.claude/`. Exécutez `ls my-plugin` pour confirmer : vous devriez voir chaque répertoire que vous avez copié.
452 </Step>
453
454 <Step title="Migrez les hooks">
455 Si vous avez des hooks dans vos paramètres, créez un répertoire de hooks :
456
457 ```bash theme={null}
458 mkdir my-plugin/hooks
459 ```
460
461 Créez `my-plugin/hooks/hooks.json` avec votre configuration de hooks. Copiez l'objet `hooks` de votre `.claude/settings.json` ou `settings.local.json`, car le format est le même. La commande reçoit l'entrée du hook en tant que JSON sur stdin, donc utilisez `jq` pour extraire le chemin du fichier :
462
463 ```json my-plugin/hooks/hooks.json theme={null}
464 {
465 "hooks": {
466 "PostToolUse": [
467 {
468 "matcher": "Write|Edit",
469 "hooks": [{ "type": "command", "command": "jq -r '.tool_input.file_path' | xargs npm run lint:fix" }]
470 }
471 ]
472 }
473 }
474 ```
475 </Step>
476
477 <Step title="Testez votre plugin migré">
478 Chargez votre plugin pour vérifier que tout fonctionne :
479
480 ```bash theme={null}
481 claude --plugin-dir ./my-plugin
482 ```
483
484 Testez chaque composant : exécutez vos commandes, vérifiez que les agents apparaissent dans `/context`, et déclenchez l'événement que chaque hook correspond pour confirmer son effet. Claude Code enregistre les hooks qui ont correspondu et comment ils se sont terminés dans le [journal de débogage](/docs/fr/hooks#debug-hooks).
485 </Step>
486</Steps>
487
488<h3 id="what-changes-when-migrating">
489 Ce qui change lors de la migration
490</h3>
491
492| Autonome (`.claude/`) | Plugin |
493| :----------------------------------------- | :------------------------------------- |
494| Disponible uniquement dans un projet | Peut être partagé via des marketplaces |
495| Fichiers dans `.claude/commands/` | Fichiers dans `plugin-name/commands/` |
496| Hooks dans `settings.json` | Hooks dans `hooks/hooks.json` |
497| Doit être copié manuellement pour partager | Installer avec `/plugin install` |
498
499<Note>
500 Après la migration, supprimez les fichiers originaux de `.claude/` pour éviter les doublons. Les définitions d'agents du projet et de l'utilisateur dans `.claude/agents/` remplacent les agents du plugin portant le même nom, donc la version du plugin ne prend effet qu'une fois que les originaux sont supprimés. Les skills du plugin sont espacés de noms sous la forme `/plugin-name:skill-name`, donc l'original `/skill-name` et la copie du plugin restent tous deux disponibles plutôt que l'un remplaçant l'autre.
501</Note>
502
503<h2 id="next-steps">
504 Prochaines étapes
505</h2>
506
507Maintenant que vous comprenez le système de plugins de Claude Code, voici les chemins suggérés pour différents objectifs :
508
509<h3 id="for-plugin-users">
510 Pour les utilisateurs de plugins
511</h3>
512
513* [Découvrir et installer des plugins](/docs/fr/discover-plugins) : parcourir les marketplaces et installer des plugins
514* [Configurer les marketplaces d'équipe](/docs/fr/discover-plugins#configure-team-marketplaces) : configurer les plugins au niveau du référentiel pour votre équipe
515
516<h3 id="for-plugin-developers">
517 Pour les développeurs de plugins
518</h3>
519
520* [Tester les plugins avec des evals](/docs/fr/plugin-evals) : mesurer ce que votre plugin change et gater CI sur celui-ci
521* [Créer et distribuer une marketplace](/docs/fr/plugin-marketplaces) : empaqueter et partager vos plugins
522* [Référence des plugins](/docs/fr/plugins-reference) : spécifications techniques complètes
523* Approfondissez les composants spécifiques du plugin :
524 * [Skills](/docs/fr/skills) : détails du développement des skills
525 * [Subagents](/docs/fr/sub-agents) : configuration et capacités des agents
526 * [Hooks](/docs/fr/hooks) : gestion des événements et automatisation
527 * [MCP](/docs/fr/mcp) : intégration d'outils externes