סיכום מהיר: Claude Code hooks הם סקריפטים לאוטומציה המתבצעים בנקודות מחזור חיים ספציפיות במהלך סשנים של קידוד AI, המאפשרים למפתחים להריץ פקודות מותאמות אישית, לאמת פעולות, לעצב קוד, לשלוח התראות ולאכוף כללי פרויקט. הוקים אלו משתלבים עם זרימת העבודה של Claude דרך אירועים כמו SessionStart, PreToolUse ו-PostToolUse, ותומכים בתבניות ביצוע מבוססות פקודה, מבוססות HTTP ומבוססות הנחיה, עם מגבלות זמן (timeouts) ניתנות להגדרה והתנהגות קוד יציאה (exit code).
מערכת ההוקים של Claude Code הופכת את עוזר הקידוד של AI מכלי שימושי לסביבת פיתוח אוטומטית לחלוטין. רוב המפתחים לא מודעים להיקף השליטה הזמינה באמצעות הוקים.
הנה העניין – הוקים לא רק מריצים סקריפטים לאחר עריכות קבצים. הם מספקים נקודות יירוט לאורך כל תהליך קבלת ההחלטות של Claude. לפני שהוא מבצע פקודה. לאחר שקריאת כלי נכשלת. כאשר הוא זקוק להרשאה. אפילו לפני עיבוד הנחיות משתמש.
מדריך זה מכסה את כל מה שהתיעוד הרשמי מספק, בתוספת תבניות מעשיות שדיוני קהילה חושפים שעובדות בפועל בסביבות ייצור.
מה Claude Code Hooks עושים בפועל
על פי התיעוד הרשמי של 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 יכולים למנוע פעולות מסוכנות לפני ביצוען. קוד יציאה 1 חוסם את הפעולה. קוד יציאה 0 מאפשר אותה. קוד יציאה 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 בפרויקט. סכמת התצורה תומכת בהוקים גלובליים ובהתאמות (matchers) ספציפיות לכלי המסננות מתי הוקים מתבצעים.
מבנה הוק פקודה בסיסי:
| { “hooks”: [ { “event”: “PostToolUse”, “command”: “prettier –write”, “args”: [“${file}”] } ] } |
המשתנה ${file} מתרחב לנתיב הקובץ בפועל מקלט הכלי. על פי התיעוד הרשמי, הוקים תומכים בהרחבות משתנים אלה בשדות command ו-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” }סקריפטים מנתחים קלט זה כדי לקבל החלטות. הוק אימות בפייתון עשוי להיראות כך:#!/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
על פי התיעוד הרשמי של הפניות הוק, לקוד יציאה 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 שולחים מטעני JSON (payloads) לנקודות קצה מרוחקות ומנתחים תגובות לשליטה בהחלטות. הם מאפשרים שילוב עם שירותי אימות, מסדי נתונים וכלים של צד שלישי.
תצורת הוק 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 ושדות מחרוזת אחרים. משתנים מתרחבים מהסביבה בה פועל Claude Code.
על פי התיעוד הרשמי של MCP, הרחבת משתני סביבה כוללת תחביר ברירת מחדל גיבוי: ${VAR:-default} מתרחב ל-VAR אם הוא מוגדר, אחרת משתמש בערך ברירת המחדל.
אילוץ אבטחה: על פי בעיית GitHub #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. זה מאפשר יצירת הוראות מודעות להקשר בהתבסס על מצב הפרויקט.
הוקי סוכן
הוקי סוכן מציינים סוכן משנה (subagent) שמטפל באירוע במקום הזרקת הנחיה ישירה. הסוכן המשנה מקבל הקשר לגבי האירוע ויכול לבצע חשיבה רב-שלבית.
| { “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 שולט אם הפעולה ממשיכה. ההודעה מוצגת ל-Claude כהקשר. השדה suggestion מספק גישות חלופיות.
כדי שהוקים יוציאו JSON, הם חייבים:
- לכתוב JSON תקני ל-stdout
- לצאת עם קוד 0 (עבור מותר) או 1 (עבור חסום)
- לכלול לפחות את השדה הבוליאני allowed
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 עצמו. זה יוצר השלכות אבטחה עבור סביבות מרובות משתמשים ותצורות משותפות.
ארגז חול לביצוע פקודות
על פי בעיית GitHub #28044, הוקי HTTP עוברים דרך פרוקסי ארגז חול המגביל גישה לרשת ומסנן משתני סביבה. להוקי פקודה אין הגבלות כאלה – הם פועלים עם גישת shell מלאה.
התיעוד ממליץ על הפרקטיקות הבאות:
- לעולם אל תשמור אישורי גישה בפקודות הוק
- השתמש במשתני סביבה עבור נתונים רגישים
- אמת את כל הקלט מהרחבות ${…}
- הטמע מגבלות זמן עבור שירותים חיצוניים
- השתמש בהוקים אסינכרוניים עבור פעולות לא קריטיות כדי למנוע חסימה בכשלים
בידוד ביצוע הוק
הוקי רמת משתמש ב-~/.claude/settings.json חלים על כל הפרויקטים. זה יוצר סיכונים בעת עבודה בגבולות אמון שונים. הוקי רמת פרויקט דורסים הוקי משתמש אך לא יכולים לבטל אותם לחלוטין.
תפריט /hooks ב-Claude Code מציג את כל ההוקים הפעילים עבור הסשן הנוכחי. סקירת רשימה זו לפני עבודה על פרויקטים רגישים עוזרת לזהות חששות אבטחה פוטנציאליים.
ניפוי באגים ופתרון בעיות
כשלים בהוקים לא תמיד צצים בבירור בשיחת 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 חיצוניות יכולות ליצור חיכוך בזרימת העבודה. פעולות חישוב כבדות מרוויחות מביצוע אסינכרוני.
אצווה (Batching) של הוקים
הוקים מרובים יכולים להתאים לאותו אירוע. על פי התיעוד הרשמי, הוקים מבוצעים ברצף לפי סדר ההגדרה. אם הוק כלשהו חוסם את הפעולה, הוקים הנותרים לא יבוצעו.
זה חשוב לביצועים. חמישה הוקים סינכרוניים של 200ms כל אחד מוסיפים שנייה אחת לכל אירוע. שילוב אימותים קשורים להוק יחיד מפחית תקורה.
תבניות מתקדמות
מעבר לאוטומציה בסיסית, הוקים מאפשרים התאמה אישית מתקדמת של זרימת עבודה.
שרשראות הוק עם מצב (Stateful Hook Chains)
הוקים יכולים לשמר מצב בין ביצועים באמצעות קבצים או מסדי נתונים. הוק 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 יכולים ליישם אימות רב-שכבתי שבו קוד יציאה 2 מאפשר ל-Claude להמשיך עם אזהרות:
- כשלים קשים (יציאה 1): חסימת פעולות מסוכנות
- אזהרות קלות (יציאה 2): התראה ל-Claude לשקול מחדש
- מעבר עם הקשר (יציאה 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
- האם ההוק רץ באופן אסינכרוני
- מקור תצורה (פרויקט, משתמש, או פלאגין)
בחירת הוק מציגה את התצורה המלאה שלו ומאפשרת השבתה זמנית עבור הסשן הנוכחי.
השבתה או הסרה של הוקים
ניתן להשבית הוקים מבלי להסיר את התצורה על ידי הוספת `"enabled": false` להגדרת ההוק. זה משמר את התצורה תוך מניעת ביצוע.
כדי להסיר הוק לצמיתות, מחק את הפריט שלו מקובץ settings.json המתאים. שינויים נכנסים לתוקף בהפעלה מחדש של הסשן הבא או בעת הרצת /reload.
הוקים ב-Skills וב-Agents
על פי התיעוד הרשמי, הוקים המוגדרים בתצורות skill או subagent חלים רק כאשר אותו skill או agent מבוצע. זה מאפשר אוטומציה מיוחדת עבור זרימות עבודה ספציפיות.
סוכן משנה לניפוי באגים עשוי לכלול הוקים שרושמים את כל קריאות הכלים:
| { “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 script hooks): הגדרת לוגיקת הוק ישירות ב-settings.json ללא קבצים חיצוניים
- שילוב כלי MCP: הפעלת כלי שרת MCP מהוקים במקום פקודות shell
- שיתוף פעולה בין סוכנים מרובים: הוקים המתאמים בין מופעי Claude על מכונות שונות
- טיפוסיות משופרת: הגדרות סוג TypeScript עבור סכמות קלט/פלט של הוק
על פי בעיית GitHub #4274, הבקשה להוקי שילוב משולבים (כלי MCP, סקריפט בשורה, קריאת API) מכוונת לפשט את התצורה ולשפר את חווית המפתחים.
שאלות נפוצות
האם הוקים יכולים למנוע מ-Claude להריץ פקודות מסוכנות?
כן. הוקי PreToolUse יכולים לחסום כל ביצוע כלי על ידי יציאה עם קוד 1. זה כולל עריכות קבצים, ביצוע פקודות וקריאות כלי MCP. ההוק מקבל את קלט הכלי המלא ויכול לאמת מול כל קריטריון לפני מתן אישור לפעולה.
כיצד אני מנפה באגים בהוק שאינו עובד?
הפעל רישום דיבאג עם CLAUDE_DEBUG=1 לפני הפעלת Claude Code. בדוק את יומני הסשן עבור פרטי ביצוע הוק כולל אילו הוקים תאמו, קלט ה-JSON שנשלח, פלט stdout/stderr וקודי יציאה. בדוק הוקים באופן עצמאי על ידי העברת JSON לדוגמה לסקריפט ההוק.
האם הוקים עובדים עם כל פלטפורמות Claude Code?
הוקים עובדים בממשק שורת הפקודה, באפליקציית הדסקטופ ובתוסף VS Code. על פי התיעוד הרשמי, הוקים מבוצעים בכל מקום שבו Claude Code פועל עם גישה למערכת הקבצים. Claude מבוסס הדפדפן ואפליקציות מובייל אינם תומכים בהוקים עקב מגבלות ארגז חול.
האם הוקים יכולים לשנות את התגובות או ההתנהגות של Claude?
הוקי הנחיה מזריקים הוראות המשפיעות על התנהגות Claude. הוקי סוכנים מפנים את הטיפול באירועים לסוכני משנה מתמחים. עם זאת, הוקים לא יכולים לשנות ישירות את הטקסט שנוצר או תהליך החשיבה של Claude – הם עובדים על ידי אספקת הקשר וחסימת פעולות.
מה ההבדל בין הוקים אסינכרוניים לסינכרוניים?
הוקים סינכרוניים חוסמים את זרימת העבודה של Claude עד לסיום או timeout. הוקים אסינכרוניים פועלים ברקע מבלי לחסום. הוקים סינכרוניים יכולים למנוע פעולות באמצעות קודי יציאה. הוקים אסינכרוניים לא יכולים לחסום מכיוון ש-Claude ממשיך לפני שההוק מסתיים. השתמש באסינכרוני לרישום והודעות, סינכרוני לאימות.
כיצד אני משתף הוקים בצוות?
בצע commit לקובץ .claude/settings.json לניהול גרסאות. הוקי רמת פרויקט חלים על כל חברי הצוות שמשכפלים את המאגר. עבור מדיניות ארגונית, צוותים יכולים לתחזק קובץ הגדרות משותף ברמת המשתמש שחברי הצוות מעתיקים ל-~/.claude/settings.json.
האם הוקי HTTP יכולים לקרוא ל-APIs פנימיים מאחורי חומות אש?
כן, אם Claude Code פועל בסביבה עם גישה לרשת לאותם APIs. הוקי HTTP מבצעים בקשות POST סטנדרטיות מהמכונה שמריצה את Claude Code. חומות אש תאגידיות ורשתות VPN חלות כרגיל. פרוקסי ארגז החול המוזכר בתיעוד שולט בחשיפת משתני סביבה, לא ניתוב רשת.
האם הוקים מגדילים את שימוש האסימונים (tokens) של Claude Code?
הוקי הנחיה מזריקים טקסט להקשר של Claude, מה שצורק אסימונים. הוקי פקודה ו-HTTP לא משפיעים ישירות על שימוש באסימונים, אך הפלט שלהם (הודעות שגיאה, הצעות) הופך לחלק מהקשר השיחה. קוד יציאה 2 עם הודעות הסבר מוסיף יותר הקשר מקוד יציאה 1 עם חסימה פשוטה.
מסקנה
הוקי Claude Code הופכים את עוזר ה-AI מכלי רב עוצמה לפלטפורמת פיתוח אוטומטית לחלוטין. מערכת האירועים מספקת נקודות יירוט לאורך זרימת העבודה של Claude – החל מאתחול הסשן ועד דחיסת הקשר.
הוקי פקודה מטפלים באימות מקומי ועיצוב. הוקי HTTP משלבים שירותים חיצוניים ומסדי נתונים. הוקי הנחיה משנים התנהגות באמצעות הזרקת הקשר. יחד, אלו מאפשרים תבניות אוטומציה שאוכפות מדיניות צוות, שומרות על איכות קוד ומשתלבות בתשתית הפיתוח הקיימת.
מערכת ההתאמה מסננת הוקים לכלים ודפוסי קבצים ספציפיים. קודי יציאה ופלט JSON שולטים בזרימת ההחלטות. ביצוע אסינכרוני מונע חסימה בפעולות איטיות. סכמת התצורה המלאה תומכת בכל דבר, החל מעיצוב אוטומטי פשוט ועד אימות מורכב רב-שלבי.
התחל עם הוקי PostToolUse בסיסיים לעיצוב קוד. הוסף אימות PreToolUse ככל שמדיניות מתפתחת. התנסה עם הוקי הנחיה לשינוי התנהגות. בנה שילובי HTTP לאכיפה בכל הצוות.
בדוק את התיעוד הרשמי של Claude Code עבור ההפניה המלאה של הוקים וסכמת התצורה המעודכנת כאשר יכולות חדשות נשלחות.
