<!-- title: Claude Code批量迁移五大战役全流程 -->

# Claude Code批量迁移五大战役全流程

## 概述

代码迁移是每个技术团队迟早要面对的硬仗——Vue 2终止维护、React Class组件淘汰、JavaScript向TypeScript全面转型、REST API迁移到GraphQL、CSS重构到Tailwind。传统迁移依赖人工逐文件修改，动辄数周甚至数月。Claude Code凭借1M token上下文窗口、`/batch`并行分解、worktree隔离执行、自定义Skill四大核心能力，将迁移周期从数周压缩到数天。本教程面向有Claude Code基础使用经验的中高级开发者，系统讲解五类最常见的代码迁移场景如何用Claude Code高效完成。

## 前置条件

- Claude Code CLI ≥ v2.1.63（支持`/batch`命令）
- Git ≥ 2.30（支持worktree）
- 目标项目已纳入Git版本控制
- 基本了解CLAUDE.md配置方法
- 建议使用Claude Opus 4.6模型（1M上下文窗口，迁移效果最佳）

## 迁移架构总览

```text
graph TD
    A[迁移需求分析] --> B{迁移类型判断}
    B --> C1[战役一: 语言迁移<br/>JS → TypeScript]
    B --> C2[战役二: 框架升级<br/>Vue2 → Vue3]
    B --> C3[战役三: 组件迁移<br/>Class → Hooks]
    B --> C4[战役四: API迁移<br/>REST → GraphQL]
    B --> C5[战役五: 样式迁移<br/>CSS → Tailwind]

    C1 & C2 & C3 & C4 & C5 --> D[CLAUDE.md迁移配置]
    D --> E{规模评估}
    E -->|<50文件| F[单Agent直接迁移]
    E -->|50-200文件| G[/batch并行分解]
    E -->|>200文件| H[分阶段+worktree隔离]

    F & G & H --> I[自动化测试验证]
    I --> J[人工Review + 合并]
```

## 迁移前准备：构建迁移CLAUDE.md

所有五大战役共享一个核心前提——在项目根目录创建专门的迁移配置。这不是简单的"告诉Claude你要迁移"，而是一份结构化的迁移蓝图。

```markdown
# CLAUDE.md — 迁移专用配置

## 项目概况
- 项目名称: my-enterprise-app
- 技术栈: Vue 2.6 + Vuex + JavaScript + SCSS
- 文件总数: 约850个源文件
- 测试覆盖率: 42%

## 当前迁移阶段
- [x] Phase 1: JavaScript → TypeScript（已完成60%）
- [ ] Phase 2: Vue 2 → Vue 3 Composition API
- [ ] Phase 3: SCSS → Tailwind CSS
- [ ] Phase 4: Vuex → Pinia

## 迁移规则
1. 每次迁移只处理一个模块，不要跨模块修改
2. 迁移后必须保持现有测试通过
3. 优先迁移工具函数和类型定义，最后迁移UI组件
4. 不允许在迁移过程中引入新功能
5. 每个文件迁移后必须能独立编译

## 禁止操作
- 不要删除任何现有测试
- 不要修改构建配置（webpack/vite）除非迁移要求
- 不要在迁移PR中混合非迁移改动

## 文件路径约定
- 类型定义: src/types/
- 工具函数: src/utils/
- 组件: src/components/
- 页面: src/views/
- 状态管理: src/store/
```

**关键原则**：CLAUDE.md中的迁移规则越精确，Claude Code产生幻觉或越界修改的概率越低。上述配置将"不要做什么"和"按什么顺序做"都写得清清楚楚。

---

## 战役一：JavaScript → TypeScript 全面转型

### 1.1 场景分析

这是最基础的迁移战役，也是后续所有战役的地基。一个中型项目通常有数百个`.js`文件需要转为`.ts`，涉及JSDoc类型标注转换、隐式any处理、第三方库类型声明安装等。

### 1.2 分阶段执行策略

**阶段一：生成类型基础**

