Claude Code Ganchos

Los ganchos de Claude Code soncomandos de Shell definidos por el usuarioque se ejecutan automáticamente en momentos concretos del ciclo de vida de Claude Code.

Con los ganchos, puedes lograr un control preciso del comportamiento de Claude Code, asegurando que ciertas operaciones (como formateo de código, registro de logs)se disparen siemprey no dependan de que el modelo grande decida autónomamente si ejecutarlas.

Casos de uso típicos de los ganchos

Los ganchos te ayudan a implementar muchas funciones prácticas. Los escenarios comunes incluyen:

  • Notificación de mensajes: cuando Claude Code espera entrada o necesita permisos, envía automáticamente alertas de escritorio/correo.
  • Formateo automático: al editar.tsel archivo, se ejecuta automáticamenteprettier, modificar.goel archivo y luego ejecutargofmt
  • Registro de operaciones: registra todos los comandos ejecutados por Claude para auditoría de cumplimiento o resolución de problemas de depuración.
  • Validación de estándares de código: si el código generado por Claude no cumple con los estándares del proyecto (como reglas de nomenclatura), proporciona retroalimentación automáticamente.
  • Control de permisos de archivos: impide que Claude modifique los archivos de configuración del entorno de producción o directorios sensibles (por ejemplo,.env、.git)

En comparación con restringir el comportamiento de Claude usando prompts, los ganchos sonreglas estrictas a nivel de aplicación, que se ejecutan forzosamente en cuanto se activa el evento correspondiente, ofreciendo mayor estabilidad y fiabilidad.

Importante recordatorio de seguridad

Cuando los ganchos se ejecutan,utilizan directamente las credenciales del entorno del sistema actual(como variables de entorno, permisos de usuario), lo que conlleva ciertos riesgos de seguridad:

  • El código de gancho malicioso puede filtrar tus datos sensibles (como claves de API, código fuente del proyecto).
  • Un comando de gancho incorrecto puede provocar borrado accidental de archivos o anomalías en el sistema.

Acciones de seguridad obligatorias:

  1. Antes de registrar un gancho, asegúrate de revisar línea por línea la lógica y los permisos del comando.
  2. Evita ejecutar en los ganchos scripts de origen desconocido.
  3. Para prácticas de seguridad detalladas, consulta en la documentación oficial lasPrecauciones de seguridad.

Explicación de los tipos de eventos de gancho

Claude Code incluye varios eventos del ciclo de vida. Puedes vincular comandos de gancho a diferentes eventos. Cada evento transmite distintos datos de contexto y afecta de manera diferente el comportamiento de Claude.

Nombre del evento Momento de activación Función principal
PreToolUse Llamada a herramientaAntes Puede interceptar la ejecución de la herramienta (por ejemplo, impedir la modificación de archivos sensibles) y proporcionar a Claude sugerencias de ajuste.
PermissionRequest Cuando aparece el cuadro de diálogo de solicitud de permisos Aprobar o rechazar automáticamente las solicitudes de permiso.
PostToolUse Llamada a herramientaDespués de completarse Ejecutar operaciones posteriores (como formatear código, registrar logs).
UserPromptSubmit Después de que el usuario envíe el prompt y antes de que Claude lo procese Preprocesar la entrada del usuario (como enriquecer la información de contexto).
Notification Cuando Claude envía una notificación Personalizar el método de notificación (como popups de escritorio, alertas por SMS).
Stop Cuando Claude finaliza una respuesta Ejecutar tareas de cierre (como limpiar archivos temporales).
SubagentStop Cuando la tarea del subagente se completa Procesar los resultados de ejecución del subagente.
PreCompact Cuando está a punto de ejecutarse una operación de compresión de contexto Personalizar reglas de compresión.
SessionStart Al iniciar una nueva sesión o reanudar una anterior Inicializar el entorno de la sesión (como cargar la configuración del proyecto).
SessionEnd Al finalizar la sesión Guardar datos de la sesión y limpiar el entorno.

Inicio rápido: Implementación del registro de comandos

A continuación, tomandoel registro de todos los comandos Bash ejecutados por Claudecomo ejemplo, te guiaremos paso a paso por la configuración y el uso de los ganchos.

Requisitos previos

