@nanobpm/nano-workforce 0.160.0 → 0.162.0

package/operations/sequenceIssues.test.ts

@@ -0,0 +1,101 @@
+// Tests for the POST /app/api/actions/start/sequence-issues operation `sequenceIssues` (epic
+// nano-workforce#605, S4/#610). The intent-shaped door GENERATES the canonical delivery graph and
+// STAGES it through the SAME compile+stage flow as `compileDeliveryGraph` — the response carries only
+// a preview + a navigational `reviewUrl` (no dispatch handle); dispatch stays an operator action.
+// Invalid input is a 400 with `issues[{path,message}]` and nothing is staged.
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
+import type { AppApi, DataLayer } from "@nanobpm/urban";
+import { bootTestApp } from "@nanobpm/urban-testkit";
+import { deliveryGraphProposals, listStagedProposals } from "../app/deliveryGraphProposals.ts";
+import { noopLog } from "../test/log.ts";
+import handler from "./sequenceIssues.ts";
+
+const APP_ROOT = resolve(import.meta.dirname, "..");
+
+async function withApp(fn: (app: AppApi, data: DataLayer) => Promise<void>): Promise<void> {
+  const dir = mkdtempSync(join(tmpdir(), "nwf-seqissues-"));
+  const app = await bootTestApp(APP_ROOT, { env: { NANO_APP_DB_URL: `file:${join(dir, "app.db")}` } });
+  try {
+    const edge = { data: app.db, log: noopLog() } as unknown as AppApi;
+    await fn(edge, app.db);
+  } finally {
+    await app.stop?.();
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+async function call(app: AppApi, body: unknown, headers: Record<string, string> = {}) {
+  const req = { path: "/app/api/actions/start/sequence-issues", headers: new Headers(headers) };
+  return (await handler({ req: req as any, params: {}, query: {}, body } as any, app)) as any;
+}
+
+test("sequence-issues: a valid intent → 200 ready, staged as a proposal, with the preview", async () => {
+  await withApp(async (app, data) => {
+    const res = await call(app, { behind: "acme/repo#100", issues: ["acme/repo#1", "acme/repo#2"] });
+    assertEquals(res.status, 200);
+    assertEquals(res.body.status, "ready");
+    assert(typeof res.body.digest === "string" && res.body.digest.length > 0);
+    assert(typeof res.body.preview === "object" && res.body.preview !== null);
+    assert(typeof res.body.preview.diagram === "string" && res.body.preview.diagram.length > 0);
+    // Staged through the SAME path as compileDeliveryGraph — visible immediately (read-after-write).
+    const row = await deliveryGraphProposals(data).get(res.body.digest);
+    assert(row, "the generated graph is staged for operator dispatch");
+    assertEquals(row?.status, "staged");
+    const live = await listStagedProposals(data);
+    assert(live.some((p) => p.digest === res.body.digest), "the staged digest is listed");
+  });
+});
+
+test("sequence-issues: the response exposes NO dispatch handle — the door stages, never dispatches", async () => {
+  await withApp(async (app) => {
+    const res = await call(app, { issues: ["acme/repo#1"] });
+    assertEquals(res.status, 200);
+    const keys = Object.keys(res.body);
+    for (const forbidden of ["runKey", "token", "approvalToken", "processInstanceKey", "processKey", "dispatchUrl"]) {
+      assert(!keys.includes(forbidden), `response must not carry a dispatch handle (${forbidden})`);
+    }
+  });
+});
+
+test("sequence-issues: an identical intent re-stages the SAME digest (idempotent), not a duplicate", async () => {
+  await withApp(async (app, data) => {
+    const a = await call(app, { issues: ["acme/repo#1", "acme/repo#2"] });
+    const b = await call(app, { issues: ["acme/repo#1", "acme/repo#2"] });
+    assertEquals(a.body.digest, b.body.digest);
+    const live = await listStagedProposals(data);
+    assertEquals(live.filter((p) => p.digest === a.body.digest).length, 1);
+  });
+});
+
+test("sequence-issues: empty issues → 400 with issues[{path,message}], nothing staged", async () => {
+  await withApp(async (app, data) => {
+    const res = await call(app, { issues: [] });
+    assertEquals(res.status, 400);
+    assert(Array.isArray(res.body.issues) && res.body.issues.length > 0);
+    for (const iss of res.body.issues) {
+      assert(typeof iss.path === "string" && typeof iss.message === "string");
+    }
+    assertEquals((await listStagedProposals(data)).length, 0);
+  });
+});
+
+test("sequence-issues: an unparseable issue ref → 400 at the offending path, nothing staged", async () => {
+  await withApp(async (app, data) => {
+    const res = await call(app, { issues: ["acme/repo#1", "garbage"] });
+    assertEquals(res.status, 400);
+    assert(res.body.issues.some((i: any) => i.path === "issues[1]"));
+    assertEquals((await listStagedProposals(data)).length, 0);
+  });
+});
+
+test("sequence-issues: a missing body folds into the same 400 contract (not a 500)", async () => {
+  await withApp(async (app) => {
+    const res = await call(app, undefined);
+    assertEquals(res.status, 400);
+    assert(Array.isArray(res.body.issues) && res.body.issues.length > 0);
+  });
+});

package/operations/sequenceIssues.ts

@@ -0,0 +1,55 @@
+// POST /app/api/actions/start/sequence-issues → operationId `sequenceIssues` (epic
+// nano-workforce#605, S4/#610). An INTENT-SHAPED door: instead of making an agent hand-author the
+// full canonical node/edge JSON for "implement issue → converge → merge" (§9.4 — 13 nodes + 12 edges
+// for four gated issues, in the evidence session), it takes the high-level intent
+// `{ behind?, issues[] }` and GENERATES that canonical delivery graph, then hands it to the SAME
+// compile+stage flow the raw `compileDeliveryGraph` door uses. It STAGES for operator review and
+// returns a navigational `reviewUrl` and NOTHING that can trigger a run — dispatch stays an
+// operator-only cockpit action (ADR 0005 Decision 7 / issue #460). No new runner, no second staging
+// path: the generator only produces the `DeliveryGraph` (`buildSequenceGraph`) and delegates.
+//
+// Invalid input (empty `issues`, an unparseable `owner/repo#N` ref, an unknown target/probe per the
+// S3 vocabulary) is a 400 carrying the uniform `issues[{path,message}]` contract; nothing is staged.
+import { compileAndStageDeliveryGraph } from "../app/deliveryGraphStage.ts";
+import { resolvePublicOrigin } from "../app/resolveApiBase.ts";
+import { buildSequenceGraph } from "../app/sequenceIssues.ts";
+import { defineOperation } from "../nano-generated/operations.ts";
+
+export default defineOperation("sequenceIssues", async ({ body, req }, app) => {
+  // Build the canonical graph from the intent. Input validation (shape, ref format, vocabulary drift)
+  // lives in the pure `buildSequenceGraph` and returns the uniform `issues[{path,message}]` contract —
+  // a directly-invoked delegate passing `undefined` folds into the same clean rejection.
+  const built = buildSequenceGraph(body);
+  if (!built.ok) {
+    app.log.warn("sequence-issues rejected", { issues: built.issues.length });
+    return { status: 400, body: { error: "invalid sequenceIssues intent", issues: built.issues } };
+  }
+
+  // Hand the CONSTRUCTED graph to the shared compile+stage flow — one compiler, one staging path,
+  // idempotency/digest inherited (AGENTS.md "no drift surfaces"). `reviewUrl` keys to the origin this
+  // request arrived on (tunnel/proxy prefix), not the static deployment-wide base (#577).
+  const staged = await compileAndStageDeliveryGraph(
+    app.data,
+    built.graph,
+    JSON.stringify(built.graph),
+    resolvePublicOrigin(req),
+  );
+  if (!staged.ok) {
+    // A generated graph is well-formed by construction; a compile failure here is a generator defect,
+    // surfaced through the SAME `issues[{path,message}]` contract (mapped from the compiler's
+    // path-qualified `errors`) rather than a 500.
+    app.log.error("sequence-issues compile failed on a generated graph", { errors: staged.body.errors.length });
+    return {
+      status: 400,
+      body: { error: "generated delivery graph failed to compile", issues: staged.body.errors },
+    };
+  }
+
+  app.log.info("sequence-issues staged", {
+    digest: staged.digest,
+    nodes: staged.nodeCount,
+    humanNodes: staged.humanNodeCount,
+    sideEffects: staged.sideEffectCount,
+  });
+  return { status: staged.status, body: staged.body };
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.160.0",
+  "version": "0.162.0",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",