Claude Code Hooks: คู่มือเชิงปฏิบัติสำหรับการทำงานอัตโนมัติของเวิร์กโฟลว์

เมื่อทำงานกับ Claude Code คุณจะเจอปัญหาคล้ายกันบ่อยๆ: มันเขียนโค้ดได้ดีแต่ลืมขั้นตอนสำคัญอย่างการจัดรูปแบบโค้ด รันเทสต์ หรือปฏิบัติตามโปรโตคอลด้านความปลอดภัย จนต้องคอยเตือนซ้ำแล้วซ้ำเล่า Claude Code Hooks ช่วยทำการเตือนเหล่านี้แบบอัตโนมัติโดยรันคำสั่งเชลล์ให้เองในจุดต่างๆ ของเวิร์กโฟลว์

ในบทเรียนนี้ เราจะตั้งค่า hooks สำหรับการจัดรูปแบบโค้ด การรันเทสต์ การแจ้งเตือน และการป้องกันไฟล์ คุณจะสร้างระบบอัตโนมัติที่บังคับใช้มาตรฐานการพัฒนาของทีมได้โดยไม่ต้องลงมือเอง

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ Claude Code ดูได้ที่คู่มือ แนวปฏิบัติที่ดีที่สุดของ Claude Code และบทเรียน Claude Skills หากอยากตั้งค่าคำแนะนำระดับโปรเจกต์ โปรดดูคู่มือ การเขียน CLAUDE.md

TL;DR

• Claude Code Hooks คือคำสั่งเชลล์ที่รันอัตโนมัติในช่วงเวลาที่กำหนดของวงจรการทำงานของ Claude Code (ก่อน/หลังเรียกใช้เครื่องมือ ตอนเริ่มเซสชัน เมื่อตอน Claude หยุด)

• ตั้งค่าใน .claude/settings.json (ระดับโปรเจกต์) หรือ ~/.claude/settings.json (ระดับทั่วระบบ) โดยใช้ JSON ที่ระบุ event, matcher และ command

• ใช้ PreToolUse เพื่อบล็อกการทำงานที่อันตรายก่อนเกิดขึ้น (รหัสออก 2 = บล็อก)

• ใช้ PostToolUse สำหรับงานเก็บกวาด เช่น จัดรูปแบบโค้ด ลินต์ หรือรันเทสต์หลัง Claude เขียนโค้ด

• Hooks รับคอนเท็กซ์แบบ JSON ผ่าน stdin และสื่อสารผลลัพธ์ผ่าน exit code, stdout และ stderr

Claude Code Hooks คืออะไร?

Claude Code Hooks คือคำสั่งเชลล์ที่รันอัตโนมัติเมื่อเกิดเหตุการณ์เฉพาะระหว่างการโค้ดกับ AI ลองนึกถึงมันเป็นทริกเกอร์อัตโนมัติที่เรียกสคริปต์ของคุณในจังหวะที่แม่นยำ—ก่อน Claude จะเขียนไฟล์ หลังจากรันคำสั่ง หรือเมื่อต้องส่งการแจ้งเตือนถึงคุณ

ระบบทำงานด้วยการเฝ้าดูการกระทำของ Claude Code และจับคู่กับกฎที่กำหนดไว้ในไฟล์คอนฟิก เมื่อเกิดการแมตช์ คำสั่งที่ระบุจะถูกรันพร้อมเข้าถึงคอนเท็กซ์ของสิ่งที่เพิ่งเกิดขึ้น ทำให้ควบคุมพฤติกรรมของ Claude ได้ และทำงานซ้ำๆ แบบที่ปกติต้องทำเองให้เป็นอัตโนมัติ

ตัวอย่าง hook พื้นฐานที่รันตัวจัดรูปแบบโค้ดทุกครั้งที่ Claude เขียนไฟล์ Python:

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

โครงสร้างของ hook นี้มีสามส่วน:

• เหตุการณ์: PostToolUse (หลัง Claude ทำงานเสร็จ)

• ตัวจับคู่: Write (เฉพาะตอนเขียนไฟล์)

• คำสั่ง: python -m black . (จัดรูปแบบไฟล์ Python ในไดเรกทอรีปัจจุบัน)

Hook จะได้รับข้อมูลละเอียดเกี่ยวกับสิ่งที่ Claude เพิ่งทำผ่านข้อมูล JSON ที่ส่งเข้าอินพุตของสคริปต์ จึงสามารถสร้างระบบอัตโนมัติขั้นสูงที่ตอบสนองต่อการเปลี่ยนแปลงไฟล์เฉพาะได้

หากต้องการต่อยอดระบบอัตโนมัติของ Claude Code ดูบทเรียน Claude Code Routines ที่สอนการตั้งเวลารัน hooks และเอเจนต์แบบเป็นรอบๆ บนคลาวด์

มาดูวิธีสร้าง hooks ตั้งแต่เริ่มต้นและลงทะเบียนใน Claude Code กัน

สิ่งที่ต้องมีล่วงหน้า

ก่อนเริ่มต้น ควรเตรียมสิ่งต่อไปนี้:

• ติดตั้งและใช้งาน Claude Code แล้ว: ควรคุ้นเคยกับการใช้ Claude Code สำหรับงานโค้ดพื้นฐาน

• คุ้นเคยกับบรรทัดคำสั่ง: Hooks รันคำสั่งเชลล์ จึงควรรู้การเขียนคำสั่งเทอร์มินัลพื้นฐานของระบบปฏิบัติการที่ใช้

• โปรแกรมแก้ไขข้อความ: จะต้องแก้ไขไฟล์คอนฟิก JSON เพื่อกำหนดค่า hooks

