<!-- title: Claude Code管道实战：Shell集成到批处理流水线 -->

# Claude Code管道实战：Shell集成到批处理流水线

**适用人群**：已掌握Claude Code基础操作，希望将其嵌入Shell脚本、构建批处理流水线的开发者  
**学习目标**：掌握`-p`模式、管道操作、`xargs`并行、会话复用、输出解析五项核心能力，构建可复用的自动化脚本

---

## 一、前置条件

| 项目 | 要求 |
|------|------|
| Claude Code | v1.0.18+（支持`--output-format stream-json`） |
| 运行环境 | macOS / Linux（Windows需WSL2） |
| Shell | Bash 4.0+ 或 Zsh |
| 并行工具 | `parallel`或`xargs -P`（可选） |
| 认证 | `ANTHROPIC_API_KEY`环境变量已配置，或已通过`claude login`登录 |

验证安装：

```bash
claude --version
# 预期输出: Claude Code v1.0.x

echo $ANTHROPIC_API_KEY | head -c 10
# 预期输出: sk-ant-api0...（前10个字符）
```

---

## 二、核心概念：Claude Code的Unix哲学

Claude Code的设计遵循Unix管道哲学——标准输入进、标准输出出、可链式组合。理解这一点是掌握自动化的关键。

```mermaid
flowchart LR
    A[数据源] -->|"stdin / 管道"| B["claude -p"]
    B -->|"stdout"| C[下游处理]
    C -->|"管道"| D["jq / grep / tee"]
    D --> E[结果文件]

    style B fill:#7c3aed,stroke:#fff,color:#fff
```

`-p`（即`--print`）模式让Claude Code退化为一个**纯函数**：接收输入，返回输出，不进入交互界面。这是所有自动化的基石。

---

## 三、-p模式七大用法

### 3.1 基础单次执行

最简单的用法——直接传prompt字符串：

```bash
claude -p "列出当前目录下所有TypeScript文件，按修改时间排序"
```

预期输出：Claude读取当前目录，输出排序后的文件列表。

### 3.2 管道输入

将任意命令的输出作为Claude的输入：

```bash
# 分析Git日志
git log --oneline -20 | claude -p "总结这20条提交的主要改动方向"

# 分析错误日志
cat error.log | claude -p "找出所有ERROR级别日志的根因，按频率排序"

# 分析diff
git diff HEAD~5 | claude -p "审查这5个提交的代码变更，标记潜在bug"
```

### 3.3 Heredoc多行Prompt

当prompt较长时，使用heredoc：

```bash
claude -p <<'PROMPT'
你是一个代码审查专家。请审查以下代码：

1. 检查安全漏洞（SQL注入、XSS、命令注入）
2. 检查性能问题
3. 检查代码风格

代码文件列表：
$(find src -name "*.ts" -not -path "*/node_modules/*" | head -20)

请逐文件给出审查结论。
PROMPT
```

### 3.4 输出格式控制

`--output-format`控制返回数据的结构：

```bash
# 纯文本（默认）
claude -p "描述src/main.ts的功能" --output-format text

# JSON格式（便于jq解析）
claude -p "列出所有TODO注释，返回JSON数组" --output-format json

# 流式JSON（实时获取中间状态）
claude -p "重构utils.ts" --output-format stream-json
```

JSON输出结构示例：

```json
{
  "type": "result",
  "subtype": "success",
  "cost_usd": 0.0042,
  "duration_ms": 3200,
  "duration_api_ms": 2800,
  "is_error": false,
  "num_turns": 1,
  "result": "src/main.ts 实现了Express服务器的入口..."
}
```

**实战技巧**：用`jq`提取关键字段：

```bash
claude -p "这个项目的核心技术栈是什么" --output-format json | jq -r '.result'
```

### 3.5 限制工具权限

在自动化场景中，安全隔离至关重要。`--allowedTools`和`--disallowedTools`控制Agent的能力边界：

```bash
# 只读模式——禁止任何文件修改
claude -p "分析项目结构" \
  --allowedTools "Read,Glob,Grep"

# 禁止网络访问和Shell执行
claude -p "重构这段代码" \
  --disallowedTools "Bash,WebSearch,WebFetch"

# 仅允许搜索和编辑
claude -p "修复所有lint错误" \
  --allowedTools "Read,Edit,Glob,Grep,Bash"
```

### 3.6 限制执行轮次

