nightralph 0.0.2 → 0.0.3

package/dist/orchestrator.js

@@ -8,7 +8,29 @@ import {
   writeFileSync,
   readdirSync
 } from "node:fs";
-import { join } from "node:path";
+import { join, dirname, basename } from "node:path";
+import {
+  getRepoRoot,
+  getRepoName,
+  getCurrentBranch,
+  createWorktree,
+  removeWorktree,
+  hasNewCommits,
+  isDirty
+} from "./worktree.js";
+import {
+  generateProgress,
+  readProgress,
+  mergeProgress,
+  writeProgress,
+  commitProgress,
+  checkTicket
+} from "./progress.js";
+import {
+  mergeBranch,
+  mergeWave,
+  updateWorktreeFromBase
+} from "./merge.js";
 function formatErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -63,7 +85,7 @@ function scanTickets(dir) {
 __name(scanTickets, "scanTickets");
 function findReadyTickets(tickets) {
   const doneNums = new Set(
-    tickets.filter((t) => t.status !== "ready-for-agent").map((t) => t.num)
+    tickets.filter((t) => t.status === "done").map((t) => t.num)
   );
   return tickets.filter((t) => {
     if (t.status !== "ready-for-agent") return false;
@@ -96,8 +118,86 @@ function renderPrompt(specBody, ticket) {
   ].join("\n");
 }
 __name(renderPrompt, "renderPrompt");
+function listTickets(tickets) {
+  console.log("\nTickets:");
+  for (const t of tickets) {
+    const blockerStr = t.blockers.length > 0 ? `blocked by [${t.blockers.join(", ")}]` : "no blockers";
+    console.log(
+      `  ${t.filename} (${t.status}) ${blockerStr}`
+    );
+  }
+}
+__name(listTickets, "listTickets");
+function* simulateWaves(tickets) {
+  const sim = new Map(
+    tickets.map((t) => [t.num, t.status])
+  );
+  let wave = 1;
+  while (true) {
+    const doneNums = new Set(
+      [...sim.entries()].filter(([, s]) => s === "done").map(([n]) => n)
+    );
+    const ready = [...tickets].filter((t) => {
+      if (sim.get(t.num) !== "ready-for-agent") {
+        return false;
+      }
+      return t.blockers.every(
+        (b) => doneNums.has(b)
+      );
+    });
+    if (ready.length === 0) break;
+    yield { wave, ready };
+    for (const t of ready) {
+      sim.set(t.num, "done");
+    }
+    wave++;
+  }
+}
+__name(simulateWaves, "simulateWaves");
+function detectDeadlocks(tickets) {
+  const doneNums = /* @__PURE__ */ new Set();
+  const ready = /* @__PURE__ */ new Set();
+  for (const t of tickets) {
+    if (t.status === "ready-for-agent") {
+      ready.add(t.num);
+    } else if (t.status === "done") {
+      doneNums.add(t.num);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const num of ready) {
+      const ticket = tickets.find(
+        (t) => t.num === num
+      );
+      if (ticket.blockers.every(
+        (b) => doneNums.has(b)
+      )) {
+        doneNums.add(num);
+        ready.delete(num);
+        changed = true;
+      }
+    }
+  }
+  return [...ready].map(
+    (num) => tickets.find((t) => t.num === num)
+  );
+}
+__name(detectDeadlocks, "detectDeadlocks");
+const PROVIDER_ARGS = {
+  claude: ["--print", "--dangerously-skip-permissions"],
+  codex: ["exec", "--full-auto"]
+};
+function getProviderArgs(cmd) {
+  const name = basename(cmd);
+  return PROVIDER_ARGS[name] ?? [];
+}
+__name(getProviderArgs, "getProviderArgs");
 function spawnAgent(opts) {
-  const args = [];
+  const args = [
+    ...getProviderArgs(opts.agentCmd)
+  ];
   if (opts.model) {
     args.push("--model", opts.model);
   }
@@ -106,18 +206,19 @@ function spawnAgent(opts) {
     { flags: "w" }
   );
   const proc = spawn(opts.agentCmd, args, {
-    stdio: ["pipe", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"],
+    cwd: opts.cwd
   });
   proc.stdout.pipe(logStream);
   proc.stderr.pipe(logStream);
   const timeout = setTimeout(() => {
     if (!proc.killed) {
       console.warn(
-        `Agent did not exit in ${opts.timeoutSecs}s; killing.`
+        `Agent did not exit in ${opts.timeout}s; killing.`
       );
       proc.kill("SIGKILL");
     }
-  }, opts.timeoutSecs * 1e3);
+  }, opts.timeout * 1e3);
   proc.stdin.write(opts.prompt);
   proc.stdin.end();
   return new Promise((resolve) => {
@@ -139,48 +240,56 @@ function spawnAgent(opts) {
 }
 __name(spawnAgent, "spawnAgent");
 function dryRun(tickets, specBody) {
-  console.log("\nTickets:");
-  for (const t of tickets) {
-    const blockerStr = t.blockers.length > 0 ? `blocked by [${t.blockers.join(", ")}]` : "no blockers";
+  listTickets(tickets);
+  console.log("\nSimulated wave order:");
+  for (const { wave, ready } of simulateWaves(tickets)) {
     console.log(
-      `  ${t.filename} (${t.status}) ${blockerStr}`
+      `  Wave ${wave}: ` + ready.map((t) => t.filename).join(", ")
     );
   }
-  console.log("\nSimulated wave order:");
-  const sim = new Map(
-    tickets.map((t) => [t.num, t.status])
-  );
-  let wave = 1;
-  while (true) {
-    const doneNums = new Set(
-      [...sim.entries()].filter(([, s]) => s !== "ready-for-agent").map(([n]) => n)
+  const stuck = detectDeadlocks(tickets);
+  if (stuck.length > 0) {
+    console.log(
+      "\nDeadlocked tickets: " + stuck.map((t) => t.filename).join(", ")
+    );
+  }
+  const firstReady = findReadyTickets(tickets);
+  if (firstReady.length > 0) {
+    console.log(
+      `
+Prompt for first ready ticket (${firstReady[0].filename}):
+`
     );
-    const ready = tickets.filter((t) => {
-      if (sim.get(t.num) !== "ready-for-agent") {
-        return false;
-      }
-      return t.blockers.every(
-        (b) => doneNums.has(b)
-      );
-    });
-    if (ready.length === 0) break;
+    console.log(
+      renderPrompt(specBody, firstReady[0])
+    );
+  }
+}
+__name(dryRun, "dryRun");
+function dryRunIsolated(opts) {
+  listTickets(opts.tickets);
+  console.log("\nSimulated wave order:");
+  for (const { wave, ready } of simulateWaves(
+    opts.tickets
+  )) {
     console.log(
       `  Wave ${wave}: ` + ready.map((t) => t.filename).join(", ")
     );
     for (const t of ready) {
-      sim.set(t.num, "done");
+      const num = String(t.num).padStart(2, "0");
+      const branchName = `${opts.repoName}/${num}-${t.slug}`;
+      const worktreePath = `../${opts.repoName}.${num}-${t.slug}`;
+      console.log(`    worktree: ${worktreePath}`);
+      console.log(`    branch:   ${branchName}`);
     }
-    wave++;
   }
-  const stuck = tickets.filter(
-    (t) => sim.get(t.num) === "ready-for-agent"
-  );
+  const stuck = detectDeadlocks(opts.tickets);
   if (stuck.length > 0) {
     console.log(
       "\nDeadlocked tickets: " + stuck.map((t) => t.filename).join(", ")
     );
   }
-  const firstReady = findReadyTickets(tickets);
+  const firstReady = findReadyTickets(opts.tickets);
   if (firstReady.length > 0) {
     console.log(
       `
@@ -188,12 +297,57 @@ Prompt for first ready ticket (${firstReady[0].filename}):
 `
     );
     console.log(
-      renderPrompt(specBody, firstReady[0])
+      renderPrompt(opts.specBody, firstReady[0])
     );
   }
+  const strategyDesc = opts.conflictStrategy === "respawn" ? "respawn (re-run agent on conflict)" : "stop (stop merging on conflict)";
+  console.log(
+    `
+Merge strategy: ${strategyDesc}`
+  );
+  console.log(`Progress file: ${opts.progressPath}`);
 }
-__name(dryRun, "dryRun");
-async function runWaves(tickets, specBody, agentCmd, model, timeoutSecs, logsDir) {
+__name(dryRunIsolated, "dryRunIsolated");
+async function respawnAndRetryMerge(opts) {
+  await updateWorktreeFromBase(
+    opts.worktreePath,
+    opts.baseBranch
+  );
+  console.log(
+    `  ${opts.ticket.filename}: respawning agent to resolve merge conflict`
+  );
+  const prompt = renderPrompt(opts.specBody, opts.ticket);
+  const logPath = join(
+    opts.logsDir,
+    opts.ticket.filename.replace(/\.md$/, ".respawn.log")
+  );
+  const exitCode = await spawnAgent({
+    prompt,
+    agentCmd: opts.agentCmd,
+    model: opts.model,
+    timeout: opts.timeout,
+    logPath,
+    cwd: opts.worktreePath
+  });
+  if (exitCode !== 0) {
+    console.log(
+      `  ${opts.ticket.filename}: respawned agent exited ${exitCode}`
+    );
+    return false;
+  }
+  const merged = await mergeBranch(
+    opts.repoRoot,
+    opts.branch
+  );
+  if (!merged) {
+    console.log(
+      `  ${opts.ticket.filename}: merge still conflicted after respawn`
+    );
+  }
+  return merged;
+}
+__name(respawnAndRetryMerge, "respawnAndRetryMerge");
+async function runWaves(tickets, specBody, agentCmd, model, timeout, logsDir) {
   mkdirSync(logsDir, { recursive: true });
   let totalCompleted = 0;
   let waveNum = 0;
@@ -217,7 +371,7 @@ Wave ${waveNum}: ` + ready.map((t) => t.filename).join(", ")
           prompt,
           agentCmd,
           model,
-          timeoutSecs,
+          timeout,
           logPath
         });
         return { ticket: t, exitCode: code };
@@ -227,17 +381,274 @@ Wave ${waveNum}: ` + ready.map((t) => t.filename).join(", ")
     for (const r of results) {
       if (r.status === "rejected") continue;
       const { ticket, exitCode } = r.value;
-      if (exitCode === 0) {
-        markDone(ticket);
-        waveCompleted++;
-        totalCompleted++;
+      if (exitCode !== 0) {
+        console.log(
+          `  ${ticket.filename}: agent exited ${exitCode}`
+        );
+        continue;
+      }
+      markDone(ticket);
+      waveCompleted++;
+      totalCompleted++;
+      console.log(
+        `  ${ticket.filename}: done`
+      );
+    }
+    if (waveCompleted === 0) {
+      console.log(
+        "\nNo tickets completed this wave. Stopping."
+      );
+      break;
+    }
+  }
+  const remaining = tickets.filter(
+    (t) => t.status === "ready-for-agent"
+  );
+  console.log(
+    `
+Finished: ${totalCompleted} completed` + (remaining.length > 0 ? `, ${remaining.length} remaining` : "")
+  );
+  return { allDone: remaining.length === 0 };
+}
+__name(runWaves, "runWaves");
+async function runWavesIsolated(opts) {
+  mkdirSync(opts.logsDir, { recursive: true });
+  const repoRoot = getRepoRoot();
+  const repoName = getRepoName();
+  const baseBranch = getCurrentBranch();
+  const progressPath = join(
+    dirname(opts.logsDir),
+    "progress.md"
+  );
+  const progress = mergeProgress(
+    generateProgress(opts.featureName, opts.tickets),
+    readProgress(progressPath)
+  );
+  writeProgress(progressPath, progress);
+  await commitProgress(
+    repoRoot,
+    progressPath,
+    `nightralph: start ${opts.featureName}`
+  );
+  let totalCompleted = 0;
+  let waveNum = 0;
+  while (true) {
+    const ready = findReadyTickets(opts.tickets);
+    if (ready.length === 0) break;
+    waveNum++;
+    console.log(
+      `
+Wave ${waveNum}: ` + ready.map((t) => t.filename).join(", ")
+    );
+    const worktreeSettled = await Promise.allSettled(
+      ready.map((t) => createWorktree({
+        repoRoot,
+        repoName,
+        baseBranch,
+        ticket: t
+      }))
+    );
+    const activeTickets = [];
+    const worktrees = [];
+    for (let i = 0; i < worktreeSettled.length; i++) {
+      const settled = worktreeSettled[i];
+      const ticket = ready[i];
+      if (settled.status === "rejected") {
         console.log(
-          `  ${ticket.filename}: done`
+          `  ${ticket.filename}: failed to create worktree: ${formatErrorMessage(settled.reason)}`
         );
+        continue;
+      }
+      activeTickets.push(ticket);
+      worktrees.push(settled.value);
+    }
+    const results = await Promise.allSettled(
+      activeTickets.map((t, i) => {
+        const prompt = renderPrompt(opts.specBody, t);
+        const logPath = join(
+          opts.logsDir,
+          t.filename.replace(/\.md$/, ".log")
+        );
+        console.log(`  Starting ${t.filename}`);
+        return spawnAgent({
+          prompt,
+          agentCmd: opts.agentCmd,
+          model: opts.model,
+          timeout: opts.timeout,
+          logPath,
+          cwd: worktrees[i].worktreePath
+        });
+      })
+    );
+    let waveCompleted = 0;
+    const successfulBranches = [];
+    const ticketsByNum = /* @__PURE__ */ new Map();
+    const worktreePathsByNum = /* @__PURE__ */ new Map();
+    for (let i = 0; i < results.length; i++) {
+      const r = results[i];
+      if (r.status === "rejected") continue;
+      const exitCode = r.value;
+      const ticket = activeTickets[i];
+      const worktree = worktrees[i];
+      if (exitCode === 0 && !hasNewCommits(
+        repoRoot,
+        baseBranch,
+        worktree.branchName
+      )) {
+        console.log(
+          `  ${ticket.filename}: agent exited 0 but made no commits; leaving ticket ready-for-agent`
+        );
+      } else if (exitCode === 0 && isDirty(
+        worktree.worktreePath
+      )) {
+        console.log(
+          `  ${ticket.filename}: agent left uncommitted changes in the worktree; leaving ticket ready-for-agent`
+        );
+      } else if (exitCode === 0) {
+        console.log(
+          `  ${ticket.filename}: agent finished, awaiting merge`
+        );
+        ticketsByNum.set(ticket.num, ticket);
+        worktreePathsByNum.set(
+          ticket.num,
+          worktree.worktreePath
+        );
+        successfulBranches.push({
+          branch: worktree.branchName,
+          ticketNum: ticket.num,
+          worktreePath: worktree.worktreePath
+        });
       } else {
         console.log(
           `  ${ticket.filename}: agent exited ${exitCode}`
         );
+        checkTicket(progress, ticket.num, {
+          branch: worktree.branchName,
+          exitCode,
+          done: false
+        });
+        writeProgress(progressPath, progress);
+        await commitProgress(
+          repoRoot,
+          progressPath,
+          `nightralph: ${ticket.filename} failed`
+        );
+        try {
+          await removeWorktree(worktree.worktreePath);
+        } catch (err) {
+          console.error(
+            `  Failed to remove worktree ${worktree.worktreePath}: ` + formatErrorMessage(err)
+          );
+        }
+      }
+    }
+    if (successfulBranches.length > 0) {
+      const mergeResult = await mergeWave({
+        repoRoot,
+        baseBranch,
+        branches: successfulBranches,
+        strategy: opts.conflictStrategy
+      });
+      for (const branchResult of mergeResult.merged) {
+        const ticket = ticketsByNum.get(
+          branchResult.ticketNum
+        );
+        if (!ticket) continue;
+        if (branchResult.merged) {
+          markDone(ticket);
+          waveCompleted++;
+          totalCompleted++;
+          console.log(
+            `  ${ticket.filename}: done`
+          );
+          checkTicket(progress, ticket.num, {
+            branch: branchResult.branch,
+            exitCode: 0
+          });
+          writeProgress(progressPath, progress);
+          await commitProgress(
+            repoRoot,
+            progressPath,
+            `nightralph: ${ticket.filename} done`
+          );
+          const worktreePath = worktreePathsByNum.get(
+            ticket.num
+          );
+          if (worktreePath) {
+            try {
+              await removeWorktree(worktreePath);
+            } catch (err) {
+              console.error(
+                `  Failed to remove worktree ${worktreePath}: ` + formatErrorMessage(err)
+              );
+            }
+          }
+        } else {
+          const worktreePath = worktreePathsByNum.get(
+            ticket.num
+          );
+          const recovered = opts.conflictStrategy === "respawn" && worktreePath ? await respawnAndRetryMerge({
+            repoRoot,
+            baseBranch,
+            branch: branchResult.branch,
+            ticket,
+            worktreePath,
+            specBody: opts.specBody,
+            agentCmd: opts.agentCmd,
+            model: opts.model,
+            timeout: opts.timeout,
+            logsDir: opts.logsDir
+          }) : false;
+          if (recovered) {
+            markDone(ticket);
+            waveCompleted++;
+            totalCompleted++;
+            console.log(
+              `  ${ticket.filename}: done (resolved via respawn)`
+            );
+            checkTicket(progress, ticket.num, {
+              branch: branchResult.branch,
+              exitCode: 0
+            });
+            writeProgress(progressPath, progress);
+            await commitProgress(
+              repoRoot,
+              progressPath,
+              `nightralph: ${ticket.filename} done (respawn)`
+            );
+            if (worktreePath) {
+              try {
+                await removeWorktree(worktreePath);
+              } catch (err) {
+                console.error(
+                  `  Failed to remove worktree ${worktreePath}: ` + formatErrorMessage(err)
+                );
+              }
+            }
+          } else {
+            console.log(
+              `  ${ticket.filename}: merge failed, staying ready-for-agent`
+            );
+          }
+        }
+      }
+      if (mergeResult.stoppedAt) {
+        console.log(
+          `
+Merge stopped at ${mergeResult.stoppedAt.branch}`
+        );
+        for (const sb of successfulBranches) {
+          const ticket = ticketsByNum.get(sb.ticketNum);
+          if (ticket && ticket.status === "done") continue;
+          try {
+            await removeWorktree(sb.worktreePath);
+          } catch (err) {
+            console.error(
+              `  Failed to remove worktree ${sb.worktreePath}: ` + formatErrorMessage(err)
+            );
+          }
+        }
+        break;
       }
     }
     if (waveCompleted === 0) {
@@ -247,26 +658,30 @@ Wave ${waveNum}: ` + ready.map((t) => t.filename).join(", ")
       break;
     }
   }
-  const remaining = tickets.filter(
+  const remaining = opts.tickets.filter(
     (t) => t.status === "ready-for-agent"
   );
   console.log(
     `
 Finished: ${totalCompleted} completed` + (remaining.length > 0 ? `, ${remaining.length} remaining` : "")
   );
+  return { allDone: remaining.length === 0 };
 }
-__name(runWaves, "runWaves");
+__name(runWavesIsolated, "runWavesIsolated");
 export {
   TICKET_RE,
   dryRun,
+  dryRunIsolated,
   findReadyTickets,
   formatErrorMessage,
+  getProviderArgs,
   markDone,
   parseBlockers,
   parseStatus,
   parseTicketFilename,
   renderPrompt,
   runWaves,
+  runWavesIsolated,
   scanTickets,
   spawnAgent
 };