```bash
# 第一步：让Claude Code分析项目并生成类型蓝图
claude -p "分析整个src/目录下的JavaScript文件，列出：
1. 所有导出的函数签名及其参数/返回类型
2. 所有接口和类型别名（从JSDoc中提取）
3. 第三方依赖中缺少@types/声明的包
4. 建议的迁移优先级排序

输出为markdown表格格式。" --output-format text > migration-type-audit.md
```

这一步利用Claude Code的`-p`模式（非交互式打印模式）进行全项目扫描，输出结构化的类型审计报告。`--output-format text`确保输出纯文本，方便后续处理。

**阶段二：批量安装类型声明**

```bash
# 基于审计报告，批量安装缺失的类型声明
claude -p "读取 migration-type-audit.md，生成npm命令来安装所有缺失的@types/包。
只输出可以直接执行的命令，不要任何解释。" --allowedTools "Bash(read_only)"
```

注意`--allowedTools`限制了Claude只能使用只读Bash命令，防止在规划阶段意外修改文件。

**阶段三：逐模块迁移**

```bash
# 对单个模块进行类型迁移
claude "将 src/utils/ 目录下所有 .js 文件迁移为 .ts：
1. 添加完整的类型注解，不使用any
2. 将JSDoc @param/@returns 转为TypeScript类型语法
3. 确保tsconfig strict模式编译通过
4. 保留所有现有导出签名不变
5. 运行 tsc --noEmit 验证"
```

**阶段四：大规模并行迁移（/batch模式）**

当迁移超过50个文件时，手动逐模块操作效率太低。`/batch`命令是专为这种场景设计的：

```bash
# 在Claude Code交互会话中执行
/batch 将 src/components/ 下所有 .js 文件迁移为 .tsx，遵循以下规则：
- 添加Props接口类型定义
- 将所有React.PropTypes转换为TypeScript类型
- 确保每个组件文件独立可编译
- 不修改组件逻辑或UI表现
```

`/batch`内部执行流程：
1. Claude分析目标范围，将变更分解为5-30个独立单元
2. 每个单元分配一个后台Agent
3. 每个Agent在独立的git worktree中执行
4. 所有Agent完成后，汇总结果并创建PR

```mermaid
sequenceDiagram
    participant U as 开发者
    participant C as Claude Code
    participant P as 规划Agent
    participant W1 as Worktree Agent 1
    participant W2 as Worktree Agent 2
    participant W3 as Worktree Agent 3
    
    U->>C: /batch JS→TS迁移 src/components/
    C->>P: 分析并分解迁移单元
    P->>C: 返回15个独立迁移单元
    C->>W1: Agent 1: Button, Modal, Tooltip
    C->>W2: Agent 2: Table, Form, Input
    C->>W3: Agent 3: Card, Tab, Dropdown
    Note over W1,W3: 并行在独立worktree中执行
    W1-->>C: 迁移完成 + diff
    W2-->>C: 迁移完成 + diff
    W3-->>C: 迁移完成 + diff
    C->>U: 汇总15个文件迁移结果
```

### 1.3 常见问题与解决

| 问题 | 原因 | 解决方案 |
|------|------|----------|
| 迁移后类型报错过多 | 第三方库缺少类型 | 在CLAUDE.md中添加`// @ts-ignore`过渡策略 |
| `/batch`部分Agent失败 | 组件间存在隐式依赖 | 先迁移独立组件，依赖密集的组件单独处理 |
| 迁移改变了函数签名 | Claude过度推断类型 | 在CLAUDE.md中明确"保持现有导出签名不变" |

---

## 战役二：Vue 2 → Vue 3 框架升级

### 2.1 场景分析

Vue 2已于2023年12月停止维护。大量企业项目仍停留在Vue 2，面临Options API到Composition API的迁移、Vuex到Pinia的状态管理迁移、过滤器（filters）废弃等破坏性变更。

### 2.2 迁移前审计

