@nanobpm/nano-workforce 0.28.0 → 0.30.0

package/workers/retro-gather/worker.test.ts

@@ -0,0 +1,78 @@
+import { assert, assertEquals, assertStringIncludes } from "jsr:@std/assert@1";
+import type { DataLayer } from "@nanobpm/urban";
+import { appendEntry } from "../../app/blackboard.ts";
+import handler from "./worker.ts";
+
+// deno-lint-ignore no-explicit-any
+function memData(): { data: DataLayer; stores: Record<string, any[]> } {
+  // deno-lint-ignore no-explicit-any
+  const stores: Record<string, any[]> = {};
+  const seq: Record<string, number> = {};
+  function tbl(name: string, pk = "id") {
+    // deno-lint-ignore no-explicit-any
+    const rows = (stores[name] ??= [] as any[]);
+    // deno-lint-ignore no-explicit-any
+    const match = (r: any, where: any) => Object.entries(where).every(([k, v]) => r[k] === v);
+    return {
+      // deno-lint-ignore no-explicit-any require-await
+      async insert(row: any) {
+        const id = (seq[name] = (seq[name] ?? 0) + 1);
+        rows.push(pk === "id" ? { id, ...row } : { ...row });
+        return pk === "id" ? id : row[pk];
+      },
+      // deno-lint-ignore no-explicit-any require-await
+      async find(where: any = {}) {
+        return rows.filter((r) => match(r, where));
+      },
+      // deno-lint-ignore no-explicit-any require-await
+      async findOne(where: any = {}) {
+        return rows.find((r) => match(r, where));
+      },
+      // deno-lint-ignore no-explicit-any require-await
+      async get(id: any) {
+        return rows.find((row) => row[pk] === id);
+      },
+      // deno-lint-ignore no-explicit-any require-await
+      async update() {},
+    };
+  }
+  // deno-lint-ignore no-explicit-any
+  const data = { table: (n: string, pk?: string) => tbl(n, pk) } as any as DataLayer;
+  return { data, stores };
+}
+
+Deno.test("retro-gather: emits a digest brief + learning count for the plan", async () => {
+  const { data, stores } = memData();
+  stores["plans"] = [{ plan_key: "o/r#3", repo: "o/r", issue_url: "https://x/3", title: "Epic" }];
+  await appendEntry(data, "o/r#3", { author_task: "t1", kind: "learning", body: "regen before build" });
+  await appendEntry(data, "o/r#3", { author_task: "t2", kind: "learning", body: "use nextest" });
+
+  const app = { data, log: () => undefined };
+  const out = await handler(
+    // deno-lint-ignore no-explicit-any
+    { variables: { planKey: "o/r#3" } } as any,
+    // deno-lint-ignore no-explicit-any
+    app as any,
+  ) as Record<string, unknown>;
+
+  assertEquals(out.retroLearnings, 2);
+  assertStringIncludes(String(out.retroDigest), "regen before build");
+  assertStringIncludes(String(out.retroDigest), "use nextest");
+  assertStringIncludes(String(out.retroDigest), "o/r#3");
+});
+
+Deno.test("retro-gather: an epic with no learnings still renders a valid brief", async () => {
+  const { data, stores } = memData();
+  stores["plans"] = [{ plan_key: "o/r#4", repo: "o/r", issue_url: "", title: null }];
+  const app = { data, log: () => undefined };
+  const out = await handler(
+    // deno-lint-ignore no-explicit-any
+    { variables: { planKey: "o/r#4" } } as any,
+    // deno-lint-ignore no-explicit-any
+    app as any,
+  ) as Record<string, unknown>;
+
+  assertEquals(out.retroLearnings, 0);
+  assert(typeof out.retroDigest === "string");
+  assertStringIncludes(String(out.retroDigest), "none");
+});

package/workers/retro-gather/worker.ts

