ചുരുക്കത്തിൽ: Claude Code ഹുക്കുകൾ AI കോഡിംഗ് സെഷനുകളിൽ നിർദ്ദിഷ്ട ലൈഫ്സൈക്കിൾ ഘട്ടങ്ങളിൽ പ്രവർത്തിക്കുന്ന ഓട്ടോമേഷൻ സ്ക്രിപ്റ്റുകളാണ്. ഇത് ഡെവലപ്പർമാർക്ക് ഇഷ്ടാനുസൃത കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാനും, പ്രവർത്തനങ്ങൾ സാധൂകരിക്കാനും, കോഡ് ഫോർമാറ്റ് ചെയ്യാനും, അറിയിപ്പുകൾ അയക്കാനും, പ്രോജക്റ്റ് നിയമങ്ങൾ നടപ്പിലാക്കാനും അനുവദിക്കുന്നു. ഈ ഹുക്കുകൾ SessionStart, PreToolUse, PostToolUse തുടങ്ങിയ ഇവന്റുകളിലൂടെ Claude-യുടെ വർക്ക്ഫ്ലോയുമായി സംയോജിക്കുന്നു. ടൈംഔട്ടുകളും എക്സിറ്റ് കോഡ് സ്വഭാവവും ക്രമീകരിക്കാവുന്ന കമാൻഡ് അധിഷ്ഠിത, HTTP അധിഷ്ഠിത, പ്രോംപ്റ്റ് അധിഷ്ഠിത എക്സിക്യൂഷൻ പാറ്റേണുകളെ ഇത് പിന്തുണയ്ക്കുന്നു.

Claude Code-ന്റെ ഹുക്ക് സിസ്റ്റം AI കോഡിംഗ് അസിസ്റ്റന്റിനെ ഒരു സഹായ ഉപകരണത്തിൽ നിന്ന് പൂർണ്ണമായി ഓട്ടോമേറ്റ് ചെയ്ത ഒരു ഡെവലപ്‌മെന്റ് പരിതസ്ഥിതിയായി മാറ്റുന്നു. ഹുക്കുകൾ വഴി ലഭ്യമായ നിയന്ത്രണത്തിന്റെ വ്യാപ്തി മിക്ക ഡെവലപ്പർമാരും മനസ്സിലാക്കുന്നില്ല.

എന്നാൽ ഒരു കാര്യമുണ്ട്—ഫയൽ എഡിറ്റുകൾക്ക് ശേഷം സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുക എന്നതിൽ മാത്രം ഒതുങ്ങുന്നില്ല ഹുക്കുകൾ. Claude-യുടെ മുഴുവൻ തീരുമാനമെടുക്കുന്ന പ്രക്രിയയിലും ഇത് ഇടപെടാനുള്ള അവസരങ്ങൾ നൽകുന്നു. ഒരു കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്. ഒരു ടൂൾ കോൾ പരാജയപ്പെട്ടതിന് ശേഷം. അനുമതി ആവശ്യമായി വരുമ്പോൾ. ഉപയോക്തൃ പ്രോംപ്റ്റുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പ് പോലും.

ഈ ഗൈഡ് ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ നൽകുന്ന എല്ലാ കാര്യങ്ങളും ഉൾക്കൊള്ളുന്നു, കൂടാതെ പ്രൊഡക്ഷൻ പരിതസ്ഥിതികളിൽ യഥാർത്ഥത്തിൽ പ്രവർത്തിക്കുന്ന പ്രായോഗിക പാറ്റേണുകളും പങ്കുവെക്കുന്നു.

Claude Code ഹുക്കുകൾ യഥാർത്ഥത്തിൽ ചെയ്യുന്നത്

ഔദ്യോഗിക Claude Code ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, Claude Code-ന്റെ ലൈഫ്സൈക്കിളിൽ പ്രത്യേക ഘട്ടങ്ങളിൽ പ്രവർത്തിക്കുന്ന ഉപയോക്താവ് നിർവചിച്ച ഷെൽ കമാൻഡുകൾ, HTTP എൻഡ്‌പോയിന്റുകൾ, അല്ലെങ്കിൽ പ്രോംപ്റ്റ് ഇൻജെക്ഷനുകൾ എന്നിവയാണ് ഹുക്കുകൾ. ഇവ സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് വഴി ഘടനാപരമായ JSON ഇൻപുട്ട് സ്വീകരിക്കുകയും എക്സിറ്റ് കോഡുകളിലൂടെയോ HTTP പ്രതികരണങ്ങളിലൂടെയോ വർക്ക്ഫ്ലോ നിയന്ത്രിക്കുകയും ചെയ്യുന്നു.

മിക്ക ഗൈഡുകളും നിർദ്ദേശിക്കുന്നതിനേക്കാൾ ആഴത്തിലുള്ള ഓട്ടോമേഷൻ ഇത് സാധ്യമാക്കുന്നു. ഹുക്കുകൾക്ക് ടൂൾ എക്സിക്യൂഷൻ പൂർണ്ണമായി തടയാനോ, Claude-യുടെ റീസണിംഗിലേക്ക് കൂടുതൽ സന്ദർഭം കുത്തിനിറയ്ക്കാനോ, ബാഹ്യ സേവനങ്ങളെ ട്രിഗർ ചെയ്യാനോ, Claude പാലിക്കേണ്ട സാധൂകരണ നിയമങ്ങൾ നടപ്പിലാക്കാനോ കഴിയും.

മൂന്ന് പ്രധാന ഹുക്ക് തരങ്ങൾ നിലവിലുണ്ട്:

കമാൻഡ് ഹുക്കുകൾ: stdout, stderr, എക്സിറ്റ് കോഡുകൾ വഴി ആശയവിനിമയം നടത്തുന്ന ഷെൽ സ്ക്രിപ്റ്റുകൾ
HTTP ഹുക്കുകൾ: POST അഭ്യർത്ഥനകൾ സ്വീകരിക്കുന്നതും JSON പ്രതികരണങ്ങൾ നൽകുന്നതുമായ വിദൂര എൻഡ്‌പോയിന്റുകൾ
പ്രോംപ്റ്റ് ഹുക്കുകൾ: പ്രത്യേക ഇവന്റുകളിൽ Claude-യുടെ സന്ദർഭത്തിലേക്ക് ഡൈനാമിക് നിർദ്ദേശങ്ങൾ കുത്തിനിറയ്ക്കുന്നു

ഓരോ തരവും വ്യത്യസ്ത ഓട്ടോമേഷൻ പാറ്റേണുകൾക്ക് ഉപകരിക്കുന്നു. കമാൻഡ് ഹുക്കുകൾ പ്രാദേശിക സാധൂകരണത്തിനും ഫോർമാറ്റിംഗിനും സഹായിക്കുന്നു. HTTP ഹുക്കുകൾ ബാഹ്യ സേവനങ്ങളുമായും ഡാറ്റാബേസുകളുമായും സംയോജിപ്പിക്കുന്നു. പ്രോംപ്റ്റ് ഹുക്കുകൾ ബാഹ്യ പ്രക്രിയകളില്ലാതെ Claude-യുടെ പെരുമാറ്റം പരിഷ്കരിക്കുന്നു.

ഹുക്ക് ലൈഫ്സൈക്കിളും ഇവന്റ് സിസ്റ്റവും

ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ Claude Code-ന്റെ എക്സിക്യൂഷൻ ഫ്ലോയിൽ സംഭവിക്കുന്ന നിരവധി ഹുക്ക് ഇവന്റുകൾ (SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, PostToolUseFailure, Notification, കൂടാതെ മറ്റുള്ളവ) നിർവചിക്കുന്നു. ഓരോന്നും എപ്പോഴാണ് സംഭവിക്കുന്നതെന്ന് മനസ്സിലാക്കുന്നത് എന്ത് ഓട്ടോമേഷൻ സാധ്യമാകുമെന്ന് നിർണ്ണയിക്കുന്നു.

Claude Code hook events and their execution flow during a typical session

ഇവന്റ്	എപ്പോൾ സംഭവിക്കുന്നു	തടയാൻ കഴിയുമോ
SessionStart	ഒരു സെഷൻ ആരംഭിക്കുമ്പോഴോ പുനരാരംഭിക്കുമ്പോഴോ	ഇല്ല
UserPromptSubmit	നിങ്ങൾ ഒരു പ്രോംപ്റ്റ് സമർപ്പിക്കുമ്പോൾ, Claude പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പ്	അതെ
PreToolUse	ഒരു ടൂൾ കോൾ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്	അതെ
PermissionRequest	അനുമതി സംഭാഷണം ദൃശ്യമാകുമ്പോൾ	അതെ
PostToolUse	ഒരു ടൂൾ കോൾ വിജയകരമാകുമ്പോൾ	ഇല്ല
PostToolUseFailure	ഒരു ടൂൾ കോൾ പരാജയപ്പെടുമ്പോൾ	ഇല്ല
Notification	Claude Code ഒരു അറിയിപ്പ് അയക്കുമ്പോൾ	ഇല്ല
SubmitMessage	Claude ഉപയോക്താവിന് ഒരു സന്ദേശം സമർപ്പിക്കുമ്പോൾ	ഇല്ല
ContextCompaction	സന്ദർഭ വിൻഡോ പരിധി സമീപിക്കുമ്പോൾ	ഇല്ല

തടയൽ ശേഷിക്ക് ഏറ്റവും പ്രാധാന്യമുണ്ട്. PreToolUse ഹുക്കുകൾക്ക് അപകടകരമായ പ്രവർത്തനങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് അവ തടയാൻ കഴിയും. എക്സിറ്റ് കോഡ് 1 പ്രവർത്തനം തടയുന്നു. എക്സിറ്റ് കോഡ് 0 അത് അനുവദിക്കുന്നു. എക്സിറ്റ് കോഡ് 2 Claude-യെ പുനർവിചിന്തനം ചെയ്യാൻ പ്രേരിപ്പിക്കുന്നു.

എന്നാൽ കാത്തിരിക്കൂ. PostToolUse ഹുക്കുകൾക്ക് പ്രവർത്തനങ്ങൾ പഴയപടിയാക്കാൻ കഴിയില്ല, കാരണം ടൂൾ ഇതിനകം പ്രവർത്തിച്ചിട്ടുണ്ട്. ഈ പരിമിതി സാധൂകരണ ലോജിക് എങ്ങനെ ഘടനാപരമായിരിക്കണം എന്ന് രൂപപ്പെടുത്തുന്നു. നിർണായക പരിശോധനകൾ PreToolUse-ൽ ആയിരിക്കണം. ക്ലീനപ്പും ഫോർമാറ്റിംഗും PostToolUse-ൽ ആയിരിക്കണം.