```bash
# 使用-p模式生成迁移审计报告
claude -p "扫描整个项目，生成Vue 2到Vue 3迁移审计报告：
1. 使用了哪些Vue 2专有API（$set, $delete, $on, $off, filters等）
2. 依赖的Vue 2专有库（vue-router v3, vuex v3等）
3. 使用了v-model的组件（Vue 3语法变更）
4. 使用了$children的组件（已移除）
5. 使用了$listeners的组件（已合并到$attrs）
6. 每个组件的迁移复杂度评估（简单/中等/复杂）

输出JSON格式。" --output-format json > vue-migration-audit.json
```

### 2.3 分层迁移策略

**第一层：构建配置升级**

```bash
claude "升级构建配置以支持Vue 3：
1. webpack.config.js中替换vue-loader配置
2. 更新alias: 'vue$' → 'vue/dist/vue.esm-bundler.js'
3. 安装 @vue/compiler-sfc 替代 vue-template-compiler
4. 配置兼容模式 @vue/compat（渐进迁移策略）
5. 运行 webpack --mode development 验证构建通过"
```

**第二层：兼容模式启动**

使用`@vue/compat`实现渐进迁移——它允许Vue 2和Vue 3代码共存：

```bash
claude "配置Vue兼容模式：
1. 安装 @vue/compat
2. 修改 main.js 入口使用兼容构建
3. 配置全局兼容配置，对已迁移组件禁用兼容警告
4. 创建迁移进度追踪文件，记录哪些组件已完成迁移
5. 启动dev server验证应用正常运行"
```

**第三层：逐组件迁移（/batch并行）**

```bash
# 对简单组件批量迁移
/batch 将 src/components/common/ 目录下的Vue 2组件迁移为Vue 3 Composition API：
- Options API → <script setup> + Composition API
- data() → ref/reactive
- computed → computed()
- methods → 普通函数
- mounted/created → onMounted/onCreated
- props定义 → defineProps<T>()
- emit → defineEmits<T>()
- filters → computed或全局方法
- 移除this.$set和this.$delete调用
每个组件必须在浏览器中无控制台警告运行
```

**第四层：复杂组件手动迁移**

对于有大量mixins、复杂依赖注入、动态组件的文件，不适合批量处理：

```bash
claude "迁移 src/views/Dashboard.vue 这个复杂组件：
1. 先读取并分析组件的所有依赖关系
2. 识别使用的所有mixins和它们的实际功能
3. 将mixins转为composables
4. 处理this.$refs在Composition API中的用法
5. 处理this.$router和this.$route的替换
6. 确保所有watch保持原有行为（immediate, deep选项）
7. 运行该组件相关的所有测试"
```

### 2.4 Vuex → Pinia 状态管理迁移

```bash
claude -p "分析src/store/目录下的Vuex store结构，输出：
1. 所有state字段及其类型
2. 所有getters及其依赖的state
3. 所有mutations和对应逻辑
4. 所有actions及其异步操作
5. 模块间的依赖关系图

格式：每个store模块一个section。" > store-analysis.md
```

```bash
# 基于分析结果，批量生成Pinia store
/batch 将 src/store/ 下每个Vuex模块迁移为Pinia store：
- state → reactive state定义
- mutations → 直接state修改或actions
- getters → computed getters
- actions → Pinia actions（保持异步逻辑）
- 模块注册 → defineStore独立定义
- 保持所有导出接口不变，组件端零修改
```

---

## 战役三：React Class组件 → Hooks 迁移

### 3.1 场景分析

React团队已明确推荐函数组件+Hooks作为标准模式。大量企业级React项目仍有数十甚至数百个Class组件。手动迁移需要深入理解生命周期映射、state管理转换、this绑定处理等细节。

### 3.2 使用react-modernization Skill

社区已开发了专门针对React迁移的Claude Code Skill：

```bash
# 安装React现代化Skill
claude skill add https://github.com/cloudorcl-lab/agents-claude/tree/main/plugins/framework-migration/skills/react-modernization
```

