Claude Code /simplify与/batch：批量代码操作实战

claude --version
# 确保输出 ≥ 2.1.63

                    ┌──────────────────────┐
                    │   /simplify 启动     │
                    │  读取 git diff       │
                    └──────────┬───────────┘
                               │
              ┌────────────────┼────────────────┐
              ▼                ▼                 ▼
    ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
    │  Agent 1:       │ │  Agent 2:       │ │  Agent 3:       │
    │  代码复用审查   │ │  代码质量审查   │ │  执行效率审查   │
    │                 │ │                 │ │                 │
    │  - 重复代码检测 │ │  - 命名规范     │ │  - 不必要计算   │
    │  - 抽象机会    │ │  - 函数复杂度   │ │  - 冗余I/O     │
    │  - 模式统一    │ │  - 类型安全     │ │  - 内存泄漏     │
    └────────┬────────┘ └────────┬────────┘ └────────┬────────┘
             │                   │                   │
             └───────────────────┼───────────────────┘
                                 ▼
                    ┌──────────────────────┐
                    │   汇总报告 + 自动修复 │
                    └──────────────────────┘

# 在 Claude Code 交互模式中输入
/simplify

Running /simplify on your recent changes...

3 review agents completed:
┌─────────────┬──────────┬──────────┐
│ Agent        │ Issues   │ Severity │
├─────────────┼──────────┼──────────┤
│ Reuse        │ 4 found  │ 2 medium │
│ Quality      │ 3 found  │ 1 high   │
│ Efficiency   │ 2 found  │ 1 medium │
└─────────────┴──────────┴──────────┘

Key findings:
1. [Quality-HIGH] `processOrder()` has cyclomatic complexity of 15
   → Suggestion: Extract validation logic into separate function
2. [Reuse-MED] Duplicate error handling pattern in 3 files
   → Suggestion: Create shared `handleApiError()` utility
3. [Efficiency-MED] `getUserData()` called twice in same flow
   → Suggestion: Cache result from first call

Apply fixes? (Y/n)

# 只审查特定文件
/simplify src/api/orders.ts src/api/payments.ts

# 审查最近3次提交的变更
/simplify --since HEAD~3

# 结合 git stash 审查已暂存的变更
git stash
/simplify --staged

// OrderDashboard.tsx — 生成后的初始版本（约280行）
import React, { useState, useEffect } from 'react';
import { fetchOrders, fetchUsers, fetchProducts } from './api';
import { format } from 'date-fns';

