Claude Code事件驱动自动化：Hooks触发到自愈流水线实战

graph TB
    subgraph 触发层["触发层（Hooks）"]
        A[PreToolUse] --> D{路由决策}
        B[PostToolUse] --> D
        C[Notification] --> D
        E[Stop] --> D
        F[SubagentStop] --> D
    end

    subgraph 执行层["执行层（-p Headless）"]
        D --> G[claude -p 单次任务]
        D --> H[claude -p --continue 续接]
        D --> I[claude -p --resume 恢复]
    end

    subgraph 编排层["编排层（Batch + Worktree）"]
        G --> J[串行批处理]
        H --> K[并行Worktree]
        I --> L[条件分支]
    end

    J --> M[结果汇总]
    K --> M
    L --> M

    M -->|反馈| 触发层

    style 触发层 fill:#e1f5fe
    style 执行层 fill:#fff3e0
    style 编排层 fill:#e8f5e9

# 基础：单次问答
claude -p "解释src/auth.ts的认证流程"

# 进阶：指定输出格式
claude -p "列出所有TODO注释" --output-format json

# 进阶：流式JSON输出（适合实时处理）
claude -p "重构数据库模块" --output-format stream-json

# 高级：限制工具和轮次
claude -p "修复lint错误" \
  --allowedTools "Read,Write,Bash" \
  --max-turns 5 \
  --output-format json

# --continue：继续最近一次对话
claude -p "为刚才的重构添加单元测试" --continue

# --resume：恢复指定会话（通过会话ID）
claude -p "继续优化性能" --resume abc123-session-id

# 组合使用：从上次中断处继续，限制轮次防止跑飞
claude -p "继续上次的数据库迁移工作" \
  --continue \
  --max-turns 8 \
  --output-format json

#!/bin/bash
# auto-fix-pipeline.sh — 自动修复流水线

PROJECT_DIR="$1"
SESSION_FILE="/tmp/claude_session_${PROJECT_DIR//\//_}.txt"

# 第一步：分析问题
RESULT=$(claude -p "分析 $PROJECT_DIR 中所有TypeScript编译错误，分类汇总" \
  --output-format json \
  --max-turns 3)

# 提取会话ID（从JSON输出中）
SESSION_ID=$(echo "$RESULT" | jq -r '.session_id // empty')

if [ -n "$SESSION_ID" ]; then
  echo "$SESSION_ID" > "$SESSION_FILE"
fi

# 第二步：基于分析结果自动修复（延续上下文）
if [ -f "$SESSION_FILE" ]; then
  claude -p "根据刚才的分析，按优先级修复错误。每修复一类就运行 tsc --noEmit 验证。" \
    --resume "$(cat "$SESSION_FILE")" \
    --max-turns 10 \
    --allowedTools "Read,Write,Bash"
fi

# 在GitHub Actions中使用JSON输出进行决策
REVIEW=$(claude -p "审查本次PR的代码变更，评估风险等级：low/medium/high" \
  --output-format json \
  --max-turns 3)

RISK_LEVEL=$(echo "$REVIEW" | jq -r '.result // "unknown"')

if [ "$RISK_LEVEL" = "high" ]; then
  echo "::warning::AI检测到高风险变更，建议人工审查"
fi

# 最小权限原则：只允许读取和搜索
claude -p "检查代码中是否有硬编码的API密钥" \
  --system-prompt "你是安全审计专家。只报告发现，不修改任何文件。" \
  --allowedTools "Read,Grep,Glob" \
  --output-format json

# 受限写入：只允许修改测试文件
claude -p "为所有未覆盖的函数生成单元测试" \
  --allowedTools "Read,Write,Grep,Glob,Bash" \
  --disallowedTools "Edit" \
  --max-turns 15

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "node ~/.claude/hooks/pre-bash-guard.js"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "node ~/.claude/hooks/post-write-format.js"
          }
        ]
      }
    ],
    "Notification": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "node ~/.claude/hooks/notify.js"
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "node ~/.claude/hooks/on-stop.js"
          }
        ]
      }
    ]
  }
}