• ไดเรกทอรีโปรเจกต์: โปรเจกต์สำหรับทดสอบ hooks อย่างปลอดภัยโดยไม่กระทบงานสำคัญ

ไม่จำเป็นต้องเชี่ยวชาญเชลล์สคริปต์ แต่การเข้าใจคำสั่งอย่าง ls, cd และการจัดการไฟล์พื้นฐานจะช่วยให้ตามตัวอย่างได้ง่ายขึ้น หากเพิ่งเริ่มต้นกับ bash หรือเทอร์มินัล แนะนำคอร์ส Introduction to Shell ของเรา

เริ่มต้นใช้งาน Claude Code Hooks

เมื่อเข้าใจว่า hook คืออะไรแล้ว มาตั้งค่าอัตโนมัติชุดแรก ขั้นตอนคือเลือก event ที่เหมาะกับความต้องการ กำหนดกฎง่ายๆ และทดสอบด้วยคำสั่งพื้นฐาน

ทำความเข้าใจเหตุการณ์ของ hook

Claude Code มี hook events มากกว่า 25 รายการ ตารางด้านล่างครอบคลุม 10 รายการที่ใช้บ่อยที่สุด สำหรับรายการทั้งหมด โปรดดูเอกสารอ้างอิง hooks อย่างเป็นทางการ

PreToolUse และ PostToolUse เป็น event ที่พบบ่อยที่สุด PreToolUse จะรันก่อน Claude ทำงาน เช่น เขียนไฟล์หรือรันคำสั่ง เหมาะสำหรับการตรวจสอบหรือบล็อกการทำงานที่เสี่ยง ส่วน PostToolUse จะรันหลัง Claude ทำงานเสร็จ เหมาะกับงานเก็บกวาดอย่างจัดรูปแบบโค้ดหรือรันเทสต์

UserPromptSubmit ทริกเกอร์เมื่อส่งพรอมป์ตให้ Claude ก่อนเริ่มประมวลผล ใช้เพื่อเพิ่มคอนเท็กซ์ให้บทสนทนา หรือยืนยันว่าพรอมป์ตตรงตามข้อกำหนด

Notification จะรันเมื่อ Claude ส่งการเตือน เช่น ขออนุญาตรันคำสั่งหรือขอข้อมูลจากคุณ ส่วน PermissionRequest ทริกเกอร์เมื่อมีไดอะล็อกขอสิทธิ์ ช่วยให้อนุมัติหรือปฏิเสธแทนผู้ใช้ได้อัตโนมัติ

Stop และ SubagentStop ทริกเกอร์เมื่อ Claude ตอบเสร็จ เหมาะสำหรับการตรวจสอบขั้นท้ายหรือสร้างรายงาน ความต่างคือ Stop จะยิงเมื่อการตอบโดยรวมของ Claude เสร็จ ส่วน SubagentStop จะยิงเมื่อผู้ช่วยที่ถูกสปอนโดยเครื่องมือ (“ซับเอเจนต์”) ทำงานเสร็จ

อีเวนต์ที่เหลืออย่าง PreCompact, SessionStart, และ SessionEnd จัดการสถานการณ์ตามวงจรอายุการใช้งาน PreCompact จะรันก่อน Claude จะย่อประวัติการสนทนา ‘SessionStart’ ยิงตอนเริ่มเซสชันใหม่เพื่อเซ็ตดีฟอลต์ และ SessionEnd ทริกเกอร์เมื่อตอนปิดเซสชัน เพื่อให้ทำความสะอาดหรือสรุปรายงานตอนจบeporting.

ทำความเข้าใจ matchers

Matcher คือฟิลเตอร์ที่ตัดสินว่าการกระทำใดของ Claude Code จะทริกเกอร์ hook โดยเทคนิคแล้ว เป็นสตริงที่ตีความเป็นเรกูลาร์เอ็กซ์เพรสชัน จึงใช้ได้ทั้งการแมตช์ตรงตัวหรือแพทเทิร์นที่ยืดหยุ่น

Matcher ที่เกี่ยวข้องที่สุดมักเป็นแบบง่าย เช่น Write (ยิงเมื่อ Claude เขียนไฟล์) หรือ Edit (ยิงเมื่อแก้ไขเนื้อหา) รวมถึงการผสมอย่าง Edit|Write เพื่อครอบคลุมหลายการกระทำ

ยังใช้แพทเทิร์นขึ้นต้นอย่าง Notebook.* เพื่อแมตช์ทุกเครื่องมือที่ขึ้นต้นด้วย “Notebook” ได้ หากอยากให้ hook ยิงทุกการกระทำ ให้ใช้เรกูลาร์เอ็กซ์เพรสชันสากล .* สตริงว่าง ("") หรือเว้น matcher เปล่าไว้

เนื่องจาก matcher แยกแยะตัวพิมพ์เล็ก-ใหญ่ และทำงานเฉพาะกับชื่อการกระทำ ควรเจาะจงให้มากที่สุด เมื่อจำเป็นต้องควบคุมละเอียดกว่าเดิม (เช่น จำกัดเฉพาะไฟล์บางชนิด) ให้อ่านเพย์โหลด JSON ที่ Claude ส่งเข้า hook แล้วใช้เรกูลาร์เอ็กซ์เพรสชันหรือเงื่อนไขของคุณเอง

สร้าง hook แรกใน Claude Code

Claude Code มีสองวิธีในการตั้งค่า hooks: ผ่านคำสั่งแบบโต้ตอบ /hooks หรือแก้ไขไฟล์คอนฟิกโดยตรง เราจะเริ่มจากวิธีโต้ตอบซึ่งเป็นมิตรกับผู้เริ่มต้นกว่า

การใช้คำสั่ง /hooks:

1. เปิด Claude Code และพิมพ์ /hooks ในอินเทอร์เฟซแชต