Claude Code സജ്ജീകരിക്കുമ്പോൾ AI ടൂൾ പെർക്കുകൾ ബ്രൗസ് ചെയ്യുക

നിങ്ങൾ Claude Code ഹുക്കുകളുമായി പ്രവർത്തിക്കുകയാണെങ്കിൽ, നിങ്ങളുടെ വർക്ക്ഫ്ലോയ്ക്ക് ചുറ്റുമുള്ള മറ്റ് AI ടൂളുകളും തിരഞ്ഞെടുക്കാൻ സാധ്യതയുണ്ട്. Get AI Perks AI, ക്ലൗഡ് ടൂളുകൾക്കുള്ള സ്റ്റാർട്ടപ്പ് ക്രെഡിറ്റുകളും സോഫ്റ്റ്‌വെയർ ഡിസ്‌കൗണ്ടുകളും ഒരിടത്ത് ശേഖരിക്കുന്നു. ഈ പ്ലാറ്റ്‌ഫോമിൽ 200+ ഓഫറുകളുണ്ട്, ഓരോന്നിനും പെർക്ക് വ്യവസ്ഥകളും ക്ലെയിം നിർദ്ദേശങ്ങളും ഉൾപ്പെടുന്നു.

Claude അല്ലെങ്കിൽ മറ്റ് AI ടൂൾ പെർക്കുകൾക്കായി തിരയുകയാണോ?

Get AI Perks പരിശോധിക്കുക:

Claude, മറ്റ് AI ടൂൾ ഓഫറുകൾ ബ്രൗസ് ചെയ്യുക
അപേക്ഷിക്കുന്നതിന് മുമ്പ് പെർക്ക് വ്യവസ്ഥകൾ താരതമ്യം ചെയ്യുക
നിങ്ങളുടെ ടൂൾ സ്റ്റാക്കിലുടനീളമുള്ള സ്റ്റാർട്ടപ്പ് ഡിസ്‌കൗണ്ടുകൾ കണ്ടെത്തുക

👉 നിലവിലെ AI സോഫ്റ്റ്‌വെയർ പെർക്കുകൾ കണ്ടെത്താൻ Get AI Perks സന്ദർശിക്കുക.

കൺഫിഗറേഷനും ഫയൽ ഘടനയും

ഒരു പ്രോജക്റ്റിനുള്ളിൽ .claude/settings.json ഫയലിലാണ് ഹുക്കുകൾ നിർവചിക്കുന്നത്. ഗ്ലോബൽ ഹുക്കുകളെയും ടൂൾ-സ്പെസിഫിക് മാച്ചറുകളെയും പിന്തുണയ്ക്കുന്ന കൺഫിഗറേഷൻ സ്കീമയാണ് ഇതിനുള്ളത്, ഇത് ഹുക്കുകൾ എപ്പോൾ പ്രവർത്തിക്കുമെന്ന് ഫിൽട്ടർ ചെയ്യുന്നു.

അടിസ്ഥാന കമാൻഡ് ഹുക്ക് ഘടന:

{
“hooks”: [
{
“event”: “PostToolUse”,
“command”: “prettier –write”,
“args”: [“${file}”]
}
]
}

ടൂൾ ഇൻപുട്ടിൽ നിന്നുള്ള യഥാർത്ഥ ഫയൽ പാത്തേക്ക് ${file} വേരിയബിൾ വികസിക്കുന്നു. ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, കമാൻഡ്, args ഫീൽഡുകളിൽ ഈ വേരിയബിൾ വികാസങ്ങളെ ഹുക്കുകൾ പിന്തുണയ്ക്കുന്നു.

ഹുക്ക് ലൊക്കേഷൻ ഹൈറാർക്കി

ഹുക്ക് നിർവചനത്തിനായി Claude Code ഒന്നിലധികം സ്ഥലങ്ങൾ പരിശോധിക്കുന്നു, വ്യക്തമായ മുൻഗണനാ ക്രമത്തോടെ:

പ്രോജക്റ്റ് ലെവൽ: നിലവിലെ വർക്ക്സ്പേസിലെ .claude/settings.json
ഉപയോക്തൃ ലെവൽ: എല്ലാ സെഷനുകൾക്കുമായി ~/.claude/settings.json
പ്ലഗിൻ നൽകുന്നത്: ഇൻസ്റ്റാൾ ചെയ്ത പ്ലഗിനുകളുമായി ബണ്ടിൽ ചെയ്ത ഹുക്കുകൾ

ഒരേ ഇവന്റിനായുള്ള ഉപയോക്തൃ ഹുക്കുകളെ പ്രോജക്റ്റ് ഹുക്കുകൾ ഓവർറൈഡ് ചെയ്യുന്നു. ഇത് ഗ്ലോബൽ നോട്ടിഫിക്കേഷൻ ഹാൻഡ്‌ലറുകൾ നിലനിർത്തുന്നതിനോടൊപ്പം പ്രോജക്റ്റ്-സ്പെസിഫിക് ഫോർമാറ്റിംഗ് നിയമങ്ങൾ അനുവദിക്കുന്നു.

തിരഞ്ഞെടുത്ത എക്സിക്യൂഷനായുള്ള മാച്ചർ പാറ്റേണുകൾ

മാച്ചർ സിസ്റ്റം ഹുക്കുകളെ പ്രത്യേക ടൂളുകളിലേക്കോ വ്യവസ്ഥകളിലേക്കോ ഫിൽട്ടർ ചെയ്യുന്നു. മാച്ചറുകളില്ലാതെ, അവരുടെ ഇവന്റിന്റെ ഓരോ സംഭവത്തിനും ഹുക്കുകൾ പ്രവർത്തിക്കും.

{
“hooks”: [
{
“event”: “PreToolUse”,
“matcher”: {
“toolName”: “edit_file”,
“pathPattern”: “src/**/*.ts”
},
“command”: “./scripts/validate-typescript.sh”
}
]
}

pathPattern ഫീൽഡ് glob സിന്റാക്സ് സ്വീകരിക്കുന്നു. toolName ഫീൽഡ് edit_file, execute_command, read_file, create_directory പോലുള്ള Claude-യുടെ ബിൽറ്റ്-ഇൻ ടൂളുകളുമായി പൊരുത്തപ്പെടുന്നു.

മാച്ചർ കോമ്പിനേഷനുകൾ AND ലോജിക്കിൽ പ്രവർത്തിക്കുമെന്ന് കമ്മ്യൂണിറ്റി ചർച്ചകൾ വെളിപ്പെടുത്തുന്നു. ഹുക്ക് പ്രവർത്തിക്കണമെങ്കിൽ വ്യക്തമാക്കിയ എല്ലാ മാച്ചറുകളും പൊരുത്തപ്പെടണം.

കമാൻഡ് ഹുക്കുകൾ: ഷെൽ സ്ക്രിപ്റ്റ് സംയോജനം

കമാൻഡ് ഹുക്കുകൾ ഘടനാപരമായ JSON ഇൻപുട്ട് ഉപയോഗിച്ച് ഷെൽ കമാൻഡുകളോ സ്ക്രിപ്റ്റുകളോ പ്രവർത്തിപ്പിക്കുന്നു. പ്രാദേശിക ഓട്ടോമേഷനായി ഏറ്റവും സാധാരണമായ ഹുക്ക് തരമാണ് ഇവ.

ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ വ്യക്തമാക്കുന്നത് കമാൻഡ് ഹുക്കുകൾ ഈ ഘടനയിൽ JSON സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് വഴി സ്വീകരിക്കുന്നു എന്നാണ്:

{
“event”: “PreToolUse”,
“toolName”: “edit_file”,
“toolInput”: {
“path”: “src/app.ts”,
“content”: “…”
},
“sessionId”: “abc123”,
“turnId”: “turn-456”
}ഇൻപുട്ട് വിവരണം നടത്താൻ സ്ക്രിപ്റ്റുകൾ ഈ ഇൻപുട്ട് പാഴ്സ് ചെയ്യുന്നു. ഒരു പൈത്തൺ സാധൂകരണ ഹുക്ക് ഇങ്ങനെയായിരിക്കും:
#!/usr/bin/env python3
import sys
import json

input_data = json.load(sys.stdin)
tool_input = input_data.get(‘toolInput’, {})
file_path = tool_input.get(‘path’, ”)

if file_path.startswith(‘protected/’):
print(“Cannot edit protected files”, file=sys.stderr)
sys.exit(1)

sys.exit(0)

എക്സിറ്റ് കോഡ് 0 പ്രവർത്തനം അനുവദിക്കുന്നു. എക്സിറ്റ് കോഡ് 1 അതിനെ തടയുകയും stderr സന്ദേശം Claude-ക്ക് കാണിക്കുകയും ചെയ്യുന്നു. എക്സിറ്റ് കോഡ് 2 പ്രത്യേക പെരുമാറ്റം ഇവന്റ് അനുസരിച്ച് ട്രിഗർ ചെയ്യുന്നു.

എക്സിറ്റ് കോഡ് 2 പെരുമാറ്റം

ഔദ്യോഗിക ഹുക്ക് റെഫറൻസ് ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, exit code 2-ന് ഇവന്റ്-സ്പെസിഫിക് അർത്ഥമുണ്ട് (PreToolUse: തടയുകയും പുനർവിചിന്തനം ചെയ്യാൻ പ്രേരിപ്പിക്കുകയും ചെയ്യുന്നു; UserPromptSubmit: തടയൽ കൂടാതെ സന്ദർഭം നൽകുന്നു; PermissionRequest: അനുമതി തടയുന്നു):

PreToolUse: ടൂൾ തടയുകയും stderr സന്ദേശം സന്ദർഭമായി ഉപയോഗിച്ച് പുനർവിചിന്തനം ചെയ്യാൻ Claude-യെ പ്രേരിപ്പിക്കുകയും ചെയ്യുന്നു
UserPromptSubmit: stderr ഔട്ട്പുട്ട് തടയൽ കൂടാതെ അധിക സന്ദർഭമായി നൽകുന്നു
PermissionRequest: അനുമതി നൽകുന്നത് തടയുന്നു