sequenceDiagram
    participant User as 用户/脚本
    participant Claude as Claude Code
    participant Hook as Hooks系统
    participant Tool as 工具(Bash/Write等)

    User->>Claude: 发送Prompt
    Note over Claude: UserPromptSubmit触发

    Claude->>Hook: PreToolUse事件
    Hook-->>Claude: 允许/拒绝/注入

    alt 被允许
        Claude->>Tool: 执行工具
        Tool-->>Claude: 工具结果
        Claude->>Hook: PostToolUse事件
        Hook-->>Claude: 后处理完成
    else 被拒绝
        Claude-->>User: 工具被阻止
    end

    Note over Claude: 可能触发Notification

    Claude-->>User: 最终响应
    Note over Claude: Stop事件触发
    Claude->>Hook: Stop回调

// ~/.claude/hooks/pre-bash-guard.js
// 从stdin读取JSON输入
let input = '';
process.stdin.on('data', (chunk) => { input += chunk; });
process.stdin.on('end', () => {
  const data = JSON.parse(input);
  const toolName = data.tool_name;   // 如 "Bash"
  const toolInput = data.tool_input; // 如 { command: "rm -rf /" }

  if (toolName === 'Bash') {
    const cmd = toolInput.command || '';

    // 规则1：阻止危险命令
    const dangerous = [
      /rm\s+-rf\s+\//,
      /git\s+push\s+--force/,
      /DROP\s+TABLE/i,
      /curl.*\|\s*sh/,
      />\s*\/dev\/sd/,
    ];

    for (const pattern of dangerous) {
      if (pattern.test(cmd)) {
        console.log(JSON.stringify({
          decision: "block",
          reason: `安全策略阻止：检测到危险命令模式 "${pattern.source}"`
        }));
        process.exit(2); // exit 2 = 阻止工具执行
      }
    }

    // 规则2：对生产环境操作要求确认标记
    if (/prod|production/i.test(cmd) && !/DRY_RUN/.test(cmd)) {
      console.log(JSON.stringify({
        decision: "block",
        reason: "生产环境操作需要添加 DRY_RUN 标记确认"
      }));
      process.exit(2);
    }
  }

  // 规则3：保护敏感文件
  if (toolName === 'Write' || toolName === 'Edit') {
    const filePath = toolInput.file_path || '';
    const protected = ['.env', 'credentials', 'secret', 'private.key'];
    if (protected.some(p => filePath.toLowerCase().includes(p))) {
      console.log(JSON.stringify({
        decision: "block",
        reason: `禁止修改敏感文件: ${filePath}`
      }));
      process.exit(2);
    }
  }

  // 允许通过
  process.exit(0);
});

// ~/.claude/hooks/post-write-format.js
const { execSync } = require('child_process');

let input = '';
process.stdin.on('data', (chunk) => { input += chunk; });
process.stdin.on('end', () => {
  const data = JSON.parse(input);

  if (data.tool_name === 'Write' || data.tool_name === 'Edit') {
    const filePath = data.tool_input.file_path || '';

    // 根据文件类型执行对应格式化
    try {
      if (filePath.endsWith('.ts') || filePath.endsWith('.tsx')) {
        execSync(`npx prettier --write "${filePath}" 2>/dev/null`, { timeout: 10000 });
        execSync(`npx eslint --fix "${filePath}" 2>/dev/null`, { timeout: 10000 });
      } else if (filePath.endsWith('.py')) {
        execSync(`black "${filePath}" 2>/dev/null`, { timeout: 10000 });
        execSync(`isort "${filePath}" 2>/dev/null`, { timeout: 10000 });
      } else if (filePath.endsWith('.go')) {
        execSync(`gofmt -w "${filePath}" 2>/dev/null`, { timeout: 10000 });
      }

      // 注入反馈信息（通过stdout返回）
      console.log(JSON.stringify({
        supplemented_output: `\n[自动格式化完成: ${filePath}]`
      }));
    } catch (e) {
      // 格式化失败不影响主流程
      console.error(`格式化警告: ${e.message}`);
    }
  }

  process.exit(0);
});

// ~/.claude/hooks/on-stop.js
const { execSync } = require('child_process');
const fs = require('fs');

