@nanobpm/nano-workforce 0.187.6 → 0.188.1

package/workers/reconcile-implement/worker.test.ts

@@ -0,0 +1,87 @@
+// Unit coverage for pr.reconcile-implement — the implement-cell's reconcile-before-escalate step
+// (issue #801). It wraps the canonical `reconcileImplement` decision with the injected GitHub read;
+// here we assert the handler wires job variables through and re-emits the decision (the gate variable
+// `reconciled` plus the adopted `status`/`pr`). The decision logic itself is exhaustively covered in
+// app/implementReconcile.test.ts.
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
+import { noopLog } from "../../test/log.ts";
+import handler from "./worker.ts";
+
+// biome-ignore lint/suspicious/noExplicitAny: tiny app double — the handler only touches app.log.
+const fakeApp: any = { log: noopLog() };
+
+test("adopts an open PR on the branch: emits reconciled + status=opened + pr", async () => {
+  const prevToken = process.env.GITHUB_TOKEN;
+  const prevTransport = process.env.NANO_PR_GITHUB_TRANSPORT;
+  const prevFetch = globalThis.fetch;
+  process.env.GITHUB_TOKEN = "t";
+  process.env.NANO_PR_GITHUB_TRANSPORT = "token";
+  // Token transport (never shells out to `gh`): stub the pulls listing so `listPrsForHead` returns one
+  // open PR opened from `feat/issue-801`.
+  globalThis.fetch = (async () =>
+    new Response(JSON.stringify([{ number: 801, html_url: "https://github.com/owner/repo/pull/801", state: "open", base: { ref: "main" } }]), {
+      status: 200,
+    })) as typeof fetch;
+  try {
+    const out = await handler(
+      { jobKey: "j1", variables: { subjectKey: "owner/repo#801", task: { id: "issue-801" }, status: null } } as never,
+      fakeApp,
+    );
+    assertEquals(out, { reconciled: true, status: "opened", pr: "owner/repo#801" });
+  } finally {
+    globalThis.fetch = prevFetch;
+    if (prevToken === undefined) delete process.env.GITHUB_TOKEN;
+    else process.env.GITHUB_TOKEN = prevToken;
+    if (prevTransport === undefined) delete process.env.NANO_PR_GITHUB_TRANSPORT;
+    else process.env.NANO_PR_GITHUB_TRANSPORT = prevTransport;
+  }
+});
+
+test("wires baseBranch through: a wrong-base open PR is NOT adopted → escalate", async () => {
+  const prevToken = process.env.GITHUB_TOKEN;
+  const prevTransport = process.env.NANO_PR_GITHUB_TRANSPORT;
+  const prevFetch = globalThis.fetch;
+  process.env.GITHUB_TOKEN = "t";
+  process.env.NANO_PR_GITHUB_TRANSPORT = "token";
+  // The only open PR on the head branch targets a different base than the run's pinned `baseBranch`.
+  globalThis.fetch = (async () =>
+    new Response(JSON.stringify([{ number: 55, html_url: "https://github.com/owner/repo/pull/55", state: "open", base: { ref: "stale-base" } }]), {
+      status: 200,
+    })) as typeof fetch;
+  try {
+    const out = await handler(
+      { jobKey: "j3", variables: { subjectKey: "owner/repo#7", task: { id: "issue-7" }, status: null, baseBranch: "epic/feat-x" } } as never,
+      fakeApp,
+    );
+    assertEquals(out, { reconciled: false, status: null, pr: null });
+  } finally {
+    globalThis.fetch = prevFetch;
+    if (prevToken === undefined) delete process.env.GITHUB_TOKEN;
+    else process.env.GITHUB_TOKEN = prevToken;
+    if (prevTransport === undefined) delete process.env.NANO_PR_GITHUB_TRANSPORT;
+    else process.env.NANO_PR_GITHUB_TRANSPORT = prevTransport;
+  }
+});
+
+test("no open PR on the branch: falls through to escalate (reconciled=false)", async () => {
+  const prevToken = process.env.GITHUB_TOKEN;
+  const prevTransport = process.env.NANO_PR_GITHUB_TRANSPORT;
+  const prevFetch = globalThis.fetch;
+  process.env.GITHUB_TOKEN = "t";
+  process.env.NANO_PR_GITHUB_TRANSPORT = "token";
+  globalThis.fetch = (async () => new Response(JSON.stringify([]), { status: 200 })) as typeof fetch;
+  try {
+    const out = await handler(
+      { jobKey: "j2", variables: { subjectKey: "owner/repo#7", task: { id: "issue-7" }, status: null } } as never,
+      fakeApp,
+    );
+    assertEquals(out, { reconciled: false, status: null, pr: null });
+  } finally {
+    globalThis.fetch = prevFetch;
+    if (prevToken === undefined) delete process.env.GITHUB_TOKEN;
+    else process.env.GITHUB_TOKEN = prevToken;
+    if (prevTransport === undefined) delete process.env.NANO_PR_GITHUB_TRANSPORT;
+    else process.env.NANO_PR_GITHUB_TRANSPORT = prevTransport;
+  }
+});

