Bun Zig→Rust 迁移案例

export const meta = {
  name: "zig-to-rust-coordinator",
  description: "读取 Zig 源码，产出逐文件的 Zig→Rust 翻译计划（复杂度 + 依赖序），供后续并行移植阶段使用",
  phases: ["所有权映射"],
};

phase("所有权映射");
log("协调器：扫描 Zig 源码树，建立所有权/生命周期映射");

// args 传入要分析的文件清单（不在脚本里调 Date.now()/随机，保证 resume 确定性）
const plan = await agent(
  `分析这批 Zig 文件的所有权与生命周期语义，映射到等价 Rust 抽象。
   对每个文件给出：直接等价 / 需人工干预的构造清单、复杂度评级、依赖的其它文件。
   待分析文件：\n${(args.files || []).join("\n")}`,
  {
    label: "ownership-mapping",
    agentType: "Explore",
    schema: {
      type: "object",
      properties: {
        files: {
          type: "array",
          items: {
            type: "object",
            properties: {
              path: { type: "string" },
              complexity: { enum: ["trivial", "moderate", "manual"] },
              dependsOn: { type: "array", items: { type: "string" } },
              manualConstructs: { type: "array", items: { type: "string" } },
            },
            required: ["path", "complexity", "dependsOn"],
          },
        },
      },
      required: ["files"],
    },
  }
);

log(`映射完成：${plan.files.length} 个文件，其中 ${plan.files.filter(f => f.complexity === "manual").length} 个需人工干预`);

export const meta = {
  name: "zig-to-rust-port",
  description: "按阶段1的翻译计划，并行逐文件把 Zig 移植为行为等价的 Rust，每文件移植后立刻对抗式审查",
  phases: ["逐文件移植"],
};

phase("逐文件移植");

// 把 manual 复杂度的文件先 log 出来——不静默截断，符合 no-silent-caps 原则
const manualFiles = (args.plan || []).filter(f => f.complexity === "manual");
if (manualFiles.length) {
  log(`以下 ${manualFiles.length} 个文件标记为需人工干预，仍走自动移植但会重点审查：`);
  manualFiles.forEach(f => log(`  - ${f.path}`));
}

// pipeline：每个文件独立流经「移植 → 审查」，stage 间无 barrier
const results = await pipeline(
  args.plan,

  // stage 1：移植（worktree 隔离，真实改文件，并行写不冲突）
  (file) =>
    agent(
      `把 Zig 文件 ${file.path} 移植为行为等价的 Rust。
       目标：通过该模块的现有测试。先正确，不必 idiomatic。
       需特别处理的构造：${(file.manualConstructs || []).join(", ") || "无"}`,
      {
        label: `port:${file.path}`,
        phase: "逐文件移植",            // 显式归组，避免在 pipeline 内争用全局 phase
        isolation: "worktree",          // 独立 worktree，避免并行写冲突
      }
    ),

  // stage 2：对抗式审查（见阶段 3）
  (portResult, file) =>
    agent(
      `你是对抗式审查者，任务是【找问题】而非批准。
       审查 ${file.path} 从 Zig 到 Rust 的移植，对比原 Zig 语义：
       - 内存/错误模型差异（allocator、错误联合 vs Result、panic 边界）
       - 行为等价但脆弱的构造
       移植产物：\n${portResult}`,
      {
        label: `review:${file.path}`,
        phase: "逐文件移植",
        schema: {
          type: "object",
          properties: {
            verdict: { enum: ["pass", "needs-human", "re-port"] },
            issues: { type: "array", items: { type: "string" } },
          },
          required: ["verdict", "issues"],
        },
      }
    )
);

// pipeline 中某 stage 抛错 → 该 item 落为 null，用前过滤
const reviewed = results.filter(Boolean);
log(`移植 + 审查完成：${reviewed.length}/${args.plan.length}，` +
    `其中 ${reviewed.filter(r => r.verdict !== "pass").length} 个待处理`);

export const meta = {
  name: "zig-to-rust-fix-loop",
  description: "对已移植文件反复跑 build/test，把失败路由到定向修复 agent，直到通过率达标或预算耗尽",
  phases: ["修复循环"],
};

phase("修复循环");

let round = 0;
let passRate = args.initialPassRate || 0;
const target = args.targetPassRate || 0.998;

// loop-until-count 与 loop-until-budget 复合条件：达标即停，预算见底也停
while (passRate < target && budget.total && budget.remaining() > 50_000) {
  round += 1;
  log(`修复循环第 ${round} 轮，当前通过率 ${(passRate * 100).toFixed(2)}%，剩余预算 ${budget.remaining()}`);

  // 1) 收集本轮的失败（build + test）
  const failures = await agent(
    "对当前分支跑 build 与测试套件（Linux x64 glibc），返回失败清单：每条含 类型(build|test)、文件、摘要",
    {
      label: `collect-failures:r${round}`,
      schema: {
        type: "object",
        properties: {
          passRate: { type: "number" },
          failures: {
            type: "array",
            items: {
              type: "object",
              properties: {
                kind: { enum: ["build", "test"] },
                file: { type: "string" },
                summary: { type: "string" },
              },
              required: ["kind", "file", "summary"],
            },
          },
        },
        required: ["passRate", "failures"],
      },
    }
  );

  passRate = failures.passRate;
  if (!failures.failures.length) break;

  // 2) 并行修复——这里用 parallel 而非 pipeline：要等本轮全部修完再重测（barrier）
  await parallel(
    failures.failures.map((f) => () =>
      agent(
        `修复 ${f.file} 的 ${f.kind} 失败：${f.summary}。
         检查失败的测试与移植后代码，做最小修改使其通过且保持行为等价。`,
        { label: `fix:${f.kind}:${f.file}`, isolation: "worktree" }
      )
    )
  );
}

log(`修复循环结束：第 ${round} 轮，最终通过率 ${(passRate * 100).toFixed(2)}%（Linux x64 glibc）`);