let input = '';
process.stdin.on('data', (chunk) => { input += chunk; });
process.stdin.on('end', () => {
  const data = JSON.parse(input);
  const sessionDir = process.cwd();

  // 保存会话结果摘要
  const summary = {
    timestamp: new Date().toISOString(),
    transcript_path: data.transcript_path,
    stop_reason: data.stop_reason,
    working_dir: sessionDir
  };

  fs.writeFileSync(
    '/tmp/claude-stop-event.json',
    JSON.stringify(summary, null, 2)
  );

  // 如果是Git仓库且有变更，自动运行测试
  try {
    const status = execSync('git status --porcelain', { encoding: 'utf-8' });
    if (status.trim().length > 0) {
      // 触发后续-p命令进行验证
      execSync(
        'claude -p "运行项目测试套件验证最近修改是否引入回归。如有失败，分析原因并修复。" ' +
        '--max-turns 8 --allowedTools "Read,Write,Bash,Grep" ' +
        '--output-format json >> /tmp/claude-auto-verify.log 2>&1 &',
        { detached: true, stdio: 'ignore' }
      );
    }
  } catch (e) {
    // 非Git仓库或无变更，跳过
  }

  process.exit(0);
});

#!/bin/bash
# batch-repo-upgrade.sh — 批量升级多个仓库的依赖
set -euo pipefail

REPOS=(
  "/home/dev/project-alpha"
  "/home/dev/project-beta"
  "/home/dev/project-gamma"
)

PROMPT="检查项目中的过期npm依赖，按安全优先级升级。
升级每个依赖后运行 npm test 验证。
如果测试失败，回滚该依赖并记录问题。"

RESULTS=()

for repo in "${REPOS[@]}"; do
  echo "=== 处理: $repo ==="

  cd "$repo"

  RESULT=$(claude -p "$PROMPT" \
    --allowedTools "Read,Write,Bash,Grep,Glob" \
    --max-turns 15 \
    --output-format json 2>/dev/null)

  # 记录结果
  echo "$RESULT" | jq -r '.result // "无输出"' > "/tmp/upgrade_$(basename $repo).txt"
  RESULTS+=("$repo: $(echo "$RESULT" | jq -r '.result // "失败"' | head -c 100)")

  echo "--- $repo 完成 ---"
done

echo "====== 汇总报告 ======"
printf '%s\n' "${RESULTS[@]}"

#!/bin/bash
# parallel-refactor.sh — 并行重构多个模块
set -euo pipefail

MODULES=("auth" "payment" "notification" "analytics" "user")
BASE_BRANCH="main"

# 为每个模块创建隔离的worktree
for module in "${MODULES[@]}"; do
  WORKTREE_PATH=".claude/worktrees/refactor-${module}"

  # 创建worktree和分支
  git worktree add "$WORKTREE_PATH" -b "refactor/${module}" HEAD 2>/dev/null || true

  # 在每个worktree中并行启动Claude Code
  (
    cd "$WORKTREE_PATH"
    claude -p "重构 ${module} 模块：
    1. 将所有any类型替换为具体类型
    2. 提取重复逻辑到共享工具函数
    3. 添加JSDoc注释
    4. 运行测试确保无回归" \
      --allowedTools "Read,Write,Bash,Grep,Glob" \
      --max-turns 12 \
      --output-format json > "/tmp/refactor_${module}.json" 2>&1

    echo "[完成] ${module} 模块重构"
  ) &
done

# 等待所有并行任务完成
wait

echo "====== 全部模块重构完成 ======"

# 汇总结果
for module in "${MODULES[@]}"; do
  RESULT_FILE="/tmp/refactor_${module}.json"
  if [ -f "$RESULT_FILE" ]; then
    STATUS=$(jq -r '.result // "未知"' "$RESULT_FILE" | head -c 200)
    echo "${module}: ${STATUS}"
  fi
done

# 在Claude Code交互会话中使用
/batch

auto-heal-pipeline/
├── .claude/
│   └── settings.json          # Hooks配置
├── scripts/
│   ├── heal-pipeline.sh       # 主流水线脚本
│   ├── hooks/
│   │   ├── post-write-lint.js # PostToolUse: 自动lint
│   │   └── on-stop-report.js  # Stop: 生成报告
│   └── report/
│       └── template.html      # 报告模板
└── CLAUDE.md                   # 项目指令

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{
          "type": "command",
          "command": "node scripts/hooks/pre-bash-guard.js"
        }]
      },
      {
        "matcher": "Write",
        "hooks": [{
          "type": "command",
          "command": "node scripts/hooks/pre-write-guard.js"
        }]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [{
          "type": "command",
          "command": "node scripts/hooks/post-write-lint.js"
        }]
      },
      {
        "matcher": "Edit",
        "hooks": [{
          "type": "command",
          "command": "node scripts/hooks/post-write-lint.js"
        }]
      }
    ],
    "Stop": [
      {
        "hooks": [{
          "type": "command",
          "command": "node scripts/hooks/on-stop-report.js"
        }]
      }
    ]
  }
}

