Crochets Claude Code : Guide pratique de l'automatisation des flux de travail

Lorsque vous travaillez avec Claude Code, vous remarquerez un problème récurrent : Il écrit du code de qualité, mais omet des étapes importantes telles que le formatage, l'exécution de tests ou le respect des protocoles de sécurité. Vous finissez par répéter les mêmes rappels à maintes reprises. 

Les Claude Code Hooks vous permettent d'automatiser ces rappels en exécutant automatiquement des commandes shell à des moments précis de votre flux de travail.

Ce tutoriel vous montre comment configurer des hooks pour le formatage du code, l'exécution des tests, les notifications et la protection des fichiers. Vous développerez un système d'automatisation qui applique vos normes de développement de manière cohérente, sans intervention manuelle.

Pour en savoir plus sur le modèle linguistique à grande échelle (LLM) qui alimente Claude Code, veuillez consulter cet article sur Claude Sonnet 4.5.

Que sont les Claude Code Hooks ?

Les Claude Code Hooks sont des commandes shell qui s'exécutent automatiquement lorsque des événements spécifiques se produisent pendant votre session de codage IA. Considérez-les comme des déclencheurs automatisés qui exécutent vos scripts personnalisés à des moments précis—avant que Claude n'écrive un fichier, après avoir exécuté une commande ou lorsqu'il vous envoie une notification.

Le système fonctionne en surveillant les actions de Claude Code et en les comparant aux règles que vous définissez dans un fichier de configuration. Lorsqu'une correspondance est détectée, la commande que vous avez spécifiée s'exécute avec accès au contexte de ce qui vient de se produire. Cela vous permet de contrôler le comportement de Claude et d'automatiser les tâches répétitives qui, autrement, nécessiteraient une intervention manuelle.

Voici un hook de base qui exécute un formateur de code chaque fois que Claude écrit un fichier Python :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python -m black ."
          }
        ]
      }
    ]
  }
}

Ce crochet est composé de trois parties : 

• Événement : PostToolUse (une fois que Claude a terminé une action)