Instalarjqla herramienta (para analizar datos JSON desde la línea de comandos):

Paso 1: Abrir la interfaz de configuración de ganchos

En la interfaz interactiva de Claude Code, escribe el comando de barra/hooks, pulsa Enter y elige el evento al que deseas vincularlo — aquí elegimosPreToolUse(se activa antes de la llamada a la herramienta, ideal para registrar comandos).

Paso 2: Añadir un matcher de eventos

La función del matcher esrestringir las condiciones de activación del ganchoy ejecutar el comando de gancho solo cuando se invoque la herramienta especificada.

  1. Selecciona+ Add new matcher…
  2. e introduce la palabra clave de coincidenciaBash; esto indica que el gancho solo se activa cuando Claude llama a la herramienta Bash.

    Consejo: escribe*para que coincida contodas las herramientasy así implementar un gancho global.

Paso 3: Añadir un comando de gancho

Selecciona+ Add new hook…e introduce el siguiente comando (función: extraer el contenido y la descripción del comando, y escribirlos en un archivo de log):

jq -r '"\(.tool_input.command) - \(.tool_input.description // "无描述信息")"' >> ~/.claude/bash-command-log.txt

Explicación del comando:

  • jq -r ...: extrae el comando del JSON (command) y la descripción (description); cuando no hay descripción, muestra "sin información de descripción".
  • >> ~/.claude/...: escribe el contenido de forma adicional en el archivo de log situado en el directorio principal del usuario.

Paso 4: Elegir la ubicación de almacenamiento de la configuración

La ubicación donde se guarda la configuración determina el alcance del gancho:

  • User settings: guardar en la configuración a nivel de usuario (~/.claude/settings.json),aplica a todos los proyectos
  • Project settings: guardar en la configuración del proyecto actual (.claude/settings.local.json),aplica solo al proyecto actual

Aquí elegimosUser settingspara implementar el registro global de comandos. Después de seleccionar, presionaEscla tecla para salir de la interfaz de configuración; así el gancho queda registrado.

Paso 5: Verificar la configuración del gancho

  1. Vuelve a escribir/hooksel comando para ver la lista de ganchos configurados.
  2. O abre directamente el archivo de configuración~/.claude/settings.jsony verás el siguiente contenido de configuración:
    {
      "hooks": {
        "PreToolUse": [
          {
            "matcher": "Bash",
            "hooks": [
              {
                "type": "command",
                "command": "jq -r '\"\\(.tool_input.command) - \\(.tool_input.description // \"无描述信息\")\"' >> ~/.claude/bash-command-log.txt"
              }
            ]
          }
        ]
      }
    }

Paso 6: Probar el efecto del gancho

  1. Escribe el comando en Claude Code:帮我执行 ls 命令
  2. Después de la ejecución, revisa el archivo de log en la terminal:
    cat ~/.claude/bash-command-log.txt
  3. Si aparece el siguiente contenido en el log, la configuración del gancho fue exitosa:
    ls - Lists files and directories

Ejemplos prácticos de ganchos

A continuación se ofrecen varias configuraciones de gancho de uso común; puedes copiarlas y usarlas directamente o modificarlas según sea necesario.

📌 Para el código de ejemplo completo, consulta el repositorio oficial:Ejemplo de validador de comandos bash

Ejemplo 1: Formatear automáticamente archivos TypeScript

Función: al editar/escribir.tsarchivos, usa automáticamenteprettierpara formatear el código.

{
  "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; }"
          }
        ]
      }
    ]
  }
}

Ejemplo 2: Corregir automáticamente el formato de archivos Markdown

Función: agregar automáticamente etiquetas de lenguaje a los bloques de código sin etiqueta y limpiar las líneas en blanco adicionales.

Primer paso: agregar la configuración de hooks

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/markdown_formatter.py"
          }
        ]
      }
    ]
  }
}

Segundo paso: crear el script de formato

Crea un nuevo archivo en el directorio del proyecto.claude/hooks/markdown_formatter.pyy pega el siguiente código:

Ejemplo práctico

#!/usr/bin/env python3
"""
Herramienta de formato Markdown: completa automáticamente las etiquetas de lenguaje de los bloques de código y limpia las líneas en blanco innecesarias
"""

import json
import sys
import re
import os