`--max-turns`防止Agent陷入循环，是自动化脚本的保底机制：

```bash
# 最多执行5轮工具调用
claude -p "修复测试失败" --max-turns 5

# 配合--allowedTools使用——双重保险
claude -p "添加TypeScript类型注解" \
  --max-turns 10 \
  --allowedTools "Read,Edit,Glob,Grep"
```

### 3.7 指定模型

在批处理场景中，可按需选择模型以控制成本：

```bash
# 简单任务用Haiku（快且便宜）
claude -p "这段代码有什么明显bug？" --model claude-haiku-4-5-20251001

# 复杂重构用Sonnet
claude -p "将这个类重构为函数式风格" --model claude-sonnet-4-6

# 高难度架构决策用Opus
claude -p "设计微服务拆分方案" --model claude-opus-4-6
```

---

## 四、Shell脚本集成四式

### 4.1 变量捕获

将Claude输出存入Shell变量：

```bash
#!/bin/bash
# analyze-project.sh - 项目分析脚本

SUMMARY=$(claude -p "用一句话概括这个项目的功能" 2>/dev/null)
echo "项目摘要: $SUMMARY"

# 提取技术栈（JSON模式+jq解析）
TECH_STACK=$(claude -p "列出项目使用的主要技术栈，JSON数组格式" \
  --output-format json 2>/dev/null | jq -r '.result')

echo "技术栈: $TECH_STACK"
```

### 4.2 文件批处理

对多个文件执行相同操作：

```bash
#!/bin/bash
# batch-add-types.sh - 批量添加TypeScript类型注解

for file in $(find src -name "*.ts" -not -path "*/node_modules/*"); do
  echo "处理: $file"

  # 创建备份
  cp "$file" "${file}.bak"

  # 让Claude添加类型注解
  claude -p "为以下TypeScript文件添加类型注解，只输出修改后的完整文件内容，不要任何解释：

$(cat "$file")" > "$file"

  echo "完成: $file"
done
```

### 4.3 错误处理与重试

自动化脚本必须有健壮的错误处理：

```bash
#!/bin/bash
# safe-batch.sh - 带错误处理的批处理

set -euo pipefail

process_file() {
  local file=$1
  local max_retries=3
  local attempt=1

  while [ $attempt -le $max_retries ]; do
    echo "[尝试 $attempt/$max_retries] 处理: $file"

    if claude -p "为这个文件添加JSDoc注释：$(cat "$file")" \
       --max-turns 5 \
       --output-format json 2>/dev/null | jq -e '.result' > /dev/null 2>&1; then

      # 成功——保存结果
      claude -p "为这个文件添加JSDoc注释：$(cat "$file")" \
        --max-turns 5 > "${file%.ts}.documented.ts"

      echo "成功: $file"
      return 0
    fi

    attempt=$((attempt + 1))
    sleep 2
  done

  echo "失败: $file（已重试$max_retries次）" >&2
  return 1
}

# 导出函数供xargs使用
export -f process_file

# 串行处理
find src -name "*.ts" | while read -r file; do
  process_file "$file" || true  # 不因单个文件失败中断整体流程
done
```

### 4.4 结果收集与报告

将多个Claude调用的结果汇总：

```bash
#!/bin/bash
# security-audit.sh - 批量安全审计

REPORT_FILE="security-report-$(date +%Y%m%d).md"
echo "# 安全审计报告 - $(date +%Y-%m-%d)" > "$REPORT_FILE"

for file in $(find src -name "*.ts" -not -path "*/node_modules/*"); do
  echo "" >> "$REPORT_FILE"
  echo "## $file" >> "$REPORT_FILE"

  RESULT=$(claude -p "对这个TypeScript文件进行安全审计。检查：
1. SQL注入风险
2. XSS风险
3. 硬编码密钥或凭证
4. 不安全的依赖使用
5. 输入验证缺失

按严重程度（高/中/低）列出发现的问题。如果没有问题，输出'无安全问题'。

文件内容：
$(cat "$file")" --model claude-haiku-4-5-20251001 2>/dev/null)

  echo "$RESULT" >> "$REPORT_FILE"
  echo "已审计: $file"
done

echo "" >> "$REPORT_FILE"
echo "---" >> "$REPORT_FILE"
echo "审计完成时间: $(date)" >> "$REPORT_FILE"

echo "报告已生成: $REPORT_FILE"
```

