用 Claude Code 造一个断点续跑的批量重构引擎

claude --version        # 确认版本
jq --version
git --version
echo "$ANTHROPIC_API_KEY" | head -c 6   # 确认鉴权在位（只打印前6位）

mkdir -p worktrees state logs

{"id":"svc-a-esm","repo":"https://github.com/acme/svc-a.git","rule":"把所有 .js 从 CommonJS(require/module.exports)迁到 ESM(import/export)，package.json 加 \"type\":\"module\"，最后跑 npm test 验证全绿"}
{"id":"svc-b-pytest","repo":"https://github.com/acme/svc-b.git","rule":"把测试框架从 nose 迁到 pytest，修正全部兼容性问题并跑通"}
{"id":"svc-c-logfmt","repo":"https://github.com/acme/svc-c.git","rule":"把项目日志从 console.log 换成 pino 结构化日志，保留原有信息字段"}

SCHEMA='{"type":"object","properties":{"status":{"type":"string","enum":["done","failed"]},"summary":{"type":"string"}},"required":["status","summary"]}'

task_state() { cat "state/$1.json" 2>/dev/null || echo '{}'; }
ts_get() { task_state "$1" | jq -r --arg k "$2" '.[$k] // empty'; }
ts_set() {  # id key value —— 原子写：写临时文件再 mv
  jq --arg k "$2" --arg v "$3" '.[$k]=$v' "state/$1.json" > "state/$1.json.tmp" \
    && mv "state/$1.json.tmp" "state/$1.json"
}

run_task() {
  local id="$1" repo="$2" rule="$3" wt="worktrees/$id" out sid status
  # 2a. 首次执行才 clone；续跑复用已有工作树
  [ -d "$wt/.git" ] || { git clone -q "$repo" "$wt" 2>>"logs/$id.err" \
    || { ts_set "$id" status clone-failed; return 1; }; }

  local prev_sid; prev_sid=$(ts_get "$id" session_id)
  if [ -n "$prev_sid" ] && [ "$prev_sid" != "none" ]; then
    # 续跑分支：在原目录里 resume 那个未完成的会话
    out=$(cd "$wt" && claude --resume "$prev_sid" -p \
          "继续完成上一轮未跑完的重构任务，规则同前：$rule。完成后自报 done。" \
          --bare --allowedTools "Read,Edit,Bash" \
          --output-format json --json-schema "$SCHEMA" 2>&1)
  else
    # 启动分支：全新无头会话
    out=$(cd "$wt" && claude -p "$rule" \
          --bare --allowedTools "Read,Edit,Bash" \
          --output-format json --json-schema "$SCHEMA" 2>&1)
  fi

  # 2b. 解析结构化结果，回写状态
  sid=$(printf '%s' "$out" | jq -r '.session_id // empty' 2>/dev/null)
  status=$(printf '%s' "$out" | jq -r '.structured_output.status // "running"' 2>/dev/null)
  ts_set "$id" session_id "${sid:-none}"
  ts_set "$id" status "$status"
  ts_set "$id" cost "$(printf '%s' "$out" | jq -r '.total_cost_usd // 0' 2>/dev/null)"
  ts_set "$id" attempts "$(( $(ts_get "$id" attempts) + 1 ))"
  ts_set "$id" updated "$(date -u +%FT%TZ)"
  printf '%s' "$out" > "logs/$id.jsonl"     # 留底，方便排查
}

MAX_PARALLEL="${MAX_PARALLEL:-2}"

wait_for_slot() {
  while [ "$(jobs -rp | wc -l)" -ge "$MAX_PARALLEL" ]; do sleep 0.5; done
}

while IFS= read -r line; do
  id=$(printf '%s' "$line"  | jq -r '.id')
  repo=$(printf '%s' "$line" | jq -r '.repo')
  rule=$(printf '%s' "$line" | jq -r '.rule')

  # 幂等：已 done 的直接跳过，不重复消费额度
  [ "$(ts_get "$id" status)" = "done" ] && { echo "skip (done): $id"; continue; }

  wait_for_slot
  echo "dispatch: $id"
  run_task "$id" "$repo" "$rule" &
done < "$QUEUE"
wait   # 等所有后台任务收尾
echo "本轮派发结束；未完成的请重跑脚本续接"

#!/usr/bin/env bash
set -uo pipefail
QUEUE="${QUEUE:-queue.jsonl}"
export MAX_PARALLEL="${MAX_PARALLEL:-2}"
mkdir -p worktrees state logs

# ...（粘贴 Step 2 的 SCHEMA + task_state/ts_get/ts_set/run_task）
# ...（粘贴 Step 3 的 wait_for_slot + 主循环）

