Comment configurer les « hooks » de Claude Code pour automatiser vos processus grâce à l'IA

Les hooks de Claude Code sont des déclencheurs déterministes qui exécutent vos commandes shell à des moments précis du cycle de vie de Claude Code. Utilisez-les pour formater automatiquement vos fichiers après modification, appliquer les règles du projet, bloquer les opérations risquées, injecter du contexte au début d'une session ou recevoir une alerte quand votre intervention est requise — sans dépendre de la mémoire du modèle.

Pourquoi les hooks sont incontournables

Les invites (prompts) sont parfaites pour guider; les hooks, eux, sont des garanties. Ils se déclenchent systématiquement chaque fois que l'événement ciblé survient (ex. : avant l'exécution d'un outil, après une modification, à l'ouverture ou la fermeture d'une session). Vous obtenez ainsi un formatage uniforme, une conformité stricte et des garde-fous fiables pour toute votre équipe — sans devoir répéter vos consignes.

Ce que les hooks de Claude Code peuvent accomplir

• Prévenir les actions risquées : Bloquez les écritures dans les fichiers .env, les configurations de production ou /.git. (Utilisez PreToolUse avec le contrôle des codes de sortie.)

• Appliquer automatiquement vos standards : Lancez prettier, gofmt ou votre linter après chaque modification ou écriture (PostToolUse).

• Injecter du contexte automatiquement : Au moment du SessionStart, intégrez les derniers tickets de suivi ou une liste de vérification directement dans la conversation.

• Des notifications sans friction : Affichez des alertes sur votre bureau dès que Claude a besoin de votre approbation (Notification).

• Filtrer les requêtes et outils : Approuvez, refusez ou demandez confirmation grâce au contrôle de décision PreToolUse / PermissionRequest.

Les hooks se configurent au niveau des paramètres de l’utilisateur, du projet ou du projet local — et peuvent également être imposés via les politiques d'entreprise. Claude Code

Les événements de hook réellement utiles au quotidien

• PreToolUse / PermissionRequest / PostToolUse — encadrez les appels d'outils (Bash, Edit, Write, Read, Grep, WebFetch, Task/sous-agents). Autorisez, refusez ou demandez confirmation; modifiez les entrées ou fournissez une rétroaction par la suite.

• UserPromptSubmit — validez ou enrichissez les invites avant leur traitement par Claude; vous pouvez injecter du texte ou du contexte structuré.

• SessionStart / SessionEnd — préparez l'environnement, chargez le contexte de départ, puis nettoyez et enregistrez les journaux à la fin.

• Notification, Stop, SubagentStop, PreCompact — alertes, contrôle de fin de réponse et hooks de compression d'historique.

Une configuration rapide et sécuritaire (en 5 étapes)

1. Ouvrez l'interface des hooks : lancez /hooks dans Claude Code. Sélectionnez un événement (par ex. : PreToolUse).

2. Ajoutez une règle de correspondance (matcher) : ex. : Edit|Write pour intercepter les modifications de fichiers, ou Bash pour encadrer les commandes shell. * intercepte tout.

3. Ajoutez le hook : choisissez type: "command" et saisissez votre commande shell (elle reçoit du JSON sur stdin; utilisez jq ou Python pour l'analyser).

4. Sélectionnez l'emplacement de sauvegarde :

   • ~/.claude/settings.json (utilisateur),

   • .claude/settings.json (projet, à versionner dans Git),

   • .claude/settings.local.json (local seulement),

   • ou politique d'entreprise (application centralisée).

5. Validez et testez : la commande /hooks affiche votre configuration; faites un test rapide et vérifiez vos journaux d'exécution.

Exemples prêts à l'emploi

1) Journaliser chaque commande Bash (audit rapide)

À enregistrer sous PreToolUse avec le matcher Bash :

jq -r '"\(.tool_input.command) - \(.tool_input.description // "No description")"' >> ~/.claude/bash-command-log.txt

jq -r '"\(.tool_input.command) - \(.tool_input.description // "No description")"' >> ~/.claude/bash-command-log.txt

jq -r '"\(.tool_input.command) - \(.tool_input.description // "No description")"' >> ~/.claude/bash-command-log.txt

Cette commande s'exécute avant chaque appel à l'outil Bash et ajoute une ligne dans un fichier journal. Claude Code

2) Formater automatiquement TypeScript après modification/écriture

PostToolUse avec le matcher Edit|Write :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | { read file_path; if echo \"$file_path\" | grep -q '\\.ts$'; then npx prettier --write \"$file_path\"; fi; }"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | { read file_path; if echo \"$file_path\" | grep -q '\\.ts$'; then npx prettier --write \"$file_path\"; fi; }"
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | { read file_path; if echo \"$file_path\" | grep -q '\\.ts$'; then npx prettier --write \"$file_path\"; fi; }"
          }
        ]
      }
    ]
  }
}

Claude Code

3) Protéger les fichiers sensibles (blocage avec le code de sortie 2)

