სწრაფი შეჯამება: Claude Code-ის ჰუკები არის ავტომატიზაციის სკრიპტები, რომლებიც ასრულებენ AI კოდირების სესიების ცხოვრების ციკლის გარკვეულ წერტილებში, რაც დეველოპერებს საშუალებას აძლევს გაუშვან მორგებული ბრძანებები, დაადასტურონ მოქმედებები, დააფორმატონ კოდი, გაგზავნონ შეტყობინებები და აღასრულონ პროექტის წესები. ეს ჰუკები ინტეგრირდება Claude-ის სამუშაო პროცესთან ისეთი მოვლენებით, როგორიცაა SessionStart, PreToolUse და PostToolUse, მხარდაჭერით ბრძანებაზე დაფუძნებული, HTTP-ზე დაფუძნებული და პრომპტზე დაფუძნებული შესრულების ნიმუშები კონფიგურირებადი დროის ლიმიტებით და გასვლის კოდის ქცევით.
Claude Code-ის ჰუკ სისტემა AI კოდირების ასისტენტს აქცევს სასარგებლო ინსტრუმენტიდან სრულად ავტომატიზირებულ დეველოპერულ გარემოში. მეტ დეველოპერს არ ესმის ჰუკების მეშვეობით კონტროლის შესაძლებლობების ფარგლები.
საქმე იმაშია, რომ ჰუკები არ არის მხოლოდ ფაილის რედაქტირების შემდეგ სკრიპტების გაშვება. ისინი უზრუნველყოფენ ჩარევის წერტილებს Claude-ის გადაწყვეტილების მიღების მთელი პროცესის განმავლობაში. სანამ ბრძანებას შეასრულებს. ინსტრუმენტის წარუმატებელი გამოძახების შემდეგ. როდესაც ნებართვა სჭირდება. მომხმარებლის პრომპტების დამუშავებამდეც კი.
ეს სახელმძღვანელო მოიცავს ყველაფერს, რასაც ოფიციალური დოკუმენტაცია უზრუნველყოფს, პლუს პრაქტიკულ ნიმუშებს, რომლებსაც საზოგადოების დისკუსიები ავლენენ, რომ რეალურად მუშაობს პროდუქციის გარემოში.
რას რეალურად აკეთებს Claude Code-ის ჰუკები
ოფიციალური Claude Code დოკუმენტაციის მიხედვით, ჰუკები არის მომხმარებლის მიერ განსაზღვრული shell ბრძანებები, HTTP ბოლო წერტილები ან პრომპტის ინექციები, რომლებიც ასრულებენ Claude Code-ის ცხოვრების ციკლის გარკვეულ წერტილებში. ისინი იღებენ სტრუქტურირებულ JSON შეყვანას stdin-ის მეშვეობით და აკონტროლებენ სამუშაო პროცესს გასვლის კოდების ან HTTP პასუხების საშუალებით.
ავტომატიზაცია უფრო ღრმად მიდის, ვიდრე უმეტეს სახელმძღვანელოებშია შემოთავაზებული. ჰუკებს შეუძლიათ მთლიანად დაბლოკონ ინსტრუმენტის შესრულება, ჩასვან დამატებითი კონტექსტი Claude-ის რეზონირებაში, გაააქტიურონ გარე სერვისები და აღასრულონ ვალიდაციის წესები, რომლებსაც Claude უნდა დაემორჩილოს.
არსებობს სამი ძირითადი ჰუკის ტიპი:
- ბრძანების ჰუკები: Shell სკრიპტები, რომლებიც კომუნიკაციას ახდენენ stdout, stderr და გასვლის კოდებით
- HTTP ჰუკები: დისტანციური ბოლო წერტილები, რომლებიც იღებენ POST მოთხოვნებს და აბრუნებენ JSON პასუხებს
- პრომპტის ჰუკები: დინამიური ინსტრუქციები, რომლებიც ჩასმულია Claude-ის კონტექსტში გარკვეულ მოვლენებზე
თითოეული ტიპი ემსახურება სხვადასხვა ავტომატიზაციის ნიმუშებს. ბრძანების ჰუკები ადგილობრივ ვალიდაციას და ფორმატირებას ახორციელებენ. HTTP ჰუკები ინტეგრირდება გარე სერვისებთან და მონაცემთა ბაზებთან. პრომპტის ჰუკები ცვლიან Claude-ის ქცევას გარე პროცესების გარეშე.
ჰუკის ცხოვრების ციკლი და მოვლენების სისტემა
ოფიციალური დოკუმენტაცია განსაზღვრავს მრავალ ჰუკის მოვლენას (SessionStart, UserPromptSubmit, PreToolUse, PermissionRequest, PostToolUse, PostToolUseFailure, Notification და სხვ.), რომლებიც ირთვება Claude Code-ის შესრულების ნაკადის დროს. იმის გაგება, თუ როდის ირთვება თითოეული, განსაზღვრავს, თუ რომელი ავტომატიზაცია ხდება შესაძლებელი.
| მოვლენა | როდის ირთვება | შეუძლია დაბლოკოს |
|---|---|---|
| SessionStart | როდესაც სესია იწყება ან გრძელდება | არა |
| UserPromptSubmit | როდესაც წარადგენთ პრომპტს, სანამ Claude დაამუშავებს მას | დიახ |
| PreToolUse | სანამ ინსტრუმენტის გამოძახება შესრულდება | დიახ |
| PermissionRequest | როდესაც ჩნდება ნებართვის დიალოგი | დიახ |
| PostToolUse | ინსტრუმენტის წარმატებით გამოძახების შემდეგ | არა |
| PostToolUseFailure | ინსტრუმენტის წარუმატებელი გამოძახების შემდეგ | არა |
| Notification | როდესაც Claude Code აგზავნის შეტყობინებას | არა |
| SubmitMessage | როდესაც Claude წარუდგენს შეტყობინებას მომხმარებელს | არა |
| ContextCompaction | როდესაც კონტექსტის ფანჯარა მიაღწევს ლიმიტებს | არა |
დაბლოკვის შესაძლებლობა ყველაზე მნიშვნელოვანია. PreToolUse ჰუკებს შეუძლიათ თავიდან აიცილონ სახიფათო ოპერაციები შესრულებამდე. Exit code 1 ბლოკავს მოქმედებას. Exit code 0 ნებას რთავს მას. Exit code 2 აიძულებს Claude-ს გადახედოს.
მაგრამ დაველოდოთ. PostToolUse ჰუკებს არ შეუძლიათ მოქმედებების გაუქმება, რადგან ინსტრუმენტი უკვე შესრულდა. ეს შეზღუდვა განსაზღვრავს, თუ როგორ იქმნება ვალიდაციის ლოგიკა. კრიტიკული შემოწმებები უნდა იყოს PreToolUse-ში. გაწმენდა და ფორმატირება უნდა იყოს PostToolUse-ში.
აირჩიეთ AI ინსტრუმენტების შეღავათები Claude Code-ის დაყენებისას
თუ მუშაობთ Claude Code-ის ჰუკებთან, შესაძლოა ასევე ირჩევდეთ სხვა AI ინსტრუმენტებს თქვენი სამუშაო პროცესის გარშემო. Get AI Perks აგროვებს სტარტაპ კრედიტებს და პროგრამულ ფასდაკლებებს AI და ღრუბლოვანი ინსტრუმენტებისთვის ერთ ადგილას. პლატფორმა მოიცავს 200+ შეთავაზებას, თითოეული შეღავათების პირობებით და განაცხადის სახელმძღვანელო მითითებებით.
ეძებთ Claude-ს ან სხვა AI ინსტრუმენტების შეღავათებს?
შეამოწმეთ Get AI Perks, რომ:
- დაათვალიეროთ Claude-ს და სხვა AI ინსტრუმენტების შეთავაზებები
- შეადაროთ შეღავათების პირობები განაცხადის დაწყებამდე
- იპოვოთ სტარტაპ ფასდაკლებები თქვენი ინსტრუმენტების მთელ წყობაში
👉 ეწვიეთ Get AI Perks-ს, რომ ნახოთ მიმდინარე AI პროგრამული უზრუნველყოფის შეღავათები.
კონფიგურაცია და ფაილის სტრუქტურა
ჰუკები განსაზღვრულია .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 ველი ემთხვევა Claude-ის ჩაშენებულ ინსტრუმენტებს, როგორიცაა edit_file, execute_command, read_file და create_directory.
საზოგადოების დისკუსიები ავლენენ, რომ მატჩერის კომბინაციები მუშაობს AND ლოგიკით. ყველა მითითებული მატჩერი უნდა ემთხვეოდეს, რომ ჰუკი შესრულდეს.
ბრძანების ჰუკები: Shell სკრიპტის ინტეგრაცია
ბრძანების ჰუკები ასრულებენ shell ბრძანებებს ან სკრიპტებს სტრუქტურირებული JSON შეყვანით. ისინი წარმოადგენენ ყველაზე გავრცელებულ ჰუკის ტიპს ადგილობრივი ავტომატიზაციისთვის.
ოფიციალური დოკუმენტაცია მიუთითებს, რომ ბრძანების ჰუკები იღებენ JSON-ს stdin-ის მეშვეობით ამ სტრუქტურით:
| { “event”: “PreToolUse”, “toolName”: “edit_file”, “toolInput”: { “path”: “src/app.ts”, “content”: “…” }, “sessionId”: “abc123”, “turnId”: “turn-456” }Scripts parse this input to make decisions. A Python validation hook might look like:#!/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) |
Exit code 0 ნებას რთავს ოპერაციას. Exit code 1 ბლოკავს მას და აჩვენებს stderr შეტყობინებას Claude-ს. Exit code 2 იწვევს სპეციალურ ქცევას მოვლენის მიხედვით.
Exit Code 2-ის ქცევა
ოფიციალური ჰუკის მითითების დოკუმენტაციის მიხედვით, exit code 2-ს აქვს მოვლენის სპეციფიკური მნიშვნელობა (PreToolUse: ბლოკავს და ითხოვს გადახედვას; UserPromptSubmit: უზრუნველყოფს კონტექსტს დაბლოკვის გარეშე; PermissionRequest: ბლოკავს ნებართვას):
- PreToolUse: ბლოკავს ინსტრუმენტს და ითხოვს Claude-ს გადახედვას stderr შეტყობინებით, როგორც კონტექსტით
- UserPromptSubmit: უზრუნველყოფს stderr გამომავალს, როგორც დამატებით კონტექსტს დაბლოკვის გარეშე
- PermissionRequest: ბლოკავს ნებართვის მინიჭებას
ეს ქმნის შუა გზას მყარ ბლოკირებასა და ნებართვას შორის. Claude იღებს უკუკავშირს იმის შესახებ, თუ რატომ შეიძლება იყოს მოქმედება პრობლემური და შეუძლია თავისი მიდგომის კორექტირება.
ასინქრონული ბრძანების ჰუკები
async: true დროშა გაშვებს ჰუკებს ფონზე, Claude-ის სამუშაო პროცესის დაბლოკვის გარეშე. ეს მნიშვნელოვანია ნელი ოპერაციებისთვის, როგორიცაა დისპეტჩერიზაციის შეტყობინებები ან მეტრიკის შეგროვება.
| { “event”: “PostToolUse”, “matcher”: { “toolName”: “execute_command” }, “command”: “./scripts/log-to-analytics.sh”, “async”: true, “timeout”: 30 } |
როდესაც ასინქრონული ჰუკი ირთვება, Claude Code იწყებს პროცესს და დაუყოვნებლივ გრძელდება. timeout ველი ადგენს მაქსიმალურ შესრულების დროს წამებში. თუ არ არის მითითებული, ასინქრონული ჰუკები იყენებენ 10-წუთიან ნაგულისხმევ დროს.
რეალური საუბარი: ასინქრონულ ჰუკებს არ შეუძლიათ ოპერაციების დაბლოკვა, რადგან ისინი სრულდება მას შემდეგ, რაც Claude გააგრძელებს. ისინი მუშაობენ ლოგირებისთვის, შეტყობინებებისთვის და გაწმენდისთვის - არა ვალიდაციისთვის.
HTTP ჰუკები: გარე სერვისის ინტეგრაცია
HTTP ჰუკები POST JSON პეილოდებს დისტანციურ ბოლო წერტილებზე და აანალიზებენ პასუხებს გადაწყვეტილების კონტროლისთვის. ისინი იძლევიან ინტეგრაციას ვალიდაციის სერვისებთან, მონაცემთა ბაზებთან და მესამე მხარის ინსტრუმენტებთან.
ძირითადი 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-ს |
| სხვა | ნებადართულია ოპერაცია | ჰუკის უკმარისობა არ ბლოკავს სამუშაო პროცესს |
პასუხის სხეულს შეიძლება ჰქონდეს message ველი, რომელსაც Claude ხედავს როგორც კონტექსტს. ეს საშუალებას აძლევს ვალიდაციის სერვისებს ახსნან, რატომ დაიბლოკა ოპერაცია.
გარემოს ცვლადის ინტერპოლაცია
HTTP ჰუკები მხარდაჭერენ ${VAR} სინტაქსს url, headers და სხვა string ველებში. ცვლადები ფართოვდებიან იმ გარემოდან, სადაც Claude Code მუშაობს.
ოფიციალური MCP დოკუმენტაციის მიხედვით, გარემოს ცვლადის გაფართოება მოიცავს ნაგულისხმევ ფოლბექ სინტაქსს: ${VAR:-default} ფართოვდება VAR-ად, თუ ის დაყენებულია, წინააღმდეგ შემთხვევაში იყენებს ნაგულისხმევ მნიშვნელობას.
უსაფრთხოების შეზღუდვა: GitHub issue #28044-ის მიხედვით, HTTP ჰუკებს შეუძლიათ მხოლოდ იმ გარემოს ცვლადებზე წვდომა, რომლებიც ექსპლიციტურად არის ჩამოთვლილი allowedEnvVars კონფიგურაციის ველში. ეს ხელს უშლის შემთხვევითი რწმუნებათა სიგელების გაჟონვას.
პრომპტის ჰუკები: კონტექსტის ინექცია
პრომპტის ჰუკები აინსტალირებენ დინამიურ ინსტრუქციებს 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 შეყვანას stdin-ის მეშვეობით და აქვეყნებს პრომპტის ტექსტს 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 } |
ასინქრონული შესრულება ხელს უშლის Claude-ის დაბლოკვას git ოპერაციების დასრულებისას. ეს ქმნის კონფიგურაციის ცვლილებების აუდიტის ჩანაწერს ხელით სტეიჯის გარეშე.
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, მათ უნდა:
- დაწერონ ვალიდური JSON stdout-ზე
- გამოვიდნენ კოდით 0 (დაშვებისთვის) ან 1 (დაბლოკვისთვის)
- მოიცავდეს მინიმუმ allowed boolean ველს
Claude Code აანალიზებს JSON-ს და იყენებს მას უკუკავშირი მარყუჟის გასაუმჯობესებლად. გასვლის კოდები მაინც განსაზღვრავენ ძირითად გადაწყვეტილებას, მაგრამ JSON უზრუნველყოფს უფრო მდიდარ კონტექსტს.
ჰუკის შეყვანის ველების მითითება
ყველა ჰუკი იღებს JSON ობიექტს stdin-ის მეშვეობით საერთო ველებით პლუს მოვლენის სპეციფიკური მონაცემებით. სრული სქემის გაგება იძლევა უფრო დახვეწილი ჰუკის ლოგიკის საშუალებას.
საერთო შეყვანის ველები
ყველა ჰუკი იღებს ამ ძირითად ველებს:
- 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 ინსტრუმენტის ჰუკები
ოფიციალური ჰუკის მითითების მიხედვით, ჰუკებს შეუძლიათ მატჩი Model Context Protocol (MCP) ინსტრუმენტებთან mcpTool მატჩერის ველის გამოყენებით. ეს საშუალებას აძლევს ჰუკის შესრულებას, როდესაც Claude იყენებს MCP სერვერების მიერ მოწოდებულ გარე ინსტრუმენტებს.
| { “event”: “PreToolUse”, “matcher”: { “mcpTool”: “database/query” }, “command”: “./scripts/validate-sql.sh” } |
mcpTool მნიშვნელობა ემთხვევა ინსტრუმენტის სახელს ფორმატში server-name/tool-name. ეს იძლევა ვალიდაციის ლოგიკას მონაცემთა ბაზის შეკითხვებისთვის, API ზარებისთვის ან სხვა გარე ოპერაციებისთვის.
GitHub-ის ფუნქციონალური მოთხოვნები მიუთითებს მზარდ ინტერესზე MCP-ის უფრო ღრმა ინტეგრაციის მიმართ, მათ შორის ჰუკების ჩათვლით, რომლებსაც შეუძლიათ MCP სერვერის შეტყობინებების შემოწმება და გარე მოვლენებზე რეაგირება.
უსაფრთხოების მოსაზრებები
ჰუკები სრულდება იგივე ნებართვებით, როგორც Claude Code თავად. ეს ქმნის უსაფრთხოების გავლენას მრავალმომხმარებლიან გარემოებში და გაზიარებულ კონფიგურაციებზე.
ბრძანების შესრულების Sandbox
GitHub issue #28044-ის მიხედვით, HTTP ჰუკები გადიან sandbox პროქსით, რომელიც ზღუდავს ქსელის წვდომას და ფილტრავს გარემოს ცვლადებს. ბრძანების ჰუკებს არ აქვთ ასეთი შეზღუდვები - ისინი მუშაობენ სრული shell წვდომით.
დოკუმენტაცია გირჩევთ ამ პრაქტიკებს:
- არასოდეს შეინახოთ რწმუნებათა სიგელები ჰუკის ბრძანებებში
- გამოიყენეთ გარემოს ცვლადები მგრძნობიარე მონაცემებისთვის
- დაადასტუროთ ყველა შეყვანა ${…} გაფართოებიდან
- დააყენეთ დროის ლიმიტები გარე სერვისებისთვის
- გამოიყენეთ async ჰუკები არაკრიტიკული ოპერაციებისთვის, რათა თავიდან აიცილოთ უკმარისობისას დაბლოკვა
ჰუკის შესრულების იზოლაცია
მომხმარებლის დონის ჰუკები ~/.claude/settings.json-ში ვრცელდება ყველა პროექტზე. ეს ქმნის რისკებს სხვადასხვა ნდობის საზღვრებს შორის მუშაობისას. პროექტის დონის ჰუკები აბათილებენ მომხმარებლის ჰუკებს, მაგრამ ვერ ახერხებენ მათ სრულად გამორთვას.
Claude Code-ის /hooks მენიუ აჩვენებს ყველა აქტიურ ჰუკს მიმდინარე სესიისთვის. ამ სიის დათვალიერება მგრძნობიარე პროექტებზე მუშაობის დაწყებამდე გვეხმარება პოტენციური უსაფრთხოების პრობლემების იდენტიფიცირებაში.
გამოვლენა და პრობლემების მოგვარება
ჰუკის უკმარისობები ყოველთვის არ ჩანს ნათლად Claude-ის საუბარში. ოფიციალური დოკუმენტაცია გთავაზობთ რამდენიმე დიაგნოსტიკურ მიდგომას.
ჰუკის შესრულების ლოგები
Claude Code აღრიცხავს ჰუკის შესრულებას სესიის დიაგნოსტიკურ გამომავალში. პრობლემების მოგვარების სახელმძღვანელოს მიხედვით, დიაგნოსტიკური ლოგირების ჩართვა ავლენს:
- რომელი ჰუკები ემთხვეოდა თითოეულ მოვლენას
- JSON შეყვანა, რომელიც გაგზავნილი იყო თითოეულ ჰუკზე
- stdout და stderr გამომავალი ჰუკის პროცესებიდან
- გასვლის კოდები და შესრულების დრო
- HTTP პასუხის კოდები და სხეულები HTTP ჰუკებისთვის
ჩართეთ დიაგნოსტიკური ლოგირება CLAUDE_DEBUG=1-ის დაყენებით გარემოში Claude Code-ის დაწყებამდე.
ჰუკების დამოუკიდებლად ტესტირება
ბრძანების ჰუკები შეიძლება შემოწმდეს Claude Code-ის გარეთ, ხელით JSON შეყვანის აგებით:
| 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 ზარებს შეუძლიათ სამუშაო პროცესის ხახუნის შექმნა. მძიმე გამოთვლითი ოპერაციები სარგებლობენ ასინქრონული შესრულებით.
ჰუკის დაჯგუფება
მრავალი ჰუკი შეიძლება ემთხვეოდეს ერთსა და იმავე მოვლენას. მითითების დოკუმენტაციის მიხედვით, ჰუკები სრულდება თანმიმდევრულად განმარტების წესით. თუ რომელიმე ჰუკი ბლოკავს ოპერაციას, დარჩენილი ჰუკები არ სრულდება.
ეს მნიშვნელოვანია შესრულებისთვის. ხუთი სინქრონული ჰუკი 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 დროშა აქტივირებს პირობით ვალიდაციის ლოგიკას ჰუკის სკრიპტებში. ეს უზრუნველყოფს, რომ ავტომატური სესიები დაიცვას უფრო მკაცრი წესები, ვიდრე ინტერაქტიული დეველოპმენტი.
აუდიტის ჩანაწერის გენერაცია
PostToolUse ჰუკები CI გარემოში ქმნიან Claude-ის ყველა ოპერაციის დეტალურ აუდიტის ლოგებს:
| { “event”: “PostToolUse”, “command”: “./scripts/log-to-database.sh”, “async”: true } |
ფონური ლოგირება არ ახდენს გავლენას შესრულებაზე, მაგრამ უზრუნველყოფს სრულ ოპერაციულ ისტორიას შესაბამისობისა და დიაგნოსტიკისთვის.
/hooks მენიუ
Claude Code უზრუნველყოფს /hooks ბრძანებას, რომელიც აჩვენებს ყველა აქტიურ ჰუკს მიმდინარე სესიისთვის. ოფიციალური დოკუმენტაციის მიხედვით, ეს მენიუ აჩვენებს:
- ჰუკის მოვლენის ტიპი
- მატჩერის ნიმუშები
- ბრძანება ან URL ბოლო წერტილი
- არის თუ არა ჰუკი async
- კონფიგურაციის წყარო (პროექტი, მომხმარებელი ან დანამატი)
ჰუკის არჩევა აჩვენებს მის სრულ კონფიგურაციას და იძლევა დროებით გამორთვის საშუალებას მიმდინარე სესიისთვის.
ჰუკების გამორთვა ან წაშლა
ჰუკები შეიძლება გამორთოთ კონფიგურაციის წაშლის გარეშე, თუ დაამატებთ "enabled": false ჰუკის განმარტებას. ეს ინახავს კონფიგურაციას, ხოლო ბლოკავს შესრულებას.
ჰუკის სამუდამოდ წასაშლელად, წაშალეთ მისი ჩანაწერი შესაბამისი settings.json ფაილიდან. ცვლილებები ძალაში შედის შემდეგ სესიის გადატვირთვაზე ან /reload-ის გაშვებისას.
ჰუკები უნარებში და აგენტებში
ოფიციალური დოკუმენტაციის მიხედვით, უნარ ან ქვე-აჟენტის კონფიგურაციებში განსაზღვრული ჰუკები მოქმედებს მხოლოდ მაშინ, როდესაც ეს უნარი ან აგენტი სრულდება. ეს იძლევა სპეციალიზებულ ავტომატიზაციას კონკრეტული სამუშაო პროცესებისთვის.
გამოვლენის ქვე-აჟენტს შეიძლება ჰქონდეს ჰუკები, რომლებიც აღრიცხავს ყველა ინსტრუმენტის ზარს:
| { “name”: “debugger”, “hooks”: [ { “event”: “PostToolUse”, “command”: “./scripts/log-debug.sh”, “async”: true } ] } |
ეს ჰუკები ირთვება მხოლოდ debugger აჟენტის სესიების დროს, ნორმალური 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
- დაამატეთ შეცდომის დამუშავება set -e-ით bash სკრიპტებში
ჰუკის მომავალი შესაძლებლობები
GitHub-ის ფუნქციონალური მოთხოვნები ავლენს დაგეგმილ და მოთხოვნილ ჰუკის გაუმჯობესებებს:
- Inline სკრიპტის ჰუკები: განსაზღვრეთ ჰუკის ლოგიკა პირდაპირ settings.json-ში გარე ფაილების გარეშე
- MCP ინსტრუმენტის ინტეგრაცია: გამოიძახეთ MCP სერვერის ინსტრუმენტები ჰუკებიდან shell ბრძანებების ნაცვლად
- მრავალ-აჟენტის თანამშრომლობა: ჰუკები, რომლებიც კოორდინაციას უწევენ Claude ინსტანციებს შორის სხვადასხვა მანქანებზე
- გაძლიერებული ტიპიზაცია: TypeScript ტიპის განმარტებები ჰუკის შეყვანის/გამომავალი სქემებისთვის
GitHub issue #4274-ის მიხედვით, ინტეგრირებული ჰუკის ტიპების (MCP ინსტრუმენტი, inline სკრიპტი, API ზარი) მოთხოვნა მიზნად ისახავს კონფიგურაციის გამარტივებას და დეველოპერის გამოცდილების გაუმჯობესებას.
ხშირად დასმული კითხვები
შეუძლიათ თუ არა ჰუკებს ხელი შეუშალონ Claude-ს სახიფათო ბრძანებების შესრულებაში?
დიახ. PreToolUse ჰუკებს შეუძლიათ დაბლოკონ ნებისმიერი ინსტრუმენტის შესრულება კოდით 1-ით გამოსვლით. ეს მოიცავს ფაილის რედაქტირებას, ბრძანების შესრულებას და MCP ინსტრუმენტის ზარებს. ჰუკი იღებს სრულ ინსტრუმენტულ შეყვანას და შეუძლია დაადასტუროს ნებისმიერი კრიტერიუმის წინააღმდეგ, სანამ ოპერაციას დაუშვებს.
როგორ უნდა გამოვავლინო ჰუკი, რომელიც არ მუშაობს?
ჩართეთ დიაგნოსტიკური ლოგირება CLAUDE_DEBUG=1-ით Claude Code-ის დაწყებამდე. შეამოწმეთ სესიის ლოგები ჰუკის შესრულების დეტალებისთვის, მათ შორის, რომელი ჰუკები ემთხვეოდა, გაგზავნილი JSON შეყვანა, stdout/stderr გამომავალი და გასვლის კოდები. შეამოწმეთ ჰუკები დამოუკიდებლად, ნიმუშის JSON-ის ჰუკის სკრიპტზე გადატანით.
მუშაობს თუ არა ჰუკები Claude Code-ის ყველა პლატფორმაზე?
ჰუკები მუშაობენ CLI-ში, დესკტოპის აპლიკაციაში და VS Code დანამატში. ოფიციალური დოკუმენტაციის მიხედვით, ჰუკები სრულდება იქ, სადაც Claude Code მუშაობს ფაილურ სისტემაზე წვდომით. ბრაუზერზე დაფუძნებული Claude და მობილური აპლიკაციები არ უჭერენ მხარს ჰუკებს sandbox შეზღუდვების გამო.
შეუძლიათ თუ არა ჰუკებს Claude-ს პასუხების ან ქცევის შეცვლა?
პრომპტის ჰუკები აინსტალირებენ ინსტრუქციებს, რომლებიც გავლენას ახდენენ Claude-ის ქცევაზე. აჟენტის ჰუკები გადასცემენ მოვლენის დამუშავებას სპეციალიზებულ ქვე-აჟენტებს. თუმცა, ჰუკებს არ შეუძლიათ პირდაპირ შეცვალონ Claude-ის გენერირებული ტექსტი ან რეზონირების პროცესი - ისინი მუშაობენ კონტექსტის მიწოდებით და ოპერაციების დაბლოკვით.
რა არის განსხვავება async და sync ჰუკებს შორის?
სინქრონული ჰუკები ბლოკავს Claude-ის სამუშაო პროცესს დასრულებამდე ან დროის ამოწურვამდე. ასინქრონული ჰუკები მუშაობენ ფონზე დაბლოკვის გარეშე. Sync ჰუკებს შეუძლიათ თავიდან აიცილონ ოპერაციები გასვლის კოდებით. Async ჰუკებს არ შეუძლიათ დაბლოკვა, რადგან Claude გრძელდება ჰუკის დასრულებამდე. გამოიყენეთ async ლოგირებისთვის და შეტყობინებებისთვის, sync ვალიდაციისთვის.
როგორ გავაზიარო ჰუკები გუნდის მასშტაბით?
.claude/settings.json ფაილი გადაიტანეთ ვერსიის კონტროლში. პროექტის დონის ჰუკები ვრცელდება ყველა გუნდის წევრზე, ვინც კლონავს საცავს. ორგანიზაციის ფართომასშტაბიანი პოლიტიკებისთვის, გუნდებს შეუძლიათ შეინახონ საერთო მომხმარებლის დონის პარამეტრების ფაილი, რომელსაც წევრები კოპირებენ ~/.claude/settings.json-ში.
შეუძლიათ თუ არა HTTP ჰუკებს შიდა API-ების გამოძახება Firewall-ის მიღმა?
დიახ, თუ Claude Code მუშაობს გარემოში, რომელსაც აქვს ქსელის წვდომა ამ API-ებთან. HTTP ჰუკები აგზავნიან სტანდარტულ POST მოთხოვნებს Claude Code-ის მართვის მანქანიდან. კორპორატიული Firewall-ები და VPN-ები ნორმალურად ვრცელდება. sandbox პროქსი, რომელიც მოხსენიებულია დოკუმენტაციაში, აკონტროლებს გარემოს ცვლადების ექსპოზიციას, ქსელის მარშრუტიზაციას არა.
ზრდის თუ არა ჰუკები Claude Code-ის ტოკენის გამოყენებას?
პრომპტის ჰუკები აინსტალირებენ ტექსტს Claude-ის კონტექსტში, რაც მოიხმარს ტოკენებს. ბრძანების და HTTP ჰუკები არ ახდენენ პირდაპირ გავლენას ტოკენის გამოყენებაზე, მაგრამ მათი გამომავალი (შეცდომის შეტყობინებები, წინადადებები) ხდება საუბრის კონტექსტის ნაწილი. Exit code 2, განმარტებითი შეტყობინებებით, უზრუნველყოფს უფრო მეტ კონტექსტს, ვიდრე exit code 1, მარტივი დაბლოკვით.
დასკვნა
Claude Code-ის ჰუკები AI ასისტენტს აქცევს ძლიერი ინსტრუმენტიდან სრულად ავტომატიზებულ დეველოპერულ პლატფორმად. მოვლენების სისტემა უზრუნველყოფს ჩარევის წერტილებს Claude-ის სამუშაო პროცესის მთელ მანძილზე - სესიის ინიციალიზაციიდან კონტექსტის კომპაქციამდე.
ბრძანების ჰუკები მართავენ ადგილობრივ ვალიდაციას და ფორმატირებას. HTTP ჰუკები აერთიანებენ გარე სერვისებსა და მონაცემთა ბაზებს. პრომპტის ჰუკები ცვლიან ქცევას კონტექსტის ინექციის გზით. ერთობლივად, ეს იძლევა ავტომატიზაციის ნიმუშებს, რომლებიც აღასრულებენ გუნდის პოლიტიკებს, ინარჩუნებენ კოდის ხარისხს და ინტეგრირდება არსებულ დეველოპერულ ინფრასტრუქტურასთან.
მატჩერის სისტემა ფილტრავს ჰუკებს კონკრეტულ ინსტრუმენტებთან და ფაილის ნიმუშებთან. გასვლის კოდები და JSON გამომავალი აკონტროლებენ გადაწყვეტილების ნაკადს. ასინქრონული შესრულება ხელს უშლის ნელი ოპერაციების დაბლოკვას. სრული კონფიგურაციის სქემა მხარდაჭერას უწევს ყველაფერს, მარტივი ავტომატური ფორმატირებიდან დაწყებული, კომპლექსურ მრავალსაფეხურიან ვალიდაციამდე.
დაიწყეთ ძირითადი PostToolUse ჰუკებით კოდის ფორმატირებისთვის. დაამატეთ PreToolUse ვალიდაცია პოლიტიკების წარმოშობისას. ექსპერიმენტი გააკეთეთ პრომპტის ჰუკებით ქცევის მოდიფიკაციისთვის. ააგეთ HTTP ინტეგრაციები გუნდის მასშტაბური აღსრულებისთვის.
შეამოწმეთ ოფიციალური Claude Code დოკუმენტაცია ჰუკის სრული მითითებისთვის და განახლებული კონფიგურაციის სქემისთვის, ახალი შესაძლებლობების გამოშვებისას.