def detect_language(code):
    """Detecta automáticamente el lenguaje de programación según el contenido del código"""
    code = code.strip()
    # Detectar JSON
    if re.search(r'^\s*[{\[]', code):
        try:
            json.loads(code)
            return 'json'
        except:
            pass
    # Detectar Python
    if re.search(r'^\s*def\s+\w+\s*\(', code, re.M) or re.search(r'^\s*(import|from)\s+\w+', code, re.M):
        return 'python'
    # Detectar JavaScript/TypeScript
    if re.search(r'\b(function\s+\w+\s*\(|const\s+\w+\s*=)', code) or re.search(r'=>|console\.(log|error)', code):
        return 'javascript'
    # Detectar Bash
    if re.search(r'^#!.*\b(bash|sh)\b', code, re.M) or re.search(r'\b(if|then|fi|for|in|do|done)\b', code):
        return 'bash'
    # Formato de texto predeterminado
    return 'text'

def format_markdown(content):
    """Formatea el contenido de Markdown"""
    # Completar el lenguaje de los bloques de código sin etiqueta
    fence_pattern = r'(?ms)^([ \t]{0,3})```([^\n]*)\n(.*?)(\n\1```)\s*$'
    def add_lang(match):
        indent, info, body, closing = match.groups()
        if not info.strip():
            lang = detect_language(body)
            return f"{indent}```{lang}\n{body}{closing}\n"
        return match.group(0)
    content = re.sub(fence_pattern, add_lang, content)
    # Limpiar líneas en blanco innecesarias (solo fuera de los bloques de código)
    content = re.sub(r'\n{3,}', '\n\n', content)
    return content.rstrip() + '\n'

if __name__ == "__main__":
    try:
        # Leer los datos JSON que envía Claude
        input_data = json.load(sys.stdin)
        file_path = input_data.get('tool_input', {}).get('file_path', '')
        # Procesar solo archivos .md/.mdx
        if not file_path.endswith(('.md', '.mdx')):
            sys.exit(0)
        # Leer y formatear el archivo
        if os.path.exists(file_path):
            with open(file_path, 'r', encoding='utf-8') as f:
                content = f.read()
            formatted_content = format_markdown(content)
            # Escribir solo cuando el contenido cambie
            if formatted_content != content:
                with open(file_path, 'w', encoding='utf-8') as f:
                    f.write(formatted_content)
                print(f"Archivo Markdown formateado: {file_path}")
    except Exception as e:
        print(f"Error de formato: {e}", file=sys.stderr)
        sys.exit(1)

Tercer paso: otorgar permiso de ejecución al script

chmod +x .claude/hooks/markdown_formatter.py

Ejemplo 3: Enviar una notificación de escritorio cuando Claude espera entrada

Función: cuando Claude necesita la entrada del usuario, muestra automáticamente un aviso de escritorio (aplica para Linux/macOS)

{
  "hooks": {
    "Notification": [
      {
        "matcher": "", // 匹配所有通知事件
        "hooks": [
          {
            "type": "command",
            "command": "notify-send 'Claude Code 提示' '请你输入指令或确认权限'"
          }
        ]
      }
    ]
  }
}

Ejemplo 4: Prohibir la modificación de archivos sensibles

Función: evitar que Claude edite.env、package-lock.jsony otros archivos sensibles

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

Nota: cuando el script devuelve el código de estado2Claude Code intercepta esta llamada de herramienta, bloqueando así la modificación del archivo.


Manual de referencia de los ganchos de Claude Code

Ruta del archivo de configuración

Nivel de configuración Ruta del archivo Alcance de aplicación
Nivel de usuario ~/.claude/settings.json Todos los proyectos
Nivel de proyecto .claude/settings.json Proyecto actual
Nivel de proyecto local (sin enviar a control de versiones) .claude/settings.local.json Proyecto actual, no incluido en el control de versiones
Nivel de política gestionada Ruta especificada por el administrador Control unificado para empresa/equipo

Estructura de configuración principal

Los Hooks se organizan porevento + matchery admiten dos tipos:command(ejecutar comandos Shell) yprompt(llamar a un LLM para decidir).