ഇത് ഹാർഡ് ബ്ലോക്കിംഗിനും അനുവദിക്കുന്നതിനും ഇടയിൽ ഒരു മധ്യവർഗ്ഗം സൃഷ്ടിക്കുന്നു. പ്രവർത്തനം എന്തുകൊണ്ട് പ്രശ്നകരമായേക്കാം എന്നതിനെക്കുറിച്ചുള്ള ഫീഡ്‌ബാക്ക് Claude-ന് ലഭിക്കുകയും അവരുടെ സമീപനം ക്രമീകരിക്കുകയും ചെയ്യാം.

അസമകാലിക കമാൻഡ് ഹുക്കുകൾ

Claude-യുടെ വർക്ക്ഫ്ലോ തടയാതെ പശ്ചാത്തലത്തിൽ ഹുക്കുകൾ പ്രവർത്തിപ്പിക്കാൻ async: true ഫ്ലാഗ് ഉപയോഗിക്കുന്നു. ഇത് ഡെപ്ലോയ്മെന്റ് അറിയിപ്പുകൾ അല്ലെങ്കിൽ മെട്രിക് ശേഖരണം പോലുള്ള സാവധാനത്തിലുള്ള പ്രവർത്തനങ്ങൾക്ക് പ്രധാനമാണ്.

{
“event”: “PostToolUse”,
“matcher”: {
“toolName”: “execute_command”
},
“command”: “./scripts/log-to-analytics.sh”,
“async”: true,
“timeout”: 30
}

ഒരു async ഹുക്ക് പ്രവർത്തിക്കുമ്പോൾ, Claude Code പ്രോസസ്സ് ആരംഭിക്കുകയും ഉടൻ തന്നെ തുടരുകയും ചെയ്യും. ടൈംഔട്ട് ഫീൽഡ് സെക്കൻഡിൽ പരമാവധി എക്സിക്യൂഷൻ സമയം സജ്ജമാക്കുന്നു. വ്യക്തമാക്കാത്തപക്ഷം, async ഹുക്കുകൾ 10 മിനിറ്റ് ഡിഫോൾട്ട് ടൈംഔട്ട് ഉപയോഗിക്കുന്നു.

യഥാർത്ഥമായി പറഞ്ഞാൽ: async ഹുക്കുകൾക്ക് പ്രവർത്തനങ്ങൾ തടയാൻ കഴിയില്ല, കാരണം Claude തുടർന്നതിന് ശേഷമാണ് അവ പ്രവർത്തിക്കുന്നത്. ലോഗിംഗ്, അറിയിപ്പുകൾ, ക്ലീനപ്പ് എന്നിവയ്ക്ക് അവ പ്രവർത്തിക്കുന്നു — സാധൂകരണത്തിനുള്ളതല്ല.

HTTP ഹുക്കുകൾ: ബാഹ്യ സേവന സംയോജനം

HTTP ഹുക്കുകൾ JSON പേലോഡുകൾ വിദൂര എൻഡ്‌പോയിന്റുകളിലേക്ക് POST ചെയ്യുകയും തീരുമാന നിയന്ത്രണത്തിനായി പ്രതികരണങ്ങൾ പാഴ്സ് ചെയ്യുകയും ചെയ്യുന്നു. സാധൂകരണ സേവനങ്ങൾ, ഡാറ്റാബേസുകൾ, മൂന്നാം കക്ഷി ടൂളുകൾ എന്നിവയുമായുള്ള സംയോജനം ഇവ സാധ്യമാക്കുന്നു.

അടിസ്ഥാന HTTP ഹുക്ക് കൺഫിഗറേഷൻ:

{
“event”: “PreToolUse”,
“url”: “api.example.com/validate”,
“headers”: {
“Authorization”: “Bearer ${API_TOKEN}”
},
“timeout”: 5
}

പേലോഡ് ഘടന കമാൻഡ് ഹുക്ക് ഇൻപുട്ടുമായി പൊരുത്തപ്പെടുന്നു, എന്നാൽ HTTP POST ബോഡി ആയി എത്തുന്നു. പ്രതികരണം Claude-യുടെ അടുത്ത നടപടി നിർണ്ണയിക്കുന്നു.

HTTP പ്രതികരണ കൈകാര്യം ചെയ്യൽ

ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, HTTP ഹുക്കുകൾ സ്റ്റാറ്റസ് കോഡും ബോഡി ഉള്ളടക്കവും അടിസ്ഥാനമാക്കി പ്രതികരണങ്ങൾ വ്യാഖ്യാനിക്കുന്നു:

സ്റ്റാറ്റസ് കോഡ്	ഫലം	സന്ദേശ സ്രോതസ്സ്
200	പ്രവർത്തനം അനുവദിക്കുക	പ്രതികരണ ബോഡി (ഓപ്ഷണൽ)
400	പ്രവർത്തനം തടയുക	Claude-ക്ക് കാണിക്കുന്ന പ്രതികരണ ബോഡി
500	ഹുക്ക് പിശക്, പ്രവർത്തനം അനുവദിക്കുക	രേഖപ്പെടുത്തിയിട്ടുണ്ടെങ്കിലും Claude-ക്ക് കാണിക്കില്ല
മറ്റുള്ളവ	പ്രവർത്തനം അനുവദിക്കുക	ഹുക്ക് പരാജയം വർക്ക്ഫ്ലോ തടയുന്നില്ല

പ്രതികരണ ബോഡിയിൽ Claude കാണുന്ന ഒരു സന്ദേശ ഫീൽഡ് ഉൾക്കൊള്ളാം. ഇത് സാധൂകരണ സേവനങ്ങൾക്ക് പ്രവർത്തനം എന്തുകൊണ്ട് തടഞ്ഞുവെന്ന് വിശദീകരിക്കാൻ സഹായിക്കുന്നു.

എൻവയോൺമെൻ്റ് വേരിയബിൾ ഇൻ്റർപോളേഷൻ

HTTP ഹുക്കുകൾ url, headers, മറ്റ് സ്ട്രിംഗ് ഫീൽഡുകളിൽ ${VAR} സിന്റാക്സ് പിന്തുണയ്ക്കുന്നു. Claude Code പ്രവർത്തിക്കുന്ന പരിതസ്ഥിതിയിൽ നിന്ന് വേരിയബിളുകൾ വികസിക്കുന്നു.

ഔദ്യോഗിക MCP ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, എൻവയോൺമെൻ്റ് വേരിയബിൾ വികസനത്തിൽ ഒരു ഡിഫോൾട്ട് ഫോൾബാക്ക് സിന്റാക്സ് ഉൾപ്പെടുന്നു: ${VAR:-default} എന്നാൽ VAR സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ അത് ഉപയോഗിക്കും, അല്ലെങ്കിൽ ഡിഫോൾട്ട് മൂല്യം ഉപയോഗിക്കും.

സുരക്ഷാ നിയന്ത്രണം: GitHub പ്രശ്നം #28044 അനുസരിച്ച്, allowedEnvVars കൺഫിഗറേഷൻ ഫീൽഡിൽ വ്യക്തമായി ലിസ്റ്റ് ചെയ്തിട്ടുള്ള എൻവയോൺമെൻ്റ് വേരിയബിളുകൾ മാത്രമേ HTTP ഹുക്കുകൾക്ക് ലഭ്യമാകൂ. ഇത് ആകസ്മികമായ ക്രെഡൻഷ്യൽ എക്സ്പോഷർ തടയുന്നു.

പ്രോംപ്റ്റ് ഹുക്കുകൾ: സന്ദർഭ കുത്തിവപ്പ്

പ്രോംപ്റ്റ് ഹുക്കുകൾ പ്രത്യേക ഇവന്റുകളിൽ Claude-യുടെ സന്ദർഭത്തിലേക്ക് ഡൈനാമിക് നിർദ്ദേശങ്ങൾ കുത്തിനിറയ്ക്കുന്നു. ബാഹ്യ പ്രക്രിയകളോ API കോളുകളോ ഇല്ലാതെ ഇവ പെരുമാറ്റം പരിഷ്കരിക്കുന്നു.

{
“event”: “SessionStart”,
“prompt”: “You are working on a TypeScript project. Always use strict null checks and prefer async/await over promises.”
}

കുത്തിനിറച്ച ടെക്സ്റ്റ് ആ സെഷനു വേണ്ടിയുള്ള Claude-യുടെ സിസ്റ്റം നിർദ്ദേശങ്ങളുടെ ഭാഗമായി മാറും. ഇവന്റ് ഡാറ്റയെ അടിസ്ഥാനമാക്കി വികസിക്കുന്ന ടെംപ്ലേറ്റ് വേരിയബിളുകളും പ്രോംപ്റ്റ് ഹുക്കുകൾക്ക് ഉപയോഗിക്കാം.

ഡൈനാമിക് പ്രോംപ്റ്റ് ജനറേഷൻ

ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, പ്രോംപ്റ്റ് ഹുക്കുകൾക്ക് ഡൈനാമിക് പ്രോംപ്റ്റുകൾ ഉണ്ടാക്കുന്ന കമാൻഡ് ഫീൽഡുകൾ പിന്തുണയ്ക്കുന്നു:

{
“event”: “ContextCompaction”,
“type”: “prompt”,
“command”: “./scripts/generate-context-summary.sh”
}

കമാൻഡ് സ്റ്റാൻഡേർഡ് JSON ഇൻപുട്ട് സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് വഴി സ്വീകരിക്കുകയും stdout-ലേക്ക് പ്രോംപ്റ്റ് ടെക്സ്റ്റ് ഔട്ട്പുട്ട് ചെയ്യുകയും ചെയ്യുന്നു. പ്രോജക്റ്റ് സ്റ്റേറ്റിനെ അടിസ്ഥാനമാക്കി സന്ദർഭ-അവബോധമുള്ള നിർദ്ദേശ ജനറേഷൻ ഇത് സാധ്യമാക്കുന്നു.

ഏജന്റ് അധിഷ്ഠിത ഹുക്കുകൾ

ഏജന്റ് ഹുക്കുകൾ നേരിട്ടുള്ള പ്രോംപ്റ്റ് ഇൻജെക്ഷന് പകരം ഇവന്റ് കൈകാര്യം ചെയ്യുന്ന ഒരു സബ്-ഏജന്റ് വ്യക്തമാക്കുന്നു. സബ്-ഏജന്റ് ഇവന്റ് സംബന്ധിച്ച സന്ദർഭം സ്വീകരിക്കുകയും ബഹു-ഘട്ടം റീസണിംഗ് നടത്തുകയും ചെയ്യാം.

