name: tdd-migrate description: TDD 迁移工作流 - 协调代理，零主上下文增长 allowed-tools: [Task, TodoWrite, Write, Read, Bash]

TDD 迁移

通过代理完成所有工作来协调 TDD 迁移。主上下文保持干净。

何时使用

“将 X 从 Python 移植到 TypeScript”
“根据现有模式创建 N 个适配器”
“将模块迁移到新架构”
“多个相似项的 TDD 实现”

参数

/tdd-migrate <source_path> <target_path> --pattern <reference> --items "item1,item2,item3"

source_path：要分析的路径（现有代码）
target_path：创建新代码的位置
pattern：要遵循的参考文件/模式
items：要创建项的逗号分隔列表

工作流

阶段 0：YAML TODO 列表
    │
    ▼
阶段 1：TLDR 分析 ──────────────────┐
    │                                    │
    ▼                                    │ 并行侦察
阶段 2：编写失败测试 ──────────────────┤ 每个项
    │                                    │
    ▼                                    │
阶段 3：实现（最小化） ──────────────┤
    │                                    │
    ▼                                    │
阶段 4：构建 + 通过测试 ─────────────┘
    │
    ▼
阶段 5：QLTY 检查 ────────────────────┐
    │                                    │ 并行
阶段 6：审查代理验证 ────────────────┘
    │
    ▼
阶段 7：TLDR 差异（新 vs 参考）
    │
    ▼
阶段 8：修复问题（如果有）
    │
    ▼
完成

关键原则

主上下文仅用于协调
- 永远不直接读取文件（使用侦察代理）
- 永远不直接实现（使用 kraken/spark 代理）
- 永远不直接运行测试（使用验证代理）
- 仅传递上下文和协调
代理完成所有工作

任务代理

探索/分析 scout

编写测试 + 实现 kraken

快速修复 spark

运行测试/验证 validator

代码审查 critic
在独立处并行
- 如果独立，所有项都可以并行实现
- 审查 + QLTY 并行运行
- TLDR 分析与规划并行运行
每个主要步骤后审查
- 实现后：critic 审查
- 修复后：validator 重新验证

指令

步骤 0：创建 YAML TODO

将 YAML 计划文件写入 thoughts/shared/plans/<name>-tdd.yaml：

---
title: <迁移名称>
date: <今天>
type: implementation-plan
approach: TDD（测试 → 构建 → 通过 → 审查）

items:
  - name: item1
    file: <target_path>/item1.ts
    test: <target_path>/__tests__/item1.test.ts
    deps: []
  - name: item2
    # ...

reference: <pattern_file>

workflow:
  per_item:
    1: Write failing test
    2: Implement minimal
    3: Build
    4: Pass test
    5: QLTY check
    6: Review
  final:
    7: Integration test
    8: TLDR diff

步骤 1：启动侦察代理（并行）

Task (scout): 使用 TLDR 分析 <source_path>
Task (scout): 分析 <pattern> 以理解结构
Task (scout): 读取迁移交接（如果存在）

步骤 2：启动 Kraken 代理（每个项并行）

对于每个项，启动一个执行完整 TDD 的 kraken：

Task (kraken): 使用 TDD 工作流实现 <item>
  1. 读取模式文件
  2. 编写失败测试
  3. 实现
  4. 运行：bun test <test_file>
  5. 运行：qlty check <impl_file>

步骤 3：审查 + 验证（并行）

Task (critic): 审查所有新文件是否符合模式
Task (validator): 运行完整测试套件
Task (validator): QLTY 检查所有文件

步骤 4：修复问题

如果 critic/validator 发现问题：

Task (spark): 修复 <特定问题>
Task (validator): 重新验证

步骤 5：TLDR 差异

Task (validator): TLDR 差异新文件 vs 参考
  - tldr structure <new_file> --lang <lang>
  - tldr structure <reference> --lang <lang>
  - 比较模式

步骤 6：更新连续性

在账本中更新已完成的工作。

示例：Rigg 适配器

/tdd-migrate /Users/cosimo/Documents/rigg/src/sdk/providers \
  /Users/cosimo/Documents/rigg/src/sdk/providers \
  --pattern lmstudio.ts \
  --items "xai,cerebras,togetherai,deepinfra,perplexity"

结果：

5 个并行 kraken 代理
39 个测试通过
所有适配器工作
约 15 分钟总时间

反模式（避免）

不好	好
在主上下文中读取文件	启动侦察代理
在主上下文中编写代码	启动 kraken/spark 代理
在主上下文中运行测试	启动验证代理
跳过审查	始终启动 critic 代理
顺序项	并行 kraken 代理
在主上下文中修复	启动 spark 代理

代理提示

Scout（分析）

探索 <path> 以理解：
1. 结构/模式
2. 接口/类型
3. 依赖关系
返回可操作的实现摘要。

Kraken（TDD）

使用 TDD 实现 <item>：
1. 读取 <pattern> 以了解结构
2. 编写失败测试到 <test_path>
3. 最小化实现到 <impl_path>
4. 运行：<test_command>
5. 运行：qlty check <impl_path>
报告：状态、问题、创建的文件。

Critic（审查）

根据 <pattern> 审查 <files>：
1. 模式符合性
2. 类型安全
3. 缺少注册
4. 安全问题
不要编辑。仅报告问题。

Spark（修复）

修复 <特定问题>：
1. 读取 <file>
2. 进行最小编辑
3. 验证修复

Validator（测试）

验证 <files>：
1. 运行 <test_command>
2. 运行 qlty check
3. 报告通过/失败/问题

成功标准

[ ] 所有测试通过
[ ] QLTY 报告无问题
[ ] Critic 发现无关键问题
[ ] TLDR 差异显示模式符合性
[ ] 所有项正确注册/导出

任务	代理
探索/分析	scout
编写测试 + 实现	kraken
快速修复	spark
运行测试/验证	validator
代码审查	critic