#!/bin/bash
# heal-pipeline.sh — 自愈代码质量流水线
set -euo pipefail

PROJECT_DIR="${1:-.}"
MAX_HEAL_ROUNDS=3
LOG_DIR="/tmp/claude-heal-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$LOG_DIR"

echo "🔬 自愈流水线启动 — 目标: $PROJECT_DIR"

cd "$PROJECT_DIR"

# ── 阶段1: 检测 ──
echo "📋 阶段1: 问题检测..."
DETECTION=$(claude -p "执行全面的代码质量检测：
1. 运行 eslint 检查所有源文件，统计错误和警告数量
2. 运行 tsc --noEmit 检查类型错误
3. 运行测试套件，记录失败用例
4. 以JSON格式输出：{ lint_errors: number, type_errors: number, test_failures: string[] }" \
  --allowedTools "Read,Bash,Grep,Glob" \
  --max-turns 5 \
  --output-format json)

echo "$DETECTION" | jq '.' > "$LOG_DIR/detection.json"

LINT_ERRORS=$(echo "$DETECTION" | jq '.result.lint_errors // 0')
TYPE_ERRORS=$(echo "$DETECTION" | jq '.result.type_errors // 0')

echo "  检测结果: Lint错误=${LINT_ERRORS}, 类型错误=${TYPE_ERRORS}"

# ── 阶段2: 自愈循环 ──
ROUND=0
while [ $ROUND -lt $MAX_HEAL_ROUNDS ]; do
  ROUND=$((ROUND + 1))
  echo "🔧 阶段2.${ROUND}: 自愈修复（第${ROUND}轮）..."

  HEAL_RESULT=$(claude -p "根据之前的检测结果，修复所有可自动修复的问题。
规则：
- 每修复一类问题后立即运行对应验证命令
- 如果修复引入新问题，立即回滚
- 记录每个修复的详细说明
- 输出JSON：{ fixed: string[], remaining: string[], rolled_back: string[] }" \
    --continue \
    --max-turns 10 \
    --allowedTools "Read,Write,Bash,Grep,Glob" \
    --output-format json)

  echo "$HEAL_RESULT" | jq '.' > "$LOG_DIR/heal_round_${ROUND}.json"

  FIXED=$(echo "$HEAL_RESULT" | jq '.result.fixed // [] | length')
  REMAINING=$(echo "$HEAL_RESULT" | jq '.result.remaining // [] | length')

  echo "  本轮修复: ${FIXED}个, 剩余: ${REMAINING}个"

  if [ "$REMAINING" -eq 0 ]; then
    echo "✅ 所有问题已修复!"
    break
  fi
done

# ── 阶段3: 最终验证 ──
echo "✅ 阶段3: 最终验证..."
VERIFY=$(claude -p "运行完整验证：eslint、tsc、全部测试。
输出JSON：{ passed: boolean, details: string }" \
  --continue \
  --max-turns 3 \
  --allowedTools "Read,Bash,Grep,Glob" \
  --output-format json)

PASSED=$(echo "$VERIFY" | jq -r '.result.passed // false')

echo "$VERIFY" | jq '.' > "$LOG_DIR/final_verify.json"

# ── 阶段4: 报告 ──
echo "📊 阶段4: 生成报告..."
cat <<EOF > "$LOG_DIR/report.md"
# 自愈流水线报告

**项目**: $(basename "$PROJECT_DIR")
**时间**: $(date '+%Y-%m-%d %H:%M:%S')
**修复轮次**: ${ROUND}

## 检测结果
- Lint错误: ${LINT_ERRORS}
- 类型错误: ${TYPE_ERRORS}

## 修复结果
$(cat "$LOG_DIR"/heal_round_*.json 2>/dev/null | jq -r '.result.fixed[]? // empty' | sed 's/^/- /')

## 最终状态
$( [ "$PASSED" = "true" ] && echo "✅ 全部通过" || echo "⚠️ 仍有未解决问题" )

## 详细日志
- 检测: $LOG_DIR/detection.json
$(for i in $(seq 1 $ROUND); do echo "- 第${i}轮修复: $LOG_DIR/heal_round_${i}.json"; done)
- 最终验证: $LOG_DIR/final_verify.json
EOF

echo "📄 报告已生成: $LOG_DIR/report.md"
echo "$LOG_DIR/report.md"

flowchart TB
    Start([流水线启动]) --> Detect[阶段1: 全面检测]

    Detect --> |claude -p --allowedTools Read,Bash| Analyze[ESLint + TSC + Tests]
    Analyze --> ParseResult[解析检测结果JSON]
    ParseResult --> CheckProblems{发现问题?}

    CheckProblems --> |无问题| FinalVerify[阶段3: 最终验证]
    CheckProblems --> |有问题| HealRound[阶段2: 自愈循环]

    HealRound --> |claude -p --continue| Fix[修复 + 逐项验证]
    Fix --> PostHook[PostToolUse Hook: 自动格式化]
    PostHook --> CheckRound{达到最大轮次?}

    CheckRound --> |否| HealRound
    CheckRound --> |是| FinalVerify

    FinalVerify --> |claude -p --continue| VerifyAll[运行全套检查]
    VerifyAll --> StopHook[Stop Hook: 生成报告]
    StopHook --> Report[输出汇总报告]

    Report --> Decision{全部通过?}
    Decision --> |是| Success([✅ 流水线成功])
    Decision --> |否| ManualReview([⚠️ 需人工审查])

    PreHook[PreToolUse Hook: 安全拦截] -.-> |阻止危险操作| Fix
    PreWrite[PreToolUse Hook: 文件保护] -.-> |保护敏感文件| Fix

    style Start fill:#4caf50,color:#fff
    style Success fill:#4caf50,color:#fff
    style ManualReview fill:#ff9800,color:#fff
    style PreHook fill:#f44336,color:#fff
    style PreWrite fill:#f44336,color:#fff
    style PostHook fill:#2196f3,color:#fff
    style StopHook fill:#9c27b0,color:#fff

graph LR
    A[Stop事件] -->|Hook脚本| B[触发 claude -p 验证]
    B -->|PostToolUse| C[自动格式化]
    C -->|发现新问题| D[触发 claude -p 修复]
    D -->|Stop事件| E[生成报告]
    E -->|发送通知| F[Slack/邮件]

// on-stop-cascade.js — Stop事件触发级联
const { exec } = require('child_process');

let input = '';
process.stdin.on('data', (chunk) => { input += chunk; });
process.stdin.on('end', () => {
  const data = JSON.parse(input);

  // 防止无限递归：检查环境变量标记
  if (process.env.CLAUDE_CASCADE_DEPTH > 2) {
    process.exit(0);
  }

  // 在后台启动验证Agent
  const env = { 
    ...process.env, 
    CLAUDE_CASCADE_DEPTH: String((parseInt(process.env.CLAUDE_CASCADE_DEPTH || '0') + 1))
  };

  exec(
    'claude -p "验证上一次修改的正确性" --max-turns 3 --output-format json',
    { env, timeout: 120000 },
    (err, stdout) => {
      if (!err && stdout) {
        // 可以继续触发通知等后续操作
        const result = JSON.parse(stdout);
        // 发送到外部系统...
      }
    }
  );

  process.exit(0);
});

#!/bin/bash
# smart-router.sh — 智能路由脚本

# 第一步：分类
CLASSIFY=$(claude -p "分析当前Git仓库的变更，将它们分为三类：
- REFACTOR: 代码重构（需运行全量测试）
- STYLE: 样式/格式修改（只需lint）
- DOCS: 文档变更（无需测试）
输出JSON：{ category: string, confidence: number }" \
  --allowedTools "Read,Bash,Grep" \
  --max-turns 3 \
  --output-format json)

CATEGORY=$(echo "$CLASSIFY" | jq -r '.result.category // "unknown"')

echo "路由决策: $CATEGORY"

case "$CATEGORY" in
  "REFACTOR")
    echo "执行完整验证流水线..."
    claude -p "运行完整测试套件，包括单元测试、集成测试和E2E测试" \
      --continue --max-turns 10 --allowedTools "Read,Bash"
    ;;
  "STYLE")
    echo "执行轻量验证..."
    claude -p "运行ESLint和Prettier检查" \
      --continue --max-turns 3 --allowedTools "Read,Bash"
    ;;
  "DOCS")
    echo "跳过测试，仅检查链接..."
    claude -p "检查文档中的死链接" \
      --continue --max-turns 3 --allowedTools "Read,Bash,Grep"
    ;;
  *)
    echo "无法分类，执行默认验证..."
    claude -p "运行基本lint和类型检查" \
      --continue --max-turns 5 --allowedTools "Read,Bash"
    ;;