2. เลือก event ที่ต้องการ (ตัวอย่างนี้ให้เลือก PostToolUse)

3. เลือก "Add new hook" จากเมนู

4. ตั้งค่า matcher (ใส่ Write เพื่อจับการเขียนไฟล์)

5. ใส่คำสั่งของคุณ:

• Mac: say "Task complete"

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

• Linux: spd-say "Task complete"

6. บันทึกคอนฟิกแล้วกลับไปที่ Claude Code โดยกด Esc สามครั้ง

คำสั่ง /hooks จะอัปเดตไฟล์ตั้งค่าและรีโหลดคอนฟิกให้อัตโนมัติ ยังสามารถใช้ /hooks ได้ทุกเมื่อเพื่อดู hooks ที่มีอยู่หรือแก้ไข

หากชอบแก้ไขไฟล์คอนฟิกโดยตรง hooks จะอยู่ที่ ~/.claude/settings.json สำหรับการตั้งค่าทั่วระบบ, .claude/settings.json ภายในไดเรกทอรีโปรเจกต์ (คอมมิตเข้ารีโปเพื่อแชร์ hooks กับทีม) หรือ .claude/settings.local.json สำหรับ hooks ส่วนตัวที่ถูกเพิ่มใน .gitignore ตามค่าเริ่มต้น สำหรับตัวอย่างด้านบน ไฟล์จะเป็นดังนี้:

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

หลังแก้ไขไฟล์ด้วยตนเอง ให้รีสตาร์ท Claude Code หรือใช้คำสั่ง /hooks เพื่อรีโหลดคอนฟิก ตอนนี้ทุกครั้งที่ Claude เขียนไฟล์ คุณจะได้ยินเสียงแจ้งเตือน

ทดสอบ hook ของคุณ

ก่อนเดินหน้าต่อ ให้ตรวจสอบว่า hook ทำงานจริง:

1. ขอให้ Claude เขียนไฟล์ Python ใดๆ (เช่น "Create a hello.py file that prints hello world")

2. ควรได้ยินเสียงแจ้งเตือนเมื่อ Claude เขียนไฟล์เสร็จ

3. หากไม่ยินอะไร ให้เปิดทรานสคริปต์ของ Claude Code โดยกด Ctrl-O เพื่อดูข้อความผิดพลาด

4. ปัญหาที่พบบ่อย ได้แก่ คำสั่ง hook หาไม่พบ สิทธิ์ไฟล์ไม่ถูกต้อง หรือไวยากรณ์ในไฟล์คอนฟิกผิดพลาด

การทดสอบพื้นฐานนี้จะช่วยประหยัดเวลาดีบักเมื่อสร้าง hooks ที่ซับซ้อนขึ้น หากเพิ่งแก้ไฟล์ตั้งค่าเอง เปลี่ยน matcher หรือ event หรือเพิ่งติดตั้งเครื่องมือใหม่ที่อยากใช้ในคำสั่ง hook ควรเปิด /hooks อีกครั้งหรือรีสตาร์ท Claude เพื่อรีโหลดคอนฟิก

รูปแบบพื้นฐาน (event, matcher, command) นี้เป็นรากฐานของระบบอัตโนมัติด้วย hook ทั้งหมด คุณสามารถขยายด้วยการเพิ่มหลายคำสั่งให้รันพร้อมกันเมื่อ event เดียวกันถูกทริกเกอร์ เช่น อยากให้ทั้งเล่นเสียงและสร้างแบ็กอัปเมื่อ Claude เขียนไฟล์

ยังสามารถสร้าง matcher แยกสำหรับเครื่องมือภายใน event เดียวกัน เพื่อให้การเขียนไฟล์กระตุ้นการทำงานต่างจากการแก้ไขโค้ด Hooks ที่แมตช์แพทเทิร์นเครื่องมือเดียวกันจะรันขนานกัน หากกำหนด matcher หลายรายการใน event เดียว แต่ละ hook จะรันเมื่อ matcher ของตนถูกทริกเกอร์

การทำงานกับอินพุตของ Hook

เมื่อ Claude Code ทริกเกอร์ hook จะส่งข้อมูลเกี่ยวกับสิ่งที่เพิ่งเกิดขึ้นผ่าน standard input (stdin) ซึ่งเป็นสตรีมข้อมูลที่ไหลเข้าสู่คำสั่งของคุณโดยตรงตอนรัน ข้อมูลนี้ทำให้ hook ทรงพลังกว่าสคริปต์ที่รันแบบสุ่มเวลา

Claude Code จัดแพ็กข้อมูลนี้เป็น JSON แล้วป้อนให้คำสั่งที่ตั้งค่าไว้ ไม่ว่าจะเป็นคำสั่งเทอร์มินัลง่ายๆ หรือสคริปต์ของคุณเอง

โครงสร้างของอินพุต hook

ทุก hook จะได้รับอ็อบเจ็กต์ JSON พร้อมฟิลด์พื้นฐานของเซสชันปัจจุบัน:

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

อธิบายแต่ละส่วน:

• session_id: ระบุเซสชันการสนทนาปัจจุบัน

• transcript_path: ชี้ไปยังประวัติการสนทนา

• cwd: โชว์ไดเรกทอรีที่ทำงานอยู่

• hook_event_name: บอกว่า event ใดถูกยิง

คอนเท็กซ์นี้ช่วยให้ hook ตัดสินใจได้อย่างชาญฉลาด: ติดตามได้ว่าเซสชันใดทริกเกอร์การทำงาน เข้าถึงประวัติการแชตทั้งหมดหากต้องการ หรือรันคำสั่งในไดเรกทอรีที่ถูกต้อง

ความแตกต่างของอินพุตตาม event