@@ -0,0 +1,28 @@
+// pr.retro-gather — first step of the `retro` process. Assemble the plan's accumulated
+// coordination knowledge (the `learning` blackboard entries agents posted while implementing, plus
+// the task-delta rollup and any other blackboard notes) into a compact markdown brief, and emit it
+// as `retroDigest`. The next step maps that onto the `senior:retro` agent's `appendPrompt`, so the
+// agent reflects on real material rather than re-deriving it.
+import type { AppJobHandler } from "@nanobpm/urban";
+import { gatherRetro, renderRetroBrief } from "../../app/retro.ts";
+
+interface In extends Record<string, unknown> {
+  planKey: string;
+}
+
+interface Out extends Record<string, unknown> {
+  retroDigest: string;
+  retroLearnings: number;
+}
+
+const handler: AppJobHandler<In, Out> = async (job, app) => {
+  const planKey = job.variables.planKey;
+  const digest = await gatherRetro(app.data, planKey);
+  app.log("info", `retro-gather: ${planKey} — ${digest.counts.learnings} learnings, ${digest.counts.deltas} deltas`);
+  return {
+    retroDigest: renderRetroBrief(digest),
+    retroLearnings: digest.counts.learnings,
+  };
+};
+
+export default handler;

package/workers/retro-record/worker.test.ts

@@ -0,0 +1,127 @@
+import { assertEquals } from "jsr:@std/assert@1";
+import handler from "./worker.ts";
+
+function fakeApp() {
+  // deno-lint-ignore no-explicit-any
+  const stores: Record<string, any[]> = { plan_retros: [] };
+  const seq: Record<string, number> = {};
+  function tbl(name: string, pk = "id") {
+    // deno-lint-ignore no-explicit-any
+    const rows = (stores[name] ??= [] as any[]);
+    // deno-lint-ignore no-explicit-any
+    const match = (r: any, where: any) => Object.entries(where).every(([k, v]) => r[k] === v);
+    return {
+      // deno-lint-ignore no-explicit-any require-await
+      async insert(row: any) {
+        const id = (seq[name] = (seq[name] ?? 0) + 1);
+        rows.push(pk === "id" ? { id, ...row } : { ...row });
+        return pk === "id" ? id : row[pk];
+      },
+      // deno-lint-ignore no-explicit-any require-await
+      async find(where: any = {}) {
+        return rows.filter((r) => match(r, where));
+      },
+      // deno-lint-ignore no-explicit-any require-await
+      async findOne(where: any = {}) {
+        return rows.find((r) => match(r, where));
+      },
+      // deno-lint-ignore no-explicit-any require-await
+      async get(id: any) {
+        return rows.find((row) => row[pk] === id);
+      },
+      // deno-lint-ignore no-explicit-any require-await
+      async update(id: any, patch: any) {
+        const r = rows.find((row) => row[pk] === id);
+        if (r) Object.assign(r, patch);
+      },
+    };
+  }
+  const app = { data: { table: (n: string, pk?: string) => tbl(n, pk) }, log: () => undefined };
+  return { app, stores };
+}
+
+Deno.test("retro-record: persists a filed retro from hoisted result vars", async () => {
+  const { app, stores } = fakeApp();
+  await handler(
+    // deno-lint-ignore no-explicit-any
+    {
+      variables: {
+        planKey: "o/r#5",
+        retroLearnings: 4,
+        status: "filed",
+        pr: "o/r#42",
+        summary: "promoted 2 lessons",
+        "io.nanobpm.agentResult": { output: "the full report" },
+      },
+    } as any,
+    // deno-lint-ignore no-explicit-any
+    app as any,
+  );
+
+  assertEquals(stores.plan_retros.length, 1);
+  const row = stores.plan_retros[0];
+  assertEquals(row.status, "filed");
+  assertEquals(row.pr_key, "o/r#42");
+  assertEquals(row.learnings, 4);
+  assertEquals(row.summary, "promoted 2 lessons");
+  assertEquals(row.report, "the full report");
+});
+
+Deno.test("retro-record: defaults to skipped when the agent filed no PR", async () => {
+  const { app, stores } = fakeApp();
+  await handler(
+    // deno-lint-ignore no-explicit-any
+    { variables: { planKey: "o/r#6", summary: "nothing durable" } } as any,
+    // deno-lint-ignore no-explicit-any
+    app as any,
+  );
+  assertEquals(stores.plan_retros[0].status, "skipped");
+  assertEquals(stores.plan_retros[0].pr_key, null);
+});
+
+Deno.test("retro-record: honours an explicit blocked status", async () => {
+  const { app, stores } = fakeApp();
+  await handler(
+    // deno-lint-ignore no-explicit-any
+    { variables: { planKey: "o/r#7", status: "blocked", summary: "no write access" } } as any,
+    // deno-lint-ignore no-explicit-any
+    app as any,
+  );
+  assertEquals(stores.plan_retros[0].status, "blocked");
+});
+
+Deno.test("retro-record: ignores a PR unless the status is filed", async () => {
+  const { app, stores } = fakeApp();
+  await handler(
+    // deno-lint-ignore no-explicit-any
+    { variables: { planKey: "o/r#8", status: "skipped", pr: "o/r#43", summary: "not durable" } } as any,
+    // deno-lint-ignore no-explicit-any
+    app as any,
+  );
+  assertEquals(stores.plan_retros[0].status, "skipped");
+  assertEquals(stores.plan_retros[0].pr_key, null);
+});
+
+Deno.test("retro-record: defaults invalid status from PR presence", async () => {
+  const { app, stores } = fakeApp();
+  await handler(
+    // deno-lint-ignore no-explicit-any
+    { variables: { planKey: "o/r#9", status: "done", pr: "o/r#44" } } as any,
+    // deno-lint-ignore no-explicit-any
+    app as any,
+  );
+  assertEquals(stores.plan_retros[0].status, "filed");
+  assertEquals(stores.plan_retros[0].pr_key, "o/r#44");
+});
+
+Deno.test("retro-record: coerces filed without a PR to skipped", async () => {
+  const { app, stores } = fakeApp();
+  await handler(
+    // deno-lint-ignore no-explicit-any
+    { variables: { planKey: "o/r#10", status: "filed", summary: "forgot the PR" } } as any,
+    // deno-lint-ignore no-explicit-any
+    app as any,
+  );
+  assertEquals(stores.plan_retros[0].status, "skipped");
+  assertEquals(stores.plan_retros[0].pr_key, null);
+});