PreToolUse avec le matcher Edit|Write :

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"import json, sys; d=json.load(sys.stdin); p=d.get('tool_input',{}).get('file_path',''); sys.exit(2 if any(x in p for x in ['.env','package-lock.json','.git/']) else 0)\""
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"import json, sys; d=json.load(sys.stdin); p=d.get('tool_input',{}).get('file_path',''); sys.exit(2 if any(x in p for x in ['.env','package-lock.json','.git/']) else 0)\""
          }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"import json, sys; d=json.load(sys.stdin); p=d.get('tool_input',{}).get('file_path',''); sys.exit(2 if any(x in p for x in ['.env','package-lock.json','.git/']) else 0)\""
          }
        ]
      }
    ]
  }
}

Le code de sortie 2 bloque l'action et transmet votre flux stderr à Claude (et/ou à l'utilisateur) selon les règles propres à l'événement. Claude Code

4) Recevoir des alertes de bureau quand Claude requiert votre attention

Hook de type Notification :

{
  "hooks": {
    "Notification": [
      {
        "hooks": [
          { "type": "command", "command": "notify-send 'Claude Code' 'Awaiting your input'" }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "Notification": [
      {
        "hooks": [
          { "type": "command", "command": "notify-send 'Claude Code' 'Awaiting your input'" }
        ]
      }
    ]
  }
}

{
  "hooks": {
    "Notification": [
      {
        "hooks": [
          { "type": "command", "command": "notify-send 'Claude Code' 'Awaiting your input'" }
        ]
      }
    ]
  }
}

Claude Code

5) Précharger du contexte au démarrage de la session

L'événement SessionStart peut injecter des directives supplémentaires ou une liste de vérification :

• Écrivez du texte brut sur stdout (code de sortie 0) pour ajouter du contexte, ou

• Renvoyez un objet JSON contenant hookSpecificOutput.additionalContext.

Contrôle avancé : codes de sortie et décisions en JSON

• 0 : succès. Le flux stdout peut être analysé en JSON pour un contrôle structuré (ex. : "allow"|"deny"|"ask" sur PreToolUse; "block" sur PostToolUse/Stop; ajout de additionalContext).

• 2 : erreur bloquante. Ignore le JSON; utilise stderr comme message d'erreur et applique le blocage selon les règles de l'événement (ex. : refuser un PreToolUse).

• Autre code non nul : non bloquant; affiche la sortie stderr en mode détaillé (verbose).

Utilisation en intégration continue (CI) et sans interface (mode headless)

Combinez les hooks avec le mode sans tête (headless) pour exécuter Claude Code dans vos pipelines de CI, scripts de compilation ou déclencheurs pré-commit : claude -p "<prompt>" --output-format stream-json. Ce mode s'applique par session, pensez donc à le spécifier à chaque exécution. Anthropic

Sécurité et gouvernance : les indispensables

• Les hooks s'exécutent automatiquement avec vos identifiants d'utilisateur; révisez attentivement vos scripts et appliquez les bonnes pratiques de sécurité (variables entre guillemets, validation des entrées, protection des répertoires sensibles, chemins absolus).

• Les modifications de configuration ne s'appliquent pas à chaud : Claude capture un instantané des hooks au début de la session et vous invite à confirmer les changements dans /hooks — une mesure de protection efficace contre les modifications non autorisées.

• Les équipes d'entreprise peuvent déployer des politiques de hooks centralisées à l'échelle de l'organisation pour garantir la conformité.

Foire aux questions (FAQ)

Qu'est-ce que les hooks de Claude Code?
Ce sont des commandes shell personnalisées qui s'exécutent lors d'événements clés du cycle de vie de Claude Code (ex. : PreToolUse, PostToolUse, SessionStart) afin d'appliquer des règles d'entreprise, d'automatiser des flux de travail ou d'enrichir le contexte. Claude Code

Où se configurent-ils?
Dans ~/.claude/settings.json, .claude/settings.json, .claude/settings.local.json, ou par l'intermédiaire des politiques d'entreprise; la commande /hooks met à votre disposition un éditeur interactif très pratique. Claude Code

Comment empêcher les actions dangereuses?
Retournez un code de sortie 2 depuis un hook PreToolUse/PermissionRequest pour bloquer l'action et renvoyer votre message d'erreur à Claude; vous pouvez aussi employer le contrôle décisionnel JSON avec « deny/ask/allow ». Claude Code

Est-il possible d'ajouter du contexte automatiquement?
Absolument — UserPromptSubmit et SessionStart peuvent transmettre du texte libre ou un champ structuré additionalContext à la conversation avant que Claude n'entame son travail. Claude Code

Les hooks sont-ils compatibles avec les plugins et outils MCP?
Oui — les plugins peuvent intégrer leurs propres hooks, et vous avez la possibilité de cibler les outils MCP grâce aux règles de correspondance (matchers); plusieurs hooks peuvent même rouler en parallèle pour un même événement. Claude Code