อีเวนต์ของเครื่องมืออย่าง PreToolUse และ PostToolUse จะมีรายละเอียดเพิ่มเติมเกี่ยวกับการกระทำ ซึ่งเป็นจุดที่ hooks มีประโยชน์สำหรับระบบอัตโนมัติ ใน PreToolUse จะมี tool_input และใน PostToolUse จะมี tool_response เพิ่มเติม:

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

ในอินพุตของ hook, file_path แสดงพาธของไฟล์ที่กำลังถูกเขียนหรือแก้ไข ส่วน content คือข้อความที่เครื่องมือกำลังจะเขียน หลังรันเสร็จ การตอบกลับของเครื่องมือจะสะท้อน filePath (สังเกตตัวสะกดแบบ camelCase) เพื่อยืนยันว่าแตะไฟล์ใดจริง พร้อมแฟล็ก success ว่าการทำงานสำเร็จหรือไม่

ข้อมูลละเอียดนี้ทำให้ hook ตอบสนองต่างกันได้ตามสิ่งที่เกิดขึ้นจริง เช่น จัดรูปแบบเฉพาะไฟล์ Python สำรองเฉพาะไดเรกทอรีสำคัญ หรือแจ้งเตือนเมื่อแก้ไขไฟล์ชนิดที่กำหนด

เหตุการณ์อย่าง UserPromptSubmit จะง่ายกว่าเพราะไม่เกี่ยวกับเครื่องมือ:

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

โปรดทราบว่า UserPromptSubmit ไม่มีการใช้ matcher ในคอนฟิก เพราะทริกเกอร์จากทุกพรอมป์ต ไม่ใช่จากการทำงานของเครื่องมือ จึงเหมาะสำหรับการล็อกบทสนทนา เพิ่มคอนเท็กซ์โปรเจกต์อัตโนมัติ หรือยืนยันพรอมป์ตก่อน Claude จะประมวลผล

การอ่านอินพุตของ hook ในทางปฏิบัติ

มาสร้าง hook ที่ล็อกทุกพรอมป์ตของผู้ใช้ เพื่อแก้ปัญหาจำไม่ได้ว่าเคยสั่ง Claude ทำอะไร โดยเฉพาะในเซสชันยาวๆ เริ่มจากคอนฟิกของ hook:

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

จากนั้นสร้างสคริปต์ Python ที่ ~/.claude/log_prompts.py ด้วยเนื้อหาดังนี้:

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

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

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

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

สคริปต์อ่านข้อมูล JSON ที่ Claude Code ส่งมา แล้วล็อกพรอมป์ตร่วมกับคอนเท็กซ์ของเซสชัน สร้างประวัติที่ค้นหาได้ซึ่งมีประโยชน์มากเมื่ออยากย้อนดูวิธีแก้ปัญหาหลังผ่านไปหลายสัปดาห์

การทำงานกับเอาต์พุตของ Hook

หลังคำสั่งของ hook รันเสร็จ ต้องบอก Claude Code ว่าเกิดอะไรขึ้นและควรไปต่อปกติหรือไม่ กลไกควบคุมนี้ทำให้ hook ไม่ใช่แค่เครื่องมือล็อก แต่เป็นระบบอัตโนมัติของเวิร์กโฟลว์ที่ชี้นำพฤติกรรมของ Claude ได้ โดยสื่อสารผ่านสามช่องทาง: standard output (stdout), standard error (stderr) และ exit code

ช่องทางเอาต์พุตและ exit code

Standard output (stdout) คือเอาต์พุตปกติ เช่น สิ่งที่พิมพ์ออกไปจะไปที่ stdout สำหรับ hooks ส่วนใหญ่ นี่คือสิ่งที่ปรากฏในทรานสคริปต์ของ Claude Code เมื่อกด Ctrl-O ซึ่งเป็นบันทึกการทำงานของระบบอัตโนมัติ โดยไม่รบกวนบทสนทนาหลัก

Standard error (stderr) ใช้สำหรับข้อความผิดพลาด สามารถเขียนไปที่ stderr ได้โดย

• Python: print("message", file=sys.stderr) หรือ

• บรรทัดคำสั่ง: echo "message" >&2

ความแตกต่างสำคัญคือ stderr สามารถส่งตรงถึง Claude เพื่อประมวลผลอัตโนมัติ ให้มันตอบสนองต่อปัญหาที่ hook ตรวจพบได้

Exit code บอก Claude Code ว่าควรทำอย่างไรต่อ:

• Exit code 0: สำเร็จ (แสดง stdout ให้ผู้ใช้)

• Exit code 2: ข้อผิดพลาดแบบบล็อก (ส่ง stderr ไปให้ Claude)

• โค้ดอื่นๆ: ข้อผิดพลาดที่ไม่บล็อก (แสดง stderr ให้ผู้ใช้ แต่ดำเนินการต่อ)

ระบบนี้ให้การควบคุมละเอียดว่าจะให้ Claude หยุด เดินหน้าต่อ หรือรับฟีดแบ็กจากสิ่งที่ระบบอัตโนมัติค้นพบ มาดูตัวอย่างสำหรับสอง exit code ที่สำคัญที่สุด

Exit code 0: การทำงานปกติ

hooks ส่วนใหญ่ใช้ exit code 0 เพื่อบอกว่าทุกอย่างเรียบร้อย นี่คือตัวอย่าง hook ที่ล็อกการทำงานกับไฟล์และแจ้งผู้ใช้:

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

hook นี้รันสองงาน: เขียนล็อกลงไฟล์ แล้วพิมพ์ข้อความลงทรานสคริปต์ วิธีมีหลายแบบ แต่แนวทางนี้ใช้ได้ข้ามแพลตฟอร์มและไม่ผูกติดกับรายละเอียดของเชลล์

