Back to Details

tdd-migrate

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

TDD Migrate

TDD 迁移

Orchestrate TDD migrations with agents doing all work. Main context stays clean.
通过Agent完成所有工作来编排TDD迁移，主上下文保持简洁。

When to Use

适用场景

  • "Port X from Python to TypeScript"
  • "Create N adapters following existing pattern"
  • "Migrate module to new architecture"
  • "TDD implementation of multiple similar items"
  • "将X从Python迁移到TypeScript"
  • "按照现有模式创建N个适配器"
  • "将模块迁移到新架构"
  • "多个相似项的TDD实现"

Parameters

参数

/tdd-migrate <source_path> <target_path> --pattern <reference> --items "item1,item2,item3"
  • source_path
    : Path to analyze (existing code)
  • target_path
    : Where to create new code
  • pattern
    : Reference file/pattern to follow
  • items
    : Comma-separated list of things to create
/tdd-migrate <source_path> <target_path> --pattern <reference> --items "item1,item2,item3"
  • source_path
    : 待分析的路径（现有代码）
  • target_path
    : 新代码的创建路径
  • pattern
    : 遵循的参考文件/模式
  • items
    : 待创建内容的逗号分隔列表

Workflow

工作流

Phase 0: YAML TODO List
    │
    ▼
Phase 1: TLDR Analysis ─────────────────┐
    │                                    │
    ▼                                    │ Parallel scouts
Phase 2: Write Failing Tests ───────────┤ per item
    │                                    │
    ▼                                    │
Phase 3: Implement (minimal) ───────────┤
    │                                    │
    ▼                                    │
Phase 4: Build + Pass Tests ────────────┘
    │
    ▼
Phase 5: QLTY Check ────────────────────┐
    │                                    │ Parallel
Phase 6: Review Agent Validates ────────┘
    │
    ▼
Phase 7: TLDR Diff (new vs reference)
    │
    ▼
Phase 8: Fix Issues (if any)
    │
    ▼
Complete
Phase 0: YAML 待办事项列表
    │
    ▼
Phase 1: TLDR 分析 ─────────────────┐
    │                                    │
    ▼                                    │ 并行scout Agent
Phase 2: 编写失败测试 ───────────┤ 每个任务项
    │                                    │
    ▼                                    │
Phase 3: （最小化）实现 ───────────┤
    │                                    │
    ▼                                    │
Phase 4: 构建 + 通过测试 ────────────┘
    │
    ▼
Phase 5: QLTY 检查 ────────────────────┐
    │                                    │ 并行
Phase 6: 评审Agent验证 ────────┘
    │
    ▼
Phase 7: TLDR 对比（新代码与参考代码）
    │
    ▼
Phase 8: 修复问题（若有）
    │
    ▼
完成

Key Principles

核心原则

  1. Main context = orchestration only
    • Never read files directly (use scout)
    • Never implement directly (use kraken/spark)
    • Never run tests directly (use validator)
    • Only pipe context and coordinate
  2. Agents do ALL work
    TaskAgent
    Explore/analyzescout
    Write tests + implementkraken
    Quick fixesspark
    Run tests/validatevalidator
    Code reviewcritic
  3. Parallel where independent
    • All items can be implemented in parallel if independent
    • Review + QLTY run in parallel
    • TLDR analysis runs in parallel with planning
  4. Review after each major step
    • After implementation: critic reviews
    • After fixes: validator re-validates
  1. 主上下文仅负责编排
    • 绝不直接读取文件（使用scout）
    • 绝不直接实现代码（使用kraken/spark）
    • 绝不直接运行测试（使用validator）
    • 仅负责传递上下文和协调工作
  2. 所有工作由Agent完成
    任务Agent
    探索/分析scout
    编写测试+实现代码kraken
    快速修复spark
    运行测试/验证validator
    代码评审critic
  3. 独立任务并行处理
    • 若任务项相互独立，可并行实现所有任务项
    • 评审与QLTY检查并行运行
    • TLDR分析与规划并行运行
  4. 关键步骤后必须评审
    • 实现完成后：critic进行评审
    • 修复完成后：validator重新验证

Instructions

操作步骤

Step 0: Create YAML TODO

步骤0：创建YAML待办事项

Write a YAML plan file to 
thoughts/shared/plans/<name>-tdd.yaml
:
yaml
---
title: <Migration Name>
date: <today>
type: implementation-plan
approach: TDD (test → build → pass → review)

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
编写YAML计划文件至 
thoughts/shared/plans/<name>-tdd.yaml
：
yaml
---
title: <Migration Name>
date: <today>
type: implementation-plan
approach: TDD (test → build → pass → review)

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

Step 1: Launch Scout Agents (parallel)

步骤1：启动Scout Agent（并行）