---

## 五、xargs并行加速

串行处理太慢？用`xargs -P`并行执行：

```mermaid
flowchart TB
    subgraph "文件列表"
        F1[file1.ts]
        F2[file2.ts]
        F3[file3.ts]
        F4[file4.ts]
        F5[file5.ts]
        F6[file6.ts]
    end

    subgraph "并行Worker池 (P=3)"
        W1["Worker 1: claude -p"]
        W2["Worker 2: claude -p"]
        W3["Worker 3: claude -p"]
    end

    F1 --> W1
    F2 --> W2
    F3 --> W3
    F4 --> W1
    F5 --> W2
    F6 --> W3

    W1 --> R[结果收集]
    W2 --> R
    W3 --> R

    style W1 fill:#059669,stroke:#fff,color:#fff
    style W2 fill:#059669,stroke:#fff,color:#fff
    style W3 fill:#059669,stroke:#fff,color:#fff
```

### 5.1 基础并行执行

```bash
#!/bin/bash
# parallel-review.sh - 并行代码审查

# 定义Worker函数
review_file() {
  local file=$1
  local result=$(claude -p "审查这个文件的代码质量，指出最多3个最重要的改进建议：

$(cat "$file")" --model claude-haiku-4-5-20251001 \
    --max-turns 1 2>/dev/null)

  echo "=== $file ===" 
  echo "$result"
  echo ""
}

export -f review_file

# 4个并发Worker
find src -name "*.ts" -not -path "*/node_modules/*" | \
  xargs -P 4 -I {} bash -c 'review_file "$@"' _ {}
```

### 5.2 GNU Parallel（更强大）

如果安装了`parallel`，可以获得进度条和更好的错误处理：

```bash
#!/bin/bash
# parallel-migrate.sh - 并行框架迁移

# 检查parallel是否安装
command -v parallel >/dev/null 2>&1 || {
  echo "请先安装GNU Parallel: brew install parallel 或 apt install parallel"
  exit 1
}

# 创建输出目录
mkdir -p ./migrated

# 并行处理，保留进度日志
find src -name "*.js" | \
  parallel --progress \
    --joblog ./migrate-joblog.txt \
    -j 3 \
    'claude -p "将以下CommonJS代码转换为ES Module语法（import/export）。
只输出转换后的代码，不要任何解释：

$(cat {})" --max-turns 1 > ./migrated/$(basename {})'
```

### 5.3 并发数选择策略

| 场景 | 推荐并发数 | 理由 |
|------|-----------|------|
| Opus模型 | 1-2 | 每次调用成本高，避免并发超额 |
| Sonnet模型 | 3-5 | 平衡速度与成本 |
| Haiku模型 | 5-10 | 速度快成本低，可高并发 |
| CI环境 | 2-3 | 受API速率限制约束 |
| 本地开发 | 4-6 | 网络带宽充裕 |

---

## 六、会话复用：--continue与--resume

### 6.1 --continue：延续上次对话

`--continue`自动加载上一次会话的完整上下文：

```bash
# 第一次：分析项目
claude -p "分析这个项目的架构，列出主要模块"
# 输出: 项目采用分层架构，包含auth、api、db三个模块...

# 第二次：基于上次分析继续深入
claude -p --continue "针对你刚才提到的auth模块，详细分析其安全机制"
# Claude记得之前说的三个模块，直接围绕auth展开
```

### 6.2 --resume：恢复指定会话

`--resume`可指定具体会话ID：

```bash
# 列出历史会话
claude sessions list
# 输出:
# abc123  2026-05-29 14:30  "项目架构分析"
# def456  2026-05-29 15:20  "Bug修复"

# 恢复指定会话
claude -p --resume abc123 "继续分析db模块"
```

### 6.3 会话复用构建多步流水线

```bash
#!/bin/bash
# pipeline.sh - 多步分析流水线

# 第一步：收集项目信息
claude -p "分析项目结构，列出所有模块及其依赖关系" \
  --output-format json > /tmp/step1-modules.json

# 第二步：基于模块信息生成测试计划（延续上下文）
claude -p --continue "基于你刚才的模块分析，为每个模块生成测试优先级（高/中/低）" \
  --output-format json > /tmp/step2-priority.json

# 第三步：生成具体测试用例
claude -p --continue "为所有高优先级模块生成具体的单元测试用例列表" \
  > /tmp/step3-testcases.md

echo "流水线完成！"
echo "- 模块分析: /tmp/step1-modules.json"
echo "- 优先级排序: /tmp/step2-priority.json"
echo "- 测试用例: /tmp/step3-testcases.md"
```