เนื่องจากไม่มีการระบุ exit code จึงถือเป็น 0 ตามค่าเริ่มต้น ข้อความที่พิมพ์จะปรากฏในทรานสคริปต์ของ Claude Code ช่วยยืนยันว่าการล็อกทำงาน รูปแบบนี้เหมาะสำหรับสร้าง trail การตรวจสอบหรือการติดตามว่า Claude เปลี่ยนแปลงโปรเจกต์ของคุณอย่างไรตามกาลเวลา

Exit code 2: บล็อกพร้อมฟีดแบ็ก

Exit code 2 จะส่งข้อความผิดพลาดของคุณตรงไปยัง Claude ทำให้มันตอบกลับอัตโนมัติ นี่คือจุดที่ hooks กลายเป็นกลไกความปลอดภัย ไม่ใช่แค่ระบบอัตโนมัติ ลองดู hook ที่บล็อกการแก้ไขไฟล์ที่อันตราย:

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

ต้องสร้างสคริปต์ตรวจสอบความปลอดภัยที่ ~/.claude/security_check.py ดังนี้:

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

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

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

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

เมื่อ hook นี้ตรวจพบพาธที่เสี่ยง จะออกด้วยโค้ด 2 Claude Code จะส่งข้อความ stderr ไปให้ Claude ซึ่งจะอธิบายสาเหตุที่ถูกบล็อกและเสนอทางเลือกอื่น ป้องกันความเสียหายกับไฟล์ระบบโดยยังคงแจ้งนโยบายความปลอดภัยของคุณแก่ Claude

สร้าง Hook การแจ้งเตือนอัจฉริยะสำหรับ Claude Code

มาสร้าง hook แจ้งเตือนแบบปรับปรุงที่ผสานการประมวลผลอินพุตกับการจัดการเอาต์พุตอัจฉริยะ เพื่อแก้ปัญหาเสียงรบกวนจาก hook เดิมที่แจ้งเตือนทุกการเปลี่ยนไฟล์:

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

สร้างสคริปต์แจ้งเตือนที่ ~/.claude/smart_notify.py:

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

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

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

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

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

hook นี้อ่านอินพุตเพื่อทราบว่าไฟล์ใดถูกแก้ไข ตัดสินระดับความสำคัญของการแจ้งเตือนตามชนิดไฟล์ ใช้ stdout เพื่อบันทึกการเปลี่ยนแปลงสำคัญลงทรานสคริปต์ ทริกเกอร์เสียงแจ้งเตือนต่างกันตามชนิดไฟล์ และออกด้วยโค้ด 0 เสมอเพราะเป็นการแจ้งข้อมูล ไม่ได้บล็อกการทำงาน

การผสานการวิเคราะห์อินพุตและการควบคุมเอาต์พุตทำให้ hook ประพฤติตัวได้อย่างชาญฉลาดตามคอนเท็กซ์ พร้อมให้ฟีดแบ็กในระดับที่เหมาะสมทั้งกับคุณและ Claude Code แทนที่จะรบกวนด้วยการแจ้งเตือนจากไฟล์ชั่วคราว คุณจะได้ยินเฉพาะการเปลี่ยนแปลงที่สำคัญกับโปรเจกต์จริง

โปรดทราบว่าตัวอย่างนี้ใช้คำสั่ง say ที่มีใน macOS บน Linux อาจใช้ notify-send และบน Windows อาจใช้คำสั่ง PowerShell เพื่อให้ได้ผลลัพธ์คล้ายกัน

ข้อผิดพลาดที่พบบ่อยกับ Claude Code Hooks

สิ่งที่มักทำให้สะดุดในสัปดาห์แรกที่ใช้ hooks:

คำสั่ง echo ในโปรไฟล์เชลล์ทำให้ hook พัง Hooks รันในเชลล์แบบไม่โต้ตอบที่ source ไฟล์ ~/.zshrc หรือ ~/.bashrc หากโปรไฟล์มีคำสั่ง echo แบบไม่ตรวจสอบอะไร มันจะพิมพ์ข้อความพ่วงหน้า stdout ของ hook และทำให้การพาร์ส JSON พัง ให้ครอบด้วยเงื่อนไขเช็คเชลล์แบบโต้ตอบ:

if [[ $- == *i* ]]; then
  echo "Welcome back"
fi

Stop hooks อาจวนลูปไม่รู้จบ Stop hook ที่ออกด้วยโค้ด 2 จะบังคับให้ Claude ทำงานต่อ หากสคริปต์ของคุณไม่เช็ค stop_hook_active จากอินพุต JSON และออกอย่างเรียบร้อยเมื่อเป็น true คุณจะวนจนหมดเวลาเสมอ ควรมีตัวป้องกันออกก่อนเสมอ

Matchers แยกแยะตัวพิมพ์เล็ก-ใหญ่ bash ไม่เท่ากับ Bash ใช้ชื่อเครื่องมือให้ตรงตามที่ปรากฏใน Claude Code

เอาต์พุตถูกจำกัดที่ 10,000 อักขระ หาก hook สร้างมากกว่านั้น จะถูกตัดก่อนฉีดเข้าไปในคอนเท็กซ์ของ Claude รักษา stdout ให้กระชับและแสดงเฉพาะสิ่งที่โมเดลต้องใช้

สับสนระหว่าง hooks ระดับทีมกับส่วนตัว Hooks ใน .claude/settings.json ถูกแชร์กับทีม (คอมมิตเข้ารีโป) สำหรับ hooks ส่วนตัวที่ไม่อยากแชร์ ให้ใช้ .claude/settings.local.json ซึ่งถูก gitignore ไว้ตามค่าเริ่มต้น

Hooks กับ skills: ควรใช้เมื่อใด