{
“event”: “PostToolUseFailure”,
“agent”: “debugger”,
“agentPrompt”: “A tool call failed. Analyze the error and suggest fixes.”
}

പേര് നൽകിയ സബ്-ഏജന്റ് പ്രോജക്റ്റ് കൺഫിഗറേഷനിൽ നിർവചിക്കണം. ലളിതമായ പ്രോംപ്റ്റ് ഇൻജെക്ഷന് നൽകാൻ കഴിയാത്ത സങ്കീർണ്ണമായ തീരുമാന ലോജിക് ഏജന്റ് ഹുക്കുകൾ സാധ്യമാക്കുന്നു.

പ്രായോഗിക ഹുക്ക് പാറ്റേണുകൾ

കമ്മ്യൂണിറ്റി ചർച്ചകളും ഔദ്യോഗിക ഉദാഹരണങ്ങളും പ്രൊഡക്ഷനിൽ വിശ്വസനീയമായി പ്രവർത്തിക്കുന്ന നിർദ്ദിഷ്ട ഓട്ടോമേഷൻ പാറ്റേണുകൾ വെളിപ്പെടുത്തുന്നു.

എഡിറ്റുകൾക്ക് ശേഷം കോഡ് ഓട്ടോ-ഫോർമാറ്റ് ചെയ്യുക

ഏറ്റവും സാധാരണമായ പാറ്റേൺ Claude ഫയലുകൾ എഡിറ്റ് ചെയ്തതിന് ശേഷം കോഡ് ഓട്ടോമാറ്റിക്കായി ഫോർമാറ്റ് ചെയ്യുന്നു:

{
“event”: “PostToolUse”,
“matcher”: {
“toolName”: “edit_file”,
“pathPattern”: “**/*.{js,ts,jsx,tsx}”
},
“command”: “prettier”,
“args”: [“–write”, “${toolInput.path}”]
}

എഡിറ്റ് ചെയ്ത ഫയൽ പാത്തേക്ക് ${toolInput.path} വേരിയബിൾ വികസിക്കുന്നു. വിജയകരമായ എഡിറ്റുകൾക്ക് ശേഷം ഫോർമാറ്റിംഗ് നടക്കുന്നു എന്ന് PostToolUse ഉറപ്പാക്കുന്നു, എന്നാൽ Claude-യുടെ വർക്ക്ഫ്ലോ തടയുന്നില്ല.

പ്രൊട്ടക്റ്റഡ് ഫയൽ മാറ്റങ്ങൾ തടയുക

PreToolUse ഹുക്കുകൾ ഫയൽ സംരക്ഷണ നിയമങ്ങൾ നടപ്പിലാക്കുന്നു:

{
“event”: “PreToolUse”,
“matcher”: {
“toolName”: “edit_file”
},
“command”: “./scripts/check-protected.sh”
}

സ്ക്രിപ്റ്റ് ലക്ഷ്യ പാതയെ സംരക്ഷിക്കപ്പെട്ട പാറ്റേണുകൾക്കെതിരെ സാധൂകരിക്കുകയും നിരോധിത എഡിറ്റുകൾ തടയുന്നതിനായി കോഡ് 1-ൽ നിന്ന് പുറത്തുകടക്കുകയും ചെയ്യുന്നു.

Claude-ക്ക് ഇൻപുട്ട് ആവശ്യമായി വരുമ്പോൾ അറിയിപ്പ് നേടുക

ഔദ്യോഗിക വർക്ക്ഫ്ലോ ഗൈഡ് അനുസരിച്ച്, Notification ഹുക്കുകൾക്ക് ഡെസ്ക്ടോപ്പ് അലേർട്ടുകൾ ട്രിഗർ ചെയ്യാനോ ബാഹ്യ സേവനങ്ങളിലേക്ക് സന്ദേശങ്ങൾ അയക്കാനോ കഴിയും:

{
“event”: “Notification”,
“command”: “osascript”,
“args”: [“-e”, “display notification \”${message}\” with title \”Claude Code\””]
}

Claude Code ഒരു അറിയിപ്പ് അയക്കുമ്പോഴെല്ലാം, ഉപയോക്തൃ ഇൻപുട്ടിനായി കാത്തിരിക്കുമ്പോഴോ ടാസ്ക് പൂർത്തിയായതിന് ശേഷമോ ഇത് പ്രവർത്തിക്കും.

രൂപീകരണത്തിന് ശേഷം സന്ദർഭം വീണ്ടും കുത്തിനിറയ്ക്കുക

സംഭാഷണ വിൻഡോ നിറയുമ്പോൾ പ്രധാനപ്പെട്ട സന്ദർഭം പുനഃസ്ഥാപിക്കുന്നതിനായി ContextCompaction ഹുക്കുകൾ സഹായിക്കുന്നു:

{
“event”: “ContextCompaction”,
“type”: “prompt”,
“command”: “cat .claude/critical-context.md”
}

കമാൻഡ് ഔട്ട്പുട്ട് രൂപീകരണം പഴയ സന്ദേശങ്ങൾ നീക്കം ചെയ്തതിന് ശേഷം Claude-യുടെ സന്ദർഭത്തിലേക്ക് വീണ്ടും കുത്തിനിറയ്ക്കുന്നു. ഇത് നിർണായക പ്രോജക്റ്റ്-സ്പെസിഫിക് നിർദ്ദേശങ്ങളുടെ നഷ്ടം തടയുന്നു.

കൺഫിഗറേഷൻ മാറ്റങ്ങൾ ഓഡിറ്റ് ചെയ്യുക

Claude കൺഫിഗറേഷൻ ഫയലുകൾ മാറ്റുന്നത് ട്രാക്ക് ചെയ്യുക:

{
“event”: “PostToolUse”,
“matcher”: {
“toolName”: “edit_file”,
“pathPattern”: “**/{package.json,.env,*.config.*}”
},
“command”: “git”,
“args”: [“add”, “${toolInput.path}”],
“async”: true
}

Git പ്രവർത്തനങ്ങൾ പൂർത്തിയാകുമ്പോൾ Claude-യെ തടയാതെ Async എക്സിക്യൂഷൻ ഇത് സാധ്യമാക്കുന്നു. ഇത് മാനുവൽ സ്റ്റേജിംഗ് ഇല്ലാതെ കൺഫിഗറേഷൻ മാറ്റങ്ങളുടെ ഒരു ഓഡിറ്റ് ട്രയൽ സൃഷ്ടിക്കുന്നു.

JSON ഔട്ട്പുട്ടും തീരുമാന നിയന്ത്രണവും

കമാൻഡ് ഹുക്കുകൾക്ക് ലളിതമായ എക്സിറ്റ് കോഡുകൾക്ക് അപ്പുറം വിശദമായ ഫീഡ്‌ബാക്ക് നൽകാൻ ഘടനാപരമായ JSON ഔട്ട്പുട്ട് ചെയ്യാൻ കഴിയും. ഔദ്യോഗിക റെഫറൻസ് അനുസരിച്ച്, JSON ഔട്ട്പുട്ട് Claude തീരുമാനമെടുക്കുന്നതിനായി വ്യാഖ്യാനിക്കുന്ന ബഹു-ഫീൽഡ് പ്രതികരണങ്ങൾ സാധ്യമാക്കുന്നു.

{
“allowed”: false,
“message”: “This file is protected by team policy”,
“suggestion”: “Create a new file in src/features/ instead”
}

allowed ഫീൽഡ് പ്രവർത്തനം തുടരുമോ എന്ന് നിയന്ത്രിക്കുന്നു. message Claude-ക്ക് സന്ദർഭമായി ദൃശ്യമാകുന്നു. suggestion ഫീൽഡ് ബദൽ സമീപനങ്ങൾ നൽകുന്നു.

JSON ഔട്ട്പുട്ട് ചെയ്യാൻ ഹുക്കുകൾക്ക് കഴിയേണ്ടത്:

Stdout-ലേക്ക് സാധുവായ JSON എഴുതുക
Exit കോഡ് 0 (അനുവദിച്ചതിന്) അല്ലെങ്കിൽ 1 (തടഞ്ഞതിന്) ഉപയോഗിച്ച് പുറത്തുകടക്കുക
குறைந்தது allowed ബൂളിയൻ ഫീൽഡ് ഉൾപ്പെടുത്തുക

Claude Code JSON പാഴ്സ് ചെയ്യുകയും ഫീഡ്‌ബാക്ക് ലൂപ്പ് മെച്ചപ്പെടുത്താൻ അത് ഉപയോഗിക്കുകയും ചെയ്യുന്നു. എക്സിറ്റ് കോഡുകൾ ഇപ്പോഴും പ്രാഥമിക തീരുമാനം നിർണ്ണയിക്കുന്നു, എന്നാൽ JSON കൂടുതൽ സമൃദ്ധമായ സന്ദർഭം നൽകുന്നു.

ഹുക്ക് ഇൻപുട്ട് ഫീൽഡുകൾ റെഫറൻസ്

എല്ലാ ഹുക്കുകളും സ്റ്റാൻഡേർഡ് ഫീൽഡുകൾക്ക് പുറമെ ഇവൻ്റ്-സ്പെസിഫിക് ഡാറ്റയുള്ള JSON ഒബ്ജക്റ്റ് സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് വഴി സ്വീകരിക്കുന്നു. പൂർണ്ണമായ സ്കീമ മനസ്സിലാക്കുന്നത് കൂടുതൽ നൂതനമായ ഹുക്ക് ലോജിക് സാധ്യമാക്കുന്നു.

Hook input JSON schema showing common fields and event-specific extensions

പൊതുവായ ഇൻപുട്ട് ഫീൽഡുകൾ

എല്ലാ ഹുക്കുകൾക്കും ഈ അടിസ്ഥാന ഫീൽഡുകൾ ലഭിക്കും:

event: ഹുക്ക് ഇവന്റ് പേര് (ഉദാഹരണത്തിന്, "PreToolUse")
sessionId: നിലവിലെ Claude സെഷൻ്റെ അദ്വിതീയ ഐഡൻ്റിഫയർ
turnId: നിലവിലെ സംഭാഷണ ടേണിൻ്റെ ഐഡൻ്റിഫയർ
timestamp: ഇവന്റ് ഫയർ ചെയ്ത സമയം (ISO 8601 ടൈംസ്റ്റാമ്പ്)

ടൂൾ ഇവന്റ് ഫീൽഡുകൾ

PreToolUse, PostToolUse, PostToolUseFailure ഇവന്റുകളിൽ ഇവ ഉൾപ്പെടുന്നു:

toolName: വിളിക്കുന്ന ടൂളിൻ്റെ പേര് (edit_file, execute_command, മുതലായവ)
toolInput: ടൂളിൻ്റെ ഇൻപുട്ട് പാരാമീറ്ററുകൾ അടങ്ങിയ ഒബ്ജക്റ്റ്
toolResponse: ടൂൾ ഔട്ട്പുട്ട് ഡാറ്റ (PostToolUse മാത്രം)
error: സന്ദേശവും കോഡും ഉൾപ്പെടെയുള്ള പിശക് വിശദാംശങ്ങൾ (PostToolUseFailure മാത്രം)

ടൂളിന് അനുസരിച്ച് toolInput ഘടന വ്യത്യസ്തമായിരിക്കും. edit_file-ന് path, content എന്നിവ ഉൾക്കൊള്ളുന്നു. execute_command-ന് command, args എന്നിവ ഉൾക്കൊള്ളുന്നു.

അനുമതി ഇവന്റ് ഫീൽഡുകൾ

PermissionRequest ഇവന്റുകളിൽ ഇവ ഉൾപ്പെടുന്നു:

permissionType: അഭ്യർത്ഥിച്ച അനുമതിയുടെ തരം (file_write, command_execute, മുതലായവ)
requestedAction: അനുമതി ആവശ്യമുള്ള നിർദ്ദിഷ്ട പ്രവർത്തനം
resourcePath: ബാധിച്ച ഫയൽ പാത അല്ലെങ്കിൽ റിസോഴ്സ് ഐഡൻ്റിഫയർ

MCP ടൂൾ ഹുക്കുകൾ

ഔദ്യോഗിക ഹുക്ക് റെഫറൻസ് അനുസരിച്ച്, mcpTool മാച്ചർ ഫീൽഡ് ഉപയോഗിച്ച് മോഡൽ കോൺടെക്സ്റ്റ് പ്രോട്ടോക്കോൾ (MCP) ടൂളുകളുമായി ഹുക്കുകൾ പൊരുത്തപ്പെടാം. Claude MCP സെർവറുകൾ നൽകുന്ന ബാഹ്യ ടൂളുകൾ ഉപയോഗിക്കുമ്പോൾ ഹുക്ക് എക്സിക്യൂഷൻ ഇത് സാധ്യമാക്കുന്നു.

{
“event”: “PreToolUse”,
“matcher”: {
“mcpTool”: “database/query”
},
“command”: “./scripts/validate-sql.sh”
}

mcpTool മൂല്യം format server-name/tool-name എന്ന വിഭാഗത്തിൽ ടൂൾ നാമവുമായി പൊരുത്തപ്പെടുന്നു. ഡാറ്റാബേസ് ക്വറികൾ, API കോളുകൾ, അല്ലെങ്കിൽ മറ്റ് ബാഹ്യ പ്രവർത്തനങ്ങൾക്കുള്ള സാധൂകരണ ലോജിക് ഇത് അനുവദിക്കുന്നു.

GitHub ഫീച്ചർ അഭ്യർത്ഥനകൾ MCP-യുമായുള്ള കൂടുതൽ ആഴത്തിലുള്ള സംയോജനത്തിനുള്ള വർദ്ധിച്ചുവരുന്ന താൽപ്പര്യം സൂചിപ്പിക്കുന്നു, MCP സെർവർ അറിയിപ്പുകൾ നിരീക്ഷിക്കാനും ബാഹ്യ ഇവന്റുകളോട് പ്രതികരിക്കാനും കഴിയുന്ന ഹുക്കുകൾ ഉൾപ്പെടെ.

സുരക്ഷാ പരിഗണനകൾ

ഹുക്കുകൾ Claude Code-ൻ്റെ അതേ അനുമതികളോടെ പ്രവർത്തിക്കുന്നു. ഇത് ബഹു-ഉപയോക്തൃ പരിതസ്ഥിതികൾക്കും പങ്കിട്ട കൺഫിഗറേഷനുകൾക്കും സുരക്ഷാ സൂചനകൾ നൽകുന്നു.

കമാൻഡ് എക്സിക്യൂഷൻ സാൻഡ്‌ബോക്സ്

GitHub പ്രശ്നം #28044 അനുസരിച്ച്, HTTP ഹുക്കുകൾ ഒരു സാൻഡ്‌ബോക്സ് പ്രോക്സി വഴി റൂട്ട് ചെയ്യുന്നു, ഇത് നെറ്റ്‌വർക്ക് ആക്സസ് നിയന്ത്രിക്കുകയും എൻവയോൺമെൻ്റ് വേരിയബിളുകൾ ഫിൽട്ടർ ചെയ്യുകയും ചെയ്യുന്നു. കമാൻഡ് ഹുക്കുകൾക്ക് അത്തരം നിയന്ത്രണങ്ങളില്ല—അവ പൂർണ്ണ ഷെൽ ആക്സസ്സോടെ പ്രവർത്തിക്കുന്നു.

ഡോക്യുമെന്റേഷൻ ഈ സമ്പ്രദായങ്ങൾ ശുപാർശ ചെയ്യുന്നു:

ഹുക്ക് കമാൻഡുകളിൽ ക്രെഡൻഷ്യലുകൾ ഒരിക്കലും സൂക്ഷിക്കരുത്
സെൻസിറ്റീവ് ഡാറ്റയ്ക്ക് എൻവയോൺമെൻ്റ് വേരിയബിളുകൾ ഉപയോഗിക്കുക
${...} വികാസങ്ങളിൽ നിന്നുള്ള എല്ലാ ഇൻപുട്ടുകളും സാധൂകരിക്കുക
ബാഹ്യ സേവനങ്ങൾക്കായി ടൈംഔട്ട് പരിധികൾ നടപ്പിലാക്കുക
പരാജയങ്ങളിൽ തടയുന്നത് ഒഴിവാക്കാൻ നോൺ-ക്രിട്ടിക്കൽ പ്രവർത്തനങ്ങൾക്ക് async ഹുക്കുകൾ ഉപയോഗിക്കുക

ഹുക്ക് എക്സിക്യൂഷൻ ഐസൊലേഷൻ

~/.claude/settings.json-ലെ ഉപയോക്തൃ തലത്തിലുള്ള ഹുക്കുകൾ എല്ലാ പ്രോജക്റ്റുകൾക്കും ബാധകമാണ്. ഇത് വ്യത്യസ്ത ട്രസ്റ്റ് അതിരുകളിലുടനീളം പ്രവർത്തിക്കുമ്പോൾ അപകടങ്ങൾ സൃഷ്ടിക്കുന്നു. പ്രോജക്റ്റ് തലത്തിലുള്ള ഹുക്കുകൾ ഉപയോക്തൃ ഹുക്കുകളെ ഓവർറൈഡ് ചെയ്യുന്നു, എന്നാൽ അവയെ പൂർണ്ണമായി പ്രവർത്തനരഹിതമാക്കാൻ കഴിയില്ല.

Claude Code-ലെ /hooks മെനു നിലവിലെ സെഷനുവേണ്ടി സജീവമായ എല്ലാ ഹുക്കുകളും കാണിക്കുന്നു. സെൻസിറ്റീവ് പ്രോജക്റ്റുകളിൽ പ്രവർത്തിക്കുന്നതിന് മുമ്പ് ഈ ലിസ്റ്റ് അവലോകനം ചെയ്യുന്നത് സാധ്യതയുള്ള സുരക്ഷാ ആശങ്കകൾ കണ്ടെത്താൻ സഹായിക്കുന്നു.

ഡീബഗ്ഗിംഗും ട്രബിൾഷൂട്ടിംഗും

ഹുക്ക് പരാജയങ്ങൾ Claude-യുടെ സംഭാഷണത്തിൽ എപ്പോഴും വ്യക്തമായി കാണില്ല. ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ നിരവധി ഡീബഗ്ഗിംഗ് സമീപനങ്ങൾ നൽകുന്നു.

ഹുക്ക് എക്സിക്യൂഷൻ ലോഗുകൾ

Claude Code സെഷൻ ഡീബഗ് ഔട്ട്പുട്ടിലേക്ക് ഹുക്ക് എക്സിക്യൂഷൻ ലോഗ് ചെയ്യുന്നു. ട്രബിൾഷൂട്ടിംഗ് ഗൈഡ് അനുസരിച്ച്, ഡീബഗ് ലോഗിംഗ് പ്രവർത്തനക്ഷമമാക്കുന്നത് വെളിപ്പെടുത്തുന്നു:

ഓരോ ഇവന്റിനും ഏത് ഹുക്കുകളാണ് പൊരുത്തപ്പെട്ടത്
ഓരോ ഹുക്കിനും അയച്ച JSON ഇൻപുട്ട്
ഹുക്ക് പ്രോസസ്സുകളിൽ നിന്നുള്ള stdout, stderr ഔട്ട്പുട്ട്
എക്സിറ്റ് കോഡുകളും എക്സിക്യൂഷൻ സമയവും
HTTP ഹുക്കുകൾക്കുള്ള HTTP പ്രതികരണ കോഡുകളും ബോഡികളും

Claude Code ആരംഭിക്കുന്നതിന് മുമ്പ് Claude_DEBUG=1 എന്ന് പരിസ്ഥിതിയിൽ സജ്ജീകരിച്ച് ഡീബഗ് ലോഗിംഗ് പ്രവർത്തനക്ഷമമാക്കുക.

ഹുക്കുകൾ സ്വതന്ത്രമായി പരീക്ഷിക്കുക

JSON ഇൻപുട്ട് സ്വമേധയാ നിർമ്മിക്കുന്നതിലൂടെ Claude Code-ന് പുറത്ത് കമാൻഡ് ഹുക്കുകൾ പരീക്ഷിക്കാൻ കഴിയും:

echo ‘{“event”:”PreToolUse”,”toolName”:”edit_file”,”toolInput”:{“path”:”test.txt”}}’ | ./scripts/my-hook.sh

യഥാർത്ഥ Claude പ്രവർത്തനങ്ങൾ ട്രിഗർ ചെയ്യാതെ ഇത് ഹുക്ക് ലോജിക് സാധൂകരിക്കുന്നു. എക്സിറ്റ് കോഡും stdout/stderr ഔട്ട്പുട്ടും പ്രതീക്ഷിച്ച പെരുമാറ്റവുമായി പൊരുത്തപ്പെടണം.

സാധാരണ ഹുക്ക് പരാജയങ്ങൾ