export function OrderDashboard() {
  const [orders, setOrders] = useState([]);
  const [users, setUsers] = useState([]);
  const [products, setProducts] = useState([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);
  const [filter, setFilter] = useState('all');

  useEffect(() => {
    const loadData = async () => {
      try {
        setLoading(true);
        const [o, u, p] = await Promise.all([
          fetchOrders(),
          fetchUsers(),
          fetchProducts()
        ]);
        setOrders(o);
        setUsers(u);
        setProducts(p);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    };
    loadData();
  }, []);

  // 以下有大量重复的过滤、排序、格式化逻辑...
  // 嵌套的三元运算符...
  // 重复的 loading/error 处理...
}

// OrderDashboard.tsx — /simplify 优化后（约120行）
import React, { useState, useEffect, useMemo } from 'react';
import { useApi } from '../hooks/useApi';      // 复用现有hook
import { formatDate, formatCurrency } from '../utils/formatters'; // 统一格式化
import { FilterBar } from './FilterBar';       // 提取的子组件
import { OrderTable } from './OrderTable';     // 提取的子组件

export function OrderDashboard() {
  const { data: orders, loading, error } = useApi(fetchOrders);
  const { data: users } = useApi(fetchUsers);
  const { data: products } = useApi(fetchProducts);
  const [filter, setFilter] = useState('all');

  const enrichedOrders = useMemo(() =>
    orders?.map(order => ({
      ...order,
      userName: users?.find(u => u.id === order.userId)?.name,
      productName: products?.find(p => p.id === order.productId)?.name,
    })) ?? [],
    [orders, users, products]
  );

  if (loading) return <LoadingSpinner />;
  if (error) return <ErrorBanner message={error} />;

  return (
    <div className="order-dashboard">
      <FilterBar value={filter} onChange={setFilter} />
      <OrderTable orders={enrichedOrders} filter={filter} />
    </div>
  );
}

┌───────────────────────────────────────────────────────────┐
│                    /batch 执行流程                         │
├───────────────────────────────────────────────────────────┤
│                                                           │
│  Phase 1: 计划阶段 (Plan)                                 │
│  ┌─────────────────────────────────────────────────┐     │
│  │ 1. 接收用户指令（如"将所有class组件改为函数组件"）  │     │
│  │ 2. 扫描目标文件范围                               │     │
│  │ 3. 分析每个文件需要的具体修改                     │     │
│  │ 4. 按依赖关系分组                                │     │
│  │ 5. 生成执行计划并展示给用户                       │     │
│  └──────────────────────┬──────────────────────────┘     │
│                         │ 用户确认                         │
│                         ▼                                 │
│  Phase 2: 执行阶段 (Execute)                              │
│  ┌─────────────────────────────────────────────────┐     │
│  │                                                  │     │
│  │  ┌──────┐  ┌──────┐  ┌──────┐  ┌──────┐        │     │
│  │  │Sub   │  │Sub   │  │Sub   │  │Sub   │        │     │
│  │  │Agent │  │Agent │  │Agent │  │Agent │        │     │
│  │  │ #1   │  │ #2   │  │ #3   │  │ #4   │        │     │
│  │  │      │  │      │  │      │  │      │        │     │
│  │  │File  │  │File  │  │File  │  │File  │        │     │
│  │  │Group │  │Group │  │Group │  │Group │        │     │
│  │  │ A    │  │ B    │  │ C    │  │ D    │        │     │
│  │  └──┬───┘  └──┬───┘  └──┬───┘  └──┬───┘        │     │
│  │     │         │         │         │             │     │
│  │     └─────────┴─────────┴─────────┘             │     │
│  │                    │                             │     │
│  │                    ▼                             │     │
│  │           变更验证 + 汇总报告                      │     │
│  └─────────────────────────────────────────────────┘     │
│                                                           │
└───────────────────────────────────────────────────────────┘

# 在 Claude Code 交互模式中
/batch 将所有 callback 风格的异步函数改为 async/await

/batch Plan: Convert callbacks to async/await

Scope: 23 files across 4 directories
┌─────────────────┬───────────┬──────────────┐
│ Group            │ Files     │ Dependencies │
├─────────────────┼───────────┼──────────────┤
│ A: Core API      │ 8 files   │ None         │
│ B: Services      │ 6 files   │ A            │
│ C: Utilities     │ 5 files   │ None         │
│ D: Tests         │ 4 files   │ A, B, C      │
└─────────────────┴───────────┴──────────────┘

Estimated changes: ~150 line modifications
Groups A & C can run in parallel, then B, then D.

Proceed? (Y/n/e-edit plan)

# React 类组件 → 函数组件
/batch 将所有 React class 组件迁移为函数组件，使用 hooks 替代生命周期方法。先列出所有需要修改的文件，按目录分组执行。

# Vue 2 → Vue 3 Composition API
/batch 将所有 Vue 2 Options API 组件迁移为 Vue 3 Composition API 的 <script setup> 语法。注意保持 props 和 emit 定义不变。

# 旧API → 新API
/batch 将代码中所有使用 deprecatedApiClient 的地方替换为 newApiService。注意参数映射关系：旧API的 page/size 对应新API的 offset/limit。先更新类型定义文件，再更新所有调用方。

# 日志框架切换
/batch 将所有 console.log/console.error 调用替换为结构化日志 logger.info/logger.error，保留原始日志信息并添加上下文字段。

# CSS Module 迁移
/batch 将所有内联 style 对象转换为 CSS Module 引用。为每个组件创建对应的 .module.css 文件，将内联样式提取到 CSS 类中，更新组件引用。

# 测试框架迁移
/batch 将所有 Jest 测试文件迁移到 Vitest。更新 import 语句、mock 语法、断言方法。先处理配置文件，再批量更新测试文件。

Group A (无依赖): 类型定义、常量、工具函数
Group B (依赖A): 服务层、数据访问层
Group C (依赖A): API控制器
Group D (依赖B,C): 测试文件

/batch 按 src/ 下的模块目录分组，每个模块作为独立的执行组。

/batch 将同名修改分为一组：所有 import 语句修改为一组，所有函数签名修改为一组，所有测试更新为一组。

# 如果 /batch 执行中途发现问题
# 直接在 Claude Code 中输入
撤销上一组 /batch 的修改

# 或用 git 回滚
git checkout -- .

大规模重构/迁移 → /batch 执行批量修改 → /simplify 清理代码质量

# Step 1: 用 /batch 做框架迁移
/batch 将所有 Express 路由迁移到 Fastify。将 router.get/post/put/delete 语法迁移为 Fastify 的 route 方法定义。将 Express 中间件转换为 Fastify 插件。更新类型定义。按 routes/ 目录分组执行。

# Step 2: /batch 完成后，运行 /simplify 清理
/simplify
# /simplify 会发现迁移过程中产生的冗余代码：
# - 重复的类型转换
# - 不必要的中间层封装
# - 遗留的 Express 风格错误处理

#!/bin/bash
# auto-simplify.sh — 自动化代码质量检查脚本

# 1. 获取变更文件列表
CHANGED_FILES=$(git diff --name-only origin/main...HEAD)

if [ -z "$CHANGED_FILES" ]; then
  echo "No changes detected."
  exit 0
fi

echo "Running /simplify on changed files..."

# 2. 以 headless 模式运行 /simplify
claude -p "/simplify $CHANGED_FILES" \
  --output-format json \
  --allowedTools "Edit,Read,Bash" \
  --max-turns 10

# 3. 检查结果
if [ $? -eq 0 ]; then
  echo "Simplify completed successfully."
  # 运行测试验证
  npm test
else
  echo "Simplify encountered issues."
  exit 1
fi

claude -p "/batch 将所有 Python 文件的 f-string 中用到的 .format() 调用改为 f-string 语法" \
  --output-format stream-json \
  --verbose \
  --include-partial-messages

{"type":"assistant","subtype":"text","text":"Analyzing 47 files..."}
{"type":"assistant","subtype":"text","text":"Group A: 12 files (core/)"}
{"type":"assistant","subtype":"text","text":"Group B: 15 files (services/)"}
{"type":"tool_use","tool":"Task","input":{"description":"Batch Group A","prompt":"..."}}
{"type":"tool_result","tool":"Task","output":"Modified 12 files successfully"}
{"type":"tool_use","tool":"Task","input":{"description":"Batch Group B","prompt":"..."}}
{"type":"tool_result","tool":"Task","output":"Modified 15 files successfully"}
{"type":"assistant","subtype":"text","text":"Batch complete: 47 files modified, 0 errors"}

claude -p "/batch 将所有 .py 文件的 print() 调用替换为 logger.info()" \
  --output-format stream-json \
  --verbose 2>/dev/null | \
  jq -r 'select(.type=="assistant") | .text' | \
  grep -E "(Group|Modified|Error|Complete)"

# .github/workflows/ai-code-quality.yml
name: AI Code Quality Gate

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  simplify-check:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Setup Claude Code
        run: npm install -g @anthropic-ai/claude-code

      - name: Run /simplify review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # 获取PR变更的文件
          CHANGED=$(git diff --name-only origin/${{ github.base_ref }}...HEAD | tr '\n' ' ')

          # 以只读模式运行质量检查（不自动修复）
          claude -p "分析以下文件的代码质量：$CHANGED。检查代码复用、命名规范、执行效率三个方面。输出JSON格式的报告。" \
            --output-format json \
            --allowedTools "Read,Glob,Grep,Bash" \
            --max-turns 15 > simplify-report.json

      - name: Upload Report
        uses: actions/upload-artifact@v4
        with:
          name: simplify-report
          path: simplify-report.json

      - name: Comment on PR
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const report = JSON.parse(fs.readFileSync('simplify-report.json', 'utf8'));
            // 解析报告并添加PR评论
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: formatReport(report)
            });