Hooks และ Claude Skills มีวัตถุประสงค์ต่างกันและทำงานร่วมกันได้ดี Skill คือไฟล์มาร์กดาวน์ที่สอน Claude ให้ทำบางอย่าง (วิธีการ ขั้นตอน เทมเพลต) ส่วน hook คือคำสั่งเชลล์ที่บังคับใช้กฎอย่างแน่นอน ไม่ว่า Claude จะตัดสินใจอย่างไร

ความแตกต่างนี้สำคัญ: skill เป็นคำแนะนำที่โมเดลอาจละเลยได้เมื่อจำเป็น; hook จะยิงทุกครั้ง เขียน skill เพื่อบันทึกขั้นตอนการย้ายระบบของทีม เขียน hook แบบ PostToolUse เพื่อรันตัวลินต์การย้ายระบบในทุกไฟล์ .sql ที่ Claude เขียน Skill ทำให้ Claude มีความสามารถ; hook ทำให้ Claude ต้องรับผิดชอบ

รูปแบบขั้นสูงสำหรับ Claude Code Hooks

นอกเหนือจากการแจ้งเตือนและการล็อกพื้นฐาน hooks ยังแก้ปัญหาเวิร์กโฟลว์การพัฒนาจริงที่ทีมพบทุกวัน ต่อไปนี้เป็นไอเดียที่คุณปรับใช้กับโปรเจกต์ของคุณได้

ข้อดีคือคุณไม่จำเป็นต้องสร้าง hooks เหล่านี้ด้วยตัวเอง เพียงให้ Claude Code ใช้หนึ่งในไอเดียพรอมป์ตด้านล่าง ควบคู่กับเอกสารอ้างอิง Hooks ก็จะสร้างโค้ดและ JSON สำหรับคอนฟิกที่เกี่ยวข้องให้

แต่ละรูปแบบสามารถปรับให้เข้ากับเครื่องมือและเวิร์กโฟลว์ของคุณ เริ่มจากสิ่งที่แก้ความหงุดหงิดในแต่ละวันมากที่สุด แล้วค่อยๆ ขยายระบบอัตโนมัติเมื่อคุ้นเคยกับการพัฒนา hook

Hooks ขั้นสูงเพื่อความปลอดภัยและการปฏิบัติตามข้อกำหนด

Hooks เหมาะมากสำหรับบังคับใช้กฎความปลอดภัยและมาตรฐานคอมพลายแอนซ์ ต่อไปนี้คือสี่กรณีใช้งาน

ตัวสแกน API key

• ปัญหา: เผลอคอมมิตความลับลงเวอร์ชันคอนโทรล

• ทริกเกอร์: ก่อนเขียนไฟล์ใดๆ

• วิธีแก้: สแกนเนื้อหาไฟล์เพื่อหา API keys โทเค็น และรหัสผ่านด้วยเรกซ์

“สร้างสคริปต์ Python ที่อ่าน JSON อินพุตของ hook ดึงเนื้อหาไฟล์ และใช้เรกซ์ตรวจจับรูปแบบความลับที่พบบ่อย เช่น api_key=, token: หรือ password= ทำการตรวจสอบภายในสำหรับรายการที่น่าสงสัยและอย่าส่งความลับดิบออกภายนอกโดยเด็ดขาด

ส่งเฉพาะบางส่วนที่ถูกปิดบัง (เช่น เหลืออักขระหัว-ท้ายอย่างละ 4 ตัว) หรือแฮชไปยัง Anthropic API เพื่อวิเคราะห์สตริงที่น่าสงสัยและแยกแยะว่าเป็นความลับจริงหรือเป็นชื่อเวรเอเบิล ออกด้วยโค้ด 2 และให้ฟีดแบ็กแก่ Claude เกี่ยวกับความลับที่ตรวจพบและวิธีที่ปลอดภัยกว่า”

ตัวบังคับส่วนหัวลิขสิทธิ์

• ปัญหา: โปรเจกต์โอเพ่นซอร์สขาดส่วนหัวลิขสิทธิ์ที่จำเป็นในไฟล์ใหม่

• ทริกเกอร์: ก่อนเขียนไฟล์ซอร์สโค้ด

• วิธีแก้: ตรวจสอบว่าไฟล์ .py, .js, .java ใหม่มีข้อความลิขสิทธิ์ที่ถูกต้อง

“พาร์สอินพุตของ hook เพื่อดึงเนื้อหาไฟล์และตรวจว่าบรรทัด 10 แรกมีข้อความลิขสิทธิ์หรือไม่ด้วยการจับสตริง หากต้องการตรวจสอบขั้นสูง ให้ส่งส่วนหัวไฟล์ไปยัง Claude ผ่าน Anthropic API เพื่อยืนยันว่ามีประกาศลิขสิทธิ์และข้อมูลไลเซนส์ที่ถูกต้อง บล็อกการสร้างไฟล์ด้วย exit code 2 หากขาดส่วนหัว และมอบเทมเพลตไลเซนส์ที่ถูกต้องให้ Claude เพิ่ม”

ตัวป้องกันไฟล์โปรดักชัน

• ปัญหา: เผลอแก้ไขไฟล์คอนฟิกระบบที่สำคัญ

• ทริกเกอร์: ก่อนแก้ไขไฟล์ในไดเรกทอรีอ่อนไหว

• วิธีแก้: บล็อกการเปลี่ยนแปลง /etc/, nginx.conf, database.yml และคอนฟิกวิกฤติอื่นๆ

