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

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

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

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

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

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

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

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

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

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

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

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

# 纯文本（默认）
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

{
  "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服务器的入口..."
}

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

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

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

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

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

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

# 简单任务用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

#!/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"

#!/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

#!/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

#!/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"

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

#!/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 "$@"' _ {}

#!/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 {})'

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

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

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

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

#!/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"

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: 流水线完成

# 提取纯文本结果
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"

# 实时监控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

# 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

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

# 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内容。'

#!/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"

# 赋予执行权限
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

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

#!/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

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

#!/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"

# 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 "迁移完成"

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

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

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

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

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

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

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

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

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