# 先让 Claude Code 扫描项目现状
claude -p "统计这个项目中所有 TypeScript 文件的使用情况：
1. 有多少个 any 类型标注
2. 有多少个文件启用了 strict 模式
3. 有多少个函数缺少返回类型
4. 有多少个参数缺少类型标注
输出JSON格式的统计报告。" \
  --output-format json \
  --allowedTools "Read,Glob,Grep,Bash"

# 在 Claude Code 交互模式中执行

# Phase 1: 类型定义基础
/batch 创建完整的类型定义体系。
- 在 src/types/ 下创建所有业务实体的接口定义
- 每个接口包含完整的字段类型和 JSDoc 注释
- 按领域分组：用户、订单、商品、支付
- 先分析现有的接口和数据结构，确保类型定义覆盖所有使用场景

# Phase 2: API层类型化
/batch 为所有 API 路由添加完整的请求/响应类型。
- 创建统一的 Request<T> 和 Response<T> 泛型类型
- 为每个路由的 req.body、req.params、req.query 添加类型标注
- 添加返回类型标注
- 按 routes/ 目录分组执行

# Phase 3: 服务层类型化
/batch 为所有 service 文件添加完整的函数签名类型。
- 替换所有 any 为具体类型
- 添加函数参数和返回值类型
- 确保与 Phase 1 定义的类型一致
- 按 services/ 目录分组执行