```mermaid
sequenceDiagram
    participant S as Shell脚本
    participant C as Claude -p
    participant F as 文件系统

    S->>C: Step 1: 分析项目结构
    C-->>C: 加载项目上下文
    C->>F: 保存模块列表
    Note over C: 会话ID: ses_001

    S->>C: Step 2: --continue 生成测试优先级
    Note over C: 复用ses_001上下文
    C->>F: 保存优先级

    S->>C: Step 3: --continue 生成测试用例
    Note over C: 复用ses_001上下文
    C->>F: 保存测试用例

    S->>S: 流水线完成
```

---

## 七、输出解析与命令链

### 7.1 jq解析JSON输出

```bash
# 提取纯文本结果
claude -p "描述这个项目的架构" --output-format json | jq -r '.result'

# 提取成本信息
claude -p "列出所有TODO" --output-format json | jq '{cost: .cost_usd, turns: .num_turns}'

# 批量处理并汇总成本
total_cost=0
for f in src/*.ts; do
  resp=$(claude -p "统计这个文件的代码行数" --output-format json 2>/dev/null)
  cost=$(echo "$resp" | jq -r '.cost_usd')
  total_cost=$(echo "$total_cost + $cost" | bc)
  echo "$f: $cost"
done
echo "总成本: \$$total_cost"
```

### 7.2 流式JSON实时监控

`stream-json`模式逐条输出事件，适合长时间任务：

```bash
# 实时监控Agent执行过程
claude -p "重构整个src目录的导入语句" \
  --output-format stream-json | \
  while IFS= read -r line; do
    event=$(echo "$line" | jq -r '.type // empty')
    case $event in
      "assistant")
        echo "[Claude] $(echo "$line" | jq -r '.message.content[0].text // empty' | head -c 100)"
        ;;
      "tool_use")
        tool=$(echo "$line" | jq -r '.message.content[0].name // empty')
        echo "[工具] 调用: $tool"
        ;;
      "result")
        cost=$(echo "$line" | jq -r '.cost_usd // empty')
        echo "[完成] 成本: \$$cost"
        ;;
    esac
  done
```

### 7.3 管道链式组合

Claude输出可直接传入其他Unix工具：

```bash
# Claude → grep → sort → uniq → 统计
claude -p "分析src/下所有TypeScript文件的导入语句，列出每个导入的模块名" | \
  grep -oP '(?<=from ")[^"]+' | \
  sort | uniq -c | sort -rn | head -20

# Claude → 生成Markdown → 写入文件
claude -p "为src/api/生成API文档，Markdown格式" | \
  tee docs/api-generated.md

# Claude → jq → 条件判断
HAS_VULNS=$(claude -p "检查package.json中的依赖是否有已知漏洞" \
  --output-format json 2>/dev/null | jq -r '.result | test("漏洞|vulnerability"; "i")')

if [ "$HAS_VULNS" = "true" ]; then
  echo "发现安全漏洞！触发告警..."
  # 发送告警通知
fi
```

---

## 八、完整实战：多仓库自动文档生成流水线

以下是一个可直接运行的完整示例，展示如何用Shell脚本+Claude Code构建批量文档生成流水线。

### 8.1 项目结构

```
doc-pipeline/
├── generate-docs.sh      # 主脚本
├── config.sh             # 配置文件
└── output/               # 输出目录
    ├── reports/
    └── summary.md
```

### 8.2 配置文件

```bash
# config.sh - 流水线配置

# 目标仓库列表
REPOS=(
  "/path/to/project-a"
  "/path/to/project-b"
  "/path/to/project-c"
)

# Claude配置
MODEL="claude-haiku-4-5-20251001"   # 用Haiku控制成本
MAX_TURNS=3                          # 限制轮次
PARALLEL_JOBS=3                      # 并发数
OUTPUT_DIR="./output/reports"

# Prompt模板
README_PROMPT='为这个项目生成一份标准README.md，包含以下部分：
1. 项目名称与简介（一句话）
2. 功能特性（3-5条）
3. 快速开始（安装和运行步骤）
4. 项目结构（目录树）
5. 技术栈
6. License

项目根目录内容：
$(ls -la)
package.json:
$(cat package.json 2>/dev/null || echo "无package.json")
主要源码文件：
$(find . -name "*.ts" -o -name "*.js" -o -name "*.py" | head -20)
请直接输出Markdown格式的README内容。'
```