package/workers/retro-record/worker.ts

@@ -0,0 +1,60 @@
+// pr.retro-record — final step of the `retro` process. Persist the `senior:retro` agent's result
+// into `plan_retros` (016_plan_retro.sql): the outcome status, the promotion PR it opened on the
+// target repo (if any), the learning count it distilled, and its summary/report. Advisory only —
+// this gates no control flow; it exists so the epic surface can show what the retro concluded.
+//
+// The agentTask runner hoists the agent's result-JSON keys (`status`, `pr`, `summary`) into
+// top-level process variables (same as pr.record-plan-review reads `job.variables.approved`), and
+// exposes the raw transcript under the `io.nanobpm.agentResult` envelope's `.output`.
+import type { AppJobHandler } from "@nanobpm/urban";
+import { recordRetro } from "../../app/retro.ts";
+
+const AGENT_RESULT_KEY = "io.nanobpm.agentResult";
+const VALID_STATUSES = new Set(["filed", "skipped", "blocked"]);
+
+interface In extends Record<string, unknown> {
+  planKey: string;
+  retroLearnings?: number;
+  status?: unknown; // filed | skipped | blocked
+  pr?: unknown; // "<owner>/<repo>#<n>" of the promotion PR, when filed
+  summary?: unknown;
+}
+
+function asStr(v: unknown): string | null {
+  return typeof v === "string" && v.trim() !== "" ? v.trim() : null;
+}
+
+function asStatus(v: unknown, hasPr: boolean): "filed" | "skipped" | "blocked" {
+  const s = asStr(v);
+  if (s && VALID_STATUSES.has(s)) {
+    if (s === "filed" && !hasPr) return "skipped";
+    return s as "filed" | "skipped" | "blocked";
+  }
+  return hasPr ? "filed" : "skipped";
+}
+
+const handler: AppJobHandler<In> = async (job, app) => {
+  const planKey = job.variables.planKey;
+
+  const rawPrKey = asStr(job.variables.pr);
+  // Default to "filed" only when a PR is present; otherwise the agent decided not to file.
+  const status = asStatus(job.variables.status, rawPrKey !== null);
+  const prKey = status === "filed" ? rawPrKey : null;
+  const summary = asStr(job.variables.summary);
+
+  const env = job.variables[AGENT_RESULT_KEY] as { output?: unknown } | undefined;
+  const report = typeof env?.output === "string" ? env.output : null;
+
+  await recordRetro(app.data, planKey, {
+    status,
+    prKey,
+    learnings: typeof job.variables.retroLearnings === "number" ? job.variables.retroLearnings : 0,
+    summary,
+    report,
+  });
+
+  app.log("info", `retro-record: ${planKey} — status=${status}${prKey ? ` pr=${prKey}` : ""}`);
+  return {};
+};
+
+export default handler;