# Phase 4: 数据访问层
/batch 为所有数据库操作添加类型标注。
- 为查询结果添加类型映射
- 替换 raw query 中的 any 为具体类型
- 确保与业务实体类型一致

# Phase 5: 清理
/simplify
# 清理类型化过程中产生的冗余代码

# 运行类型检查
npx tsc --noEmit

# 如果有错误，让 Claude Code 修复
claude -p "运行 npx tsc --noEmit 并修复所有类型错误" \
  --max-turns 15

# 运行测试确保没有破坏功能
npm test

## Type Safety Rules
- 禁止使用 any 类型，特殊情况用 unknown 并添加类型守卫
- 所有公共函数必须有参数类型和返回类型
- 新文件必须启用 strict 模式
- API 路由必须使用 Request<T> 和 Response<T> 泛型

# 原因：项目文件太多，扫描时间过长
# 解决：缩小范围
/batch 只处理 src/api/ 目录下的文件，将 callback 改为 async/await

# 原因：审查范围包含了稳定代码
# 解决：先 git stash 不相关变更，只保留目标变更
git stash push -m "temp" -- src/stable/
/simplify
git stash pop

# 原因：两个Agent修改了同一文件
# 解决：使用更精细的分组策略
/batch 将所有测试文件的 import 路径从 '@/utils' 改为 '@/lib/utils'。每个文件作为独立任务，不要并行修改同一个文件。

# 解决：分阶段执行，每阶段完成后 commit
# Phase 1
/batch 处理 src/types/ 目录的类型迁移
git add -A && git commit -m "chore: batch phase 1 - types"

# Phase 2
/batch 处理 src/api/ 目录的类型迁移
git add -A && git commit -m "chore: batch phase 2 - api"

# 在 Claude Code 交互模式中设置定时巡检
/loop 每天早上9点运行以下任务：
1. 拉取最新代码
2. 检查最近24小时的提交
3. 对新增/修改的文件运行 /simplify 审查
4. 生成代码质量报告并保存到 docs/reports/

graph TD
    A[开发功能] --> B[git add 暂存变更]
    B --> C{变更规模?}
    C -->|小规模<br><10个文件| D[运行 /simplify]
    C -->|大规模<br>≥10个文件| E[运行 /batch]
    E --> F[审查执行计划]
    F --> G[确认并执行]
    G --> H[批量修改完成]
    H --> D
    D --> I[审查优化建议]
    I --> J{自动修复?}
    J -->|是| K[应用修复]
    J -->|否| L[仅保留报告]
    K --> M[运行测试验证]
    L --> M
    M --> N{测试通过?}
    N -->|是| O[git commit 提交]
    N -->|否| P[修复测试失败]
    P --> M
    O --> Q[CI/CD 代码质量检查]
    Q --> R{质量门禁通过?}
    R -->|是| S[合并到主分支]
    R -->|否| T[运行 /simplify 修复]
    T --> M

    style D fill:#4CAF50,color:#fff
    style E fill:#2196F3,color:#fff
    style K fill:#FF9800,color:#fff
    style S fill:#8BC34A,color:#fff

## Code Quality Standards
- 所有函数不超过30行
- 嵌套不超过3层
- 所有 API 调用必须有超时设置
- 所有异步操作必须有错误处理
- 禁止使用 var 关键字
- 所有 React 组件必须有 displayName

<!-- .claude/commands/batch-add-logging.md -->
# 批量添加结构化日志

对以下文件添加结构化日志：

1. 分析 $ARGUMENTS 中的所有文件
2. 为每个函数的入口和出口添加 logger.debug 日志
3. 为每个错误处理分支添加 logger.error 日志
4. 日志格式：`[模块名.函数名] 操作描述 {关键参数}`
5. 使用项目统一的 logger 实例
6. 按文件分组并行执行

/project:batch-add-logging src/api/*.ts

/batch 分析整个 monorepo 的包依赖图。然后按照以下顺序批量升级所有包的依赖版本：
1. 先升级 packages/shared/ 中的共享包
2. 再升级依赖共享包的中间层包
3. 最后升级应用层包
每个包升级后运行该包的测试，确保兼容性。