package/workers/reconcile-implement/worker.ts

@@ -0,0 +1,60 @@
+// pr.reconcile-implement — reconcile the implement-cell result from GitHub before escalating (issue #801).
+//
+// Runs on the shared `implement-cell`'s escalate arm (`ic_gw` "clean terminal?" → here), IMMEDIATELY
+// before the human escalation, for EVERY caller that composes the cell: a standalone `feature` run and
+// a plan-fanout wave slice. When the implement step returned no machine-readable `status` (a harness
+// that opened a green PR but reported nothing — #796's implement-stage twin), it looks for an OPEN PR
+// on the cell's deterministic `feat/<task.id>` branch and, when one exists, ADOPTS it — emitting
+// `reconciled = true` (the `ic_reconcile_gw` gate routes straight to the cell's done end) plus
+// `status = "opened"` and a `pr` key so the caller converges the adopted PR exactly as if the agent
+// had reported it. Only when nothing is observable does it fall through (`reconciled = false`) to the
+// human escalation as today.
+//
+// The decision + the injected GitHub read (`listPrsForHead`) live in the canonical, exhaustively
+// tested `app/implementReconcile.ts` mirror — this handler is the thin engine seam. `taskId` is
+// derived from the in-scope `task` process variable (`task.id`) — `implement-cell.bpmn` defines no
+// `<zeebe:ioMapping>` input for this step; the engine populates `task` (and `subjectKey`, `status`,
+// `pr`, `baseBranch`) from process scope. `pr` is passed through so the reconcile step's `pr` output
+// never wipes a PR key the implement harness already set. `baseBranch` (the run's pinned base) is
+// passed through so an open PR on the deterministic head branch is only adopted when it targets that
+// base — never a stale/unrelated PR sharing the head branch but aimed at a different base.
+import type { AppJobHandler } from "@nanobpm/urban";
+import { listPrsForHead } from "../../app/github.ts";
+import { type ReconcileImplementResult, reconcileImplement } from "../../app/implementReconcile.ts";
+
+interface In extends Record<string, unknown> {
+  subjectKey?: unknown;
+  task?: unknown;
+  status?: unknown;
+  pr?: unknown;
+  baseBranch?: unknown;
+}
+
+/** The cell's deterministic branch is `feat/<task.id>`; `task` is the implement-cell's slice object.
+ *  Read it defensively (the process variable is untyped at the engine seam). */
+function taskId(task: unknown): unknown {
+  if (task !== null && typeof task === "object" && "id" in task) return task.id;
+  return undefined;
+}
+
+const handler: AppJobHandler<In, ReconcileImplementResult> = async (job, app) => {
+  const res = await reconcileImplement(
+    {
+      status: job.variables.status,
+      subjectKey: job.variables.subjectKey,
+      taskId: taskId(job.variables.task),
+      pr: job.variables.pr,
+      baseBranch: job.variables.baseBranch,
+    },
+    listPrsForHead,
+    process.env.GITHUB_TOKEN ?? "",
+  );
+  app.log.info("reconcile-implement", {
+    subjectKey: job.variables.subjectKey ?? null,
+    reconciled: res.reconciled,
+    pr: res.pr,
+  });
+  return res;
+};
+
+export default handler;