安装后，该Skill会在Claude Code中注入React迁移的专业知识，包括：
- Class生命周期到Hooks的精确映射表
- `this.setState`到`useState`的批量更新处理
- `componentDidMount`+`componentDidUpdate`→`useEffect`的依赖数组生成
- HOC模式到自定义Hook的转换
- Error Boundary处理（Class组件特有）

### 3.3 分类迁移策略

```bash
# 第一步：分类组件
claude -p "扫描 src/ 目录下所有React Class组件，按迁移复杂度分类：
- 简单：只有render和基本state，无生命周期方法
- 中等：使用componentDidMount/componentDidUpdate
- 复杂：使用shouldComponentUpdate、getSnapshotBeforeUpdate、Error Boundary
- 特殊：使用HOC包装或context直接访问

输出：{category: {files: [...], count: N}}" --output-format json > react-class-audit.json
```

**简单组件批量迁移**：

```bash
/batch 将以下简单React Class组件迁移为函数组件+Hooks：
[从审计结果中导入简单组件列表]

规则：
- class Component extends React.Component → function Component
- constructor + this.state → const [x, setX] = useState()
- this.setState → setter函数直接调用
- this.props → props参数解构
- this.handleChange → const handleChange = useCallback(...)
- 保持所有PropTypes定义不变
```

**中等复杂度组件迁移**：

```bash
claude "迁移 src/components/DataGrid.jsx：
这是一个使用多个生命周期的中等复杂组件。

转换规则：
1. componentDidMount → useEffect(() => { ... }, [])
2. componentDidUpdate(prevProps) → useEffect(() => { ... }, [dep1, dep2])
3. componentWillUnmount → useEffect return cleanup
4. this.state = {a, b, c} → const [a, setA] = useState() + const [b, setB] = useState()
5. this.setState({a: 1, b: 2}) → 批量调用setA(1); setB(2)
6. 使用React.memo替代PureComponent/shouldComponentUpdate

关键：仔细分析componentDidUpdate中哪些props变化时触发逻辑，
生成精确的useEffect依赖数组。"
```

### 3.4 特殊模式处理

**Error Boundary处理**——这是Hooks无法替代的Class组件场景：

```typescript
// Claude Code应该知道Error Boundary必须保留为Class组件
// 在CLAUDE.md中明确指示：
// "Error Boundary组件保留为Class组件，不做迁移"

// 但可以将内部逻辑抽取为自定义Hook
function useErrorHandler() {
  const [error, setError] = useState<Error | null>(null);
  const resetError = useCallback(() => setError(null), []);
  return { error, setError, resetError };
}
```

---

## 战役四：REST API → GraphQL 迁移

### 4.1 场景分析

从REST到GraphQL的迁移不只是API调用方式的改变，还涉及数据获取模式、缓存策略、错误处理的全面重构。Claude Code擅长从现有REST端点推断GraphQL Schema。

### 4.2 Schema逆向工程

```bash
# 从REST API调用代码逆向推断数据模型
claude -p "扫描src/目录下所有API调用代码（fetch/axios调用），分析并输出：
1. 所有API端点URL及其HTTP方法
2. 每个端点的请求参数结构
3. 每个端点的响应数据结构
4. 数据实体之间的关系（从嵌套响应推断）
5. 推断出的GraphQL Schema定义（type Query, type Mutation, type实体）

输出GraphQL Schema SDL格式。" > inferred-schema.graphql
```

### 4.3 分层迁移

**第一层：Schema验证和补全**

```bash
claude "基于 inferred-schema.graphql 和后端API文档（如果有），完成以下工作：
1. 验证推断的Schema是否覆盖所有现有REST端点
2. 添加缺失的输入类型（Input types）
3. 为每个Query/Mutation添加描述注释
4. 设计分页策略（Cursor-based或Offset-based）
5. 生成schema.graphql最终版本"
```

**第二层：Apollo Client配置**