esac

#!/bin/bash
# nightly-patrol.sh — 每夜巡检脚本
# crontab: 0 2 * * * /path/to/nightly-patrol.sh /path/to/project

PROJECT="$1"
DATE=$(date +%Y%m%d)
LOG="/tmp/nightly-patrol-${DATE}.log"

cd "$PROJECT" || exit 1
git pull origin main 2>/dev/null

# 巡检任务列表
claude -p "执行每日代码健康巡检：

1. 检查依赖安全性: npm audit (只报告critical和high)
2. 检查过期依赖: npx npm-check-updates
3. 检查代码复杂度: 找到圈复杂度超过15的函数
4. 检查测试覆盖率: 运行覆盖率报告，标记低于80%的模块
5. 检查TODO/FIXME数量变化: 与上周对比

输出结构化JSON报告。" \
  --allowedTools "Read,Bash,Grep,Glob" \
  --max-turns 8 \
  --output-format json > "$LOG" 2>&1

# 如果有Critical安全问题，发送告警
CRITICAL=$(jq -r '.result.critical_vulnerabilities // 0' "$LOG")
if [ "$CRITICAL" -gt 0 ]; then
  # 发送Slack通知（使用webhook）
  curl -s -X POST "$SLACK_WEBHOOK" \
    -H 'Content-type: application/json' \
    --data "{\"text\":\"🚨 巡检告警: ${CRITICAL}个Critical安全漏洞 - ${PROJECT}\"}" \
    > /dev/null