Task (scout): Analyze <source_path> with TLDR
Task (scout): Analyze <pattern> to understand structure
Task (scout): Read migration handoff if exists
Task (scout): Analyze <source_path> with TLDR
Task (scout): Analyze <pattern> to understand structure
Task (scout): Read migration handoff if exists

Step 2: Launch Kraken Agents (parallel per item)

步骤2：启动Kraken Agent（按任务项并行）

For each item, launch ONE kraken that does full TDD:
Task (kraken): Implement <item> using TDD workflow
  1. Read pattern file
  2. Write failing test
  3. Implement
  4. Run: bun test <test_file>
  5. Run: qlty check <impl_file>
针对每个任务项，启动一个kraken来完成完整的TDD流程：
Task (kraken): Implement <item> using TDD workflow
  1. Read pattern file
  2. Write failing test
  3. Implement
  4. Run: bun test <test_file>
  5. Run: qlty check <impl_file>

Step 3: Review + Validate (parallel)

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

Task (critic): Review all new files against pattern
Task (validator): Run full test suite
Task (validator): QLTY check all files
Task (critic): Review all new files against pattern
Task (validator): Run full test suite
Task (validator): QLTY check all files

Step 4: Fix Issues

步骤4：修复问题

If critic/validator found issues:
Task (spark): Fix <specific issue>
Task (validator): Re-validate
若critic/validator发现问题：
Task (spark): Fix <specific issue>
Task (validator): Re-validate

Step 5: TLDR Diff

步骤5：TLDR对比

Task (validator): TLDR diff new files vs reference
  - tldr structure <new_file> --lang <lang>
  - tldr structure <reference> --lang <lang>
  - Compare patterns
Task (validator): TLDR diff new files vs reference
  - tldr structure <new_file> --lang <lang>
  - tldr structure <reference> --lang <lang>
  - Compare patterns

Step 6: Update Continuity

步骤6：更新连续性记录

Update ledger with completed work.
更新分类账，记录已完成的工作。

Example: Rigg Adapters

示例：Rigg 适配器

bash
/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"
Resulted in:
  • 5 parallel kraken agents
  • 39 tests passing
  • All adapters working
  • ~15 minutes total
bash
/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 Agent
  • 39个测试通过
  • 所有适配器正常工作
  • 总耗时约15分钟

Anti-Patterns (AVOID)

反模式（需避免）

BadGood
Read files in main contextLaunch scout agent
Write code in main contextLaunch kraken/spark agent
Run tests in main contextLaunch validator agent
Skip reviewAlways launch critic
Sequential itemsParallel krakens
Fix in main contextLaunch spark
错误做法正确做法
在主上下文中读取文件启动scout Agent
在主上下文中编写代码启动kraken/spark Agent
在主上下文中运行测试启动validator Agent
跳过评审始终启动critic
串行处理任务项并行使用kraken
在主上下文中修复问题启动spark

Agent Prompts

Agent 提示词

Scout (analysis)

Scout (analysis)

Explore <path> to understand:
1. Structure/patterns
2. Interfaces/types
3. Dependencies
Return actionable summary for implementation.
Explore <path> to understand:
1. Structure/patterns
2. Interfaces/types
3. Dependencies
Return actionable summary for implementation.

Kraken (TDD)

Kraken (TDD)

Implement <item> using TDD:
1. Read <pattern> for structure
2. Write failing test to <test_path>
3. Implement minimal to <impl_path>
4. Run: <test_command>
5. Run: qlty check <impl_path>
Report: status, issues, files created.
Implement <item> using TDD:
1. Read <pattern> for structure
2. Write failing test to <test_path>
3. Implement minimal to <impl_path>
4. Run: <test_command>
5. Run: qlty check <impl_path>
Report: status, issues, files created.

Critic (review)

Critic (review)

Review <files> against <pattern>:
1. Pattern compliance
2. Type safety
3. Missing registrations
4. Security issues
DO NOT edit. Report issues only.
Review <files> against <pattern>:
1. Pattern compliance
2. Type safety
3. Missing registrations
4. Security issues
DO NOT edit. Report issues only.

Spark (fix)

Spark (fix)

Fix <specific issue>:
1. Read <file>
2. Make minimal edit
3. Verify fix
Fix <specific issue>:
1. Read <file>
2. Make minimal edit
3. Verify fix

Validator (test)

Validator (test)

Validate <files>:
1. Run <test_command>
2. Run qlty check
3. Report pass/fail/issues
Validate <files>:
1. Run <test_command>
2. Run qlty check
3. Report pass/fail/issues

Success Criteria

成功标准

  • All tests pass
  • QLTY reports no issues
  • Critic found no critical issues
  • TLDR diff shows pattern compliance
  • All items registered/exported properly
  • 所有测试通过
  • QLTY检查无问题
  • Critic未发现严重问题
  • TLDR对比显示符合模式要求
  • 所有任务项已正确注册/导出