Claude Code in Action 学习笔记 02

{
  "PreToolUse": [
    {
      "matcher": "Read",
      "hooks": [
        {
          "type": "command",
          "command": "node /home/hooks/read_hook.ts"
        }
      ]
    }
  ]
}

{
  "PostToolUse": [
    {
      "matcher": "Write|Edit|MultiEdit",
      "hooks": [
        {
          "type": "command",
          "command": "node /home/hooks/edit_hook.ts"
        }
      ]
    }
  ]
}

{
  "session_id": "2d6a1e4d-6...",
  "transcript_path": "/Users/sg/...",
  "hook_event_name": "PreToolUse",
  "tool_name": "Read",
  "tool_input": {
    "file_path": "/code/queries/.env"
  }
}

"matcher": "Read|Grep"

"command": "node ./hooks/read_hook.js"

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Read|Grep",
        "hooks": [
          {
            "type": "command",
            "command": "node ./hooks/read_hook.js"
          }
        ]
      }
    ]
}

async function main() {
  const chunks = [];
  for await (const chunk of process.stdin) {
    chunks.push(chunk);
  }

  const toolArgs = JSON.parse(Buffer.concat(chunks).toString());

  // 提取 Claude 试图读取的文件路径
  const readPath =
    toolArgs.tool_input?.file_path || toolArgs.tool_input?.path || "";

  // 检查 Claude 是否试图读取 .env 文件
  if (readPath.includes('.env')) {
    console.error("You cannot read the .env file");
    process.exit(2);
  }
}

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Read|Grep",
        "hooks": [
          {
            "type": "command",
            "command": "node $PWD/hooks/read_hook.js"
          }
        ]
      }
    ]
  }
}

{
  "name": "queries",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "setup": "npm install && node ./scripts/init-claude.js",
    "test": "echo \"Error: no test specified\" && exit 1",
    "sdk": "tsx sdk.ts"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "module",
  "dependencies": {
    "@anthropic-ai/claude-agent-sdk": "^0.1.5",
    "@types/node": "^24.0.13",
    "sqlite": "^5.1.1",
    "sqlite3": "^5.1.7",
    "tsx": "^4.20.3",
    "typescript": "^5.8.3"
  }
}

import fs from "fs";
import path from "path";

// Get the current working directory
const pwd = process.cwd();

// Define file paths
const templatePath = path.join(".claude", "settings.example.json");
const outputPath = path.join(".claude", "settings.local.json");

try {
  // Read the template file
  const templateContent = fs.readFileSync(templatePath, "utf8");

  // Replace all instances of $PWD with the actual working directory
  const processedContent = templateContent.replace(/\$PWD/g, pwd);

  // Parse to validate JSON (optional but recommended)
  JSON.parse(processedContent);

  // Ensure .claude directory exists
  const claudeDir = path.dirname(outputPath);
  if (!fs.existsSync(claudeDir)) {
    fs.mkdirSync(claudeDir, { recursive: true });
  }

  // Write the processed content to settings.json
  fs.writeFileSync(outputPath, processedContent, "utf8");

  console.log(`✅ Successfully created ${outputPath}`);
  console.log(`   Replaced $PWD with: ${pwd}`);
} catch (error) {
  if (error.code === "ENOENT") {
    console.error(`❌ Error: Could not find ${templatePath}`);
    console.error(
      "   Make sure you run this script from the project root directory."
    );
  } else if (error instanceof SyntaxError) {
    console.error("❌ Error: Invalid JSON after processing");
    console.error(error.message);
  } else {
    console.error("❌ Error:", error.message);
  }
  process.exit(1);
}

// Note: the "@anthropic-ai/claude-code" package has been renamed
// to "@anthropic-ai/claude-agent-sdk"
import { query } from "@anthropic-ai/claude-agent-sdk";
import path from "path";

const REVIEW_DIR = "src/queries";