കമ്മ്യൂണിറ്റി ചർച്ചകൾ ഈ പതിവ് പ്രശ്നങ്ങൾ തിരിച്ചറിയുന്നു:

ടൈംഔട്ട് പിശകുകൾ: ഡിഫോൾട്ട് 10 മിനിറ്റ് ടൈംഔട്ട് സാവധാനത്തിലുള്ള പ്രവർത്തനങ്ങൾക്ക് വളരെ കുറവ്—timeout ഫീൽഡ് ഉപയോഗിച്ച് വർദ്ധിപ്പിക്കുക
പാത വികസന പരാജയങ്ങൾ: ഫയൽ സന്ദർഭം ഉൾക്കൊള്ളാത്ത ഇവന്റുകൾക്ക് ${file} പോലുള്ള വേരിയബിളുകൾ നിർവചിക്കപ്പെട്ടിട്ടില്ല
അനുമതി പിശകുകൾ: ഹുക്ക് സ്ക്രിപ്റ്റുകൾക്ക് എക്സിക്യൂട്ട് അനുമതികളില്ല—chmod +x script.sh പ്രവർത്തിപ്പിക്കുക
JSON പാഴ്സ് പിശകുകൾ: ഹുക്കുകളിൽ നിന്നുള്ള ഫോർമാറ്റ് ചെയ്യാത്ത JSON ഔട്ട്പുട്ട്—തിരികെ നൽകുന്നതിന് മുമ്പ് jq ഉപയോഗിച്ച് സാധൂകരിക്കുക
പരിസ്ഥിതി വേരിയബിൾ ലഭ്യമല്ലാത്തത്: ഹുക്ക് പ്രോസസ്സിലേക്ക് വേരിയബിളുകൾ പ്രൊപ്പഗേറ്റ് ചെയ്യുന്നില്ല—Claude Code-ൻ്റെ പരിസ്ഥിതി പരിശോധിക്കുക

ഹുക്ക് പ്രകടനം

സമന്വയ ഹുക്കുകൾ പൂർത്തിയാകുന്നതുവരെ Claude-യുടെ വർക്ക്ഫ്ലോ തടയുന്നു. ഡിഫോൾട്ട് 10 മിനിറ്റ് ടൈംഔട്ട് അനന്തമായി തടയുന്നത് തടയുന്നു, എന്നാൽ ചെറിയ കാലതാമസങ്ങൾ പോലും ഒന്നിലധികം പ്രവർത്തനങ്ങളിൽ കൂടിച്ചേരുന്നു.

ലളിതമായ സാധൂകരണ ഹുക്കുകൾക്ക് പ്രകടനം കാര്യമായ സ്വാധീനമില്ലെന്ന് പ്രാക്ടീഷണർമാർ റിപ്പോർട്ട് ചെയ്യുന്നു. ഫയൽ ഫോർമാറ്റിംഗ് ഹുക്കുകൾ ശ്രദ്ധേയമായ എന്നാൽ സ്വീകാര്യമായ പ്രകടനം ഉണ്ടാക്കുന്നു. ബാഹ്യ API കോളുകൾക്ക് വർക്ക്ഫ്ലോ ഘർഷണം സൃഷ്ടിക്കാൻ കഴിയും. ഹെവി കമ്പ്യൂട്ടേഷൻ പ്രവർത്തനങ്ങൾക്ക് async എക്സിക്യൂഷൻ പ്രയോജനകരമാണ്.

ഹുക്ക് ബാച്ചിംഗ്

ഒരേ ഇവന്റിന് ഒന്നിലധികം ഹുക്കുകൾക്ക് പൊരുത്തപ്പെടാം. റെഫറൻസ് ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, ഹുക്കുകൾ നിർവചന ക്രമത്തിൽ ക്രമാനുഗതമായി പ്രവർത്തിക്കുന്നു. ഏതെങ്കിലും ഹുക്ക് പ്രവർത്തനം തടയുകയാണെങ്കിൽ, ബാക്കിയുള്ള ഹുക്കുകൾ പ്രവർത്തിക്കില്ല.

ഇത് പ്രകടനത്തിന് പ്രധാനമാണ്. 200ms വീതമുള്ള അഞ്ച് സമന്വയ ഹുക്കുകൾ ഒരു ഇവന്റിന് ഒരു സെക്കൻഡ് ചേർക്കുന്നു. ബന്ധപ്പെട്ട സാധൂകരണങ്ങളെ ഒരു ഹുക്കിലേക്ക് സംയോജിപ്പിക്കുന്നത് ഓവർഹെഡ് കുറയ്ക്കുന്നു.

വിപുലമായ പാറ്റേണുകൾ

അടിസ്ഥാന ഓട്ടോമേഷന് പുറമെ, ഹുക്കുകൾ സങ്കീർണ്ണമായ വർക്ക്ഫ്ലോ കസ്റ്റമൈസേഷൻ സാധ്യമാക്കുന്നു.

സ്റ്റേറ്റ്ഫുൾ ഹുക്ക് ചെയിനുകൾ

ഫയലുകളോ ഡാറ്റാബേസുകളോ ഉപയോഗിച്ച് പ്രവർത്തനങ്ങൾക്കിടയിൽ സ്റ്റേറ്റ് നിലനിർത്താൻ ഹുക്കുകൾക്ക് കഴിയും. ഒരു PostToolUse ഹുക്ക് വിജയകരമായ പ്രവർത്തനങ്ങൾ രേഖപ്പെടുത്താം, അത് ഒരു PreToolUse ഹുക്ക് പിന്നീട് സാധൂകരിക്കാം:

#!/bin/bash
# Record successful edits
echo “${toolInput.path}” >> .claude/edit-history.txt

ഒരു അനുബന്ധ PreToolUse ഹുക്കിന് ആവർത്തന പ്രവർത്തനങ്ങൾ തടയുന്നതിനോ ഓർഡറിംഗ് പരിമിതികൾ നടപ്പിലാക്കുന്നതിനോ ഈ ചരിത്രം പരിശോധിക്കാൻ കഴിയും.

വ്യവസ്ഥകളോടെയുള്ള ഹുക്ക് പ്രവർത്തനം

എൻവയോൺമെൻ്റ് വേരിയബിളുകൾ റൺടൈമിൽ ഹുക്ക് പെരുമാറ്റം നിയന്ത്രിക്കുന്നു. CLAUDE_SKIP_HOOKS=1 സജ്ജീകരിക്കുന്നത് അടിയന്തര സാഹചര്യങ്ങളിൽ ഹുക്കുകൾ പ്രവർത്തനരഹിതമാക്കുന്നു.

ഹുക്കുകൾക്ക് തന്നെ എൻവയോൺമെൻ്റ് ഫ്ലാഗുകൾ പരിശോധിക്കാൻ കഴിയും:

#!/bin/bash
if [ “$STRICT_MODE” = “1” ]; then
# Apply strict validation
exit 1
fi
exit 0

ഇത് കൺഫിഗറേഷൻ മാറ്റങ്ങളില്ലാതെ ഡെവലപ്‌മെൻ്റ് മോഡ് വേഴ്സസ് പ്രൊഡക്ഷൻ മോഡ് പെരുമാറ്റം സാധ്യമാക്കുന്നു.

ബഹു-ഘട്ടം സാധൂകരണം

PreToolUse ഹുക്കുകൾക്ക് ബഹു-തല സാധൂകരണം നടപ്പിലാക്കാൻ കഴിയും, അവിടെ exit code 2 Claude-യെ മുന്നറിയിപ്പുകളോടെ തുടരാൻ അനുവദിക്കുന്നു:

കഠിനമായ പരാജയങ്ങൾ (exit 1): അപകടകരമായ പ്രവർത്തനങ്ങൾ തടയുക
സോഫ്റ്റ് മുന്നറിയിപ്പുകൾ (exit 2): പുനർവിചിന്തനം ചെയ്യാൻ Claude-യെ അറിയിക്കുക
സന്ദർഭത്തോടെ പാസ് (exit 0 + JSON): കൂടുതൽ വിവരങ്ങൾ നൽകുക

ഇത് ബൈനറി അനുവദിക്കുക/നിഷേധിക്കുക എന്നതിനേക്കാൾ സങ്കീർണ്ണമായ ഒരു സാധൂകരണ സ്പെക്ട്രം സൃഷ്ടിക്കുന്നു.

CI/CD-യുമായുള്ള സംയോജനം

ഔദ്യോഗിക പ്ലാറ്റ്ഫോം ഇന്റഗ്രേഷൻ ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, Claude Code CI/CD പരിതസ്ഥിതികളിൽ ഓട്ടോമേറ്റഡ് കോഡ് റിവ്യൂവിനും പ്രശ്ന ട്രയെജിനും പ്രവർത്തിക്കുന്നു. ഹുക്കുകൾ ഈ ഓട്ടോമേഷൻ വിപുലീകരിക്കുന്നു.

GitHub Actions വർക്ക്ഫ്ലോകൾക്ക് ഓട്ടോമേറ്റഡ് സെഷനുകളിൽ ടീം പോളിസികൾ നടപ്പിലാക്കുന്ന ഹുക്കുകൾ നിർവചിക്കാൻ കഴിയും:

-- name: Run Claude Code with strict hooks
env:
STRICT_MODE: 1
run: |
claude “Review this PR and suggest improvements”

STRICT_MODE ഫ്ലാഗ് ഹുക്ക് സ്ക്രിപ്റ്റുകളിലെ വ്യവസ്ഥകളോടെയുള്ള സാധൂകരണ ലോജിക് സജീവമാക്കുന്നു. ഇത് ഓട്ടോമേറ്റഡ് സെഷനുകൾ ഇൻ്ററാക്ടീവ് വികസനത്തേക്കാൾ കർശനമായ നിയമങ്ങൾ പാലിക്കുന്നു എന്ന് ഉറപ്പാക്കുന്നു.

ഓഡിറ്റ് ട്രയൽ ജനറേഷൻ

CI പരിതസ്ഥിതികളിലെ PostToolUse ഹുക്കുകൾ Claude പ്രവർത്തനങ്ങളുടെ വിശദമായ ഓഡിറ്റ് ലോഗുകൾ സൃഷ്ടിക്കുന്നു:

{
“event”: “PostToolUse”,
“command”: “./scripts/log-to-database.sh”,
“async”: true
}