• Le comparateur : Write (uniquement lors de l'écriture de fichiers)

• La commande : python -m black . (formater les fichiers Python dans le répertoire actuel)

Le hook reçoit des informations détaillées sur les actions récemment effectuées par Claude via des données JSON envoyées à l'entrée du script, ce qui vous permet de créer une automatisation plus sophistiquée qui réagit à des modifications de fichiers spécifiques.

Si vous êtes intéressé par l'automatisation au-delà des flux de travail de codage, Claude Cowork propose une automatisation similaire assistée par l'IA pour les tâches liées aux fichiers et aux documents.

Ensuite, nous examinerons comment créer de tels hooks à partir de zéro et les enregistrer dans Claude Code afin de les ajouter à vos workflows.

Conditions préalables

Avant de vous plonger dans Claude Code Hooks, vous devrez configurer quelques éléments :

• Claude Code est installé et fonctionne correctement. Il est recommandé d'être à l'aise avec Claude Code pour les tâches de codage de base.

• Connaissance de la ligne de commande : Les hooks exécutent des commandes shell, il est donc nécessaire de savoir rédiger des commandes de terminal de base pour votre système d'exploitation.

• Accès à l'éditeur de texte : Vous devrez modifier les fichiers de configuration JSON pour configurer vos hooks.

• Répertoire du projet : Un projet de codage où vous pouvez tester en toute sécurité les hooks sans affecter le travail important

Il n'est pas nécessaire d'être un expert en scripts shell, mais comprendre comment exécuter des commandes telles que ` ls`, ` cd` et les opérations de base sur les fichiers vous aidera à suivre les exemples. Si vous débutez avec les scripts bash ou le terminal, je vous recommande de suivre notre cours d'introduction au shell .

Commencer avec Claude Code Hooks

Maintenant que vous comprenez ce que sont les hooks, nous allons configurer votre première automatisation. Le processus consiste à sélectionner l'événement adapté à vos besoins, à configurer une règle simple et à la tester à l'aide d'une commande de base.

Comprendre les événements hook

Claude Code propose dix événements différents dans lesquels vous pouvez exécuter vos commandes. Chaque événement se déclenche à un moment précis, vous permettant ainsi de contrôler différentes parties de votre flux de travail :

PreToolUse Les événements les plus courants sont « PostToolUse » ( avant l'exécution) et « PreToolUse » (après l'exécution). L'événement « » se produit avant que Claude n'effectue une action telle que l'écriture d'un fichier ou l'exécution d'une commande, ce qui le rend idéal pour la validation ou le blocage d'opérations dangereuses. L'événement « PostToolUse » se produit après que Claude a terminé une action, ce qui convient parfaitement aux tâches de nettoyage telles que le formatage de code ou l'exécution de tests.

UserPromptSubmit se déclenche lorsque vous soumettez une requête à Claude, avant qu'il ne traite votre demande. Vous pouvez utiliser cette fonctionnalité pour ajouter du contexte à votre conversation ou pour vérifier que les invites répondent à certaines exigences.

Notification s'exécute lorsque Claude vous envoie des alertes, par exemple pour demander l'autorisation d'exécuter une commande ou lorsqu'il a besoin de votre intervention. PermissionRequest se déclenche lorsque Claude Code affiche une boîte de dialogue d'autorisation, vous permettant d'approuver ou de refuser automatiquement la demande au nom de l'utilisateur.

Stop et SubagentStop se déclenchent lorsque Claude a fini de répondre, ce qui est utile pour les vérifications finales ou la génération de rapports. La différence entre les deux réside dans le fait que Stop se déclenche lorsque Claude termine sa réponse globale, tandis que SubagentStop se déclenche lorsqu'un assistant généré par un outil (un « sous-agent ») termine son travail.

Les événements restants, PreCompact et SessionStart, gèrent des situations particulières telles que le nettoyage des conversations et l'initialisation des sessions.

Les événements restants, PreCompact, SessionStart et SessionEnd, gèrent des situations spécifiques au cycle de vie. PreCompact s'exécute juste avant que Claude ne raccourcisse l'historique des conversations. « SessionStart » se déclenche au début d'une nouvelle session pour configurer les paramètres par défaut, et « SessionEnd » se déclenche à la fin de la session, permettant ainsi le nettoyage ou la création d'un rapport final.

Comprendre les matchers

Les matchers sont les filtres qui déterminent quelles actions Claude Code déclenchent un hook. Techniquement, il s'agit de chaînes interprétées comme des expressions régulières, vous pouvez donc utiliser soit des correspondances exactes, soit des modèles plus flexibles. 

Les correspondances les plus pertinentes sont les plus simples, telles que Write (se déclenche lorsque Claude écrit un fichier) ou Edit (se déclenche lors de la modification de contenu), ainsi que des combinaisons telles que Edit|Write pour couvrir plusieurs actions. 

Vous pouvez également utiliser des modèles de préfixe tels que Notebook.* pour rechercher tous les outils commençant par « Notebook ». Si vous souhaitez que le hook se déclenche à chaque action, veuillez utiliser l'expression régulière universelle .*, une chaîne vide ("") ou laisser matcher vide.

Étant donné que les correspondances sont sensibles à la casse et ne s'appliquent qu'aux noms d'actions, il est préférable de les garder aussi spécifiques que possible. Lorsque vous avez besoin d'un contrôle plus précis (par exemple, pour limiter le hook à certains types de fichiers), vous pouvez consulter la charge utile JSON que Claude transmet au hook et y appliquer vos propres expressions régulières ou conditions.

Création de votre premier hook dans Claude Code

Claude Code propose deux méthodes pour configurer les hooks : via la commande interactive /hooks ou en modifiant directement les fichiers de configuration. Commençons par l'approche interactive, car elle est plus adaptée aux débutants.

Utilisation de la commande « /hooks » :

1. Veuillez ouvrir Claude Code et saisir /hooks dans l'interface de chat.

2. Veuillez sélectionner votre événement déclencheur (choisissez « PostToolUse » pour cet exemple).

3. Veuillez sélectionner « Ajouter un nouveau hook » dans le menu.

4. Définissez votre modèle de correspondance (entrez Write pour cibler l'écriture du fichier)

5. Veuillez saisir votre commande :

• Mac : say "Task complete"

• Windows : powershell -c [console]::beep()

• Linux : spd-say "Task complete"

6. Veuillez enregistrer la configuration et revenir à Claude Code en appuyant trois fois sur la touche Échap.

La commande « /hooks » mettra automatiquement à jour votre fichier de paramètres et rechargera la configuration. Vous pouvez également utiliser /hooks à tout moment pour consulter vos hooks existants ou apporter des modifications.

Si vous préférez modifier directement les fichiers de configuration, les hooks se trouvent dans ~/.claude/settings.json pour les paramètres globaux ou dans .claude/settings.json dans le répertoire de votre projet. Dans le cas de notre exemple ci-dessus, cela donnerait :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "say 'Task complete'"
          }
        ]
      }
    ]
  }
}