{
  "hooks": {
    "【钩子事件名】": [
      {
        "matcher": "【工具匹配规则】", // 部分事件可省略
        "hooks": [
          {
            "type": "command/prompt",
            "command": "【Shell 命令】", // type=command 时必填
            "prompt": "【LLM 提示词】",  // type=prompt 时必填
            "timeout": 30 // 可选,超时时间(秒)
          }
        ]
      }
    ]
  }
}

Reglas de los matchers (solo se aplican a eventos de tipo herramienta)

Regla de coincidencia Ejemplo Descripción
Coincidencia exacta Write Solo coincide con laWriteherramienta
Coincidencia múltiple de herramientas Edit | Write Coincide conEditoWriteherramientas
Coincidencia por prefijo Notebook.* Coincide con todas lasNotebookherramientas que empiecen con
Coincidencia total */ cadena vacía Coincide con todas las herramientas

Trucos de configuración especiales

Escenario Método de configuración Ejemplo
Referenciar un script dentro del proyecto Usar variables de entorno$CLAUDE_PROJECT_DIR "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/check-style.sh"
Hooks de plugins Configurado dentro del pluginhooks/hooks.json, usando${CLAUDE_PLUGIN_ROOT}para referenciar el archivo del plugin "command": "${CLAUDE_PLUGIN_ROOT}/scripts/format.sh"
Hooks a nivel de componente (Skill/Agent) Definidos en el frontmatter del componente, con alcance limitado al ciclo de vida del componente Consulta la siguientetabla deconfiguración extendida

Configuración extendida (Skill/Agente/comandos de barra)

La configuración extendida permite incrustar configuraciones de Hooks directamente en la definición de un Skill, Agent o comando slash personalizado. Estos Hooks solo surten efecto cuando el componente correspondiente se activa y se ejecuta; al terminar la ejecución del componente, se limpian automáticamente y no afectan a la sesión global.

Eventos de hook admitidos

Solo se admitenPreToolUse、PostToolUse、Stoptres tipos de eventos, con la misma funcionalidad que los Hooks globales, pero el alcance se limita al ciclo de vida del Skill/comando slash actual.

Opción de configuración específica

  • once: true(opcional): cuando se establece entrue, este Hook se ejecuta solo una vez en toda la sesión; después de la primera ejecución exitosa se elimina automáticamente para evitar disparos repetidos.

Ejemplo de configuración completa

---
# Skill/斜杠命令的基础信息
name: secure-operations
description: 执行Shell命令前先做安全校验的工具
# Hooks 配置段
hooks:
  PreToolUse:
    # 匹配器:仅拦截Bash工具调用
    - matcher: "Bash"
      hooks:
        - type: "command"
          # 要执行的安全校验脚本
          command: "./scripts/security-check.sh"
          # 会话内仅执行一次
          once: true
          # 超时时间(秒),避免脚本卡死
          timeout: 15
---

Configuración de hooks en Agent

Eventos de hook admitidos

También solo admitePreToolUse、PostToolUse、Stoptres tipos de eventos, con alcance limitado al ciclo de ejecución de la tarea del sub-Agent.

Opción de configuración específica

No hay opciones exclusivas adicionales; no se admiteonce: true(los Hooks se disparan cada vez que el Agent ejecuta una tarea).

Ejemplo de configuración completa

---
# Agent 的基础信息
name: code-reviewer
description: 自动审查代码修改并运行代码检查的子代理
# Hooks 配置段
hooks:
  PostToolUse:
    # 匹配器:拦截Edit(编辑)或Write(写入)工具
    - matcher: "Edit|Write"
      hooks:
        - type: "command"
          # 代码检查脚本,执行lint校验
          command: "./scripts/run-linter.sh"
          # 超时时间(秒)
          timeout: 30
---

Notas:

  1. Las reglas de matcher de los Hooks en componentes son exactamente las mismas que las de los Hooks globales: admiten coincidencia exacta (por ejemplo,"Write"), coincidencia múltiple de herramientas (por ejemplo,"Edit|Write"), coincidencia con comodines ("*"), y distinguen entre mayúsculas y minúsculas;
  2. Los Hooks en componentes y los Hooks globales se ejecutan en paralelo: si tanto el global como el componente configuran Hooks para el mismo evento, al dispararse ambos tipos de Hooks se ejecutan juntos sin conflicto;
  3. Requisitos de formato: los Hooks en componentes deben escribirse en el frontmatter (---la zona delimitada), siguiendo la sintaxis YAML; un error de sangría invalidará la configuración;
  4. Recomendación de ruta de script: prioriza las rutas relativas (por ejemplo,./scripts/xxx.sh), o recurre a$CLAUDE_PROJECT_DIRla variable de entorno para especificar una ruta absoluta, asegurando que el componente pueda encontrar el script en cualquier directorio.