```bash
claude "配置Apollo Client：
1. 安装 @apollo/client 和 graphql 依赖
2. 创建Apollo Client实例，配置缓存策略
3. 设置认证链接（从现有axios拦截器迁移）
4. 配置错误处理策略
5. 创建自定义Hook替代现有API调用函数

参考现有 src/services/api.js 中的认证和错误处理逻辑。"
```

**第三层：逐页面迁移API调用**

```bash
# 逐页面替换REST调用为GraphQL
claude "迁移 src/pages/UserManagement/ 页面的数据获取：
1. 将 getUserList() REST调用替换为 useQuery(GET_USERS)
2. 将 createUser() REST调用替换为 useMutation(CREATE_USER)
3. 将 updateUser() REST调用替换为 useMutation(UPDATE_USER) + cache.updateQuery
4. 将 deleteUser() REST调用替换为 useMutation(DELETE_USER) + cache.evict
5. 处理加载状态和错误状态（对应现有loading/error state）
6. 确保分页行为与原REST分页一致"
```

**第四层：批量迁移（/batch模式）**

```bash
/batch 将 src/pages/ 下所有页面的REST API调用迁移为GraphQL：
- 每个页面独立迁移
- 先生成该页面的GraphQL query/mutation定义
- 替换数据获取逻辑为Apollo Hook
- 保持UI渲染逻辑不变
- 保持错误处理和加载状态行为一致
```

### 4.4 缓存策略迁移

REST通常使用React Query或SWR缓存，迁移到GraphQL需要重新设计缓存：

```bash
claude "设计GraphQL缓存策略，替代现有的React Query缓存配置：
1. 读取现有React Query的queryKey和staleTime配置
2. 为Apollo Cache设计对应的typePolicy
3. 配置keyFields（决定缓存ID生成规则）
4. 配置merge函数处理分页数据合并
5. 配置read函数处理缓存数据读取
6. 生成完整的cache配置文件"
```

---

## 战役五：CSS/SCSS → Tailwind CSS 样式迁移

### 5.1 场景分析

样式迁移是视觉敏感度最高的迁移类型——稍有偏差就会导致UI走样。Claude Code需要"看到"样式效果才能准确迁移，因此这个战役对上下文管理要求最高。

### 5.2 样式审计

```bash
claude -p "扫描 src/ 目录下所有样式文件，分析：
1. 使用了哪些CSS特性（flexbox、grid、animation、media query等）
2. 使用的CSS预处理器特性（变量、mixin、嵌套、@extend等）
3. 自定义设计系统的值（颜色、字号、间距、阴影等）
4. 全局样式 vs 组件样式的比例
5. 哪些样式可以被Tailwind内置utility覆盖
6. 哪些样式需要自定义Tailwind配置

输出结构化报告。" --output-format text > style-audit.md
```

### 5.3 Tailwind配置生成

```bash
claude "基于 style-audit.md 分析结果，生成Tailwind配置：
1. 读取 src/styles/variables.scss 中的所有变量
2. 将SCSS变量映射为tailwind.config.js的theme扩展
3. 颜色变量 → theme.extend.colors
4. 字号变量 → theme.extend.fontSize
5. 间距变量 → theme.extend.spacing
6. 阴影变量 → theme.extend.boxShadow
7. 断点变量 → theme.screens
8. 生成完整的tailwind.config.js

确保配置覆盖项目中100%的自定义设计值。"
```

### 5.4 渐进迁移策略

Tailwind支持与现有CSS共存，可以渐进迁移：

```bash
# 先迁移简单的utility类组件
/batch 将 src/components/ui/ 目录下的基础组件样式迁移为Tailwind：
- 读取每个组件的SCSS module文件
- 将每个CSS属性转换为对应的Tailwind类名
- 使用className替换className+style import
- 处理伪类（hover, focus, active）→ Tailwind修饰符
- 处理响应式 → Tailwind断点前缀（sm:, md:, lg:）
- 处理CSS变量引用 → Tailwind theme()函数
- 删除已迁移的SCSS文件
- 确保视觉表现完全一致（截图对比）

每个组件迁移后生成before/after截图路径
```