Après avoir modifié le fichier manuellement, veuillez redémarrer Claude Code ou utiliser la commande /hooks pour recharger votre configuration. Désormais, chaque fois que Claude enregistre un fichier, vous entendrez une notification sonore.

Vérification de votre crochet

Avant de poursuivre, veuillez vérifier que votre crochet fonctionne correctement :

1. Veuillez demander à Claude de créer un fichier Python (par exemple, « Créez un fichier hello.py qui affiche hello world »).

2. Vous devriez entendre la notification audio lorsque Claude aura terminé l'opération d'écriture.

3. Si vous n'entendez rien, veuillez vérifier la transcription de Claude Code en appuyant sur Ctrl-O pour voir les messages d'erreur éventuels.

4. Les problèmes courants incluent l'impossibilité de trouver la commande hook, des autorisations de fichier incorrectes ou des erreurs de syntaxe dans votre fichier de configuration.

Le fait de vérifier le bon fonctionnement de ce test de base vous évite de passer du temps à déboguer plus tard, lorsque vous créerez des hooks plus complexes. Si vous venez de modifier manuellement le fichier de paramètres, de changer un matcher ou un événement, ou d'installer de nouveaux outils que vous souhaitez utiliser dans une commande hook, il peut être utile de rouvrir /hooks ou de redémarrer Claude pour recharger la configuration.

Ce modèle de base (événement, comparateur, commande) constitue le fondement de toute automatisation des hooks. Vous pouvez développer cette fonctionnalité en ajoutant plusieurs commandes à exécuter simultanément lorsque le même événement se produit. Par exemple, vous pourriez souhaiter à la fois jouer un son et créer une sauvegarde lorsque Claude écrit un fichier. 

Vous pouvez également créer des comparateurs distincts pour différents outils au sein d'un même événement, de sorte que l'écriture de fichiers déclenche des actions différentes de celles liées à l'édition de code. Tous les crochets correspondant au même modèle d'outil fonctionnent en parallèle. Si vous configurez plusieurs comparateurs pour le même événement, chaque hook s'exécute lorsque son comparateur est déclenché.

Utilisation des entrées Hook

Lorsque Claude Code déclenche un hook, il transmet des informations sur ce qui vient de se produire via l'entrée standard (stdin), un flux de données qui est directement acheminé vers votre commande lorsqu'elle s'exécute. Ces données sont ce qui rend les hooks puissants, plutôt que de simples scripts aléatoires s'exécutant à des moments arbitraires. 

Claude Code compile ces informations au format JSON et les transmet à la commande que vous avez configurée, qu'il s'agisse d'une simple commande de terminal ou d'un script personnalisé.

Analyse des entrées de crochet

Chaque hook reçoit un objet JSON contenant les champs de base relatifs à la session en cours :

{
  "session_id": "abc123",
  "transcript_path": "/Users/you/.claude/projects/my-project/conversation.jsonl", 
  "cwd": "/Users/you/my-project",
  "hook_event_name": "PostToolUse"
}

Traduisons chaque composant :

• session_id: identifie votre conversation actuelle

• transcript_path: renvoie à l'historique des conversations

• cwd: affiche le répertoire de travail

• hook_event_name: vous indique quel événement a été déclenché

Disposer de ce contexte permet à vos hooks de prendre des décisions intelligentes : vous pouvez suivre quelle conversation a déclenché une action, accéder à l'historique complet des discussions si nécessaire, ou exécuter des commandes dans le répertoire approprié.

Variations d'entrée basées sur les événements

Les événements liés aux outils, tels que PreToolUse et PostToolUse, fournissent des informations supplémentaires sur l'action, ce qui rend les hooks particulièrement utiles pour l'automatisation. Dans PreToolUse, l'tool_input est spécifiée, et l'tool_response est également spécifiée dans PostToolUse:

{
  "session_id": "abc123",
  "hook_event_name": "PostToolUse",
  "tool_name": "Write",
  "tool_input": {
    "file_path": "/path/to/file.py",
    "content": "print('Hello world')"
  },
  "tool_response": {
    "filePath": "/path/to/file.py", 
    "success": true
  }
}

Dans l'entrée hook, file_path indique le chemin d'accès du fichier en cours d'écriture ou de modification, tandis que content contient le texte exact que l'outil est sur le point d'écrire. filePath Après l'exécution, la réponse de l'outil renvoie le nom de fichier final (notez le camelCase) pour confirmer quel fichier a été réellement modifié, ainsi qu'un indicateur d'success e indiquant si l'opération s'est correctement déroulée. 

Ces informations détaillées permettent à vos hooks de réagir différemment en fonction de ce qui s'est réellement passé. Vous pouvez formater uniquement les fichiers Python, sauvegarder uniquement les répertoires importants ou envoyer des notifications uniquement lorsque certains types de fichiers sont modifiés.

Les événements tels que UserPromptSubmit sont plus simples, car ils ne nécessitent pas d'outils :

{
  "session_id": "abc123",
  "hook_event_name": "UserPromptSubmit", 
  "prompt": "Write a function to calculate factorial"
}

Veuillez noter que les hooks d' UserPromptSubmit s n'utilisent pas de matchers dans leur configuration. Ils se déclenchent à chaque invite, et non lors des opérations effectuées à l'aide d'outils. Cela les rend idéales pour enregistrer des conversations, ajouter automatiquement le contexte d'un projet ou valider les invites avant que Claude ne les traite.

Lecture des données d'entrée dans la pratique

Créons un hook qui enregistre chaque invite utilisateur. Cela permet de résoudre le problème lié à la perte de trace des tâches que vous avez confiées à Claude, en particulier lors de longues sessions de codage. Tout d'abord, la configuration du crochet :

{
  "hooks": {
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/log_prompts.py"
          }
        ]
      }
    ]
  }
}

Ensuite, veuillez créer le script Python à l'adresse ~/.claude/log_prompts.py avec le contenu suivant :

#!/usr/bin/env python3
import json
import sys
from datetime import datetime

# Read JSON data from stdin
input_data = json.load(sys.stdin)

# Extract information
session_id = input_data.get("session_id", "unknown")
prompt = input_data.get("prompt", "")
timestamp = datetime.now().isoformat()

# Log the prompt
log_entry = f"{timestamp} | Session: {session_id[:8]} | {prompt}\n"
with open("prompt_history.txt", "a") as f:
    f.write(log_entry)

Le script lit les données JSON envoyées par Claude Code et enregistre l'invite avec le contexte de session. Cela crée un historique consultable de vos interactions, qui s'avère extrêmement utile lorsque vous avez besoin de vous rappeler comment vous avez résolu un problème plusieurs semaines plus tard.

Utilisation des sorties Hook

Une fois votre commande hook exécutée, il est nécessaire d'informer Claude Code de ce qui s'est produit et de lui indiquer s'il convient de poursuivre normalement. Ce mécanisme de contrôle transforme les hooks, qui sont de simples outils de journalisation, en un puissant système d'automatisation des flux de travail capable de guider le comportement de Claude. Cela se produit via trois canaux : la sortie standard (stdout), l'erreur standard (stderr) et les codes de sortie.

Canaux de sortie et codes de sortie

La sortie standard (stdout) désigne la sortie normale. Par exemple, si vous imprimez quelque chose, cela sera envoyé à stdout. Pour la plupart des hooks, voici ce qui apparaît dans la transcription de Claude Code lorsque vous appuyez sur Ctrl-O, vous fournissant ainsi un enregistrement de ce qu'a fait votre automatisation sans encombrer la conversation principale.

L'erreur standard (stderr) fait référence aux messages d'erreur. Veuillez vous adresser à stderr en utilisant 

• Python : print("message", file=sys.stderr) ou

• Ligne de commande : echo "message" >&2

La principale différence réside dans le fait que les messages d'erreur ( stderr ) peuvent être envoyés directement à Claude pour un traitement automatique, lui permettant ainsi de répondre aux problèmes détectés par vos hooks.

Les codes de sortie indiquent à Claude Code la prochaine action à effectuer :