Eventos de gancho -- Eventos de tipo herramienta (compatibles con matchers)

Nombre del evento Momento de activación Matcher habitual Función principal
PreToolUse Llamada a herramientaantes Bash/Edit/Write/Read Interceptar la ejecución de la herramienta, modificar los parámetros de entrada, aprobar/rechazar permisos automáticamente
PermissionRequest Al mostrarse el cuadro de diálogo de solicitud de permisos mismoPreToolUse Procesar automáticamente las solicitudes de permisos, sin necesidad de confirmación manual del usuario
PostToolUse Llamada a herramientacuando se completa con éxito mismoPreToolUse Ejecutar operaciones posteriores (como formateo de código, registro de logs)
Notification Cuando Claude envía una notificación permission_prompt/idle_prompt/auth_success Personalizar el método de notificación (como ventana emergente de escritorio, alerta por correo)
PreCompact Antes de ejecutar la operación de compresión de contexto manual(activación manual)/auto(activación automática) Personalizar las reglas de compresión y respaldar el contexto importante

Eventos de gancho -- Eventos de tipo sesión/tarea (sin matchers)

Nombre del evento Momento de activación Función principal
UserPromptSubmit Después de que el usuario envíe el prompt y antes de que Claude lo procese Validar la validez del prompt y complementar la información de contexto
Stop Cuando el agente principal completa la respuesta (no se activa si el usuario interrumpe) Determinar de forma inteligente si es necesario continuar ejecutando la tarea
SubagentStop Cuando se completa la tarea del sub-Agent Evaluar el resultado de la subtarea y decidir si finalizarla
SessionStart Al iniciar/reanudar la sesión Inicializar el entorno, cargar la configuración del proyecto y establecer variables de entorno persistentes
SessionEnd Al finalizar la sesión Limpiar archivos temporales, registrar logs de sesión y guardar el estado de trabajo

Comparación de tipos de gancho

Claude Code admite dos tipos de hooks para satisfacer las necesidades de diferentes escenarios.

Característica commandTipo (hook de comando) promptTipo (hook de prompt)
Método de ejecución Ejecuta comandos/scripts de Shell Llama a un LLM (modelo Haiku por defecto) para tomar decisiones inteligentes
Lógica de decisión Basada en lógica de código,juicio determinista. Basada en el contexto,juicio semántico flexible.
Dificultad de configuración Requiere escribir scripts; la barrera de entrada es alta. Solo requiere escribir un prompt; es sencillo y fácil de usar.
Velocidad de respuesta Rápida (ejecución local) Más lenta (requiere llamadas a API).
Escenarios aplicables Reglas fijas como formateo de código, registro de logs, interceptación de permisos, etc. Escenarios flexibles como evaluación de finalización de tareas, juicio de intenciones complejas, etc.
Configuración central command + timeout prompt + timeout(puede usar$ARGUMENTSplaceholders)

Entrada y salida -- Entrada del gancho (JSON a través de stdin)

Todos los hooks reciben campos comunes; algunos eventos incluyen campos específicos.

Tipo de campo Campo común Descripción
Información básica session_id Identificador único de sesión
transcript_path Ruta del archivo de registro de la conversación
cwd Directorio de trabajo actual al ejecutar el hook
permission_mode Modo de permiso actual (default/plan/acceptEdits, etc.)
hook_event_name Nombre del evento de hook activado actualmente

Ejemplos de campos específicos de cada evento

Nombre del evento Campos específicos Ejemplo
PreToolUse tool_name/tool_input {"tool_name":"Write","tool_input":{"file_path":"/test.txt"}}
UserPromptSubmit prompt {"prompt":"帮我写一个排序函数"}
SessionEnd reason {"reason":"clear/logout/other"}

Salida del gancho (dos formas)

Método 1: Código de salida (escenarios simples)