പശ്ചാത്തലത്തിലുള്ള ലോഗിംഗ് പ്രകടനത്തെ ബാധിക്കില്ല, എന്നാൽ അനുസരണത്തിനും ഡീബഗ്ഗിംഗിനും പൂർണ്ണമായ പ്രവർത്തന ചരിത്രം നൽകുന്നു.

The /hooks മെനു

Claude Code ഒരു /hooks കമാൻഡ് നൽകുന്നു, ഇത് നിലവിലെ സെഷനുവേണ്ടി സജീവമായ എല്ലാ ഹുക്കുകളും പ്രദർശിപ്പിക്കുന്നു. ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, ഈ മെനു കാണിക്കുന്നു:

ഹുക്ക് ഇവന്റ് തരം
മാച്ചർ പാറ്റേണുകൾ
കമാൻഡ് അല്ലെങ്കിൽ URL എൻഡ്‌പോയിന്റ്
ഹുക്ക് async ആയി പ്രവർത്തിക്കുമോ
കൺഫിഗറേഷൻ സ്രോതസ്സ് (പ്രോജക്റ്റ്, ഉപയോക്താവ്, അല്ലെങ്കിൽ പ്ലഗിൻ)

ഒരു ഹുക്ക് തിരഞ്ഞെടുക്കുന്നത് അതിൻ്റെ പൂർണ്ണമായ കൺഫിഗറേഷൻ കാണിക്കുകയും നിലവിലെ സെഷനുവേണ്ടി താൽക്കാലികമായി പ്രവർത്തനരഹിതമാക്കാൻ അനുവദിക്കുകയും ചെയ്യുന്നു.

ഹുക്കുകൾ പ്രവർത്തനരഹിതമാക്കുകയോ നീക്കം ചെയ്യുകയോ ചെയ്യുക

ഹുക്ക് നിർവചനത്തിലേക്ക് "enabled": false ചേർക്കുന്നതിലൂടെ കൺഫിഗറേഷൻ നീക്കം ചെയ്യാതെ തന്നെ ഹുക്കുകൾ പ്രവർത്തനരഹിതമാക്കാൻ കഴിയും. ഇത് കൺഫിഗറേഷൻ സംരക്ഷിക്കുകയും എക്സിക്യൂഷൻ തടയുകയും ചെയ്യുന്നു.

ഹുക്ക് സ്ഥിരമായി നീക്കം ചെയ്യാൻ, അനുയോജ്യമായ settings.json ഫയലിൽ നിന്ന് അതിൻ്റെ എൻട്രി ഇല്ലാതാക്കുക. മാറ്റങ്ങൾ അടുത്ത സെഷൻ റീസ്റ്റാർട്ട് ചെയ്യുമ്പോൾ അല്ലെങ്കിൽ /reload പ്രവർത്തിപ്പിക്കുമ്പോൾ ഫലത്തിൽ വരും.

സ്കിൽസ്, ഏജൻ്റുകൾ എന്നിവയിലെ ഹുക്കുകൾ

ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, സ്കിൽ അല്ലെങ്കിൽ സബ്-ഏജൻ്റ് കൺഫിഗറേഷനുകളിൽ നിർവചിച്ചിട്ടുള്ള ഹുക്കുകൾ ആ സ്കിൽ അല്ലെങ്കിൽ ഏജൻ്റ് പ്രവർത്തിക്കുമ്പോൾ മാത്രമേ ബാധകമാകൂ. ഇത് പ്രത്യേക വർക്ക്ഫ്ലോകൾക്ക് വേണ്ടി പ്രത്യേക ഓട്ടോമേഷൻ സാധ്യമാക്കുന്നു.

ഒരു ഡീബഗ്ഗിംഗ് സബ്-ഏജന്റിൽ എല്ലാ ടൂൾ കോളുകളും ലോഗ് ചെയ്യുന്ന ഹുക്കുകൾ ഉൾക്കൊള്ളാം:

{
“name”: “debugger”,
“hooks”: [
{
“event”: “PostToolUse”,
“command”: “./scripts/log-debug.sh”,
“async”: true
}
]
}

ഈ ഹുക്കുകൾ സാധാരണ Claude Code പ്രവർത്തന സമയത്ത് മാത്രമല്ല, ഡീബഗ്ഗർ ഏജൻ്റ് സെഷനുകളിൽ മാത്രം പ്രവർത്തിക്കും.

പാത ഉപയോഗിച്ച് സ്ക്രിപ്റ്റുകൾ റെഫർ ചെയ്യുക

ഹുക്ക് കമാൻഡുകൾക്ക് റിലേറ്റീവ്, അബ്സൊല്യൂട്ട് പാത്തുകൾ രണ്ടും പിന്തുണയ്ക്കുന്നു. Claude Code പ്രവർത്തിക്കുന്ന പ്രോജക്റ്റ് റൂട്ടിൽ നിന്നാണ് റിലേറ്റീവ് പാത്തുകൾ പരിഹരിക്കുന്നത്.

കമ്മ്യൂണിറ്റി ചർച്ചകളിൽ നിന്നുള്ള മികച്ച രീതികൾ:

.claude/hooks/ ഡയറക്ടറിയിൽ ഹുക്ക് സ്ക്രിപ്റ്റുകൾ സംഭരിക്കുക
വിശദമായ പേരുകൾ ഉപയോഗിക്കുക: validate-typescript.sh അല്ലാതെ hook1.sh
സ്ക്രിപ്റ്റുകൾ എക്സിക്യൂട്ടബിൾ ആക്കുക: chmod +x .claude/hooks/*.sh
Shebang ലൈൻ ഉൾപ്പെടുത്തുക: #!/usr/bin/env bash അല്ലെങ്കിൽ #!/usr/bin/env python3
bash സ്ക്രിപ്റ്റുകളിൽ set -e ഉപയോഗിച്ച് പിശക് കൈകാര്യം ചെയ്യൽ ചേർക്കുക

ഭാവിയിലെ ഹുക്ക് കഴിവുകൾ

GitHub ഫീച്ചർ അഭ്യർത്ഥനകൾ പ്രോജക്റ്റ് ചെയ്തതും അഭ്യർത്ഥിച്ചതുമായ ഹുക്ക് മെച്ചപ്പെടുത്തലുകൾ വെളിപ്പെടുത്തുന്നു:

Inline സ്ക്രിപ്റ്റ് ഹുക്കുകൾ: ബാഹ്യ ഫയലുകളില്ലാതെ settings.json-ൽ നേരിട്ട് ഹുക്ക് ലോജിക് നിർവചിക്കുക
MCP ടൂൾ സംയോജനം: ഷെൽ കമാൻഡുകൾക്ക് പകരം ഹുക്കുകളിൽ നിന്ന് MCP സെർവർ ടൂളുകൾ വിളിക്കുക
ബഹു-ഏജൻ്റ് സഹകരണം: വ്യത്യസ്ത മെഷീനുകളിൽ Claude ഇൻസ്റ്റൻസുകൾക്കിടയിൽ ഏകോപിപ്പിക്കുന്ന ഹുക്കുകൾ
മെച്ചപ്പെടുത്തിയ ടൈപ്പിംഗ്: ഹുക്ക് ഇൻപുട്ട്/ഔട്ട്പുട്ട് സ്കീമകൾക്കുള്ള ടൈപ്പ്സ്ക്രിപ്റ്റ് ഡെഫനിഷനുകൾ

GitHub പ്രശ്നം #4274 അനുസരിച്ച്, സംയോജിത ഹുക്ക് തരങ്ങൾക്കുള്ള (MCP ടൂൾ, ഇൻലൈൻ സ്ക്രിപ്റ്റ്, API കോൾ) അഭ്യർത്ഥന കൺഫിഗറേഷൻ ലളിതമാക്കുന്നതിനും ഡെവലപ്പർ അനുഭവം മെച്ചപ്പെടുത്തുന്നതിനും ലക്ഷ്യമിടുന്നു.

പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ

അപകടകരമായ കമാൻഡുകൾ പ്രവർത്തിക്കുന്നത് Claude-ന് തടയാൻ ഹുക്കുകൾക്ക് കഴിയുമോ?

അതെ. PreToolUse ഹുക്കുകൾക്ക് കോഡ് 1 ഉപയോഗിച്ച് പുറത്തുകടക്കുന്നതിലൂടെ ഏത് ടൂൾ എക്സിക്യൂഷനും തടയാൻ കഴിയും. ഇത് ഫയൽ എഡിറ്റുകൾ, കമാൻഡ് എക്സിക്യൂഷൻ, MCP ടൂൾ കോളുകൾ എന്നിവ ഉൾക്കൊള്ളുന്നു. പ്രവർത്തനം അനുവദിക്കുന്നതിന് മുമ്പ് ഹുക്ക് പൂർണ്ണ ടൂൾ ഇൻപുട്ട് സ്വീകരിക്കുകയും ഏതെങ്കിലും മാനദണ്ഡങ്ങൾക്കെതിരെ സാധൂകരിക്കുകയും ചെയ്യുന്നു.

പ്രവർത്തിക്കാത്ത ഹുക്ക് എങ്ങനെ ഡീബഗ് ചെയ്യാം?

Claude Code ആരംഭിക്കുന്നതിന് മുമ്പ് CLAUDE_DEBUG=1 ഉപയോഗിച്ച് ഡീബഗ് ലോഗിംഗ് പ്രവർത്തനക്ഷമമാക്കുക. ഹുക്ക് എക്സിക്യൂഷൻ വിശദാംശങ്ങൾ, ഏത് ഹുക്കുകളാണ് പൊരുത്തപ്പെട്ടത്, JSON ഇൻപുട്ട് അയച്ചത്, stdout/stderr ഔട്ട്പുട്ട്, എക്സിറ്റ് കോഡുകൾ എന്നിവയ്ക്കായി സെഷൻ ലോഗുകൾ പരിശോധിക്കുക. സാമ്പിൾ JSON ഹുക്ക് സ്ക്രിപ്റ്റിലേക്ക് പൈപ്പ് ചെയ്യുന്നതിലൂടെ ഹുക്കുകൾ സ്വതന്ത്രമായി പരീക്ഷിക്കുക.

എല്ലാ Claude Code പ്ലാറ്റ്ഫോമുകളിലും ഹുക്കുകൾ പ്രവർത്തിക്കുമോ?

CLI, ഡെസ്ക്ടോപ്പ് ആപ്പ്, VS Code വിപുലീകരണം എന്നിവയിൽ ഹുക്കുകൾ പ്രവർത്തിക്കുന്നു. ഔദ്യോഗിക ഡോക്യുമെന്റേഷൻ അനുസരിച്ച്, Claude Code പ്രവർത്തിക്കുന്ന ഏത് സ്ഥലത്തും ഫയൽ സിസ്റ്റത്തിലേക്കുള്ള ആക്സസ്സോടെ ഹുക്കുകൾ പ്രവർത്തിക്കുന്നു. ബ്രൗസർ അടിസ്ഥാനമാക്കിയുള്ള Claude-യും മൊബൈൽ ആപ്പുകളും സാൻഡ്‌ബോക്സിംഗ് പരിമിതികൾ കാരണം ഹുക്കുകൾ പിന്തുണയ്ക്കുന്നില്ല.

ഹുക്കുകൾക്ക് Claude-യുടെ പ്രതികരണങ്ങളോ പെരുമാറ്റമോ മാറ്റാൻ കഴിയുമോ?

പ്രോംപ്റ്റ് ഹുക്കുകൾ Claude-യുടെ പെരുമാറ്റത്തെ സ്വാധീനിക്കുന്ന നിർദ്ദേശങ്ങൾ കുത്തിനിറയ്ക്കുന്നു. ഏജൻ്റ് ഹുക്കുകൾ പ്രത്യേക സബ്-ഏജൻ്റുകളിലേക്ക് ഇവൻ്റ് കൈകാര്യം ചെയ്യൽ നിർവഹിക്കുന്നു. എന്നിരുന്നാലും, ഹുക്കുകൾക്ക് Claude-യുടെ ജനറേറ്റ് ചെയ്ത ടെക്സ്റ്റ് അല്ലെങ്കിൽ റീസണിംഗ് പ്രോസസ്സ് നേരിട്ട് മാറ്റാൻ കഴിയില്ല—അവ സന്ദർഭം നൽകുകയും പ്രവർത്തനങ്ങൾ തടയുകയും ചെയ്തുകൊണ്ട് പ്രവർത്തിക്കുന്നു.

Async, sync ഹുക്കുകൾ തമ്മിൽ എന്താണ് വ്യത്യാസം?

സമന്വയ ഹുക്കുകൾ പൂർത്തിയാകുന്നതുവരെ അല്ലെങ്കിൽ ടൈംഔട്ട് ആകുന്നത് വരെ Claude-യുടെ വർക്ക്ഫ്ലോ തടയുന്നു. അസമന്വയ ഹുക്കുകൾ പശ്ചാത്തലത്തിൽ തടയൽ കൂടാതെ പ്രവർത്തിക്കുന്നു. Sync ഹുക്കുകൾക്ക് എക്സിറ്റ് കോഡുകളിലൂടെ പ്രവർത്തനങ്ങൾ തടയാൻ കഴിയും. Async ഹുക്കുകൾക്ക് തടയാൻ കഴിയില്ല, കാരണം Claude ഹുക്ക് പൂർത്തിയാകുന്നതിന് മുമ്പ് തുടരുന്നു. ലോഗിംഗ്, അറിയിപ്പുകൾ എന്നിവയ്ക്ക് async ഉപയോഗിക്കുക, സാധൂകരണത്തിന് sync ഉപയോഗിക്കുക.

ഒരു ടീമിന് ഹുക്കുകൾ എങ്ങനെ പങ്കുവെക്കാം?

.claude/settings.json ഫയൽ വെർഷൻ കൺട്രോളിലേക്ക് കമ്മിറ്റ് ചെയ്യുക. പ്രോജക്റ്റ് തലത്തിലുള്ള ഹുക്കുകൾ റെപ്പോസിറ്ററി ക്ലോൺ ചെയ്യുന്ന എല്ലാ ടീം അംഗങ്ങൾക്കും ബാധകമാകും. ഓർഗനൈസേഷൻ-വൈഡ് പോളിസികൾക്കായി, ടീമുകൾക്ക് ഒരു പങ്കിട്ട ഉപയോക്തൃ തലത്തിലുള്ള സജ്ജീകരണ ഫയൽ സൂക്ഷിക്കാൻ കഴിയും, അത് അംഗങ്ങൾ ~/.claude/settings.json ലേക്ക് പകർത്താം.

HTTP ഹുക്കുകൾക്ക് ഫയർവാളുകൾക്ക് പിന്നിലുള്ള ആന്തരിക API-കൾ വിളിക്കാൻ കഴിയുമോ?

അതെ, Claude Code ആ API-കളിലേക്ക് നെറ്റ്‌വർക്ക് ആക്സസ് ഉള്ള ഒരു പരിതസ്ഥിതിയിൽ പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ. HTTP ഹുക്കുകൾ Claude Code പ്രവർത്തിക്കുന്ന മെഷീനിൽ നിന്ന് സ്റ്റാൻഡേർഡ് POST അഭ്യർത്ഥനകൾ നടത്തുന്നു. കോർപ്പറേറ്റ് ഫയർവാളുകളും VPN-കളും സാധാരണയായി ബാധകമാകും. ഡോക്യുമെന്റേഷനിൽ പരാമർശിച്ചിട്ടുള്ള സാൻഡ്‌ബോക്സ് പ്രോക്സി എൻവയോൺമെൻ്റ് വേരിയബിൾ എക്സ്പോഷർ നിയന്ത്രിക്കുന്നു, നെറ്റ്‌വർക്ക് റൂട്ടിംഗ് അല്ല.

ഹുക്കുകൾ Claude Code-ൻ്റെ ടോക്കൺ ഉപയോഗം വർദ്ധിപ്പിക്കുന്നുണ്ടോ?

പ്രോംപ്റ്റ് ഹുക്കുകൾ Claude-യുടെ സന്ദർഭത്തിലേക്ക് ടെക്സ്റ്റ് കുത്തിനിറയ്ക്കുന്നു, അത് ടോക്കണുകൾ ഉപയോഗിക്കുന്നു. കമാൻഡ്, HTTP ഹുക്കുകൾ ടോക്കൺ ഉപയോഗത്തെ നേരിട്ട് ബാധിക്കുന്നില്ല, എന്നാൽ അവയുടെ ഔട്ട്പുട്ട് (പിശക് സന്ദേശങ്ങൾ, നിർദ്ദേശങ്ങൾ) സംഭാഷണ സന്ദർഭത്തിൻ്റെ ഭാഗമായി മാറുന്നു. വിശദീകരണ സന്ദേശങ്ങളുള്ള എക്സിറ്റ് കോഡ് 2, ലളിതമായ തടയൽ ഉള്ളതിനേക്കാൾ കൂടുതൽ സന്ദർഭം നൽകുന്നു.

ഉപസംഹാരം

Claude Code ഹുക്കുകൾ AI അസിസ്റ്റൻ്റിനെ ഒരു ശക്തമായ ഉപകരണത്തിൽ നിന്ന് പൂർണ്ണമായി ഓട്ടോമേറ്റ് ചെയ്ത ഒരു ഡെവലപ്‌മെൻ്റ് പ്ലാറ്റ്ഫോമായി മാറ്റുന്നു. ഇവൻ്റ് സിസ്റ്റം Claude-യുടെ വർക്ക്ഫ്ലോയിലുടനീളം—സെഷൻ ആരംഭം മുതൽ കോൺടെക്സ്റ്റ് കോംപാക്ഷൻ വരെ—ഇൻ്റർസെപ്ഷൻ പോയിൻ്റുകൾ നൽകുന്നു.

കമാൻഡ് ഹുക്കുകൾ പ്രാദേശിക സാധൂകരണവും ഫോർമാറ്റിംഗും കൈകാര്യം ചെയ്യുന്നു. HTTP ഹുക്കുകൾ ബാഹ്യ സേവനങ്ങളും ഡാറ്റാബേസുകളും സംയോജിപ്പിക്കുന്നു. പ്രോംപ്റ്റ് ഹുക്കുകൾ സന്ദർഭ കുത്തിവപ്പ് വഴി പെരുമാറ്റം പരിഷ്കരിക്കുന്നു. ഇവയെല്ലാം ഒരുമിച്ച് ടീം പോളിസികൾ നടപ്പിലാക്കുന്ന, കോഡ് നിലവാരം നിലനിർത്തുന്ന, നിലവിലുള്ള ഡെവലപ്‌മെൻ്റ് ഇൻഫ്രാസ്ട്രക്ചറുമായി സംയോജിപ്പിക്കുന്ന ഓട്ടോമേഷൻ പാറ്റേണുകൾ സാധ്യമാക്കുന്നു.

മാച്ചർ സിസ്റ്റം ഹുക്കുകളെ പ്രത്യേക ടൂളുകളിലേക്കും ഫയൽ പാറ്റേണുകളിലേക്കും ഫിൽട്ടർ ചെയ്യുന്നു. എക്സിറ്റ് കോഡുകളും JSON ഔട്ട്പുട്ടും തീരുമാന ഫ്ലോ നിയന്ത്രിക്കുന്നു. Async എക്സിക്യൂഷൻ സാവധാനത്തിലുള്ള പ്രവർത്തനങ്ങളിൽ തടയുന്നത് തടയുന്നു. പൂർണ്ണമായ കൺഫിഗറേഷൻ സ്കീമ ലളിതമായ ഓട്ടോ-ഫോർമാറ്റിംഗ് മുതൽ സങ്കീർണ്ണമായ ബഹു-ഘട്ടം സാധൂകരണം വരെ എല്ലാം പിന്തുണയ്ക്കുന്നു.

കോഡ് ഫോർമാറ്റിംഗിനായി ലളിതമായ PostToolUse ഹുക്കുകളിൽ നിന്ന് ആരംഭിക്കുക. പോളിസികൾ ഉയർന്നുവരുമ്പോൾ PreToolUse സാധൂകരണം ചേർക്കുക. പെരുമാറ്റം പരിഷ്കരിക്കുന്നതിന് പ്രോംപ്റ്റ് ഹുക്കുകൾ പരീക്ഷിക്കുക. ടീം-വൈഡ് നടപ്പാക്കലിനായി HTTP സംയോജനങ്ങൾ നിർമ്മിക്കുക.

പുതിയ കഴിവുകൾ ലഭ്യമാകുമ്പോൾ പൂർണ്ണമായ ഹുക്ക്സ് റെഫറൻസിനും അപ്ഡേറ്റ് ചെയ്ത കൺഫിഗറേഷൻ സ്കീമയ്ക്കും ഔദ്യോഗിക Claude Code ഡോക്യുമെന്റേഷൻ പരിശോധിക്കുക.