• Code de sortie 0 : Succès (affiche stdout à l'utilisateur)

• Code de sortie 2 : Erreur de blocage (envoie stderr à Claude)

• Code de sortie 3 : Exécution différée (indique que la commande s'est terminée sans erreur, mais que ses effets sont reportés jusqu'à ce que des conditions supplémentaires soient remplies) 

• Autres codes : Erreur non bloquante (affiche l'stderr e à l'utilisateur, mais continue à fonctionner)

Ce système vous permet de contrôler avec précision quand Claude doit s'arrêter, continuer ou obtenir des commentaires sur ce que votre automatisation a détecté. Examinons quelques exemples pour les deux codes de sortie les plus importants.

Code de sortie 0 : Fonctionnement normal

La plupart des hooks utilisent le code de sortie 0 pour indiquer que tout s'est déroulé correctement. Voici un hook complet qui enregistre les opérations sur les fichiers et en informe l'utilisateur :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "python3 -c \"import datetime; open('activity.log','a').write('File written: ' + datetime.datetime.now().isoformat() + '\\n'); print('Logged file operation')\""
          }
        ]
      }
    ]
  }
}

Ce hook exécute deux commandes : enregistrement dans un fichier, puis affichage d'un message dans la transcription. Il existe plusieurs méthodes pour y parvenir, mais cette approche est multiplateforme et évite de dépendre des spécificités de la ligne de commande.

Comme il n'y a pas de code de sortie explicite, la valeur par défaut est 0. Le message imprimé apparaît dans la transcription de Claude Code, vous indiquant que la connexion a fonctionné. Ce modèle est idéal pour créer des pistes d'audit ou suivre les modifications que Claude apporte à votre projet au fil du temps.

Code de sortie 2 : Blocage avec retour d'information

Le code de sortie 2 transmet votre message d'erreur directement à Claude, lui permettant de répondre automatiquement. C'est là que les hooks deviennent un mécanisme de sécurité plutôt qu'une simple automatisation. Voici un hook qui empêche les opérations dangereuses sur les fichiers :

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/security_check.py"
          }
        ]
      }
    ]
  }
}

Veuillez créer le script de vérification de sécurité à l'adresse suivante: ~/.claude/security_check.py:

#!/usr/bin/env python3
import json
import sys

# Read hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Check for dangerous patterns
dangerous_paths = ["/etc/", "/usr/", "production.conf"]
is_dangerous = any(pattern in file_path for pattern in dangerous_paths)

if is_dangerous:
    # Block the operation and tell Claude why
    print(f"Blocked modification of {file_path} - this appears to be a system or production file", file=sys.stderr)
    sys.exit(2)  # Sends stderr message to Claude
else:
    # Allow the operation
    print(f"Approved modification of {file_path}")
    sys.exit(0)  # Shows stdout in transcript

Lorsque ce hook détecte un chemin dangereux, il se ferme avec le code 2. Claude Code envoie le message stderr à Claude, qui peut alors vous expliquer pourquoi l'opération a été bloquée et vous proposer des alternatives. Cela permet d'éviter tout dommage accidentel aux fichiers système tout en tenant Claude informé de vos politiques de sécurité.

Création d'un hook de notification intelligent pour Claude Code

Développons notre hook de notification amélioré qui combine le traitement des entrées et la gestion intelligente des sorties. Cela résout le problème de bruit provenant de notre hook d'origine qui signalait chaque modification de fichier :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "python3 ~/.claude/smart_notify.py"
          }
        ]
      }
    ]
  }
}

Veuillez créer le script de notification à l'adresse suivante: ~/.claude/smart_notify.py:

#!/usr/bin/env python3
import json
import sys
import os
import subprocess

# Read the hook input
input_data = json.load(sys.stdin)
tool_input = input_data.get("tool_input", {})
file_path = tool_input.get("file_path", "")

# Categorize file importance
important_extensions = [".py", ".js", ".ts", ".java", ".cpp"]
config_files = ["Dockerfile", "requirements.txt", "package.json"]

is_code = any(file_path.endswith(ext) for ext in important_extensions)
is_config = any(filename in file_path for filename in config_files)

if is_code:
    # Important: notify and log
    print(f"Code file modified: {os.path.basename(file_path)}")
    subprocess.run(["say", "Code updated"], check=False)  # Mac
    sys.exit(0)  # Show message in transcript