fi

graph TD
    A[自动化安全] --> B[权限最小化]
    A --> C[递归防护]
    A --> D[输出验证]
    A --> E[审计追踪]

    B --> B1["--allowedTools 限定必需工具"]
    B --> B2["--max-turns 限制Agent轮次"]
    B --> B3["--system-prompt 约束行为边界"]

    C --> C1["环境变量标记递归深度"]
    C --> C2["全局超时机制"]
    C --> C3["退出码检测死循环"]

    D --> D1["jq校验JSON输出结构"]
    D --> D2["敏感信息脱敏"]
    D --> D3["错误边界处理"]

    E --> E1["记录所有-p调用日志"]
    E --> E2["Hook执行日志持久化"]
    E --> E3["Git diff审计每次修改"]

# 错误：给予所有权限
claude -p "修复bug" --dangerously-skip-permissions

# 正确：精确指定所需工具
claude -p "修复bug" \
  --allowedTools "Read,Write,Grep,Bash" \
  --disallowedTools "NotebookEdit" \
  --max-turns 5

# 在Hook脚本中设置深度限制
MAX_DEPTH=${CLAUDE_CASCADE_DEPTH:-0}
if [ "$MAX_DEPTH" -ge 3 ]; then
  echo "级联深度超限，终止"
  exit 0
fi
export CLAUDE_CASCADE_DEPTH=$((MAX_DEPTH + 1))

# 使用Docker容器隔离自动化执行
docker run --rm \
  -v "$(pwd):/workspace" \
  -e ANTHROPIC_API_KEY="$ANTHROPIC_API_KEY" \
  claude-code-auto \
  claude -p "修复所有lint错误" \
    --max-turns 10 \
    --allowedTools "Read,Write,Bash,Grep"

# 开启verbose输出查看完整决策过程
claude -p "分析代码" --verbose --output-format stream-json

# 使用--verbose配合stream-json实时观察Agent思考过程
claude -p "重构模块" --verbose --output-format stream-json 2>&1 | \
  jq -c 'select(.type == "assistant") | .message.content'

# 查看会话历史
claude sessions list

# 查看特定会话的详细日志
claude sessions show <session-id>