### 8.3 主脚本

```bash
#!/bin/bash
# generate-docs.sh - 多仓库文档生成流水线
set -euo pipefail

source ./config.sh

mkdir -p "$OUTPUT_DIR"

# 单仓库处理函数
process_repo() {
  local repo_path=$1
  local repo_name=$(basename "$repo_path")

  echo "[$(date +%H:%M:%S)] 开始处理: $repo_name"

  # 进入仓库目录执行
  cd "$repo_path"

  # 生成README
  local readme_content
  readme_content=$(claude -p "$README_PROMPT" \
    --model "$MODEL" \
    --max-turns "$MAX_TURNS" \
    --allowedTools "Read,Glob,Grep" \
    2>/dev/null)

  if [ $? -eq 0 ] && [ -n "$readme_content" ]; then
    echo "$readme_content" > "${OUTPUT_DIR}/${repo_name}-README.md"
    echo "[$(date +%H:%M:%S)] 完成: $repo_name ✓"
    return 0
  else
    echo "[$(date +%H:%M:%S)] 失败: $repo_name ✗" >&2
    return 1
  fi
}

export -f process_repo
export README_PROMPT MODEL MAX_TURNS OUTPUT_DIR

echo "======================================="
echo " 多仓库文档生成流水线"
echo " 仓库数量: ${#REPOS[@]}"
echo " 并发数: $PARALLEL_JOBS"
echo " 模型: $MODEL"
echo "======================================="

# 并行执行
SUCCESS=0
FAIL=0

printf '%s\n' "${REPOS[@]}" | \
  xargs -P "$PARALLEL_JOBS" -I {} bash -c 'process_repo "$@"' _ {} && \
  ((SUCCESS++)) || ((FAIL++))

# 生成汇总报告
echo "# 文档生成汇总" > ./output/summary.md
echo "" >> ./output/summary.md
echo "- 生成时间: $(date)" >> ./output/summary.md
echo "- 处理仓库: ${#REPOS[@]}" >> ./output/summary.md
echo "- 成功: $SUCCESS / 失败: $FAIL" >> ./output/summary.md

echo ""
echo "流水线执行完毕！报告目录: $OUTPUT_DIR"
```

### 8.4 执行与验证

```bash
# 赋予执行权限
chmod +x generate-docs.sh

# 执行
./generate-docs.sh

# 查看结果
ls -la output/reports/
cat output/summary.md
```

预期输出：

```
=======================================
 多仓库文档生成流水线
 仓库数量: 3
 并发数: 3
 模型: claude-haiku-4-5-20251001
=======================================
[14:30:01] 开始处理: project-a
[14:30:01] 开始处理: project-b
[14:30:01] 开始处理: project-c
[14:30:15] 完成: project-a ✓
[14:30:18] 完成: project-c ✓
[14:30:22] 完成: project-b ✓

流水线执行完毕！报告目录: ./output/reports
```

---

## 九、进阶技巧

### 9.1 stream-json + tee 实时观测与持久化

```bash
claude -p "重构整个src目录" \
  --output-format stream-json 2>/dev/null | \
  tee /tmp/claud-refactor-$(date +%s).jsonl | \
  jq --unbuffered -r 'select(.type == "result") | .result'
```

这行命令同时做到：
- `tee`将原始流式JSON保存为日志
- `jq`实时提取最终结果

### 9.2 条件分支执行

```bash
#!/bin/bash
# adaptive-process.sh - 根据Claude判断结果分支执行

ANALYSIS=$(claude -p "分析这个项目的测试覆盖率情况。
如果覆盖率低于50%，输出: LOW
如果覆盖率在50%-80%之间，输出: MEDIUM
如果覆盖率高于80%，输出: HIGH
只输出这一个词。" --max-turns 2 2>/dev/null)

case "$ANALYSIS" in
  *LOW*)
    echo "覆盖率过低，启动全面测试生成..."
    claude -p "为所有缺少测试的模块生成单元测试" \
      --max-turns 20 \
      --allowedTools "Read,Edit,Write,Glob,Grep,Bash"
    ;;
  *MEDIUM*)
    echo "覆盖率中等，启动增量测试补充..."
    claude -p "为覆盖率低于50%的文件补充测试" \
      --max-turns 10
    ;;
  *HIGH*)
    echo "覆盖率良好，无需操作。"
    ;;
  *)
    echo "无法判断覆盖率: $ANALYSIS"
    ;;
esac
```