elif is_config:
    # Very important: louder notification
    print(f"Configuration file changed: {os.path.basename(file_path)}")
    subprocess.run(["say", "Configuration updated - review changes"], check=False)
    sys.exit(0)
else:
    # Not important: silent success
    sys.exit(0)

Ce hook lit les données d'entrée pour déterminer quel fichier a été modifié, évalue l'importance de la notification en fonction du type de fichier, utilise stdout pour consigner les modifications importantes dans le journal, déclenche différentes alertes audio en fonction du type de fichier et se termine toujours avec le code 0, car il s'agit d'actions informatives et non bloquantes.

La combinaison de l'analyse des entrées et du contrôle des sorties crée un mécanisme qui s'adapte intelligemment au contexte tout en fournissant un niveau de rétroaction approprié à la fois pour vous et pour Claude Code. Au lieu de recevoir des notifications gênantes pour chaque fichier temporaire, vous n'êtes informé que des modifications qui ont une réelle importance pour votre projet.

Veuillez noter que cet exemple utilise la commande say, disponible sur macOS. Sous Linux, vous pouvez utiliser la commande ` notify-send`, et sous Windows, une commande PowerShell, pour obtenir des notifications similaires.

Modèles avancés pour les hooks Claude Code

Au-delà des notifications et de la journalisation de base, les hooks peuvent résoudre les problèmes réels liés au flux de travail de développement auxquels les équipes sont confrontées quotidiennement. Voici quelques suggestions que vous pouvez adapter à vos propres projets.

Ce qui est remarquable, c'est que vous n'avez pas besoin de créer ces hooks manuellement. Il vous suffit de fournir à Claude Code l'une des idées suggérées ci-dessous, accompagnée de la référence Hooks dans sa documentation, et il générera le code et le JSON pertinents pour la configuration.

Chacun de ces modèles peut être personnalisé en fonction de vos outils et de votre flux de travail spécifiques. Commencez par ceux qui résolvent vos plus grandes frustrations quotidiennes, puis développez votre automatisation à mesure que vous vous familiarisez avec le développement de hooks.

Crochets avancés pour la sécurité et la conformité

Scanner de clés API

• Problème : Commettre accidentellement des secrets dans le contrôle de version

• Déclencheurs : Avant d'écrire un fichier

• Solution : Analyse du contenu des fichiers à la recherche de clés API, jetons et mots de passe à l'aide de modèles d'expressions régulières

Veuillez créer un script Python qui lit le fichier JSON d'entrée du hook, extrait le contenu du fichier et utilise des expressions régulières pour détecter les formats de secrets courants tels que api_key=, token: ou password=.  Pour toute correspondance suspecte, veuillez effectuer une vérification locale et . Veuillez ne jamais envoyer de secrets bruts à l'extérieur. 

Veuillez envoyer uniquement des extraits masqués (par exemple, en conservant 4 caractères préfixes/suffixes) ou des hachages à l'API Anthropic afin d'analyser les chaînes suspectes et de déterminer s'il s'agit de secrets réels ou de noms de variables. Veuillez quitter avec le code 2 et fournir à Claude des commentaires sur les secrets détectés et les alternatives plus sûres.

Responsable de l'application des licences

• Problème : Les projets open source ne comportent pas les en-têtes de licence requis dans les nouveaux fichiers.

• Déclencheurs : Avant de rédiger les fichiers de code source

• Solution : Vérification que les nouveaux fichiers .py, .js, .java contiennent le texte de licence approprié.

Analysez l'entrée du hook pour obtenir le contenu du fichier et vérifiez si les 10 premières lignes contiennent le texte de la licence à l'aide d'une correspondance de chaînes. Pour une validation plus approfondie, veuillez envoyer l'en-tête du fichier à Claude via l'API Anthropic afin de vérifier qu'il contient les mentions de copyright et les informations de licence appropriées. Bloquer la création du fichier avec le code de sortie 2 si les en-têtes sont manquants, et fournir à Claude le modèle de licence approprié à ajouter.

Protection des fichiers de production

• Problème : Modification accidentelle de fichiers de configuration système critiques

• Déclencheurs : Avant de modifier des fichiers dans des répertoires sensibles