“ดึงพาธไฟล์จาก JSON อินพุตของ hook และตรวจว่าตรงกับแพทเทิร์นอย่าง /etc/, production.yml หรือชื่อไฟล์วิกฤติอื่น ใช้ API ของ Claude เพื่อวิเคราะห์พาธไฟล์และตัดสินว่าเป็นคอนฟิกที่อาจกระทบระบบโปรดักชันหรือไม่ ออกด้วยโค้ด 2 และให้คำแนะนำที่เฉพาะเจาะจงเกี่ยวกับแนวปฏิบัติการพัฒนาที่ปลอดภัยเมื่อพบพาธที่เสี่ยง”

ตัวเพิ่มประสิทธิภาพรูปภาพ

• ปัญหา: ไฟล์รูปภาพขนาดใหญ่ทำให้แอปและรีโพช้าลง

• ทริกเกอร์: หลังเพิ่มไฟล์รูปภาพใหม่

• วิธีแก้: บีบอัดไฟล์ PNG/JPEG โดยยังรักษาคุณภาพภาพ

“พาร์สอินพุตของ hook เพื่อได้พาธไฟล์และตรวจว่าเป็นรูปภาพด้วยการดูส่วนขยาย รันเครื่องมือบีบอัดอย่าง imageoptim หรือเรียก TinyPNG API เพื่อบีบอัดโดยรักษาคุณภาพ บันทึกผลการบีบอัดลง stdout เพื่อดูการประหยัดขนาดไฟล์ในทรานสคริปต์ของ Claude”

Hooks ขั้นสูงเพื่อระบบเวอร์ชันคอนโทรลอัตโนมัติ

เวิร์กโฟลว์ Git และเอกสารเป็นอีกพื้นที่ที่ hooks มีประโยชน์ มาดูไอเดียบางส่วน

ตัวตรวจสาขา Git

• ปัญหา: สมาชิกทีมเผลอพุชการเปลี่ยนแปลงไปยังสาขาที่ป้องกันไว้

• ทริกเกอร์: ก่อนการเขียนหรือแก้ไขไฟล์ใดๆ

• วิธีแก้: ตรวจสอบสาขา Git ปัจจุบันและบล็อกการทำงานบน main/master/production

“ใช้คำสั่ง bash ง่ายๆ git branch --show-current เพื่อดึงชื่อสาขาปัจจุบันและเทียบกับรายการสาขาที่ป้องกัน หากอยู่บนสาขาที่ป้องกัน ให้ออกด้วยโค้ด 2 และส่งข้อความอธิบายนโยบายการป้องกันสาขาให้ Claude สำหรับกฎการตั้งชื่อสาขาที่ซับซ้อน ใช้ API ของ Claude เพื่อวิเคราะห์ชื่อสาขาและตัดสินว่าเข้ากับแพทเทิร์นที่ป้องกันหรือไม่”

คอมมิตอัตโนมัติอย่างชาญฉลาด

• ปัญหา: ลืมคอมมิตหรือเขียนข้อความคอมมิตไม่ดี

• ทริกเกอร์: หลังแก้ไขไฟล์ใดๆ

• วิธีแก้: สเตจและคอมมิตการเปลี่ยนแปลงอัตโนมัติพร้อมข้อความที่ AI สร้างอย่างกระชับ

“อ่านพาธไฟล์ที่แก้ไขจากอินพุตของ hook รัน git diff เพื่อดึงความเปลี่ยนแปลง แล้วส่ง diff ไปยัง API ของ Claude พร้อมพรอมป์ตให้สร้างข้อความคอมมิตแบบกระชับ ใช้ข้อความที่ได้กับคำสั่ง git add และ git commit เพื่อคอมมิตอัตโนมัติ ระบุชื่อไฟล์และชนิดการเปลี่ยนแปลงในพรอมป์ต API เพื่อให้ข้อความคอมมิตสอดคล้องกับมาตรฐาน conventional commits”

ตัวสร้างเอกสาร

• ปัญหา: เอกสาร API ไม่สอดคล้องกับการเปลี่ยนแปลงของโค้ด

• ทริกเกอร์: หลังแก้ไขไฟล์อินเทอร์เฟซ (คอนโทรลเลอร์ โมเดล API)

• วิธีแก้: รันเครื่องมือสร้างเอกสารอย่าง JSDoc, Sphinx หรือ OpenAPI โดยอัตโนมัติ

“ตรวจพาธไฟล์ที่แก้ไขเพื่อระบุว่าเป็นเอ็นด์พอยต์ API โมเดล หรือไฟล์อินเทอร์เฟซด้วยการจับแพทเทิร์น ส่งเนื้อหาไฟล์ไปยัง API ของ Claude เพื่อสกัดการเปลี่ยนแปลง API และสร้างอัปเดตเอกสาร รันเครื่องมือสร้างเอกสารที่เหมาะสม (jsdoc, sphinx-build เป็นต้น) และคอมมิตเอกสารที่อัปเดตอัตโนมัติ

Hooks ขั้นสูงเพื่อการร่วมมือและการผสานเวิร์กโฟลว์

สุดท้าย hooks ช่วยให้สมาชิกทีมทุกคนตามการอัปเดตได้ทัน

การเชื่อมต่อกับ Slack

• ปัญหา: ทีมไม่ทราบถึงการเปลี่ยนแปลงสำคัญในฐานโค้ดที่ใช้ร่วมกัน

• ทริกเกอร์: เมื่อมีการแจ้งเตือนสำหรับการทำงานสำคัญ

• วิธีแก้: โพสต์ข้อความฟอร์แมตสวยไปยังช่องทีม พร้อมชื่อไฟล์และสรุปการเปลี่ยนแปลง

“ดึงข้อมูลไฟล์จากอินพุตของ hook และกรองเฉพาะไฟล์สำคัญ เช่น ซอร์สโค้ดหรือคอนฟิก ใช้ API ของ Claude เพื่อสรุปสิ่งที่เปลี่ยนจากชื่อไฟล์และชนิดไฟล์ ส่งข้อความฟอร์แมตแล้วไปยัง Slack ผ่าน webhook URL พร้อมแท็กสมาชิกทีมสำหรับการเปลี่ยนแปลงวิกฤติ”