**复杂样式处理**：

```bash
# 对于使用SCSS mixin、@extend等高级特性的样式
claude "迁移 src/components/ChartWidget.scss，这个文件使用了：
1. @include respond-to(breakpoint) mixin → Tailwind响应式前缀
2. @extend %card-base → Tailwind @apply或组合类名
3. CSS Grid复杂布局 → Tailwind grid utilities
4. CSS animation → Tailwind animation utilities + 自定义keyframes
5. SCSS嵌套选择器 → Tailwind group/group-hover 或变体

输出：ChartWidget组件使用Tailwind的完整代码"
```

### 5.5 视觉回归检测

```bash
# 迁移后自动运行视觉回归测试
claude "配置视觉回归测试流程：
1. 安装 playwright 和 pixelmatch
2. 编写脚本：迁移前对每个页面截图保存为baseline
3. 迁移后再次截图并对比
4. 设置允许的像素差异阈值为0.1%
5. 生成差异报告，标注差异位置
6. 如果差异超过阈值，自动标记需要人工review的文件"
```

---

## 高级技巧：跨战役联合迁移

实际项目中，五大战役往往需要联合进行。以下是一个完整的联合迁移编排方案。

### 6.1 迁移依赖关系

```mermaid
graph LR
    A[战役一: JS→TS] --> B[战役二: Vue2→Vue3]
    B --> C[战役三: Class→Composition API]
    A --> D[战役四: REST→GraphQL]
    B --> E[战役五: SCSS→Tailwind]

    style A fill:#4CAF50,color:#fff
    style B fill:#2196F3,color:#fff
    style C fill:#FF9800,color:#fff
    style D fill:#9C27B0,color:#fff
    style E fill:#F44336,color:#fff
```

### 6.2 联合CLAUDE.md配置

```markdown
# CLAUDE.md — 联合迁移总控配置

## 全局迁移顺序（严格按序执行）
1. Phase 1: TypeScript基础建设（类型定义 + 工具函数）
2. Phase 2: Vue 3兼容模式启动
3. Phase 3: 基础组件Vue 3迁移（简单组件先行）
4. Phase 4: GraphQL层建设（Schema + Client配置）
5. Phase 5: 页面级API迁移
6. Phase 6: 样式迁移（从ui组件开始）
7. Phase 7: 复杂组件迁移 + 清理兼容模式

## 跨战役规则
- TypeScript迁移和Vue 3迁移不要同时修改同一文件
- 样式迁移不影响组件逻辑，可以与其他战役并行
- API迁移独立于框架迁移，通过Adapter层解耦
- 每个Phase完成后必须通过CI才能开始下一Phase

## 进度追踪
- 每个Phase完成后在migration-progress.md中标记
- 记录每个Phase的实际耗时vs预估耗时
- 记录遇到的阻塞点和解决方案
```

### 6.3 自动化迁移脚本

将整个迁移流程编排为可重复执行的脚本：

