catherd-cli 1.3.0 → 1.5.0

package/src/services/milestones.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { CatherdError } from "../domain/errors.ts";
 import type { RunRecord } from "../domain/record.ts";
-import { git } from "../infra/git.ts";
+import { commitExists, git } from "../infra/git.ts";
 import { nonBlankLines } from "../infra/store.ts";
 import { listDispatches } from "./dispatches.ts";
 import { readAgentRuns, readRecords, readRoutes, type Run, runPaths } from "./run-store.ts";
@@ -50,27 +50,95 @@ export interface MilestoneReviewer {
   record: RunRecord | null;
 }
 
-/**
- * The milestone's latest passing reviewer since its lanes started: a dispatch named reviewer-<m>…, status
- * ok; or a record_agent_run row with role reviewer and the same name, status ok. Null when there is none.
- */
-export function milestoneReviewer(
+/** Every reviewer attempt of the milestone since its lanes started that ended ok, oldest first, partial or not. */
+function reviewerAttempts(
   run: Run,
   m: string,
-  start = milestoneStart(run, m),
-): MilestoneReviewer | null {
-  const found: MilestoneReviewer[] = [
+  start: string | null,
+): (MilestoneReviewer & { partial: boolean })[] {
+  return [
     ...readRecords(run)
       .records.filter((r) => reviewsMilestone(r.name, m) && r.status === "ok" && since(r.endedAt, start))
-      .map((r) => ({ name: r.name, at: r.endedAt, record: r })),
+      .map((r) => ({ name: r.name, at: r.endedAt, record: r, partial: r.replyStatus === "partial" })),
     ...readAgentRuns(run)
       .filter(
         (a) =>
           a.role === "reviewer" && reviewsMilestone(a.name, m) && a.status === "ok" && since(a.at, start),
       )
-      .map((a) => ({ name: a.name, at: a.at, record: null })),
-  ];
-  return found.sort((a, b) => Date.parse(a.at) - Date.parse(b.at)).at(-1) ?? null;
+      .map((a) => ({ name: a.name, at: a.at, record: null, partial: a.replyStatus === "partial" })),
+  ].sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+}
+
+/**
+ * The milestone's latest passing reviewer since its lanes started: a dispatch named reviewer-<m>…, status
+ * ok; or a record_agent_run row with role reviewer and the same name, status ok. A reply of STATUS: partial
+ * read only part of the diff and is not the milestone's review (plan 23). Null when there is none.
+ */
+export function milestoneReviewer(
+  run: Run,
+  m: string,
+  start = milestoneStart(run, m),
+): MilestoneReviewer | null {
+  const full = reviewerAttempts(run, m, start).filter((a) => !a.partial);
+  const last = full.at(-1);
+  return last ? { name: last.name, at: last.at, record: last.record } : null;
+}
+
+/** Plan 23: the milestone's latest reviewer that stopped at STATUS: partial, when no full review stands; else null. */
+export function partialReviewer(
+  run: Run,
+  m: string,
+  start = milestoneStart(run, m),
+): MilestoneReviewer | null {
+  if (milestoneReviewer(run, m, start)) return null;
+  const last = reviewerAttempts(run, m, start)
+    .filter((a) => a.partial)
+    .at(-1);
+  return last ? { name: last.name, at: last.at, record: last.record } : null;
+}
+
+export const FINDING = /^\s*(?:[-*]\s*)?(BLOCKER|BUG|NIT)\b/;
+
+/** A reviewer reply's findings by severity; null when there is no reply to read. */
+export function countFindings(run: Run, r: RunRecord): { BLOCKER: number; BUG: number; NIT: number } | null {
+  const file = join(run.dir, r.replyPath);
+  if (!r.replyPath || !existsSync(file)) return null;
+  const n = { BLOCKER: 0, BUG: 0, NIT: 0 };
+  for (const line of readFileSync(file, "utf8").split("\n")) {
+    const k = FINDING.exec(line)?.[1] as keyof typeof n | undefined;
+    if (k) n[k]++;
+  }
+  return n;
+}
+
+/** The roles a fix round runs as. */
+const FIX_ROLES = new Set(["worker", "writer", "artist"]);
+
+/**
+ * Plan 23: the milestone reviewer's BLOCKER and BUG lines while no fix round has ended since (a worker,
+ * writer or artist of the milestone, ended ok after the review); null when there are none, or for a native
+ * reviewer, whose reply catherd does not keep.
+ */
+export function openFindings(
+  run: Run,
+  m: string,
+  start = milestoneStart(run, m),
+): { name: string; blocker: number; bug: number } | null {
+  const reviewer = milestoneReviewer(run, m, start);
+  if (!reviewer?.record) return null;
+  const n = countFindings(run, reviewer.record);
+  if (!n || n.BLOCKER + n.BUG === 0) return null;
+  const after = (at: string) => Date.parse(at) > Date.parse(reviewer.at);
+  const ofM = (name: string, lane: string | null | undefined) =>
+    inMilestone(lane, m) || namesMilestone(name, m);
+  const fixed =
+    readRecords(run).records.some(
+      (r) => FIX_ROLES.has(r.role) && r.status === "ok" && ofM(r.name, r.lane) && after(r.endedAt),
+    ) ||
+    readAgentRuns(run).some(
+      (a) => FIX_ROLES.has(a.role) && a.status === "ok" && ofM(a.name, a.lane) && after(a.at),
+    );
+  return fixed ? null : { name: reviewer.name, blocker: n.BLOCKER, bug: n.BUG };
 }
 
 /** A reviewer record for the milestone since its lanes started (see milestoneReviewer). */
@@ -80,6 +148,15 @@ export const reviewerPassed = (run: Run, m: string, start = milestoneStart(run,
 /** The verifier's contract puts `VERDICT: PASS` or `VERDICT: FAIL` on the reply's first line (role-prompts.ts). */
 const VERDICT_PASS = /^VERDICT: PASS\b/;
 
+/**
+ * Plan 23: `VERDICT: BLOCKED: environment — <the probe that proves it>`, a verdict on the machine, not on the
+ * work. Its probe, or null when `line` is no such verdict ("" when it names none).
+ */
+export function blockedByEnvironment(line: string | null | undefined): string | null {
+  const m = /^VERDICT:\s*BLOCKED:\s*environment\b\s*(?:—|–|-|:)?\s*(.*)$/i.exec(line?.trim() ?? "");
+  return m ? (m[1] ?? "").trim() : null;
+}
+
 /** A headless verifier's reply: its first non-blank line, trimmed; null when there is no reply to read. */
 export function replyVerdict(run: Run, r: RunRecord): string | null {
   const file = join(run.dir, r.replyPath);
@@ -106,11 +183,17 @@ export interface MilestoneVerifier {
   passed: boolean;
   /** what the attempt said: a native row's status, or a headless reply's first non-blank line ("no reply") */
   verdict: string;
+  /** plan 23: the probe of a `VERDICT: BLOCKED: environment` attempt ("" when it named none); null otherwise */
+  blocked: string | null;
 }
 
+/** The one name a milestone's verifier is counted under (spec 1.5 "The ledger"): verifier-<m>, exactly. */
+export const verifierName = (m: string): string => `verifier-${m}`;
+
 /**
  * The milestone's latest verifier attempt since its lanes started, whatever it said: a record_agent_run row
- * with role verifier whose name names the milestone (the skill records a FAIL as failed), passing when its
+ * with role verifier named exactly verifier-<m> (the skill records a FAIL as failed; verifier-M2-pre or
+ * verifier-M2-gate1 is not M2's verifier), passing when its
  * status is ok; or a headless verifier's dispatch record of the same shape, passing when it exited ok and its
  * reply opens VERDICT: PASS (status ok means only the CLI exited). A later FAIL undoes an earlier PASS. Null
  * when there is none.
@@ -122,16 +205,21 @@ export function milestoneVerifier(
 ): MilestoneVerifier | null {
   const found: MilestoneVerifier[] = [
     ...readAgentRuns(run)
-      .filter((a) => a.role === "verifier" && namesMilestone(a.name, m) && since(a.at, start))
-      .map((a) => ({
-        name: a.name,
-        at: a.at,
-        headless: false,
-        passed: a.status === "ok",
-        verdict: a.status,
-      })),
+      .filter((a) => a.role === "verifier" && a.name === verifierName(m) && since(a.at, start))
+      .map((a) => {
+        // plan 23: a native verifier's verdict line, when record_agent_run passed it
+        const blocked = a.status === "ok" ? null : blockedByEnvironment(a.verdict);
+        return {
+          name: a.name,
+          at: a.at,
+          headless: false,
+          passed: a.status === "ok",
+          verdict: blocked === null ? a.status : (a.verdict ?? a.status),
+          blocked,
+        };
+      }),
     ...readRecords(run)
-      .records.filter((r) => r.role === "verifier" && namesMilestone(r.name, m) && since(r.endedAt, start))
+      .records.filter((r) => r.role === "verifier" && r.name === verifierName(m) && since(r.endedAt, start))
       .map((r) => {
         const first = replyVerdict(run, r);
         const passed = r.status === "ok" && first !== null && VERDICT_PASS.test(first);
@@ -142,6 +230,7 @@ export function milestoneVerifier(
           headless: true,
           passed,
           verdict: r.status === "ok" ? said : `${r.status}, ${said}`,
+          blocked: r.status === "ok" ? blockedByEnvironment(first) : null,
         };
       }),
   ];
@@ -170,12 +259,16 @@ export function landedMilestones(run: Run): string[] {
 }
 
 /**
- * The files the milestone's commit range changed: from the previous landed commit (else the commit's own
- * parent) to `commit`. Throws E_IO_UNEXPECTED when git cannot say.
+ * The files the milestone's commit range changed: from the previous landed commit, else the HEAD the run
+ * started on (meta.json `startHead`, when that commit is still there), else the commit's own parent, to
+ * `commit`. Throws E_IO_UNEXPECTED when git cannot say.
  */
 export async function milestoneFiles(run: Run, commit: string): Promise<string[]> {
-  const base = landedCommits(run).at(-1);
   const repo = run.meta.repo;
+  const start = run.meta.startHead;
+  const base =
+    landedCommits(run).at(-1) ??
+    (start && (await commitExists(repo, start).catch(() => false)) ? start : undefined);
   const r = base
     ? await git(repo, ["diff", "--name-only", base, commit])
     : await git(repo, ["show", "--name-only", "--format=", "--first-parent", commit]);
@@ -186,6 +279,24 @@ export async function milestoneFiles(run: Run, commit: string): Promise<string[]
   return r.out.split("\n").filter(Boolean);
 }
 
+/** The most commits a digest lists; the rest are counted. */
+const DIGEST_COMMITS = 20;
+
+/**
+ * The commits the milestone lands, `<short hash> <subject>`, oldest first: from the previous landed commit
+ * (else the commit alone) to `commit`. Just the hash when git cannot say: a digest never fails a landing.
+ */
+export async function milestoneCommits(run: Run, commit: string): Promise<string[]> {
+  const base = landedCommits(run).at(-1);
+  const range = base ? [`${base}..${commit}`] : ["-1", commit];
+  const r = await git(run.meta.repo, ["log", "--reverse", "--format=%h %s", ...range]);
+  if (r.kind !== "ok") return [commit.slice(0, 7)];
+  const all = r.out.split("\n").filter(Boolean);
+  return all.length > DIGEST_COMMITS
+    ? [...all.slice(-DIGEST_COMMITS), `and ${all.length - DIGEST_COMMITS} earlier`]
+    : all;
+}
+
 /** `rev`'s full commit hash in the run's repo. Throws E_IO_UNEXPECTED when git cannot say. */
 export async function fullCommit(run: Run, rev: string): Promise<string> {
   const r = await git(run.meta.repo, ["rev-parse", "--verify", "--quiet", `${rev}^{commit}`]);