@fullstackhouse/cerber 0.7.0 → 0.9.0

package/dist/server/daemon.js

@@ -1,13 +1,63 @@
-import { artifactKey } from "../core/artifact.js";
+import { SCHEMA_VERSION, artifactId, artifactKey } from "../core/artifact.js";
 import { evaluateAutoSend } from "../core/autosend.js";
-import { searchAwaitingMe, submitReview } from "../core/gh.js";
+import { loadConfig } from "../core/config.js";
+import { fetchPrInfo, searchAwaitingMe, submitReview } from "../core/gh.js";
 import { buildReviewPayload, computeCalibration } from "../core/send.js";
-import { appendAutoSendLog, updateArtifactByKey } from "../core/state.js";
+import { appendAutoSendLog, deleteArtifact, listArtifacts, loadArtifact, saveArtifact, updateArtifactByKey, } from "../core/state.js";
 import { ReviewInProgressError } from "../runner/inflight.js";
 import { pool, reviewPr } from "../runner/review.js";
 /**
- * Poll GitHub for PRs awaiting the user's review and keep their artifacts
- * warm. Reviews are read-only; the daemon NEVER sends anything.
+ * A pure discovery stub: enough artifact for the queue to show an awaiting row.
+ * The AI run that follows (automatic or clicked) replaces it wholesale.
+ */
+export function stubArtifact(ref) {
+    const now = new Date().toISOString();
+    return {
+        schemaVersion: SCHEMA_VERSION,
+        id: artifactId(ref),
+        status: "awaiting",
+        createdAt: now,
+        updatedAt: now,
+        pr: {
+            owner: ref.owner,
+            repo: ref.repo,
+            number: ref.number,
+            title: ref.title,
+            url: ref.url,
+            author: ref.author,
+            body: "",
+            baseRefName: "",
+            headRefName: "",
+            headSha: "",
+            state: "OPEN",
+            additions: 0,
+            deletions: 0,
+            changedFiles: 0,
+        },
+        diff: "",
+        summary: "",
+        chapters: [],
+        comments: [],
+        verdict: null,
+        run: null,
+        sent: null,
+        refresh: null,
+        calibration: null,
+    };
+}
+/** An artifact nothing has touched yet — safe to delete when its PR leaves the queue. */
+export function isPureStub(artifact) {
+    return artifact.status === "awaiting" && artifact.comments.length === 0 && artifact.run === null;
+}
+/** How many open-PR artifacts to re-check against GitHub per poll, and how often each. */
+const STATE_REFRESH_CAP = 10;
+const STATE_REFRESH_MIN_MS = 30 * 60_000;
+/**
+ * The inbox loop behind `cerber serve`: poll GitHub for PRs awaiting the
+ * user's review, list them as `awaiting`, and (unless auto-review is off)
+ * draft a review for each. Merged/closed PRs are archived out of the queue.
+ * Reviews stay local; the daemon NEVER sends anything except via the
+ * explicitly opted-in auto-send path.
  */
 export function startDaemon(opts) {
     let timer = null;
@@ -17,68 +67,181 @@ export function startDaemon(opts) {
         polling: false,
         repos: opts.repos,
         intervalMs: opts.intervalMs,
+        pollEnabled: true,
+        autoReview: opts.autoReview,
+        trustedRuns: false,
         polls: 0,
         errors: 0,
         lastPollAt: null,
         nextPollAt: new Date(Date.now()).toISOString(),
         lastSummary: null,
+        lastPollError: null,
         autoSend: opts.autoSend,
         autoSendThreshold: opts.autoSendThreshold,
         autoSent: 0,
         autoSendCandidates: 0,
     };
     const log = (m) => console.log(`[daemon] ${m}`);
+    /** When GitHub last confirmed an artifact's PR state, by artifact id. In-memory:
+     *  a restart just re-checks sooner, which is harmless. */
+    const stateCheckedAt = new Map();
+    async function discover() {
+        const filters = opts.repos.length > 0 ? opts.repos : [undefined];
+        const seen = new Set();
+        return (await Promise.all(filters.map((repo) => searchAwaitingMe(repo))))
+            .flat()
+            .filter((r) => {
+            const id = artifactId(r);
+            if (seen.has(id))
+                return false;
+            seen.add(id);
+            return true;
+        });
+    }
+    /**
+     * Make the local queue mirror what's actually awaiting: stub artifacts for
+     * newly discovered PRs, archive merged/closed ones, drop stubs whose review
+     * request went away. Freshness decisions always come from local artifacts —
+     * search results lag GitHub by minutes and never override them.
+     */
+    async function syncQueue(refs) {
+        let discovered = 0;
+        for (const ref of refs) {
+            if (await loadArtifact(artifactId(ref)))
+                continue;
+            await saveArtifact(stubArtifact(ref));
+            discovered++;
+        }
+        const awaitingIds = new Set(refs.map((r) => artifactId(r)));
+        let refreshed = 0;
+        for (const artifact of await listArtifacts()) {
+            if (artifact.status === "running")
+                continue;
+            if (awaitingIds.has(artifact.id))
+                continue;
+            if (artifact.pr.state !== "OPEN")
+                continue;
+            if (isPureStub(artifact)) {
+                // Discovered earlier, gone from the search now: merged/closed (archive
+                // it), or the request was withdrawn / handled elsewhere (drop it — it
+                // holds no work, and search lag at worst re-creates it next poll).
+                try {
+                    const pr = await fetchPrInfo(artifact.pr);
+                    if (pr.state !== "OPEN") {
+                        await updateArtifactByKey(artifactKey(artifact.id), (a) => ({ ...a, pr }));
+                        log(`[${artifact.id}] ${pr.state.toLowerCase()} — archived`);
+                    }
+                    else {
+                        await deleteArtifact(artifact.id);
+                        log(`[${artifact.id}] no longer awaiting your review — removed from the queue`);
+                    }
+                }
+                catch {
+                    // GitHub unreachable — leave the stub; next poll retries.
+                }
+                continue;
+            }
+            // Anything with real work in it: periodically confirm the PR is still
+            // open, so merged/closed ones stop cluttering the queue. Capped and
+            // spaced out — this is book-keeping, not a data feed.
+            if (refreshed >= STATE_REFRESH_CAP)
+                continue;
+            const last = stateCheckedAt.get(artifact.id) ?? 0;
+            if (Date.now() - last < STATE_REFRESH_MIN_MS)
+                continue;
+            refreshed++;
+            stateCheckedAt.set(artifact.id, Date.now());
+            try {
+                const pr = await fetchPrInfo(artifact.pr);
+                if (pr.state !== "OPEN") {
+                    await updateArtifactByKey(artifactKey(artifact.id), (a) => ({
+                        ...a,
+                        pr: { ...a.pr, state: pr.state },
+                    }));
+                    log(`[${artifact.id}] ${pr.state.toLowerCase()} — archived`);
+                }
+            }
+            catch {
+                // Same: book-keeping can wait for the next poll.
+            }
+        }
+        return { discovered };
+    }
+    async function reviewAll(refs) {
+        let reviewed = 0;
+        let skipped = 0;
+        let failed = 0;
+        await pool(refs, opts.parallel, async (ref) => {
+            const label = artifactId(ref);
+            try {
+                const result = await reviewPr(ref, {
+                    model: opts.model,
+                    withSource: opts.withSource,
+                    trust: opts.trust,
+                    onProgress: (m) => log(`[${label}] ${m}`),
+                });
+                if (result.skipped)
+                    skipped++;
+                else {
+                    reviewed++;
+                    await handleAutoSend(result.artifact);
+                }
+            }
+            catch (err) {
+                if (err instanceof ReviewInProgressError) {
+                    // The cockpit (or an earlier, slower poll) is already on it.
+                    skipped++;
+                    return;
+                }
+                failed++;
+                status.errors++;
+                log(`[${label}] failed: ${err instanceof Error ? err.message : err}`);
+            }
+        });
+        return { reviewed, skipped, failed };
+    }
     async function poll() {
         if (status.polling)
             return;
         status.polling = true;
         status.lastPollAt = new Date().toISOString();
         try {
-            const filters = opts.repos.length > 0 ? opts.repos : [undefined];
-            const seen = new Set();
-            const refs = (await Promise.all(filters.map((repo) => searchAwaitingMe(repo))))
-                .flat()
-                .filter((r) => {
-                const id = `${r.owner}/${r.repo}#${r.number}`;
-                if (seen.has(id))
-                    return false;
-                seen.add(id);
-                return true;
-            });
-            let reviewed = 0;
-            let skipped = 0;
-            let failed = 0;
-            await pool(refs, opts.parallel, async (ref) => {
-                const label = `${ref.owner}/${ref.repo}#${ref.number}`;
-                try {
-                    const result = await reviewPr(ref, {
-                        model: opts.model,
-                        onProgress: (m) => log(`[${label}] ${m}`),
-                    });
-                    if (result.skipped)
-                        skipped++;
-                    else {
-                        reviewed++;
-                        await handleAutoSend(result.artifact);
-                    }
-                }
-                catch (err) {
-                    if (err instanceof ReviewInProgressError) {
-                        // The cockpit (or an earlier, slower poll) is already on it.
-                        skipped++;
-                        return;
-                    }
-                    failed++;
-                    status.errors++;
-                    log(`[${label}] failed: ${err instanceof Error ? err.message : err}`);
-                }
-            });
-            status.lastSummary = `${refs.length} awaiting; ${reviewed} reviewed, ${skipped} up to date${failed > 0 ? `, ${failed} failed` : ""}`;
+            // The config is re-read every poll, so the cockpit's Settings toggles
+            // take effect on the next tick — no restart. CLI --no-* flags cap it.
+            // loadConfig is strict on purpose (a typo must not silently change trust
+            // or the knobs), so a broken file skips the tick loudly instead of
+            // proceeding on guessed defaults.
+            const config = await loadConfig();
+            const knobs = config.daemon;
+            const autoReview = opts.autoReview && knobs.autoReview;
+            status.pollEnabled = knobs.poll;
+            status.autoReview = autoReview;
+            // Recomputed too, so a trust rule added mid-run shows up in the strip.
+            status.trustedRuns = autoReview && opts.trust !== false && config.trust.length > 0;
+            if (!knobs.poll) {
+                // Deliberately off is not an outage — don't leave a stale error up.
+                status.lastPollError = null;
+                status.lastSummary = "polling off (settings) — the queue only shows what you review by hand";
+                return;
+            }
+            const refs = await discover();
+            status.lastPollError = null;
+            const { discovered } = await syncQueue(refs);
+            if (autoReview) {
+                const { reviewed, skipped, failed } = await reviewAll(refs);
+                status.lastSummary =
+                    `${refs.length} awaiting; ${reviewed} reviewed, ${skipped} up to date` +
+                        `${failed > 0 ? `, ${failed} failed` : ""}`;
+            }
+            else {
+                status.lastSummary = `${refs.length} awaiting${discovered > 0 ? `, ${discovered} new` : ""} (auto-review off)`;
+            }
             log(status.lastSummary);
         }
         catch (err) {
             status.errors++;
-            status.lastSummary = `poll failed: ${err instanceof Error ? err.message : err}`;
+            status.lastPollError = err instanceof Error ? err.message : String(err);
+            status.lastSummary = `poll failed: ${status.lastPollError}`;
             log(status.lastSummary);
         }
         finally {

package/dist/server/index.js

@@ -9,7 +9,10 @@ import { randomUUID } from "node:crypto";
 import { ArtifactStatusSchema, VerdictSchema, artifactKey } from "../core/artifact.js";
 import { toMarkdown } from "../core/export.js";
 import { fetchPrDiff, fetchPrInfo, submitReview } from "../core/gh.js";
+import { z } from "zod";
+import { DaemonConfigSchema, configPath, loadConfig, saveConfig } from "../core/config.js";
 import { refreshArtifact } from "../core/refresh.js";
+import { TrustRuleError, describeRule, explainRule, parseTrustRule } from "../core/trust.js";
 import { buildReviewPayload, computeCalibration } from "../core/send.js";
 import { listArtifacts, loadArtifactByKey, reconcileRunning, updateArtifactByKey, } from "../core/state.js";
 import { isReviewRunning } from "../runner/inflight.js";
@@ -34,6 +37,91 @@ export async function buildApp(opts) {
         });
     }
     app.get("/api/daemon", (c) => c.json(opts.daemon ? opts.daemon.status() : { enabled: false }));
+    // ---- Config: trust rules, edited from the cockpit's Settings view ----
+    const trustView = (lines) => lines.flatMap((line) => {
+        try {
+            const rule = parseTrustRule(line);
+            return rule ? [{ rule: describeRule(rule), explanation: explainRule(rule), denies: rule.negated }] : [];
+        }
+        catch {
+            // loadConfig rejects these, so reaching here means the file changed
+            // under us; showing the rest beats failing the whole screen.
+            return [];
+        }
+    });
+    app.get("/api/config", async (c) => {
+        try {
+            const config = await loadConfig();
+            return c.json({ path: configPath(), trust: trustView(config.trust), daemon: config.daemon });
+        }
+        catch (err) {
+            return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+        }
+    });
+    // The inbox knobs. The daemon re-reads the config every poll, so a toggle
+    // here applies on the next tick without restarting serve.
+    app.post("/api/config/daemon", async (c) => {
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "body must be JSON" }, 400);
+        }
+        try {
+            const config = await loadConfig();
+            const daemon = DaemonConfigSchema.parse({ ...config.daemon, ...body });
+            await saveConfig({ ...config, daemon });
+            return c.json({ path: configPath(), trust: trustView(config.trust), daemon });
+        }
+        catch (err) {
+            if (err instanceof z.ZodError) {
+                return c.json({ error: err.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ") }, 400);
+            }
+            return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+        }
+    });
+    app.post("/api/config/trust", async (c) => {
+        let body;
+        try {
+            body = await c.req.json();
+        }
+        catch {
+            return c.json({ error: "body must be JSON" }, 400);
+        }
+        const { rule, remove } = body;
+        if (typeof rule !== "string" || !rule.trim()) {
+            return c.json({ error: "rule is required" }, 400);
+        }
+        let parsed;
+        try {
+            parsed = parseTrustRule(rule);
+        }
+        catch (err) {
+            // The message explains what to write instead — show it verbatim.
+            if (err instanceof TrustRuleError)
+                return c.json({ error: err.message }, 400);
+            throw err;
+        }
+        if (!parsed)
+            return c.json({ error: `not a trust rule: ${rule}` }, 400);
+        const canonical = describeRule(parsed);
+        try {
+            const config = await loadConfig();
+            const without = config.trust.filter((line) => {
+                const existing = parseTrustRule(line);
+                return !existing || describeRule(existing) !== canonical;
+            });
+            const trust = remove === true ? without : [...without, canonical];
+            await saveConfig({ ...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 });
+        }
+        catch (err) {
+            return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+        }
+    });
     app.get("/api/reviews", async (c) => {
         const artifacts = await listArtifacts();
         return c.json(artifacts.map((a) => ({
@@ -48,6 +136,7 @@ export async function buildApp(opts) {
                 owner: a.pr.owner,
                 repo: a.pr.repo,
                 number: a.pr.number,
+                state: a.pr.state,
                 additions: a.pr.additions,
                 deletions: a.pr.deletions,
                 changedFiles: a.pr.changedFiles,
@@ -188,15 +277,32 @@ export async function buildApp(opts) {
             return c.json({ error: "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
+        // overrides that per re-review, ?source=0 opts one out.
+        const sourceParam = c.req.query("source");
+        const withSource = sourceParam == null ? opts.withSource : sourceParam !== "0";
         // Mark it running before responding, so the cockpit's next poll can't catch
         // the old "ready" status and conclude the run already finished.
         const running = await updateArtifactByKey(key, (a) => ({
             ...a,
             status: "running",
-            run: { model: null, startedAt: new Date().toISOString(), finishedAt: null, costUsd: null, error: null },
+            run: {
+                model: null,
+                startedAt: new Date().toISOString(),
+                finishedAt: null,
+                costUsd: null,
+                error: null,
+                withSource: withSource !== false,
+                trusted: false,
+            },
         }));
         // Minutes-long: run it detached and let the cockpit poll the artifact.
-        void reviewPr(ref, { force: true, onProgress: (m) => console.log(`[rerun ${artifact.id}] ${m}`) })
+        void reviewPr(ref, {
+            force: true,
+            withSource,
+            trust: opts.trust,
+            onProgress: (m) => console.log(`[rerun ${artifact.id}] ${m}`),
+        })
             .catch(async (err) => {
             const message = err instanceof Error ? err.message : String(err);
             console.error(`[rerun ${artifact.id}] failed: ${message}`);
@@ -281,7 +387,10 @@ export async function startServer(opts) {
     serve({ fetch: app.fetch, port: opts.port, hostname: opts.host }, (info) => {
         const tokenHint = opts.token ? `/?token=${opts.token}` : "";
         console.log(`cerber cockpit: http://${opts.host}:${info.port}${tokenHint}`);
-        if (opts.daemon)
-            console.log("daemon: polling for PRs awaiting your review");
+        if (opts.daemon) {
+            const s = opts.daemon.status();
+            console.log(`inbox: polling every ${Math.round(s.intervalMs / 60_000)}m` +
+                `${s.autoReview ? ", drafting a review for each PR awaiting you" : " (auto-review off — click review in the queue)"}`);
+        }
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fullstackhouse/cerber",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "description": "AI code-review cockpit: Claude reviews your PRs into local artifacts; nothing reaches GitHub until you say so.",
   "license": "MIT",
   "repository": "github:fullstackhouse/cerber",