```bash
#!/bin/bash
# migrate.sh — Claude Code迁移编排脚本

set -e

PHASE=${1:-"all"}
PROJECT_DIR=$(pwd)

# 阶段一：TypeScript基础建设
phase1_ts_foundation() {
    echo "=== Phase 1: TypeScript Foundation ==="
    
    # 生成类型审计报告
    claude -p "分析项目并生成TypeScript迁移审计报告" \
        --output-format json > reports/ts-audit.json
    
    # 安装类型依赖
    claude -p "根据reports/ts-audit.json生成npm install命令" \
        --allowedTools "Bash(read_only)" | bash
    
    # 迁移types和utils
    /batch 将src/types/和src/utils/下所有JS文件迁移为TS
    
    echo "Phase 1 complete."
}

# 阶段二：Vue 3兼容模式
phase2_vue3_compat() {
    echo "=== Phase 2: Vue 3 Compat Mode ==="
    
    claude "配置Vue 3兼容模式，确保应用正常启动"
    
    # 运行dev server验证
    npm run dev -- --port 3000 &
    DEV_PID=$!
    sleep 10
    
    # 检查是否有编译错误
    if curl -s http://localhost:3000 | grep -q "error"; then
        echo "Compat mode setup failed. Check logs."
        kill $DEV_PID
        exit 1
    fi
    kill $DEV_PID
    
    echo "Phase 2 complete."
}

# 阶段三：组件迁移
phase3_component_migration() {
    echo "=== Phase 3: Component Migration ==="
    
    # 简单组件批量迁移
    /batch 迁移src/components/common/下所有简单Vue组件为Composition API
    
    # 中等复杂度逐个迁移
    for component in $(cat reports/medium-complexity-components.txt); do
        claude "迁移 $component 为Vue 3 Composition API"
        
        # 每个组件迁移后验证
        if ! npm run test -- --grep "$component"; then
            echo "Test failed for $component, reverting..."
            git checkout -- "$component"
        fi
    done
    
    echo "Phase 3 complete."
}

# 执行指定阶段
case $PHASE in
    "1") phase1_ts_foundation ;;
    "2") phase2_vue3_compat ;;
    "3") phase3_component_migration ;;
    "all")
        phase1_ts_foundation
        phase2_vue3_compat
        phase3_component_migration
        ;;
    *)
        echo "Usage: ./migrate.sh [1|2|3|all]"
        exit 1
        ;;
esac
```

### 6.4 迁移质量门禁

```yaml
# .claude/hooks/migration-quality-gate.json
# 在每个迁移步骤后自动运行的质量检查

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "command": "bash -c 'npx tsc --noEmit 2>&1 | head -20'",
        "description": "TypeScript类型检查"
      },
      {
        "matcher": "Write|Edit",
        "command": "bash -c 'npm run lint 2>&1 | tail -5'",
        "description": "代码风格检查"
      },
      {
        "matcher": "Write|Edit",
        "command": "bash -c 'npm run test -- --passWithNoTests 2>&1 | tail -10'",
        "description": "单元测试执行"
      }
    ]
  }
}
```

这个Hook配置在每次Claude Code写入或编辑文件后，自动运行类型检查、lint和测试。任何检查失败都会立即反馈给Claude，让它自动修复问题。

---

## 实战案例：电商平台全栈迁移

### 项目背景

某中型电商平台前端项目：
- 320个组件文件
- 45个Vuex Store模块
- 85个API调用函数
- 120个SCSS样式文件
- 测试覆盖率38%

### 迁移执行

```bash
# Step 1: 全局评估（用时约15分钟）
claude -p "全面分析这个电商平台项目的迁移需求：
1. JavaScript→TypeScript：估算文件数和复杂度
2. Vue 2→Vue 3：列出所有破坏性API使用
3. Vuex→Pinia：分析store模块依赖
4. REST→GraphQL：从API调用推断数据模型
5. SCSS→Tailwind：分析设计系统token

输出：总体迁移工时估算和风险点" --output-format text > full-migration-plan.md

# Step 2: 分阶段执行（利用-p模式串联）
# Phase 1: TypeScript（2天）
claude -p "执行Phase 1 TypeScript基础迁移..." --max-turns 50

# Phase 2: Vue 3 compat（1天）
claude -p "执行Phase 2 Vue 3兼容模式配置..." --max-turns 30

# Phase 3: 组件迁移（3天，/batch并行）
/batch Vue 3组件迁移，覆盖所有320个组件...

# Step 3: 验证（半天）
claude -p "运行完整测试套件和构建，验证迁移完整性"
```

### 迁移结果

