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 un mod

6 

7> Demandez à Claude d'écrire un mod Claude Code à partir d'une description, ou écrivez-en un vous-même qui compte les appels d'outils et ajoute une commande. Apprenez la boucle de rechargement et de validation.

8 

9Un mod est un [plugin](/docs/fr/plugins/overview) Claude Code avec un fichier d'entrée, appelé le module de hooks : un fichier JavaScript ou TypeScript dont les fonctions Claude Code appelle lorsque des événements se produisent. Il y a deux façons d'en créer un :

10 

11* **Demander à Claude de l'écrire** : [décrivez ce que vous voulez](#ask-claude-for-a-mod) dans une session Claude Code

12* **L'écrire vous-même** : [suivez le tutoriel](#write-a-mod-yourself) pour apprendre comment fonctionne le code d'un mod. Vous n'avez pas besoin de Node.js, d'un bundler ou d'une étape de build, car Claude Code charge les fichiers `.js` et `.ts` directement.

13 

14Si vous n'avez pas encore décidé si un mod est le bon outil, lisez d'abord la [comparaison sur la page d'aperçu](/docs/fr/plugins/mods/overview#compare-mods-settings-hooks-skills-and-mcp-servers).

15 

16<Note>

17 Les mods nécessitent Claude Code v2.1.287 ou ultérieur. Dans votre shell, exécutez `claude --version` pour vérifier. Pour voir si les mods peuvent se charger pour vous, consultez [Vérifier si les mods peuvent se charger](/docs/fr/plugins/mods/troubleshoot#check-whether-mods-can-load).

18</Note>

19 

20<h2 id="ask-claude-for-a-mod">

21 Demander à Claude un mod

22</h2>

23 

24Décrivez le mod que vous voulez dans une session Claude Code interactive, et Claude l'écrit. Claude fonctionne à partir d'une [skill](/docs/fr/skills) intégrée nommée `plugin-authoring`, qui lui indique où écrire le mod, quels événements et méthodes votre version a, et comment le mod est chargé. Claude peut charger la skill lorsque vous demandez un mod, ou vous pouvez la charger vous-même en exécutant `/plugin-authoring` à l'invite Claude Code.

25 

26Le mod s'exécute une fois que vous l'approuvez, sauf dans [les sessions où un mod que Claude écrit ne peut pas se charger](#sessions-that-skip-the-approval).

27 

28<Steps>

29 <Step title="Décrivez le mod">

30 Demandez le mod avec vos propres mots, par exemple `make a mod that shows the current git branch above the prompt`. Claude écrit le mod dans un répertoire qui lui est propre dans le dossier des mods de la session, qui est `~/.claude/dev-mods/` suivi de l'ID de la session. Le chemin complet d'un mod ressemble à `~/.claude/dev-mods/3f2a9c1e-5b7d-4e8a-9c21-6d0f4b8a7e13/git-branch/`.

31 

32 <Note>

33 Dans les [modes de permission](/docs/fr/permission-modes#protected-paths) `default` et `acceptEdits`, Claude Code demande avant que Claude crée chacun des fichiers du mod, car `~/.claude` est un chemin protégé. Approuvez chaque fichier au fur et à mesure.

34 </Note>

35 </Step>

36 

37 <Step title="Approuvez le mod">

38 Lorsque Claude enregistre le premier fichier, Claude Code demande s'il faut activer le rechargement à chaud pour la session. Le rechargement à chaud exécute les mods que Claude écrit dans cette session et récupère chaque modification ultérieure.

39 

40 Choisissez l'une de ces réponses :

41 

42 * **Activer pour cette session** : les mods dans le dossier des mods de la session se chargent à la fin du tour, et se rechargent à la fin de chaque tour qui les modifie. Votre réponse dure pour la session, y compris après l'avoir reprise.

43 * **Pas maintenant** : rien ne se charge pour l'instant. Les fichiers restent où Claude les a écrits, et les mods se chargent la prochaine fois que cette session démarre. Pour empêcher un mod de jamais se charger, supprimez son répertoire.

44 </Step>

45 

46 <Step title="Vérifiez que le mod s'est chargé">

47 Exécutez `/plugin` à l'invite Claude Code et appuyez sur Tab jusqu'à ce que l'onglet **Installed** soit sélectionné. Il liste le mod, et vous pouvez l'éteindre là.

48 </Step>

49 

50 <Step title="Essayez le mod">

51 Utilisez ce que vous avez demandé. Pour l'exemple d'invite, le nom de la branche actuelle apparaît au-dessus de la boîte d'invite. Si le mod ne fait pas ce que vous vouliez, dites à Claude ce qu'il faut changer. Le mod se recharge à la fin de chaque tour qui modifie ses fichiers, vous pouvez donc essayer la modification dès que Claude a terminé.

52 </Step>

53</Steps>

54 

55<h3 id="use-the-mod-in-other-sessions">

56 Utilisez le mod dans d'autres sessions

57</h3>

58 

59Un mod que Claude a écrit ne se charge que dans la session qui l'a créé, et Claude Code supprime le dossier des mods de cette session une fois qu'il est plus ancien que [`cleanupPeriodDays`](/docs/fr/settings-reference#cleanupperioddays). Pour conserver le mod, copiez son répertoire hors du dossier des mods vers un endroit qui vous appartient, comme `~/mods/git-branch`. Ensuite, choisissez comment le charger :

60 

61* **Dans une session que vous démarrez** : dans votre shell, exécutez `claude --plugin-dir ~/mods/git-branch`

62* **Pour d'autres personnes** : [ajoutez-le à une marketplace](#share-your-mod) pour qu'elles puissent l'installer

63 

64<h3 id="sessions-that-skip-the-approval">

65 Sessions où un mod que Claude écrit ne peut pas se charger

66</h3>

67 

68Un mod que Claude écrit ne se charge qu'après que vous l'approuviez, dans un espace de travail de confiance où les mods sont autorisés à s'exécuter. Dans ces sessions, il ne se charge pas :

69 

70* **Personne n'est là pour approuver** : la session ne peut pas vous montrer une invite, comme dans une exécution `claude -p` ou en [mode `dontAsk`](/docs/fr/permission-modes)

71* **L'espace de travail n'est pas de confiance** : vous n'avez pas accepté l'invite de confiance pour le répertoire

72* **Les mods sont arrêtés** : vous avez démarré avec `--safe-mode` ou `--bare`, vous avez défini `disableAllHooks`, ou les [paramètres gérés](/docs/fr/plugins/mods/admin#choose-how-much-to-allow) de votre organisation le bloquent

73 

74<h2 id="write-a-mod-yourself">

75 Écrivez un mod vous-même

76</h2>

77 

78Dans ce tutoriel, vous construisez un mod nommé `first-mod` qui compte les appels d'outils que Claude fait, affiche le compte à côté du spinner pendant que Claude travaille, et ajoute une commande `/tally` qui l'imprime. Vous lisez ensuite les déclarations de type que Claude Code écrit à côté de votre mod et exécutez `claude plugin validate`. Ensemble, ils vous montrent les événements et méthodes que votre version offre et ce que Claude Code lit à partir de votre code.

79 

80Cet enregistrement montre le mod terminé. Le spinner compte les appels d'outils, `/tally` imprime le compte, et une modification du code prend effet pendant que la session s'exécute :

81 

82<Frame>

83 <video autoPlay muted loop playsInline controls className="w-full dark:hidden" src="https://mintcdn.com/claude-code/dgiVO_Od1X1faduV/images/mods-first-mod-light.mp4?fit=max&auto=format&n=dgiVO_Od1X1faduV&q=85&s=eb561134afa90375777408453ba51c77" aria-label="In a Claude Code session, the prompt 'list the files here and read the README' is typed and sent. The spinner reads 'Thinking · tool calls: 1' and the count rises as Claude works. The /tally command prints 'first-mod: Claude has made 3 tool calls since this mod loaded'. A line says first-mod reloaded and lists its four hooks. On the next prompt the spinner reads 'Thinking · tools used: 1'." data-path="images/mods-first-mod-light.mp4" />

84 

85 <video autoPlay muted loop playsInline controls className="w-full hidden dark:block" src="https://mintcdn.com/claude-code/dgiVO_Od1X1faduV/images/mods-first-mod-dark.mp4?fit=max&auto=format&n=dgiVO_Od1X1faduV&q=85&s=09779dadc7ef66c2b1e2da0c2e31ac72" aria-label="In a Claude Code session, the prompt 'list the files here and read the README' is typed and sent. The spinner reads 'Thinking · tool calls: 1' and the count rises as Claude works. The /tally command prints 'first-mod: Claude has made 3 tool calls since this mod loaded'. A line says first-mod reloaded and lists its four hooks. On the next prompt the spinner reads 'Thinking · tools used: 1'." data-path="images/mods-first-mod-dark.mp4" />

86</Frame>

87 

88Vous écrivez trois fichiers :

89 

90```text theme={null}

91first-mod/

92├── .claude-plugin/

93│ └── plugin.json

94└── hooks/

95 ├── hooks.json

96 └── register.js

97```

98 

99* **`plugin.json`** : le [manifeste](/docs/fr/plugins/manifest-reference) du plugin

100* **`hooks.json`** : [pointe vers votre fichier de code](/docs/fr/plugins/mods/reference#files)

101* **`register.js`** : votre code, appelé le module de hooks

102 

103<Steps>

104 <Step title="Créez le répertoire du plugin">

105 Créez les deux répertoires qui contiennent les fichiers :

106 

107 <Tabs>

108 <Tab title="Bash ou Zsh">

109 ```bash theme={null}

110 mkdir -p first-mod/.claude-plugin first-mod/hooks

111 ```

112 </Tab>

113 

114 <Tab title="PowerShell">

115 ```powershell theme={null}

116 New-Item -ItemType Directory -Force first-mod\.claude-plugin, first-mod\hooks

117 ```

118 </Tab>

119 </Tabs>

120 </Step>

121 

122 <Step title="Écrivez le manifeste">

123 Un mod est un plugin, et un mod a besoin d'un [manifeste](/docs/fr/plugins/manifest-reference). Le manifeste de ce mod n'a pas de champs spéciaux. Enregistrez ceci comme `first-mod/.claude-plugin/plugin.json` :

124 

125 ```json first-mod/.claude-plugin/plugin.json theme={null}

126 {

127 "name": "first-mod",

128 "version": "0.1.0",

129 "description": "Counts Claude's tool calls, shows the count beside the spinner, and adds a /tally command",

130 "author": { "name": "Your Name" }

131 }

132 ```

133 </Step>

134 

135 <Step title="Dites à Claude Code où se trouve votre code">

136 Lorsque Claude Code charge un plugin, il lit le `hooks/hooks.json` du plugin. La clé `modules` dans ce fichier donne le chemin vers votre code, et l'avoir est ce qui rend le plugin un mod. Listez un chemin, relatif à `hooks.json`. Ici, il pointe vers `register.js`, que vous écrivez à l'étape suivante.

137 

138 Enregistrez ceci comme `first-mod/hooks/hooks.json` :

139 

140 ```json first-mod/hooks/hooks.json theme={null}

141 {

142 "description": "The first-mod hooks module",

143 "modules": ["./register.js"]

144 }

145 ```

146 </Step>

147 

148 <Step title="Écrivez le code">

149 Ce fichier est le code du mod, appelé le module de hooks. Lorsque le mod se charge, Claude Code appelle la fonction `register` que le fichier exporte et lui passe une fonction nommée [`on`](/docs/fr/plugins/mods/reference#the-hook-function). Chaque appel à `on` enregistre un gestionnaire d'événement, appelé un hook, pour l'événement qu'il nomme.

150 

151 Enregistrez ceci comme `first-mod/hooks/register.js` :

152 

153 ```javascript first-mod/hooks/register.js theme={null}

154 // The count, shared by the hooks below

155 let calls = 0

156 

157 // Claude Code calls this once when the mod loads

158 export function register(on) {

159 // Runs when the session starts, before your first prompt

160 on('session.start', async ($, e, next) => {

161 // Add the /tally command

162 await $.command.register({

163 name: 'tally',

164 description: 'Show how many tool calls Claude has made',

165 })

166 // Let the session start as usual

167 return next(e)

168 })

169 

170 // Runs each time Claude is about to use a tool

171 on('tool.call', async ($, e, next) => {

172 calls += 1

173 // Ask Claude Code to draw the interface again, so the new count shows

174 $.ui.invalidate('ui.render')

175 // Let the tool run as usual

176 return next(e)

177 })

178 

179 // Runs when you type /tally, and only then, because of the matcher

180 on('command.run', { command: 'tally' }, async () => {

181 // The text to print in the transcript

182 return { text: 'Claude has made ' + calls + ' tool calls since this mod loaded' }

183 })

184 

185 // Runs each time Claude Code draws the spinner

186 on('ui.render', { component: 'Spinner' }, async ($, e, next) => {

187 // Keep Claude Code's spinner, with the count added after its word

188 return next({ ...e, props: { ...e.props, suffix: ' · tool calls: ' + calls + '…' } })

189 })

190 }

191 ```

192 

193 Le fichier garde un compte dans `calls` et enregistre quatre hooks :

194 

195 * **[`session.start`](/docs/fr/plugins/mods/reference#session)** s'exécute lorsque la session démarre, avant votre première invite, et à nouveau chaque fois que le mod se recharge. Il ajoute la commande `/tally` à Claude Code.

196 * **[`tool.call`](/docs/fr/plugins/mods/reference#tools)** s'exécute chaque fois que Claude est sur le point d'utiliser un outil. Il ajoute un à `calls` et demande à Claude Code de redessiner l'interface.

197 * **[`command.run`](/docs/fr/plugins/mods/reference#commands-and-configuration)** s'exécute lorsque vous tapez `/tally`. Il retourne le texte à imprimer.

198 * **[`ui.render`](/docs/fr/plugins/mods/reference#interface)** s'exécute chaque fois que Claude Code dessine le spinner. Il ajoute le compte après le mot du spinner.

199 

200 [Comment fonctionne le mod d'exemple](#how-the-example-mod-works) explique les trois arguments que chaque hook prend et ce que chacun retourne.

201 </Step>

202 

203 <Step title="Chargez le mod">

204 Démarrez Claude Code avec le drapeau `--plugin-dir`, qui charge un répertoire de plugin pour une session sans l'installer :

205 

206 ```bash theme={null}

207 claude --plugin-dir ./first-mod

208 ```

209 </Step>

210 

211 <Step title="Essayez le mod">

212 Demandez à Claude de faire quelque chose qui prend quelques appels d'outils, comme `list the files here and read the README`. Pendant que Claude travaille, le mot du spinner est suivi d'un compte qui augmente, comme dans `Thinking · tool calls: 2…`. Lorsque Claude a terminé, tapez `/tally` et appuyez sur Entrée. La transcription affiche `first-mod: Claude has made 2 tool calls since this mod loaded`, avec votre propre compte. Claude Code met le nom du plugin devant le texte de la commande.

213 

214 Pour vérifier la commande sans une session interactive, exécutez-la en mode non-interactif :

215 

216 ```bash theme={null}

217 claude -p "/tally" --plugin-dir ./first-mod

218 ```

219 

220 ```text theme={null}

221 first-mod: Claude has made 0 tool calls since this mod loaded

222 ```

223 

224 Si `/tally` n'est pas dans la liste des commandes, le module ne s'est pas chargé. Consultez [Découvrez pourquoi un mod ne fait rien](/docs/fr/plugins/mods/troubleshoot#find-out-why-a-mod-does-nothing).

225 </Step>

226 

227 <Step title="Modifiez le code pendant que la session s'exécute">

228 Laissez la session ouverte. Dans `register.js`, changez `' · tool calls: '` en `' · tools used: '` dans le hook `ui.render` et enregistrez. La ligne en surbrillance est celle qui change :

229 

230 ```javascript first-mod/hooks/register.js {4} theme={null}

231 // Runs each time Claude Code draws the spinner

232 on('ui.render', { component: 'Spinner' }, async ($, e, next) => {

233 // Keep Claude Code's spinner, with the count added after its word

234 return next({ ...e, props: { ...e.props, suffix: ' · tools used: ' + calls + '…' } })

235 })

236 ```

237 

238 Une ligne dans la transcription dit que `first-mod` s'est rechargé et liste ses hooks, et le prochain spinner utilise le nouveau texte, comme dans `Thinking · tools used: 1…`.

239 </Step>

240</Steps>

241 

242<h3 id="how-the-example-mod-works">

243 Comment fonctionne le mod d'exemple

244</h3>

245 

246Chaque fonction que vous passez à `on` est un hook, qui est un gestionnaire d'événement. Claude Code passe à chaque hook les trois mêmes arguments :

247 

248* **L'API des mods**, nommée `$` : chaque méthode qu'un mod peut appeler pour atteindre l'extérieur de lui-même, dans des [espaces de noms](/docs/fr/plugins/mods/reference#mods-api-methods) tels que `$.ui` et `$.command`

249* **L'événement**, nommé `e` : l'[entrée de l'événement](/docs/fr/plugins/mods/reference#events) en tant que données simples, comme le nom et les arguments d'un appel d'outil

250* **Le gestionnaire suivant**, nommé [`next`](/docs/fr/plugins/mods/events#how-a-hook-handles-an-event) : une fonction qui transmet l'événement aux autres mods puis au comportement propre de Claude Code, et retourne le résultat

251 

252Les hooks dans `first-mod` gèrent leurs événements de trois façons qu'un hook peut :

253 

254* **Observer** : le hook `session.start` enregistre la commande, et le hook `tool.call` compte l'appel et demande un redessinage. Les deux retournent `next(e)`, donc la session démarre et l'outil s'exécute comme d'habitude.

255* **Répondre** : le hook `command.run` retourne son propre résultat et n'appelle jamais `next`. Le deuxième argument à `on`, `{ command: 'tally' }`, est un filtre, appelé un [matcher](/docs/fr/plugins/mods/events#filter-which-events-a-hook-handles), donc le hook s'exécute uniquement pour `/tally`.

256* **Réécrire** : le hook `ui.render` appelle `next` avec une copie de `e` dont `suffix` contient le compte, donc Claude Code dessine son spinner habituel avec votre texte après le mot

257 

258Claude Code surveille un répertoire chargé avec `--plugin-dir` et recharge à chaud le module de hooks lorsqu'un fichier dedans change. Chaque rechargement exécute `register` à nouveau, donc `calls` revient à `0` et `/tally` recommence à compter. Pour conserver une valeur entre les rechargements, consultez [Conserver l'état](/docs/fr/plugins/mods/interface#keep-state).

259 

260<h2 id="keep-working-on-a-mod">

261 Continuez à travailler sur un mod

262</h2>

263 

264Une fois qu'un mod se charge, vous pouvez demander à Claude de le modifier, vérifier votre code par rapport aux définitions de type pour votre version, lister les événements et appels que Claude Code trouve dedans, et le tester.

265 

266<h3 id="change-a-mod-with-claude">

267 Modifiez un mod avec Claude

268</h3>

269 

270Pour modifier un mod que vous avez déjà, démarrez la session avec `--plugin-dir` pointé vers le répertoire du mod, afin que ce que Claude écrit se charge dans la même session :

271 

272```bash theme={null}

273claude --plugin-dir ./first-mod

274```

275 

276Ensuite, demandez la modification, par exemple `add a /tally-reset command to this mod that sets the tally back to zero`. Claude édite le module de hooks, exécute `claude plugin validate`, et corrige ce qu'il rapporte. Un répertoire que vous chargez avec `--plugin-dir` est un [chemin protégé](/docs/fr/permission-modes#protected-paths), donc en modes `default` et `acceptEdits` vous êtes invité à approuver chacune des modifications de Claude au mod. Le tableau des chemins protégés donne le résultat pour les autres modes de permission.

277 

278Les fichiers que Claude enregistre pendant son tour se rechargent à la fin du tour, vous pouvez donc essayer `/tally-reset` dès que Claude a terminé.

279 

280<h3 id="get-the-types-for-your-build">

281 Obtenez les définitions de type pour votre version

282</h3>

283 

284Chaque fois que Claude Code charge ou recharge un mod à partir d'un répertoire que vous passez à `--plugin-dir`, ou un mod [que Claude a écrit pour vous](#ask-claude-for-a-mod), il écrit des fichiers de déclaration TypeScript, se terminant par `.d.ts`, dans `.claude-plugin/types/` à l'intérieur du répertoire du mod. Ils décrivent les événements exacts, les méthodes de l'API des mods, et les éléments dans la version de Claude Code que vous exécutez, afin que votre éditeur puisse autocomplète et vérifier le type de vos hooks. Pour parcourir les déclarations en ligne, lisez [`mods/types/claude-code.d.ts`](https://github.com/anthropics/claude-code/blob/main/mods/types/claude-code.d.ts) dans le référentiel Claude Code, dont la première ligne nomme la version qui l'a écrit. Le répertoire contient ces fichiers :

285 

286| Chemin | Ce qu'il déclare |

287| :- | :- |

288| `claude-code/index.d.ts` | Chaque événement et son entrée et résultat, chaque espace de noms et méthode de l'API des mods, et les éléments que chaque surface peut dessiner |

289| `claude-code-tools/index.d.ts` | Les entrées et résultats des outils intégrés, afin que vérifier `e.tool === 'Bash'` réduise `e` |

290| `claude-code-mcp/index.d.ts` | Les entrées des outils MCP qui ont été connectés la dernière fois que vous avez enregistré un fichier dans le mod |

291| `index.d.ts` dans un répertoire nommé pour un plugin | Ce que ce plugin ajoute à l'API des mods. Il y a un répertoire pour chaque plugin que votre `plugin.json` liste sous `dependencies`. |

292| `tsconfig.json` | Les options du compilateur qui conviennent à un module de hooks |

293 

294Si votre mod n'a pas son propre `tsconfig.json`, Claude Code en ajoute un à la racine du mod qui étend le généré, afin que votre éditeur et `tsc -p ./first-mod` vérifient le type du mod sans plus de configuration.

295 

296Les événements et méthodes peuvent changer entre les versions, donc faites confiance à ces fichiers plutôt qu'à n'importe quelle page, celle-ci incluse, lorsqu'ils ne sont pas d'accord.

297 

298`claude-code/index.d.ts` est la référence la plus complète pour votre build, avec un commentaire et un exemple pour chaque méthode de l'API des mods. Pour chercher quelque chose, recherchez le fichier pour son nom, comme `'tool.call'`.

299 

300<h3 id="check-what-claude-code-reads-from-your-mod">

301 Vérifiez ce que Claude Code lit à partir de votre mod

302</h3>

303 

304Pour voir votre mod comme Claude Code le voit, sans exécuter votre code ou démarrer une session, utilisez `claude plugin validate`. Il vérifie le manifeste et exécute la même analyse statique sur la source du module de hooks que Claude Code exécute lorsqu'il charge un mod. Dans votre shell, exécutez-le sur le répertoire du mod :

305 

306```bash theme={null}

307claude plugin validate ./first-mod

308```

309 

310Pour `first-mod`, la sortie inclut ces lignes.

311 

312```text theme={null}

313 ❯ ./register.js hooks: session.start, tool.call, command.run{command=tally}, ui.render{component=Spinner}

314 ❯ ./register.js calls: $.command.register, $.ui.invalidate

315 

316✔ Validation passed

317```

318 

319La ligne `hooks:` liste les événements que votre module hook, chacun avec son filtre entre accolades. La ligne `calls:` liste chaque méthode de l'API des mods qu'il appelle. Un module qui lit ou définit des variables d'environnement obtient également des lignes `env reads:` et `env writes:`, et un qui utilise [`$.state`](/docs/fr/plugins/mods/interface#keep-state) obtient `state reads:` et `state writes:`.

320 

321Si un événement que vous aviez l'intention de hooker manque de la première ligne, Claude Code n'appellera pas ce hook non plus. La cause habituelle est un nom d'événement mal orthographié, que la commande rapporte comme une erreur telle que `"tool.calls" is not an event`.

322 

323Suivez ces règles afin que l'analyse statique puisse trouver chaque hook et appel :

324 

325* Épellez chaque appel de l'API des mods en entier : `$`, l'espace de noms, puis la méthode, comme dans `$.store.get('notes')`. Vous pouvez passer `$` à une fonction déclarée au niveau supérieur du même fichier, et pour une fonction vôtre nommée `loadNotes`, la ligne `calls:` lit alors `$.store.get (via loadNotes)`. Passer `$` à une méthode, une fonction définie à l'intérieur du hook, ou une fonction que vous importez d'un autre de vos fichiers échoue la validation. Les fonctions `read` et `update` que [`$.state`](/docs/fr/plugins/mods/interface#keep-state) utilise sont les imports qui peuvent le prendre. N'assignez pas `$` ou l'un de ses espaces de noms à une variable, ne le déstructurez pas, ou ne l'indexez pas avec un nom calculé. `const ui = $.ui` échoue avec `$.ui is used as a value`.

326* Écrivez le nom de l'événement dans chaque appel `on` comme un littéral de chaîne, comme `'tool.call'`. Une variable, ou une boucle sur une liste de noms, échoue avec `the event name passed to on() is not a string literal`.

327* À l'intérieur de `register`, ne déclarez pas une deuxième variable ou paramètre nommé `on`. La validation échoue avec `"on" is declared again (shadowed)`.

328* Importez uniquement à partir de fichiers à l'intérieur du répertoire du plugin, par chemin relatif. Le seul import nu autorisé est `claude-code`, pour les types et quelques helpers.

329* Utilisez les déclarations `import` en haut du fichier, comme dans `import { name } from './file.js'`. Un `import()` dynamique échoue avec `a dynamic import(); a hooks module imports its own files with an import declaration`.

330* Écrivez chaque fichier en tant que module ES, avec `import` et non `require`. La [référence](/docs/fr/plugins/mods/reference#files) liste les extensions de fichier que Claude Code charge.

331 

332<h3 id="test-the-mod">

333 Testez le mod

334</h3>

335 

336Vous pouvez écrire des tests automatisés pour un mod et les exécuter à partir de votre shell avec `claude plugin test`, sans session, connexion ou réseau. Un test lève les événements que vos hooks gèrent et vérifie ce que les hooks ont fait.

337 

338Ce test lève deux appels d'outils, exécute `/tally`, et vérifie que la réponse compte les deux. Enregistrez-le comme `first-mod/tests/first-mod.test.ts` :

339 

340```typescript first-mod/tests/first-mod.test.ts theme={null}

341import { expect, test } from 'claude-code/testing'

342 

343test('/tally reports the tool calls the mod has seen', async ($, on) => {

344 // Answer each tool call in Claude Code's place, so no tool runs

345 on('tool.call', () => ({ result: 'ok' }))

346 

347 // Raise two tool calls, which the mod's tool.call hook counts

348 await $.tool.call({ tool: 'Bash', command: 'ls' })

349 await $.tool.call({ tool: 'Read', file_path: 'README.md' })

350 

351 // Run /tally and check the text its hook returns

352 const answer = await $.command.run({ command: 'tally', args: '' })

353 expect(answer.text).toBe('Claude has made 2 tool calls since this mod loaded')

354})

355```

356 

357Dans votre shell, exécutez les tests à partir du répertoire `first-mod` :

358 

359```bash theme={null}

360claude plugin test

361```

362 

363La sortie nomme chaque test et s'il a réussi, avec des timings qui varient d'une exécution à l'autre :

364 

365```text theme={null}

366tests/first-mod.test.ts:

367(pass) /tally reports the tool calls the mod has seen [22.87ms]

368 

369 1 pass

370 0 fail

371Ran 1 test across 1 file. [0.19s]

372```

373 

374[Testez un mod](/docs/fr/plugins/mods/test) couvre le stubbing d'un appel de modèle ou du store, et le test des minuteurs et des dessins.

375 

376<h2 id="share-your-mod">

377 Partagez votre mod

378</h2>

379 

380Un mod est un plugin, donc vous le versionnez dans le manifeste et les gens l'installent et le mettent à jour avec les commandes `/plugin`. Pour le donner à d'autres personnes, [ajoutez-le à une marketplace](/docs/fr/plugins/publish).

381 

382Avant de le faire, vérifiez le `name` du plugin : `claude plugin validate` échoue un nom qui [ressemble à l'un des propres d'Anthropic](/docs/fr/plugins/manifest-reference#name), comme un qui commence par `claude-`. Les événements et méthodes peuvent changer entre les versions, donc votre README est l'endroit pour dire quelle version de Claude Code vous avez testée.

383 

384Continuez à développer contre le répertoire avec `--plugin-dir`, pas contre une copie installée. Claude Code met en cache un plugin installé par version, donc vos modifications n'atteignent pas la copie installée jusqu'à ce que vous augmentiez la version et réinstalliez.

385 

386<h2 id="next-steps">

387 Prochaines étapes

388</h2>

389 

390* [Dessinez dans l'interface](/docs/fr/plugins/mods/interface) : ouvrez un volet, dessinez au-dessus de l'invite, et ajoutez des boutons et des champs de texte

391* [Réagissez aux événements](/docs/fr/plugins/mods/events) : hooquez les appels d'outils, les invites, et les tours

392* [Utilisez l'API des mods](/docs/fr/plugins/mods/api) : ajoutez des commandes et des outils, appelez un modèle, et exécutez du travail sur un minuteur

393* [Testez un mod](/docs/fr/plugins/mods/test) : stubifiez ce que Claude Code répondrait, et testez les minuteurs et les dessins

394* [Dépannez un mod](/docs/fr/plugins/mods/troubleshoot) : les raisons pour lesquelles un mod ne fait rien, et le journal de débogage

395* [Lisez la source des mods intégrés](/docs/fr/plugins/mods/overview#read-the-source-of-built-in-mods) : des plugins complets, chacun avec son module de hooks et ses tests