• Solution : Blocage des modifications apportées à /etc/, nginx.conf, database.yml et autres configurations critiques.

Extrayez le chemin d'accès au fichier à partir du JSON d'entrée du hook et vérifiez s'il correspond à des modèles tels que /etc/, production.yml ou d'autres noms de fichiers critiques. Veuillez utiliser l'API de Claude pour analyser le chemin d'accès au fichier et déterminer s'il s'agit d'un fichier de configuration susceptible d'affecter les systèmes de production. Veuillez quitter avec le code 2 et fournir des conseils spécifiques sur les pratiques de développement plus sûres lorsque des chemins dangereux sont détectés.

Optimiseur d'images

• Problème : Les fichiers image volumineux ralentissent les applications et les référentiels.

• Déclencheurs : Après avoir ajouté de nouveaux fichiers image

• Solution : Compresser des fichiers PNG/JPEG tout en conservant la qualité visuelle

Analysez l'entrée du hook pour obtenir le chemin d'accès au fichier et vérifiez s'il s'agit d'un fichier image en comparant l'extension. Veuillez utiliser des outils de compression tels qu'imageoptim, ou appeler l'API TinyPNG pour compresser l'image tout en préservant sa qualité. Veuillez enregistrer les résultats de la compression dans stdout afin de pouvoir constater la réduction de la taille des fichiers dans la transcription de Claude.

Crochets avancés pour l'automatisation du contrôle de version

Validateur de branche Git

• Problème : Les membres de l'équipe peuvent accidentellement pousser des modifications vers des branches protégées.

• Déclencheurs : Avant toute opération d'écriture ou de modification de fichier

• Solution : Vérification de la branche Git actuelle et blocage des opérations sur main/master/production

Veuillez utiliser la commande bash simple git branch --show-current pour obtenir le nom de la branche actuelle et le comparer à une liste de branches protégées. Si vous vous trouvez sur une branche protégée, veuillez quitter avec le code 2 et envoyer à Claude un message d'erreur expliquant les politiques de protection des branches. Pour les règles de nommage de branches complexes, veuillez utiliser l'API de Claude afin d'analyser les noms de branches et de déterminer s'ils correspondent aux modèles de protection.

Validation automatique intelligente

• Problème : Oublier de valider les modifications ou rédiger des messages de validation inadéquats

• Déclencheurs : Après toute modification de fichier

• Solution : Mise en scène et validation automatiques des modifications avec des messages descriptifs générés par l'IA

Veuillez lire les chemins d'accès aux fichiers modifiés à partir de l'entrée du hook, exécutez git diff pour obtenir les modifications, puis envoyez le diff à l'API de Claude avec une invite demandant un message de commit concis. Veuillez utiliser le message généré avec les commandes git add et git commit pour valider automatiquement les modifications. Veuillez inclure les noms de fichiers et les types de modification dans l'invite API afin de garantir que les messages de validation respectent les normes de validation conventionnelles.

Générateur de documentation

• Problème : La documentation de l'API n'est plus synchronisée avec les modifications apportées au code.

• Déclencheurs : Après avoir modifié les fichiers d'interface (contrôleurs, modèles, API)

• Solution : Exécution automatique d'outils de documentation tels que JSDoc, Sphinx ou les générateurs OpenAPI.

Veuillez vérifier le chemin d'accès du fichier modifié afin de déterminer s'il s'agit d'un point de terminaison API, d'un modèle ou d'un fichier d'interface à l'aide de la correspondance de motifs. Veuillez envoyer le contenu du fichier à l'API de Claude, en lui demandant d'extraire les modifications de l'API et de générer les mises à jour de la documentation. Veuillez exécuter l'outil de génération de documentation approprié (jsdoc, sphinx-build, etc.) et valider automatiquement la documentation mise à jour.

Crochets avancés pour la collaboration et l'intégration des flux de travail

Intégration Slack

• Problème : L'équipe n'étant pas informée des modifications importantes apportées aux bases de code partagées

• Déclencheurs : Lorsque des notifications sont envoyées pour des opérations importantes

• Solution : Publier des messages formatés sur les canaux de l'équipe avec les noms de fichiers et les résumés des modifications