| 指标 | 迁移前 | 迁移后 | 改善 |
|------|--------|--------|------|
| TypeScript覆盖率 | 0% | 94% | +94% |
| Vue 3组件占比 | 0% | 100% | +100% |
| 类型安全级别 | 无 | strict | 质的飞跃 |
| 测试覆盖率 | 38% | 45% | +7% |
| 构建时间 | 47s | 32s | -32% |
| 包体积 | 2.8MB | 2.1MB | -25% |
| 迁移耗时 | — | 6.5天 | 传统预估30天 |

---

## 迁移避坑清单

### 必须避免的错误

1. **不要一次性迁移整个项目**——使用渐进策略，每个阶段独立可验证
2. **不要忽略测试覆盖**——迁移前先补充关键路径测试，用测试守护迁移
3. **不要跨战役并行修改同一文件**——严格遵守迁移顺序
4. **不要跳过兼容模式**——Vue 2→3使用`@vue/compat`过渡，不要直接替换
5. **不要在/batch中处理有循环依赖的文件组**——先拆解依赖再批量处理

### CLAUDE.md最佳实践

```markdown
## 迁移CLAUDE.md黄金规则

### 写什么
- 当前迁移阶段和已完成进度
- 严格的文件修改范围（精确到目录）
- 每类迁移的转换规则（给出具体代码示例）
- 禁止操作清单（比正面指令更重要）

### 不写什么
- 不要写模糊指令（如"尽量保持一致"）
- 不要写过长配置（超过200行会降低关注度）
- 不要写与迁移无关的项目信息
```

### /batch使用技巧

- **控制单元粒度**：在prompt中明确"每个单元不超过10个文件"
- **验证每个Agent**：`/batch`完成后逐个检查worktree中的diff
- **处理失败Agent**：记录失败单元，用单Agent模式重试
- **合并策略**：按依赖顺序合并worktree，先合并底层依赖

## 延伸阅读

- [Claude Code官方文档 - Commands](https://code.claude.com/docs/en/commands) — `/batch`和`/simplify`命令官方参考
- [Anthropic Code Modernization Playbook](https://resources.anthropic.com/code-modernization-playbook) — Anthropic官方代码现代化手册
- [Claude Code Worktrees文档](https://code.claude.com/docs/en/worktrees) — worktree并行隔离机制
- [MCPMarket - React Modernization Skill](https://mcpmarket.com/tools/skills/react-modernization-hook-migration) — React Hooks迁移专用Skill
- [OneWave-AI/full-codebase-migrator](https://github.com/OneWave-AI/claude-skills/blob/main/full-codebase-migrator/SKILL.md) — 生产级全代码库迁移Skill

## 参考来源

1. [Migrating Between Frameworks With Claude Code](https://www.visimade.com/p/analystdev-blog?article=migrating-between-frameworks-with-claude-code) — 框架迁移实战指南
2. [Claude Code /batch: Migrate Entire Codebases in Parallel](https://vibecoding.ae/blog/claude-code-batch-migrate-codebases) — /batch并行迁移详解
3. [How to migrate with Claude Code and not die trying](https://dev.to/sergioazoc/how-to-migrate-with-claude-code-and-not-die-trying-56gf) — 迁移避坑经验分享
4. [.NET Framework to .NET 10 Migration with Claude Code](https://talkthinkdo.com/guides/legacy-modernisation/dotnet-framework-migration-claude-code/) — .NET迁移实战案例
5. [Claude Code Batch Processing Complete Guide](https://smartscope.blog/en/generative-ai/claude/claude-code-batch-processing/) — /batch命令完整参考

## 训练营适用性评估

| 维度 | 评估 |
|------|------|
| 适合训练营类型 | 企业级实战训练营、前端架构师培训、技术债治理专项 |
| 预计教学时长 | 2天（12小时）：Day1理论+战役一二三，Day2战役四五+联合实战 |
| 学员基础要求 | 2年以上前端开发经验，有实际项目迁移需求 |
| 实验环境要求 | 每人一个中型Vue/React示例项目（预置300+组件），Claude Code API额度 |
| 难度评级 | ⭐⭐⭐⭐（高级） |

> [!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)
