@fullstackhouse/cerber 0.34.0 → 0.35.1

package/dist/server/index.js

@@ -9,13 +9,15 @@ import { randomUUID } from "node:crypto";
 import { isPureStub } from "./daemon.js";
 import { ArtifactStatusSchema, SCHEMA_VERSION, SeveritySchema, VerdictSchema, artifactId, artifactKey, } from "../core/artifact.js";
 import { toMarkdown } from "../core/export.js";
-import { currentLogin, fetchAssignableUsers, fetchPrDiff, fetchPrInfo, handOffReview, parsePrRef, postIssueComment, submitReview, } from "../core/gh.js";
+import { currentLogin, fetchAssignableUsers, fetchPrDiff, fetchPrInfo, handOffReview, parsePrRef, postIssueComment, postReplies, submitReview, } from "../core/gh.js";
 import { z } from "zod";
 import { DaemonConfigSchema, configPath, loadConfig, saveConfig } from "../core/config.js";
 import { refreshArtifact, userOwnsStatus } from "../core/refresh.js";
 import { withWriter } from "../core/history.js";
 import { TrustRuleError, describeRule, explainRule, parseTrustRule } from "../core/trust.js";
-import { buildReviewPayload, computeCalibration } from "../core/send.js";
+import { buildReviewPayload, computeCalibration, describeReplyFailures, recordReplies, } from "../core/send.js";
+import { raisedChanged, startRaisedCheck } from "../core/raised.js";
+import { checkAlreadyRaised, claimRaisedCheck, finishRaisedCheck, isRaisedCheckRunning, prepareRaisedCheck, releaseRaisedCheck, } from "../runner/raised.js";
 import { listArtifacts, loadArtifact, loadArtifactByKey, saveArtifact, updateArtifactByKey, } from "../core/state.js";
 import { isReviewRunning } from "../runner/inflight.js";
 import { reviewPr } from "../runner/review.js";
@@ -29,6 +31,8 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
  * own decision about a PR. Everything else is a fact some other path owns.
  */
 const SETTLEABLE = ["reviewed", "skipped"];
+/** What the user may decide about a finding somebody else already raised. */
+const RaisedDecisionSchema = z.enum(["send", "reply"]).nullable();
 /**
  * What a handoff needs: one person, a note to post, and a confirmation.
  *
@@ -65,6 +69,22 @@ const HandoffSchema = z.object({
  * that has not written yet.
  */
 const inFlight = (a) => a.status === "running" || isReviewRunning(a.id);
+/**
+ * What to say when the in-flight claim is why a request was refused. The check
+ * for findings others already raised holds the claim too, for up to a minute,
+ * and "a review is running" would send the user looking for a run that isn't.
+ */
+const busy = (a, otherwise) => isRaisedCheckRunning(a.id)
+    ? "cerber is checking which findings other reviewers already raised — give it a minute"
+    : otherwise;
+/** Run a check for already-raised findings detached; its failures land on the artifact. */
+function checkInBackground(artifact) {
+    return checkAlreadyRaised(artifact, {
+        log: (m) => console.log(`[raised ${artifact.id}] ${m}`),
+    }).catch((err) => {
+        console.error(`[raised ${artifact.id}] ${err instanceof Error ? err.message : String(err)}`);
+    });
+}
 export async function buildApp(opts) {
     const app = new Hono();
     // Whatever any route writes to an artifact is stamped with the request that
@@ -111,7 +131,8 @@ export async function buildApp(opts) {
         }
     });
     // The inbox knobs. The daemon re-reads the config every poll, so a toggle