### 9.3 定时任务（Cron集成）

```bash
# 每天凌晨2点执行代码审查
# crontab -e 添加：
0 2 * * * cd /path/to/project && /path/to/daily-review.sh >> /var/log/claude-review.log 2>&1
```

对应的`daily-review.sh`：

```bash
#!/bin/bash
cd "$(dirname "$0")"

DATE=$(date +%Y-%m-%d)
REPORT="daily-review-${DATE}.md"

# 获取最近24小时的提交
DIFF=$(git log --since="24 hours ago" --name-only --pretty=format:"%h %s" 2>/dev/null)

if [ -z "$DIFF" ]; then
  echo "[$DATE] 无新提交，跳过审查" >> "$REPORT"
  exit 0
fi

echo "# 每日代码审查 - $DATE" > "$REPORT"
echo "" >> "$REPORT"

claude -p "审查以下最近24小时的代码变更，重点检查：
1. 安全问题
2. 性能退化
3. 代码风格不一致

提交记录和变更文件：
$DIFF" >> "$REPORT" 2>/dev/null

echo "审查完成: $REPORT"
```

### 9.4 Makefile集成

```makefile
# Makefile - Claude Code自动化命令

.PHONY: review doc test migrate

# 代码审查
review:
	@git diff main...HEAD | claude -p "审查当前分支的所有变更，\
		标记高风险修改" --model claude-sonnet-4-6

# 生成API文档
doc:
	@claude -p "为src/api/目录生成OpenAPI格式的API文档" \
		--output-format json | jq -r '.result' > docs/api.md
	@echo "文档已生成: docs/api.md"

# 生成测试
test:
	@claude -p "为src/下所有没有对应测试文件的模块生成测试" \
		--max-turns 15 --allowedTools "Read,Write,Glob,Grep,Bash"

# 框架迁移
migrate:
	@echo "开始迁移..."
	@for f in src/**/*.js; do \
	 claude -p "将CommonJS转为ESM: $$(cat $$f)" \
	   --max-turns 1 > "$${f%.js}.mjs"; \
	done
	@echo "迁移完成"
```

---

## 十、常见问题排查

### Q1: `-p`模式下卡住不动

**原因**：Claude Code在等待工具权限确认。  
**解决**：在非交互模式下必须用`--allowedTools`预授权所需工具：

```bash
# 错误——会卡住
claude -p "修改config.json"

# 正确——预授权编辑权限
claude -p "修改config.json" --allowedTools "Read,Edit,Write"
```

### Q2: 输出包含ANSI转义码

**原因**：终端颜色码混入输出。  
**解决**：

```bash
# 方法1: 设置NO_COLOR环境变量
NO_COLOR=1 claude -p "列出所有函数名"

# 方法2: 用sed过滤
claude -p "列出所有函数名" | sed 's/\x1b\[[0-9;]*m//g'
```

### Q3: 并行执行时API限流

**原因**：并发请求超过API速率限制。  
**解决**：

```bash
# 降低并发数
xargs -P 2  # 从4降到2

# 或在脚本中加入限速
process_with_rate_limit() {
  local file=$1
  claude -p "处理 $file" --max-turns 1
  sleep 1  # 每次调用后等待1秒
}
```

### Q4: stream-json解析中断

**原因**：输出流被意外截断。  
**解决**：使用`--output-format json`替代`stream-json`，或用`jq`的容错模式：

```bash
claude -p "重构代码" --output-format stream-json | \
  jq -R -r 'fromjson? | select(.type == "result") | .result' 2>/dev/null
```

### Q5: 会话上下文丢失

**原因**：`--continue`只能恢复最近一次会话，如果中间有其他调用会覆盖。  
**解决**：用`--resume`指定具体会话ID：

```bash
# 先保存会话ID
SESSION_ID=$(claude -p "分析项目" --output-format json | jq -r '.session_id')
# 后续用ID恢复
claude -p --resume "$SESSION_ID" "继续分析"
```

---

## 十一、成本控制检查清单

在将Claude Code脚本投入生产前，逐项检查：