Extraire les informations relatives aux fichiers à partir de l'entrée du hook et filtrer les types de fichiers importants tels que les fichiers de code source ou de configuration. Veuillez utiliser l'API de Claude pour générer un résumé lisible par l'utilisateur des modifications apportées en fonction des noms et des types de fichiers. Veuillez envoyer le message formaté à Slack en utilisant les URL webhook avec les mentions des membres de l'équipe pour les modifications importantes.

Répartiteur de webhooks

• Problème : Les déclencheurs manuels du pipeline CI/CD entraînent des retards de déploiement.

• Déclencheurs : Lorsque des événements spécifiques se produisent (modifications de configuration, fichiers de déploiement modifiés)

• Solution : Appel d'API externes pour déclencher des compilations, des déploiements ou d'autres processus automatisés

Vérifiez le chemin d'accès du fichier modifié par rapport à des modèles tels que Dockerfile, package.json ou des configurations de déploiement afin de déterminer si le CI/CD doit être déclenché. Veuillez utiliser la bibliothèque de requêtes Python pour appeler les URL des webhooks avec les en-têtes d'authentification et les données de charge utile relatives aux modifications. Veuillez inclure les chemins d'accès aux fichiers et modifier les métadonnées dans la charge utile du webhook afin que les systèmes externes puissent prendre des décisions éclairées concernant ce qu'il convient de créer ou de déployer.

Mise à jour de la page d'état

• Problème : Les clients ne sont pas informés des activités de maintenance ou de déploiement.

• Déclencheurs : Lorsque les fichiers de déploiement ou d'infrastructure sont modifiés

• Solution : Mise à jour des pages d'état du service avec des notifications de maintenance

Analysez les entrées de hook pour les modifications de fichiers d'infrastructure telles que les manifestes Kubernetes ou les configurations Terraform à l'aide de modèles de chemin d'accès aux fichiers. Générez des messages de maintenance à l'aide de l'API de Claude en fonction du type de modifications détectées dans l'infrastructure. Veuillez publier les mises à jour de statut sur des services tels que StatusPage.io ou PagerDuty en utilisant leurs API REST, en précisant les types d'incidents appropriés et leur durée estimée.

Notification du statut de l'équipe

• Problème : Conflits lorsque plusieurs développeurs travaillent simultanément sur les mêmes fonctionnalités sans le savoir

• Déclencheurs : Lorsque vous démarrez une nouvelle session Claude Code

• Solution : Informer les canaux de l'équipe que vous commencez à travailler sur un projet ou un composant spécifique

Veuillez consulter le répertoire du projet à partir de l'entrée du hook et utiliser l'API de Claude pour analyser les fichiers récents ou l'historique git afin de comprendre le type de travail effectué. Veuillez envoyer un message formaté aux canaux de communication de l'équipe en indiquant votre nom, le nom du projet et le domaine d'intérêt. Veuillez inclure la durée estimée du travail et inviter les membres de l'équipe à se coordonner s'ils travaillent sur des fonctionnalités connexes.

Conclusion

Les Claude Code Hooks transforment les assistants de codage IA imprévisibles en flux de travail automatisés qui s'exécutent exactement lorsque vous en avez besoin. Dans ce tutoriel, vous avez appris à configurer des hooks à l'aide de la commande interactive /hooks et d'une configuration manuelle, à comprendre les données d'entrée JSON qui alimentent l'automatisation intelligente et à contrôler le comportement de Claude grâce à des codes de sortie et des sorties structurées. 

Les modèles pratiques que nous avons abordés comprennent des validateurs de sécurité qui bloquent les opérations dangereuses et des notifications intelligentes qui réduisent le bruit. Ces exemples illustrent comment les hooks permettent de résoudre des problèmes de développement concrets tout en vous offrant un contrôle total sur votre assistant IA. Maintenant que vous comprenez les principes fondamentaux, vous pouvez mettre en place une automatisation qui répond aux besoins spécifiques de votre équipe en matière de flux de travail. 

Pour en savoir plus sur l'utilisation des outils d'IA, veuillez consulter le cours « Understanding Prompt Engineering » (Comprendre l'ingénierie des invites) de DataCamp. Comprendre l'ingénierie des invites, qui aborde les stratégies de prompting directement liées au développement de hooks. Pour acquérir des compétences plus approfondies en codage IA, nous vous invitons à essayer notre cours intermédiaire chatGPT pour acquérir les compétences qui feront des assistants IA des partenaires plus fiables dans votre processus de développement.