ตัวกระจาย Webhook

• ปัญหา: การทริกเกอร์ CI/CD ด้วยมือทำให้ดีเลย์ในการดีพลอย

• ทริกเกอร์: เมื่อเกิดเหตุการณ์เฉพาะ (เปลี่ยนคอนฟิก แก้ไฟล์ดีพลอย)

• วิธีแก้: เรียก API ภายนอกเพื่อทริกเกอร์บิลด์ ดีพลอย หรือกระบวนการอัตโนมัติอื่น

“ตรวจพาธไฟล์ที่แก้ไขกับแพทเทิร์นอย่าง Dockerfile, package.json หรือคอนฟิกดีพลอยเพื่อพิจารณาว่าควรทริกเกอร์ CI/CD หรือไม่ ใช้ไลบรารี requests ใน Python เพื่อเรียก webhook URL พร้อมเฮดเดอร์ยืนยันตัวตนและเพย์โหลดข้อมูลการเปลี่ยนแปลง รวมพาธไฟล์และเมทาดาทาการเปลี่ยนแปลงไว้ในเพย์โหลดเพื่อให้ระบบภายนอกตัดสินใจได้ว่าอะไรควรถูกบิลด์หรือดีพลอย”

อัปเดตหน้าสถานะ

• ปัญหา: ลูกค้าไม่ทราบกิจกรรมบำรุงรักษาหรือการดีพลอย

• ทริกเกอร์: เมื่อแก้ไขไฟล์ดีพลอยหรือโครงสร้างพื้นฐาน

• วิธีแก้: อัปเดตหน้าสถานะบริการด้วยข้อความแจ้งบำรุงรักษา

“พาร์สอินพุตของ hook เพื่อหาไฟล์โครงสร้างพื้นฐานอย่างแมเนเฟสต์ Kubernetes หรือคอนฟิก Terraform ด้วยแพทเทิร์นพาธไฟล์ สร้างข้อความบำรุงรักษาด้วย API ของ Claude ตามชนิดการเปลี่ยนแปลงโครงสร้างพื้นฐานที่ตรวจพบ โพสต์อัปเดตสถานะไปยังบริการอย่าง StatusPage.io หรือ PagerDuty ผ่าน REST API ของพวกเขา พร้อมประเภทเหตุการณ์และเวลาประมาณการ”

ตัวแจ้งสถานะทีม

• ปัญหา: เกิดความขัดแย้งเมื่อมีนักพัฒนาหลายคนทำงานในฟีเจอร์เดียวกันโดยไม่รู้กัน

• ทริกเกอร์: เมื่อเริ่มเซสชัน Claude Code ใหม่

• วิธีแก้: แจ้งช่องทางทีมว่าคุณเริ่มทำงานในโปรเจกต์หรือคอมโพเนนต์ใด

“อ่านไดเรกทอรีโปรเจกต์จากอินพุตของ hook และใช้ API ของ Claude เพื่อวิเคราะห์ไฟล์ล่าสุดหรือประวัติ git เพื่อเข้าใจประเภทงานที่ทำอยู่ ส่งข้อความฟอร์แมตไปยังช่องสื่อสารของทีมพร้อมชื่อคุณ ชื่อโปรเจกต์ และพื้นที่โฟกัส ระบุเวลาที่คาดว่าจะใช้และเชิญชวนให้ผู้ที่ทำฟีเจอร์ที่เกี่ยวข้องประสานงาน”

ข้อคิดส่งท้าย

Claude Code Hooks เปลี่ยนผู้ช่วยโค้ด AI ที่คาดเดายากให้เป็นเวิร์กโฟลว์อัตโนมัติที่ทำงานตรงจังหวะที่ต้องการ ในบทเรียนนี้ คุณได้เรียนรู้การตั้งค่า hooks ทั้งผ่านคำสั่งโต้ตอบ /hooks และการคอนฟิกด้วยมือ เข้าใจข้อมูลอินพุต JSON ที่ขับเคลื่อนระบบอัตโนมัติอัจฉริยะ และควบคุมพฤติกรรมของ Claude ผ่าน exit code และเอาต์พุตแบบมีโครงสร้าง

รูปแบบเชิงปฏิบัติที่ครอบคลุม ได้แก่ ตัวตรวจความปลอดภัยที่บล็อกการทำงานเสี่ยง และการแจ้งเตือนอัจฉริยะที่ลดเสียงรบกวน ตัวอย่างเหล่านี้แสดงให้เห็นว่า hooks แก้ปัญหาการพัฒนาจริง พร้อมให้อำนาจคุณควบคุมผู้ช่วย AI ได้อย่างเต็มที่ เมื่อเข้าใจพื้นฐานแล้ว คุณสามารถสร้างระบบอัตโนมัติที่ตรงกับเวิร์กโฟลว์เฉพาะของทีมได้

หากอยากเรียนรู้เพิ่มเติมเกี่ยวกับการทำงานกับเครื่องมือ AI ดูคอร์สของ DataCamp เรื่อง Understanding Prompt Engineering ซึ่งครอบคลุมกลยุทธ์การพรอมป์ตที่ทำงานสอดรับกับการพัฒนา hook สำหรับทักษะ AI ด้านโค้ดที่กว้างขึ้น ลอง Intermediate ChatGPT เพื่อพัฒนาทักษะที่ทำให้ผู้ช่วย AI เป็นพาร์ตเนอร์ที่ไว้ใจได้ในเวิร์กโฟลว์การพัฒนาของคุณ