Transmita el estado de ejecución mediante el código de salida,stdout/stderrpara información de retroalimentación.

Código de salida Significado Descripción del comportamiento
0 Ejecución exitosa stdoutPuede devolver JSON para control avanzado; algunos eventos (comoUserPromptSubmit) agregaránstdoutal contexto
2 Bloquear operación Solo usestderrcomo mensaje de error para Claude,bloquea que el evento actual continúe ejecutándose
Otros valores distintos de cero Error no bloqueante stderrSolo en modo detallado (ctrl+o) se muestra, no afecta la ejecución del evento

Comportamiento del código de salida 2 en cada evento

Nombre del evento Comportamiento desencadenado
PreToolUse Bloquea la llamada a la herramienta, muestra a Claudestderr
UserPromptSubmit Bloquea el procesamiento del prompt, borra la entrada del usuario
Stop Impide que Claude se detenga, fuerza a continuar trabajando
PostToolUse/Notification Solo muestrastderr, no afecta las operaciones completadas

Método 2: Salida JSON (escenarios avanzados)

Cuando el código de salida es0, se puede mediantestdoutdevolver JSON para un control preciso, los campos principales son los siguientes:

Campos JSON comunes Función
continue: true/false Si se permite que el evento continúe (falsetiene prioridad sobre otras reglas)
stopReason continue=falserazón mostrada al usuario cuando
systemMessage Mensaje de advertencia mostrado al usuario

Ejemplos de campos JSON específicos de eventos

Nombre del evento Campos específicos Ejemplo
PreToolUse permissionDecision(allow/deny/ask) {"hookSpecificOutput":{"permissionDecision":"allow","updatedInput":{"file_path":"/new.txt"}}}
UserPromptSubmit decision: block/undefined {"decision":"block","reason":"提示包含敏感信息"}
PostToolUse additionalContext {"hookSpecificOutput":{"additionalContext":"文件已格式化完成"}}

Configuración de hooks para herramientas MCP

Las herramientas MCP se integran a la perfección con Hooks, coincidiendo mediante reglas de nomenclatura específicas.

Reglas de nomenclatura de las herramientas MCP

mcp__<服务器名>__<工具名>

Ejemplo:mcp__github__search_repositories、mcp__filesystem__read_file

Ejemplos de coincidencia

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "mcp__memory__.*", // 匹配 memory 服务器的所有工具
        "hooks": [{"type": "command", "command": "echo '内存操作日志' >> log.txt"}]
      },
      {
        "matcher": "mcp__.*__write.*", // 匹配所有服务器的写操作工具
        "hooks": [{"type": "command", "command": "./validate-write.py"}]
      }
    ]
  }
}

Seguridad y depuración

Mejores prácticas de seguridad

Puntos clave de seguridad Acciones específicas
Validación de entrada Validación estrictatool_inputde las rutas de archivo y parámetros de comandos, previniendo path traversal (como../)
referencia de variable En comandos Shell, use"$VAR"en lugar de$VAR, evitando la inyección de parámetros
Minimización de permisos A los scripts de hook solo se les otorgan los permisos necesarios, evite usarsudoy otros comandos de alto riesgo
Exclusión de archivos sensibles Interceptar operaciones sobre.env、.git, y archivos de clave
Revisión de comandos Antes de registrar hooks, ejecute manualmente los comandos para verificar la lógica y confirmar que no hay comportamientos maliciosos

Consejos de depuración

Tipo de problema Pasos de solución de problemas
El hook no funciona 1. Ejecute/hooksel comando para verificar si la configuración está registrada<br>2. Verifique que la sintaxis JSON sea correcta<br>3. Compruebe si las reglas del matcher coinciden con el nombre de la herramienta (distingue mayúsculas y minúsculas)
La ejecución del comando falló 1. Ejecute manualmente el comando del hook, confirme que se ejecuta correctamente<br>2. Verifique si el script tiene permiso de ejecución (chmod +x script.sh)<br>3. Use una ruta absoluta para llamar al script, evite problemas de variables de entorno
Ver registros detallados Agregue al iniciar Claude Code--debugel parámetro, para ver todo el proceso de ejecución del hook

Documentación de referencia: Para ver la descripción completa de las funciones del hook, consulte ladocumentación de referencia del hook。

Otras extensiones