| 检查项 | 命令/方法 | 目的 |
|--------|----------|------|
| 限制轮次 | `--max-turns N` | 防止Agent无限循环 |
| 选择模型 | `--model haiku` | 简单任务用低成本模型 |
| 限制工具 | `--allowedTools` | 减少不必要的工具调用 |
| 设置预算 | 环境变量或平台限额 | 硬性成本上限 |
| 监控消耗 | `jq '.cost_usd'` | 每次调用后记录成本 |
| 错误重试 | `|| true` + 重试逻辑 | 避免一个失败全盘停止 |
| 日志留存 | `tee` | 事后审计和优化 |

```mermaid
flowchart TD
    A[脚本启动] --> B{设置--max-turns?}
    B -->|否| Z[警告: 可能无限循环]
    B -->|是| C{设置--model?}
    C -->|否| Z
    C -->|是| D{设置--allowedTools?}
    D -->|否| Z
    D -->|是| E{记录成本?}
    E -->|否| F[建议: 添加成本日志]
    E -->|是| G[检查通过 ✓]
    G --> H[可以投入运行]

    style G fill:#059669,stroke:#fff,color:#fff
    style Z fill:#dc2626,stroke:#fff,color:#fff
```

---

## 延伸阅读

- [Run Claude Code programmatically](https://code.claude.com/docs/en/headless) — Anthropic官方Headless模式文档
- [Claude Code Batch Processing Complete Guide](https://smartscope.blog/en/generative-ai/claude/claude-code-batch-processing/) — /batch命令与-p模式批处理详解
- [CLI Automation - Batch Processing & Workflows](https://moinsen-dev.github.io/claude_code_vibe_coding_guide/advanced/cli-automation) — CLI自动化完整指南
- [Headless Mode: Running Claude Code Without Human Interaction](https://inbounter.com/learn/claude/automation/headless-mode) — Headless模式深度教程
- [Claude Code Cheat Sheet](https://computingforgeeks.com/claude-code-cheat-sheet/) — 完整CLI速查表（2026）

## 训练营适用性评估

| 维度 | 评估 |
|------|------|
| 适合训练营类型 | DevOps自动化、开发者生产力、AI工具链 |
| 教学时长 | 3-4小时（含动手实验） |
| 学员基础要求 | Shell脚本基础、Git基础、Claude Code入门 |
| 实验环境需求 | 每人一个含5+文件的TypeScript项目、API Key |
| 难度等级 | 中级（需Shell编程基础） |

## 参考来源

1. [Run Claude Code programmatically - Claude Code Docs](https://code.claude.com/docs/en/headless) — Anthropic官方Headless/编程式执行文档，-p模式核心参考
2. [Claude Code Batch Processing Complete Guide](https://smartscope.blog/en/generative-ai/claude/claude-code-batch-processing/) — /batch命令与headless批处理系统指南
3. [CLI Automation - Vibe Coding Guide](https://moinsen-dev.github.io/claude_code_vibe_coding_guide/advanced/cli-automation) — CLI自动化与批处理工作流实战
4. [Claude Code --continue and --resume Guide](https://pasqualepillitteri.it/en/news/366/claude-code-continue-resume-guide) — 会话复用机制完整教程
5. [Headless Mode - Claude Code Tips](https://claudecodetips.com/en/guide/advanced/44) — Headless模式Unix管道技巧集

> [!tip] 51学通信知识星球
> **星主：爱卫生**（微信：gprshome201101）——公众号「51学通信」创办者，19 年通信行业运维与讲师经验，著有《GPRS网络信令实例详解》《EPC原理与实践》《5G核心网原理与实践》三本纸质书（各大电商平台有售）。
> **星球定位**：深耕 5G 核心网、IMS、NFV/AI、云原生等 ICT 领域，主打运维岗位与信令分析。
> **当前规模**：5200 篇主题 / 990 个回答，198 元/年。
> **加入福利**：加入星球后请加爱卫生微信，拉您进知识星球年度陪伴与答疑群——不限量回复您的各种问题，另有群内分享。
> **AI 加持**：51学通信知识星球已作为 skill 接入 WorkBuddy，使用 deepseek-4-flash 在海量星球帖子中精准找贴、找视频、找 FAQ 和案例，做总结、找文档和 PPT 等场景全覆盖。

![51学通信知识星球海报-扫码加入](https://wiki.500nian.com/images/zhixingqiu_qrcode.png)