async function main() {
  // process.exit(0);
  // Read JSON input from stdin
  const input = await new Promise((resolve) => {
    let data = "";
    process.stdin.on("data", (chunk) => (data += chunk));
    process.stdin.on("end", () => resolve(data));
  });

  const hookData = JSON.parse(input);
  const toolInput = hookData.tool_input;

  // Check if this is a file modification in ./queries
  const filePath = toolInput.file_path || toolInput.path;
  if (!filePath) {
    process.exit(0);
  }

  // Normalize paths for comparison
  const normalizedFilePath = path.resolve(filePath);
  const queriesDir = path.resolve(process.cwd(), REVIEW_DIR);

  // Check if file is within queries directory (handles subdirectories too)
  if (!normalizedFilePath.startsWith(queriesDir + path.sep)) {
    process.exit(0);
  }

  // Prepare prompt for analysis
  const newContent =
    toolInput.content || toolInput.contents || toolInput.new_string;
  const prompt = `You are reviewing a proposed change to a database query file.
Your task is to analyze if the new or modified query functions could be 
accomplished by reusing or slightly modifying existing query functions.

Within reason, we want to prevent duplicate queries from being added into this project,
so you are seeing if the proposed change will duplicate any existing functionality.

File: ${filePath}
New content:
<new_content>
${newContent}
</new_content>

Please research and analyze the existing queries in the ./queries directory and:
1. Identify any new query functions being added in this change
2. For each new query function, determine if it could be accomplished by:
   - Using an existing query function as-is
   - Slightly modifying an existing query function, perhaps by adding additional 
      arguments or expanding a select statement

If yes, provide specific feedback on which existing functions could be used instead. Be concise and specific.
If no, just say "Changes look appropriate."`;

  const messages = [];
  for await (const message of query({
    prompt,
  })) {
    messages.push(message);
  }

  // Extract the analysis result
  const resultMessage = messages.find((m) => m.type === "result");
  if (!resultMessage || resultMessage.subtype !== "success") {
    process.exit(0);
  }

  // If changes are appropriate, allow them
  if (resultMessage.result.includes("Changes look appropriate")) {
    process.exit(0);
  }

  // Otherwise, block with feedback
  console.error(`Query duplication detected:\n\n${resultMessage.result}`);
  process.exit(2);
}

main().catch((err) => {
  console.error(`Hook error: ${err.message}`);
  process.exit(1);
});

Claude Code 尝试编辑文件
       ↓
   Hook 被触发
       ↓
  检查是否是 queries 目录
       ↓
    是 → 调用 Claude SDK 分析代码
       ↓
  检测到重复 → 阻止编辑并给出建议
  没有重复 → 允许编辑继续

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "node hooks/query_hook.js"
          }
        ]
      }
    ]
  }
}

❌ Hook blocked the operation:

Query duplication detected:

The new function `getStalePendingOrders` duplicates functionality
already available in `getPendingOrders`. Consider modifying the
existing function to accept an optional `minDaysOld` parameter instead.

{
  "session_id": "9ecf22fa-edf8-4332-ae85-b6d5456eda64",
  "transcript_path": "<path_to_transcript>",
  "hook_event_name": "PostToolUse",
  "tool_name": "TodoWrite",
  "tool_input": {
    "todos": [{ "content": "write a readme", "status": "pending", "priority": "medium", "id": "1" }]
  },
  "tool_response": {
    "oldTodos": [],
    "newTodos": [{ "content": "write a readme", "status": "pending", "priority": "medium", "id": "1" }]
  }
}

{
  "session_id": "af9f50b6-f042-4773-b3e2-c3a4814765ce",
  "transcript_path": "<path_to_transcript>",
  "hook_event_name": "Stop",
  "stop_hook_active": false
}

{
  "PostToolUse": [
    {
      "matcher": "*",
      "hooks": [
        {
          "type": "command",
          "command": "jq . > post-log.json"
        }
      ]
    }
  ]
}

import { query } from "@anthropic-ai/claude-agent-sdk";

const prompt = "Look for duplicate queries in the ./src/queries dir";

for await (const message of query({
  prompt,
})) {
  console.log(JSON.stringify(message, null, 2));
}

for await (const message of query({
  prompt,
  options: {
    allowedTools: ["Edit"]
  }
})) {
  console.log(JSON.stringify(message, null, 2));
}

// Note: the "@anthropic-ai/claude-code" package has been renamed
// to "@anthropic-ai/claude-agent-sdk"
import { query } from "@anthropic-ai/claude-agent-sdk";

const prompt = "Hi, please get the new version number of the claude code?";

for await (const message of query({
  prompt,
  options: {
    allowedTools: ["WebSearch", "WebFetch"]
  }
})) {
  console.log(JSON.stringify(message, null, 2));
}

tsx sdk.ts