# 收尾：汇总报告
echo "================ 批量重构汇总 ================"
for f in state/*.json; do
  i=$(basename "$f" .json)
  printf "%-18s %-10s \$%-8s attempts=%s\n" \
    "$i" "$(jq -r '.status' "$f")" "$(jq -r '.cost//0' "$f")" "$(jq -r '.attempts//0' "$f")"
done
total=$(cat state/*.json | jq -s '[.[] | (.cost//0|tonumber)] | add // 0')
echo "----------------------------------------------"
echo "本轮总花费: \$$total   (重跑只增不减已完成项)"

./overnight.sh                    # 跑到一半
# ... 6 小时后，机器重启 / 你按了 Ctrl-C / 网断了 ...
./overnight.sh                    # 立刻重跑

claude -p "正在重构 svc-a..." \
  --output-format stream-json --verbose --include-partial-messages \
  | jq -rc 'select(.type=="stream_event" and .event.delta.type?=="text_delta") | .event.delta.text'

watch -n 5 '
  done=$(grep -l "\"status\": \"done\"" state/*.json 2>/dev/null | wc -l)
  total=$(ls state/*.json 2>/dev/null | wc -l)
  echo "进度: $done / $total 已完成"
  grep -L "\"status\": \"done\"" state/*.json 2>/dev/null | xargs -r -n1 basename
'

export CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS=600000   # 单个后台 agent 最多等 10 分钟

#!/usr/bin/env bash
set -uo pipefail
QUEUE="${QUEUE:-queue.jsonl}"
MAX_PARALLEL="${MAX_PARALLEL:-2}"
export CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS=600000
mkdir -p worktrees state logs

SCHEMA='{"type":"object","properties":{"status":{"type":"string","enum":["done","failed"]},"summary":{"type":"string"}},"required":["status","summary"]}'

ts_get() { { cat "state/$1.json" 2>/dev/null || echo '{}'; } | jq -r --arg k "$2" '.[$k] // empty'; }
ts_set() { jq --arg k "$2" --arg v "$3" '.[$k]=$v' "state/$1.json" > "state/$1.json.tmp" && mv "state/$1.json.tmp" "state/$1.json"; }

run_task() {
  local id="$1" repo="$2" rule="$3" wt="worktrees/$1" out sid status
  [ -d "$wt/.git" ] || git clone -q "$repo" "$wt" 2>>"logs/$1.err" || { ts_set "$1" status clone-failed; return 1; }
  local prev; prev=$(ts_get "$1" session_id)
  if [ -n "$prev" ] && [ "$prev" != none ]; then
    out=$(cd "$wt" && claude --resume "$prev" -p "继续完成上一轮未跑完的重构：$rule。完成后自报 done。" \
          --bare --allowedTools "Read,Edit,Bash" --output-format json --json-schema "$SCHEMA" 2>&1)
  else
    out=$(cd "$wt" && claude -p "$rule" --bare --allowedTools "Read,Edit,Bash" \
          --output-format json --json-schema "$SCHEMA" 2>&1)
  fi
  sid=$(printf '%s' "$out" | jq -r '.session_id // empty' 2>/dev/null)
  status=$(printf '%s' "$out" | jq -r '.structured_output.status // "running"' 2>/dev/null)
  ts_set "$1" session_id "${sid:-none}"
  ts_set "$1" status "$status"
  ts_set "$1" cost "$(printf '%s' "$out" | jq -r '.total_cost_usd // 0' 2>/dev/null)"
  ts_set "$1" attempts "$(( $(ts_get "$1" attempts) + 1 ))"
  printf '%s' "$out" > "logs/$1.jsonl"
}

wait_for_slot() { while [ "$(jobs -rp | wc -l)" -ge "$MAX_PARALLEL" ]; do sleep 0.5; done; }

while IFS= read -r l; do
  id=$(printf '%s' "$l" | jq -r '.id'); repo=$(printf '%s' "$l" | jq -r '.repo'); rule=$(printf '%s' "$l" | jq -r '.rule')
  [ "$(ts_get "$id" status)" = done ] && { echo "skip(done): $id"; continue; }
  wait_for_slot; echo "dispatch: $id"; run_task "$id" "$repo" "$rule" &
done < "$QUEUE"
wait

echo "================ 汇总 ================"
for f in state/*.json; do i=$(basename "$f" .json)
  printf "%-18s %-10s \$%-8s attempts=%s\n" "$i" "$(jq -r '.status' "$f")" "$(jq -r '.cost//0' "$f")" "$(jq -r '.attempts//0' "$f")"
done
echo "总花费: \$$(cat state/*.json | jq -s '[.[]|(.cost//0|tonumber)]|add // 0')"

chmod +x overnight.sh
QUEUE=queue.jsonl MAX_PARALLEL=3 ./overnight.sh
# 断了就再敲一遍同样的命令，自动续跑

flowchart TD
  A[queue.jsonl 任务队列] --> B[读取一行任务]
  B --> C{state/id.json<br/>status==done?}
  C -- 是 --> Z[跳过，不消费额度]
  C -- 否 --> D{有有效 session_id?}
  D -- 否 --> E[首次: git clone 工作树]
  D -- 是 --> F[续跑: 复用已有工作树]
  E --> G[启动分支<br/>claude -p --bare --json-schema]
  F --> H[续跑分支<br/>claude --resume sid -p]
  G --> I[解析 JSON:<br/>session_id / structured_output / cost]
  H --> I
  I --> J{structured_output.status}
  J -- done --> K[标记完成]
  J -- running/failed --> L[保留 session_id<br/>等下一轮续跑]
  K --> M[等并发槽位]
  L --> M
  M --> B
  Z --> N{队列还有任务?}
  N -- 是 --> B
  N -- 否 --> R[汇总报告 + 总成本]

sequenceDiagram
  participant U as 你/CI
  participant O as overnight.sh
  participant W as worktrees/id
  participant C as claude -p
  U->>O: ./overnight.sh（首轮）
  O->>W: git clone（首次）
  O->>C: claude -p rule --bare --json-schema
  C-->>O: {session_id:S1, status:running, cost:0.12}
  Note over O: 写 state/id.json（S1 未完成）
  U-xO: Ctrl-C / 断电（S1 留在 running）
  U->>O: ./overnight.sh（重跑）
  O->>O: 读 state，status≠done，有 S1
  O->>C: claude --resume S1 -p 续跑
  C-->>O: {session_id:S1, status:done, cost:0.31}
  Note over O: 标记 done，成本累加