-    // here applies on the next tick without restarting serve.
+    // here applies on the next tick without restarting serve — and what the
+    // status reports about them applies at once, since the cockpit reads it.
     app.post("/api/config/daemon", async (c) => {
         let body;
         try {
@@ -124,6 +145,7 @@ export async function buildApp(opts) {
             const config = await loadConfig();
             const daemon = DaemonConfigSchema.parse({ ...config.daemon, ...body });
             await saveConfig({ ...config, daemon });
+            opts.daemon?.reconfigure({ ...config, daemon });
             return c.json({ path: configPath(), trust: trustView(config.trust), daemon });
         }
         catch (err) {
@@ -166,6 +188,7 @@ export async function buildApp(opts) {
             });
             const trust = remove === true ? without : [...without, canonical];
             await saveConfig({ ...config, trust });
+            opts.daemon?.reconfigure({ ...config, trust });
             // Full ConfigView — the cockpit replaces its config state with this
             // wholesale, so omitting daemon would crash the Settings toggles.
             return c.json({ path: configPath(), trust: trustView(trust), daemon: config.daemon });
@@ -321,6 +344,7 @@ export async function buildApp(opts) {
             refresh: null,
             filed: null,
             handoff: null,
+            raisedCheck: null,
             settledAt: null,
             calibration: null,
             chat: [],
@@ -414,11 +438,35 @@ export async function buildApp(opts) {
     app.patch("/api/reviews/:key/comments/:id", async (c) => {
         const body = await c.req.json();
         const id = c.req.param("id");
+        // What Send does with a finding somebody else already raised: post it
+        // anyway, answer in their thread, or — null — the default for where they
+        // raised it. Refused rather than coerced when it cannot mean anything: a
+        // comment nobody else raised has no thread to answer, and neither does a
+        // review body.
+        const decision = RaisedDecisionSchema.safeParse(body.raisedDecision);
+        if (body.raisedDecision !== undefined) {
+            if (!decision.success) {
+                return c.json({ error: "raisedDecision must be \"send\", \"reply\", or null for the default" }, 400);
+            }
+            const artifact = await loadArtifactByKey(c.req.param("key"));
+            const target = artifact?.comments.find((cm) => cm.id === id);
+            if (!artifact || !target)
+                return c.json({ error: "not found" }, 404);
+            if (!target.alreadyRaised) {
+                return c.json({ error: "nobody else raised this comment, so there is nothing to decide" }, 409);
+            }
+            if (decision.data === "reply" && target.alreadyRaised.where.kind !== "thread") {
+                return c.json({ error: `@${target.alreadyRaised.by} raised it in a review body, which has no thread to reply in` }, 409);
+            }
+        }
         const updated = await updateArtifactByKey(c.req.param("key"), (a) => ({
             ...a,
             comments: a.comments.map((cm) => cm.id === id
                 ? {
                     ...cm,
+                    ...(decision.success && body.raisedDecision !== undefined && cm.alreadyRaised
+                        ? { alreadyRaised: { ...cm.alreadyRaised, decision: decision.data } }
+                        : {}),
                     ...(body.body !== undefined ? { body: String(body.body) } : {}),
                     ...(body.severity !== undefined
                         ? { severity: SeveritySchema.nullable().parse(body.severity) }
@@ -454,6 +502,7 @@ export async function buildApp(opts) {
                     editedByUser: false,
                     originalLine: null,
                     drifted: false,
+                    alreadyRaised: null,
                 },
             ],
         }));
@@ -536,7 +585,7 @@ export async function buildApp(opts) {
         if (artifact.sent)
             return c.json({ error: `already sent at ${artifact.sent.at}` }, 409);
         if (isReviewRunning(artifact.id)) {
-            return c.json({ error: "a review of this PR is already running" }, 409);
+            return c.json({ error: busy(artifact, "a review of this PR is already running") }, 409);
         }
         const ref = { owner: artifact.pr.owner, repo: artifact.pr.repo, number: artifact.pr.number };
         // Source-backed unless the server was started with --no-source; ?source=1
@@ -600,7 +649,7 @@ export async function buildApp(opts) {
         if (artifact.sent)
             return c.json({ error: `already sent at ${artifact.sent.at}` }, 409);
         if (isReviewRunning(artifact.id) || turnInFlight(artifact)) {
-            return c.json({ error: "a run for this PR is already in flight" }, 409);
+            return c.json({ error: busy(artifact, "a run for this PR is already in flight") }, 409);
         }
         let request;
         try {
@@ -644,10 +693,16 @@ export async function buildApp(opts) {
             // The cockpit stays live throughout, so fold the result onto whatever
             // is on disk now rather than overwriting it — an edit the user made
             // while waiting must not vanish when the answer lands.
-            await updateArtifactByKey(key, (current) => ({
-                ...mergeConcurrentEdits(artifact, result.artifact, current),
-                pendingChat: null,
-            }));
+            // A finding the turn added is compared with what others said, like
+            // the review's own were. Marked in the same write that clears the
+            // turn, so the cockpit's poll has no gap in which nothing is pending.
+            const added = result.artifact.comments.some((cm) => !artifact.comments.some((before) => before.id === cm.id));
+            const landed = await updateArtifactByKey(key, (current) => {
+                const merged = { ...mergeConcurrentEdits(artifact, result.artifact, current), pendingChat: null };
+                return added ? startRaisedCheck(merged, new Date().toISOString()) : merged;
+            });
+            if (added && landed)
+                void checkInBackground(landed);
         })
             .catch(async (err) => {
             const message = err instanceof Error ? err.message : String(err);
@@ -724,22 +779,86 @@ export async function buildApp(opts) {
         // run used to save `sent: null` back over the record when it landed, so the
         // guard above would wave a *second* submission through afterwards.
         if (inFlight(artifact)) {
-            return c.json({ error: "a review of this PR is running — wait for it to finish" }, 409);
+            return c.json({ error: busy(artifact, "a review of this PR is running — wait for it to finish") }, 409);
         }
         const payload = buildReviewPayload(artifact, event);
+        const ref = { owner: artifact.pr.owner, repo: artifact.pr.repo, number: artifact.pr.number };
+        let url;
         try {
-            const { url } = await submitReview({ owner: artifact.pr.owner, repo: artifact.pr.repo, number: artifact.pr.number }, { event: payload.event, body: payload.body, comments: payload.comments, commitId: payload.commitId });
-            const updated = await updateArtifactByKey(c.req.param("key"), (a) => ({
-                ...a,
-                status: "sent",
-                sent: { at: new Date().toISOString(), event: payload.event, url, auto: false },
-                calibration: computeCalibration(a, payload.event),
+            ({ url } = await submitReview(ref, {
+                event: payload.event,
+                body: payload.body,
+                comments: payload.comments,
+                commitId: payload.commitId,
             }));
-            return c.json(updated);
         }
         catch (err) {
             return c.json({ error: err instanceof Error ? err.message : String(err) }, 502);
         }
+        // Recorded before the replies go: the review is up, and a reply failing
+        // must not leave the row claiming it isn't — the "already sent" guard is
+        // what keeps a retry from posting the review twice.
+        await updateArtifactByKey(c.req.param("key"), (a) => ({
+            ...a,
+            status: "sent",
+            sent: { at: new Date().toISOString(), event: payload.event, url, auto: false },
+            calibration: computeCalibration(a, payload.event),
+        }));
+        const outcomes = await postReplies(ref, payload.replies);
+        const updated = await updateArtifactByKey(c.req.param("key"), (a) => recordReplies(a, outcomes));
+        const replyError = describeReplyFailures(outcomes);
+        if (replyError)
+            console.error(`[send ${artifact.id}] ${replyError}`);
+        return c.json({ ...updated, replyError });
+    });
+    // ---- Already raised: compare the draft with what others said on the PR ----
+    // Read-only against GitHub. Detached, like a chat turn: the cockpit polls
+    // `raisedCheck.checkingSince` until it clears.
+    app.post("/api/reviews/:key/raised", async (c) => {
+        const key = c.req.param("key");
+        const artifact = await loadArtifactByKey(key);
+        if (!artifact)
+            return c.json({ error: "not found" }, 404);
+        // A sent review is history, and a running one checks for itself when it lands.
+        if (artifact.sent)
+            return c.json({ error: `already sent at ${artifact.sent.at}` }, 409);
+        // Before the in-flight guard, which a running check also trips: a second
+        // open while one is out is answered with what is on disk, not refused.
+        if (isRaisedCheckRunning(artifact.id))
+            return c.json(artifact, 202);
+        if (inFlight(artifact) || turnInFlight(artifact) || !claimRaisedCheck(artifact.id)) {
+            return c.json({ error: "a run for this PR is in flight — it checks when it lands" }, 409);
+        }
+        // The claim is held from here, across the GitHub read as well as any model
+        // call: Send waits on it, and a Send landing mid-read would post the
+        // duplicate the read was about to find. It is in memory, so a check that
+        // finds nothing new still writes nothing.
+        let detached = false;
+        try {
+            const step = await prepareRaisedCheck(artifact, { log: (m) => console.log(`[raised ${artifact.id}] ${m}`) });
+            if (!step.needsModel) {
+                const current = await loadArtifactByKey(key);
+                if (!current)
+                    return c.json({ error: "not found" }, 404);
+                // Nothing new is no write: `updatedAt` is what the queue sorts and ages
+                // rows by, and merely opening a review must not move it.
+                if (!raisedChanged(current, step.fold(current)))
+                    return c.json(current);
+                return c.json(await updateArtifactByKey(key, step.fold));
+            }
+            const marked = await updateArtifactByKey(key, (a) => startRaisedCheck(a, new Date().toISOString()));
+            if (!marked)
+                return c.json({ error: "not found" }, 404);
+            detached = true;
+            void finishRaisedCheck(marked, step).catch((err) => {
+                console.error(`[raised ${artifact.id}] ${err instanceof Error ? err.message : String(err)}`);
+            });
+            return c.json(marked, 202);
+        }
+        finally {
+            if (!detached)
+                releaseRaisedCheck(artifact.id);
+        }
     });
     // Preview what send would post, without posting anything.
     app.get("/api/reviews/:key/send-preview", async (c) => {
@@ -812,7 +931,7 @@ export async function buildApp(opts) {
         // settling one out from under a run that is about to report on it is the
         // same race the send path refuses.
         if (inFlight(artifact)) {
-            return c.json({ error: "a review of this PR is running — wait for it to finish" }, 409);
+            return c.json({ error: busy(artifact, "a review of this PR is running — wait for it to finish") }, 409);
         }
         // Nor while a chat turn is being answered. A turn's result is folded onto
         // whatever the artifact says when it lands, and the fold is written for a
@@ -889,6 +1008,12 @@ export async function buildApp(opts) {
                 console.error(`[handoff ${artifact.id}] the review did not post: ${sendError}`);
             }
         }
+        // The draft carries its replies too, when it went: they are part of the
+        // composition the box sends, and only ever ones the user chose to make.
+        const replies = sent && payload ? await postReplies(ref, payload.replies) : [];
+        const replyError = describeReplyFailures(replies);
+        if (replyError)
+            console.error(`[handoff ${artifact.id}] ${replyError}`);
         let noteError = null;
         let posted = null;
         if (note) {
@@ -909,7 +1034,7 @@ export async function buildApp(opts) {
             // deciding not to review this one, which is a skip.
             const settles = !sent && !a.sent;
             return {
-                ...a,
+                ...recordReplies(a, replies),
                 status: sent ? "sent" : a.sent ? a.status : "skipped",
                 settledAt: settles ? at : a.settledAt,
                 // Cerber's account of why a row is filed away cannot stand next to your
@@ -930,7 +1055,7 @@ export async function buildApp(opts) {
         });
         if (!updated)
             return c.json({ error: "not found" }, 404);
-        return c.json({ artifact: updated, noteError, sendError });
+        return c.json({ artifact: updated, noteError, sendError, replyError });
     });
     // Static cockpit build. In the published package web/dist ships alongside dist/.
     // __dirname is src/server (dev via tsx) or dist/server (built) — both are two levels below the repo root.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fullstackhouse/cerber",
-  "version": "0.34.0",
+  "version": "0.35.1",
   "description": "AI code-review cockpit: Claude reviews your PRs into local artifacts; nothing reaches GitHub until you say so.",
   "license": "MIT",
   "keywords": [
@@ -41,7 +41,7 @@
     "build": "tsc -p tsconfig.build.json && vite build --config web/vite.config.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p web/tsconfig.json --noEmit",
     "test": "vitest run",
-    "prepublishOnly": "pnpm build"
+    "prepublishOnly": "node scripts/refuse-sentinel-publish.mjs && pnpm build"
   },
   "dependencies": {
     "@hono/node-server": "^1.13.7",
@@ -51,7 +51,6 @@
     "zod": "^3.24.1"
   },
   "devDependencies": {
-    "@semantic-release/git": "^11.0.1",
     "@types/node": "^22.10.5",
     "@types/react": "^19.0.4",
     "@types/react-dom": "^19.0.2",
@@ -65,6 +64,7 @@
     "tsx": "^4.19.2",
     "typescript": "^5.7.3",
     "vite": "^6.0.7",
-    "vitest": "^2.1.8"
+    "vitest": "^2.1.8",
+    "yaml": "^2.9.1"
   }
 }