nightralph 0.0.0

package/dist/test/orchestrator.test.js

@@ -0,0 +1,749 @@
+// test/orchestrator.test.ts
+import { test } from "@substrate-system/tapzero";
+import {
+  mkdtempSync,
+  mkdirSync as mkdirSync2,
+  writeFileSync as writeFileSync2,
+  readFileSync as readFileSync2,
+  existsSync,
+  readdirSync as readdirSync2
+} from "node:fs";
+import { join as join2 } from "node:path";
+import { tmpdir } from "node:os";
+
+// src/orchestrator.ts
+import { spawn } from "node:child_process";
+import {
+  createWriteStream,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  readdirSync
+} from "node:fs";
+import { join } from "node:path";
+function formatErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var TICKET_RE = /^(\d+)-(.+)\.md$/;
+function parseTicketFilename(filename) {
+  const m = filename.match(TICKET_RE);
+  if (!m) return null;
+  return { num: Number(m[1]), slug: m[2] };
+}
+function parseStatus(body) {
+  const m = body.match(/\*\*Status:\*\*\s*(.+)/i);
+  return m ? m[1].trim().toLowerCase() : "";
+}
+function parseBlockers(body) {
+  const m = body.match(/\*\*Blocked by:\*\*\s*(.+)/i);
+  if (!m) return [];
+  const text = m[1];
+  if (/none/i.test(text)) return [];
+  const nums = [];
+  const re = /(\d+)/g;
+  let match;
+  while (match = re.exec(text)) {
+    nums.push(Number(match[1]));
+  }
+  return nums;
+}
+function scanTickets(dir) {
+  const files = readdirSync(dir).filter((f) => TICKET_RE.test(f)).sort((a, b) => a.localeCompare(
+    b,
+    void 0,
+    { numeric: true, sensitivity: "base" }
+  ));
+  return files.map((filename) => {
+    const parsed = parseTicketFilename(filename);
+    const filepath = join(dir, filename);
+    const body = readFileSync(filepath, "utf8");
+    return {
+      num: parsed.num,
+      slug: parsed.slug,
+      filename,
+      filepath,
+      body,
+      status: parseStatus(body),
+      blockers: parseBlockers(body)
+    };
+  });
+}
+function findReadyTickets(tickets) {
+  const doneNums = new Set(
+    tickets.filter((t) => t.status !== "ready-for-agent").map((t) => t.num)
+  );
+  return tickets.filter((t) => {
+    if (t.status !== "ready-for-agent") return false;
+    return t.blockers.every((b) => doneNums.has(b));
+  });
+}
+function markDone(ticket) {
+  const updated = ticket.body.replace(
+    /\*\*Status:\*\*\s*.+/i,
+    "**Status:** done"
+  );
+  writeFileSync(ticket.filepath, updated);
+  ticket.status = "done";
+  ticket.body = updated;
+}
+function renderPrompt(specBody, ticket) {
+  return [
+    "---- SPEC CONTEXT ----",
+    specBody,
+    "",
+    "---- TICKET ----",
+    ticket.filename,
+    ticket.body,
+    "",
+    "---- AGENT INSTRUCTIONS ----",
+    "You are an autonomous coding agent. Implement the ticket.",
+    ""
+  ].join("\n");
+}
+function spawnAgent(opts) {
+  const args = [];
+  if (opts.model) {
+    args.push("--model", opts.model);
+  }
+  const logStream = createWriteStream(
+    opts.logPath,
+    { flags: "w" }
+  );
+  const proc = spawn(opts.agentCmd, args, {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  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.`
+      );
+      proc.kill("SIGKILL");
+    }
+  }, opts.timeoutSecs * 1e3);
+  proc.stdin.write(opts.prompt);
+  proc.stdin.end();
+  return new Promise((resolve) => {
+    proc.on("close", (code) => {
+      clearTimeout(timeout);
+      logStream.end();
+      resolve(code ?? 1);
+    });
+    proc.on("error", (err) => {
+      clearTimeout(timeout);
+      logStream.end();
+      console.error(
+        "Agent process error:",
+        formatErrorMessage(err)
+      );
+      resolve(1);
+    });
+  });
+}
+async function runWaves(tickets, specBody, agentCmd, model, timeoutSecs, logsDir) {
+  mkdirSync(logsDir, { recursive: true });
+  let totalCompleted = 0;
+  let waveNum = 0;
+  while (true) {
+    const ready = findReadyTickets(tickets);
+    if (ready.length === 0) break;
+    waveNum++;
+    console.log(
+      `
+Wave ${waveNum}: ` + ready.map((t) => t.filename).join(", ")
+    );
+    const results = await Promise.allSettled(
+      ready.map(async (t) => {
+        const prompt = renderPrompt(specBody, t);
+        const logPath = join(
+          logsDir,
+          t.filename.replace(/\.md$/, ".log")
+        );
+        console.log(`  Starting ${t.filename}`);
+        const code = await spawnAgent({
+          prompt,
+          agentCmd,
+          model,
+          timeoutSecs,
+          logPath
+        });
+        return { ticket: t, exitCode: code };
+      })
+    );
+    let waveCompleted = 0;
+    for (const r of results) {
+      if (r.status === "rejected") continue;
+      const { ticket, exitCode } = r.value;
+      if (exitCode === 0) {
+        markDone(ticket);
+        waveCompleted++;
+        totalCompleted++;
+        console.log(
+          `  ${ticket.filename}: done`
+        );
+      } else {
+        console.log(
+          `  ${ticket.filename}: agent exited ${exitCode}`
+        );
+      }
+    }
+    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` : "")
+  );
+}
+
+// test/orchestrator.test.ts
+function tmp() {
+  return mkdtempSync(
+    join2(tmpdir(), "nightralph-orch-test-")
+  );
+}
+function makeTicketBody(opts) {
+  const lines = [
+    "# Test ticket",
+    "",
+    `**Status:** ${opts.status}`
+  ];
+  if (opts.blockers && opts.blockers.length > 0) {
+    lines.push(
+      `**Blocked by:** ${opts.blockers.join(", ")}`
+    );
+  }
+  return lines.join("\n");
+}
+function makeTicket(overrides) {
+  return {
+    slug: overrides.filename.replace(
+      /^\d+-(.+)\.md$/,
+      "$1"
+    ),
+    filepath: `/fake/${overrides.filename}`,
+    body: makeTicketBody({
+      status: overrides.status ?? "ready-for-agent"
+    }),
+    status: overrides.status ?? "ready-for-agent",
+    blockers: overrides.blockers ?? [],
+    ...overrides
+  };
+}
+test("parseTicketFilename parses valid names", (t) => {
+  const r = parseTicketFilename("01-add-auth.md");
+  t.ok(r, "should return a result");
+  t.equal(r.num, 1, "num");
+  t.equal(r.slug, "add-auth", "slug");
+});
+test("parseTicketFilename with multi-digit number", (t) => {
+  const r = parseTicketFilename("123-foo-bar.md");
+  t.ok(r, "should return a result");
+  t.equal(r.num, 123, "num");
+  t.equal(r.slug, "foo-bar", "slug");
+});
+test("parseTicketFilename rejects non-matching names", (t) => {
+  t.equal(
+    parseTicketFilename("readme.md"),
+    null,
+    "no leading number"
+  );
+  t.equal(
+    parseTicketFilename("01-thing.txt"),
+    null,
+    "wrong extension"
+  );
+  t.equal(
+    parseTicketFilename("not-a-ticket"),
+    null,
+    "no extension"
+  );
+});
+test("parseStatus extracts status", (t) => {
+  t.equal(
+    parseStatus("**Status:** ready-for-agent"),
+    "ready-for-agent",
+    "basic"
+  );
+  t.equal(
+    parseStatus("**Status:**   Done  "),
+    "done",
+    "trims and lowercases"
+  );
+  t.equal(
+    parseStatus("no status here"),
+    "",
+    "missing status returns empty"
+  );
+});
+test("parseStatus works in multi-line body", (t) => {
+  const body = [
+    "# Ticket",
+    "",
+    "**Status:** ready-for-agent",
+    "**Blocked by:** 1, 2"
+  ].join("\n");
+  t.equal(parseStatus(body), "ready-for-agent");
+});
+test("parseBlockers extracts blocker numbers", (t) => {
+  t.deepEqual(
+    parseBlockers("**Blocked by:** 1, 2, 3"),
+    [1, 2, 3],
+    "comma-separated"
+  );
+  t.deepEqual(
+    parseBlockers("**Blocked by:** #4 and #5"),
+    [4, 5],
+    "hash-prefixed"
+  );
+});
+test("parseBlockers returns empty for none", (t) => {
+  t.deepEqual(
+    parseBlockers("**Blocked by:** none"),
+    [],
+    "explicit none"
+  );
+  t.deepEqual(
+    parseBlockers("**Blocked by:** None"),
+    [],
+    "case-insensitive none"
+  );
+  t.deepEqual(
+    parseBlockers("no blockers field at all"),
+    [],
+    "missing field"
+  );
+});
+test("scanTickets reads and parses ticket files", (t) => {
+  const dir = tmp();
+  writeFileSync2(
+    join2(dir, "01-first.md"),
+    makeTicketBody({
+      status: "ready-for-agent",
+      blockers: []
+    })
+  );
+  writeFileSync2(
+    join2(dir, "02-second.md"),
+    makeTicketBody({
+      status: "ready-for-agent",
+      blockers: [1]
+    })
+  );
+  writeFileSync2(
+    join2(dir, "ignore-me.txt"),
+    "not a ticket"
+  );
+  const tickets = scanTickets(dir);
+  t.equal(tickets.length, 2, "finds 2 tickets");
+  t.equal(tickets[0].num, 1, "first ticket num");
+  t.equal(tickets[0].slug, "first", "first ticket slug");
+  t.equal(
+    tickets[0].status,
+    "ready-for-agent",
+    "first ticket status"
+  );
+  t.deepEqual(
+    tickets[0].blockers,
+    [],
+    "first has no blockers"
+  );
+  t.equal(tickets[1].num, 2, "second ticket num");
+  t.deepEqual(
+    tickets[1].blockers,
+    [1],
+    "second blocked by 1"
+  );
+});
+test("scanTickets returns sorted by number", (t) => {
+  const dir = tmp();
+  writeFileSync2(
+    join2(dir, "10-z.md"),
+    makeTicketBody({ status: "ready-for-agent" })
+  );
+  writeFileSync2(
+    join2(dir, "02-a.md"),
+    makeTicketBody({ status: "ready-for-agent" })
+  );
+  writeFileSync2(
+    join2(dir, "03-b.md"),
+    makeTicketBody({ status: "ready-for-agent" })
+  );
+  const tickets = scanTickets(dir);
+  t.deepEqual(
+    tickets.map((t2) => t2.num),
+    [2, 3, 10],
+    "numeric sort"
+  );
+});
+test("findReadyTickets returns unblocked ready tickets", (t) => {
+  const tickets = [
+    makeTicket({
+      num: 1,
+      filename: "01-a.md",
+      status: "ready-for-agent",
+      blockers: []
+    }),
+    makeTicket({
+      num: 2,
+      filename: "02-b.md",
+      status: "ready-for-agent",
+      blockers: [1]
+    }),
+    makeTicket({
+      num: 3,
+      filename: "03-c.md",
+      status: "done",
+      blockers: []
+    })
+  ];
+  const ready = findReadyTickets(tickets);
+  t.equal(ready.length, 1, "only one is ready");
+  t.equal(ready[0].num, 1, "ticket 1 is ready");
+});
+test("findReadyTickets unblocks after deps done", (t) => {
+  const tickets = [
+    makeTicket({
+      num: 1,
+      filename: "01-a.md",
+      status: "done",
+      blockers: []
+    }),
+    makeTicket({
+      num: 2,
+      filename: "02-b.md",
+      status: "ready-for-agent",
+      blockers: [1]
+    }),
+    makeTicket({
+      num: 3,
+      filename: "03-c.md",
+      status: "ready-for-agent",
+      blockers: [1, 2]
+    })
+  ];
+  const ready = findReadyTickets(tickets);
+  t.equal(ready.length, 1, "only ticket 2 is ready");
+  t.equal(
+    ready[0].num,
+    2,
+    "ticket 2 unblocked because 1 is done"
+  );
+});
+test("findReadyTickets returns nothing when all blocked", (t) => {
+  const tickets = [
+    makeTicket({
+      num: 1,
+      filename: "01-a.md",
+      status: "ready-for-agent",
+      blockers: [2]
+    }),
+    makeTicket({
+      num: 2,
+      filename: "02-b.md",
+      status: "ready-for-agent",
+      blockers: [1]
+    })
+  ];
+  const ready = findReadyTickets(tickets);
+  t.equal(ready.length, 0, "circular dep deadlock");
+});
+test("markDone updates file and ticket object", (t) => {
+  const dir = tmp();
+  const filepath = join2(dir, "01-test.md");
+  const body = makeTicketBody({
+    status: "ready-for-agent"
+  });
+  writeFileSync2(filepath, body);
+  const ticket = {
+    num: 1,
+    slug: "test",
+    filename: "01-test.md",
+    filepath,
+    body,
+    status: "ready-for-agent",
+    blockers: []
+  };
+  markDone(ticket);
+  t.equal(ticket.status, "done", "in-memory status");
+  const onDisk = readFileSync2(filepath, "utf8");
+  t.ok(
+    onDisk.includes("**Status:** done"),
+    "file updated on disk"
+  );
+  t.ok(
+    !onDisk.includes("ready-for-agent"),
+    "old status removed"
+  );
+});
+test("renderPrompt includes spec and ticket", (t) => {
+  const ticket = makeTicket({
+    num: 1,
+    filename: "01-thing.md"
+  });
+  const prompt = renderPrompt("spec body here", ticket);
+  t.ok(
+    prompt.includes("spec body here"),
+    "contains spec"
+  );
+  t.ok(
+    prompt.includes("01-thing.md"),
+    "contains ticket filename"
+  );
+  t.ok(
+    prompt.includes("AGENT INSTRUCTIONS"),
+    "contains instructions"
+  );
+});
+var MOCK_PASS = join2(
+  process.cwd(),
+  "test",
+  "mock-agent-pass.js"
+);
+var MOCK_FAIL = join2(
+  process.cwd(),
+  "test",
+  "mock-agent-fail.js"
+);
+test("runWaves completes unblocked tickets", async (t) => {
+  const base = tmp();
+  const issuesDir = join2(base, "issues");
+  const logsDir = join2(base, "logs");
+  mkdirSync2(issuesDir);
+  writeFileSync2(
+    join2(issuesDir, "01-first.md"),
+    makeTicketBody({
+      status: "ready-for-agent"
+    })
+  );
+  writeFileSync2(
+    join2(issuesDir, "02-second.md"),
+    makeTicketBody({
+      status: "ready-for-agent"
+    })
+  );
+  const tickets = scanTickets(issuesDir);
+  await runWaves(
+    tickets,
+    "test spec",
+    MOCK_PASS,
+    null,
+    10,
+    logsDir
+  );
+  t.equal(
+    tickets[0].status,
+    "done",
+    "ticket 1 done"
+  );
+  t.equal(
+    tickets[1].status,
+    "done",
+    "ticket 2 done"
+  );
+  const onDisk = readFileSync2(
+    join2(issuesDir, "01-first.md"),
+    "utf8"
+  );
+  t.ok(
+    onDisk.includes("**Status:** done"),
+    "ticket 1 persisted to disk"
+  );
+});
+test("runWaves respects dependency order", async (t) => {
+  const base = tmp();
+  const issuesDir = join2(base, "issues");
+  const logsDir = join2(base, "logs");
+  mkdirSync2(issuesDir);
+  writeFileSync2(
+    join2(issuesDir, "01-base.md"),
+    makeTicketBody({
+      status: "ready-for-agent"
+    })
+  );
+  writeFileSync2(
+    join2(issuesDir, "02-depends-on-1.md"),
+    makeTicketBody({
+      status: "ready-for-agent",
+      blockers: [1]
+    })
+  );
+  writeFileSync2(
+    join2(issuesDir, "03-depends-on-2.md"),
+    makeTicketBody({
+      status: "ready-for-agent",
+      blockers: [2]
+    })
+  );
+  const tickets = scanTickets(issuesDir);
+  await runWaves(
+    tickets,
+    "test spec",
+    MOCK_PASS,
+    null,
+    10,
+    logsDir
+  );
+  for (const ticket of tickets) {
+    t.equal(
+      ticket.status,
+      "done",
+      `${ticket.filename} completed`
+    );
+  }
+});
+test("runWaves stops dependents when agent fails", async (t) => {
+  const base = tmp();
+  const issuesDir = join2(base, "issues");
+  const logsDir = join2(base, "logs");
+  mkdirSync2(issuesDir);
+  writeFileSync2(
+    join2(issuesDir, "01-will-fail.md"),
+    makeTicketBody({
+      status: "ready-for-agent"
+    })
+  );
+  writeFileSync2(
+    join2(issuesDir, "02-blocked.md"),
+    makeTicketBody({
+      status: "ready-for-agent",
+      blockers: [1]
+    })
+  );
+  const tickets = scanTickets(issuesDir);
+  await runWaves(
+    tickets,
+    "test spec",
+    MOCK_FAIL,
+    null,
+    10,
+    logsDir
+  );
+  t.equal(
+    tickets[0].status,
+    "ready-for-agent",
+    "failed ticket keeps status"
+  );
+  t.equal(
+    tickets[1].status,
+    "ready-for-agent",
+    "dependent never ran"
+  );
+});
+test("runWaves writes log files", async (t) => {
+  const base = tmp();
+  const issuesDir = join2(base, "issues");
+  const logsDir = join2(base, "logs");
+  mkdirSync2(issuesDir);
+  writeFileSync2(
+    join2(issuesDir, "01-task.md"),
+    makeTicketBody({
+      status: "ready-for-agent"
+    })
+  );
+  const tickets = scanTickets(issuesDir);
+  await runWaves(
+    tickets,
+    "test spec",
+    MOCK_PASS,
+    null,
+    10,
+    logsDir
+  );
+  t.ok(
+    existsSync(join2(logsDir, "01-task.log")),
+    "log file created"
+  );
+});
+test("runWaves skips already-done tickets", async (t) => {
+  const base = tmp();
+  const issuesDir = join2(base, "issues");
+  const logsDir = join2(base, "logs");
+  mkdirSync2(issuesDir);
+  writeFileSync2(
+    join2(issuesDir, "01-done.md"),
+    makeTicketBody({ status: "done" })
+  );
+  writeFileSync2(
+    join2(issuesDir, "02-ready.md"),
+    makeTicketBody({
+      status: "ready-for-agent",
+      blockers: [1]
+    })
+  );
+  const tickets = scanTickets(issuesDir);
+  await runWaves(
+    tickets,
+    "test spec",
+    MOCK_PASS,
+    null,
+    10,
+    logsDir
+  );
+  t.equal(
+    tickets[0].status,
+    "done",
+    "pre-done ticket unchanged"
+  );
+  t.equal(
+    tickets[1].status,
+    "done",
+    "dependent ran and completed"
+  );
+  t.ok(
+    !existsSync(join2(logsDir, "01-done.log")),
+    "no log for skipped ticket"
+  );
+});
+test("runWaves handles parallel independent tickets", async (t) => {
+  const base = tmp();
+  const issuesDir = join2(base, "issues");
+  const logsDir = join2(base, "logs");
+  mkdirSync2(issuesDir);
+  writeFileSync2(
+    join2(issuesDir, "01-a.md"),
+    makeTicketBody({ status: "ready-for-agent" })
+  );
+  writeFileSync2(
+    join2(issuesDir, "02-b.md"),
+    makeTicketBody({ status: "ready-for-agent" })
+  );
+  writeFileSync2(
+    join2(issuesDir, "03-c.md"),
+    makeTicketBody({ status: "ready-for-agent" })
+  );
+  writeFileSync2(
+    join2(issuesDir, "04-final.md"),
+    makeTicketBody({
+      status: "ready-for-agent",
+      blockers: [1, 2, 3]
+    })
+  );
+  const tickets = scanTickets(issuesDir);
+  await runWaves(
+    tickets,
+    "test spec",
+    MOCK_PASS,
+    null,
+    10,
+    logsDir
+  );
+  for (const ticket of tickets) {
+    t.equal(
+      ticket.status,
+      "done",
+      `${ticket.filename} completed`
+    );
+  }
+  const logs = readdirSync2(logsDir);
+  t.equal(logs.length, 4, "all four logs written");
+});
+//# sourceMappingURL=orchestrator.test.js.map