pierre-review 0.1.21 → 0.1.23

package/dist/review/review-manager.js

@@ -2,49 +2,73 @@ import { config } from '../config.js';
 import { LOCAL_ACCOUNT_ID } from '../auth/account.js';
 import { getLatestClaudeReview, getReviewPrContext } from '../db/queries.js';
 import { runReview } from './agent.js';
-import { insertQueuedReview, reconcileOrphanedReviews } from './persist.js';
-// In-memory state (analogous to sync/sync-manager.ts). At most one review per PR;
-// a global gate (config.reviewConcurrency) bounds concurrent reviews overall.
-const running = new Set(); // prIds with a review in flight
+import { insertQueuedReview, markReviewCancelled, reconcileOrphanedReviews, } from './persist.js';
+// In-memory state (analogous to sync/sync-manager.ts). At most one review per PR.
+// `config.reviewConcurrency` bounds concurrent RUNNING reviews; extras wait in a
+// FIFO `pending` queue and launch as slots free (so the user can bulk-trigger).
+const running = new Set(); // prIds with a review actively running
+const pending = []; // FIFO of queued reviews waiting for a slot
+const claimed = new Set(); // prIds either running OR pending — the sync guard
 const reviewIdByPr = new Map();
 const progressByReview = new Map();
 const controllers = new Map();
 export async function startReview(prId, model, requestedMode, log) {
     if (!config.claudeReviewEnabled)
         return { ok: false, reason: 'disabled' };
-    if (running.has(prId))
+    // `claimed` covers BOTH running and queued, so a re-trigger of an in-flight or
+    // already-queued PR is rejected without a TOCTOU double-start.
+    if (claimed.has(prId))
         return { ok: false, reason: 'already_running' };
-    if (running.size >= config.reviewConcurrency) {
+    // Runaway guard for bulk triggering: cap the queue depth.
+    if (pending.length >= config.reviewMaxQueued)
         return { ok: false, reason: 'busy' };
-    }
-    // Reserve the slot SYNCHRONOUSLY before any await, so a second concurrent
-    // startReview for the same prId sees `running.has(prId)` immediately (no
-    // TOCTOU double-start). Roll it back on any early-bail / insert failure below.
-    running.add(prId);
+    // Reserve SYNCHRONOUSLY before any await; roll back on early-bail / insert failure.
+    claimed.add(prId);
     let reviewId;
     let ctx;
     try {
         ctx = await getReviewPrContext(prId, LOCAL_ACCOUNT_ID);
         if (!ctx) {
-            running.delete(prId);
+            claimed.delete(prId);
             return { ok: false, reason: 'not_found' };
         }
         if (!ctx.headSha) {
-            running.delete(prId);
+            claimed.delete(prId);
             return { ok: false, reason: 'no_head' };
         }
         reviewId = await insertQueuedReview(prId, ctx.headSha, model, LOCAL_ACCOUNT_ID);
     }
     catch (err) {
-        running.delete(prId);
+        claimed.delete(prId);
         throw err;
     }
-    const headSha = ctx.headSha;
+    const item = {
+        reviewId,
+        prId,
+        model,
+        requestedMode,
+        headSha: ctx.headSha,
+        ctx,
+        log,
+    };
+    reviewIdByPr.set(prId, reviewId);
+    if (running.size < config.reviewConcurrency) {
+        launch(item);
+        return { ok: true, reviewId, queued: false };
+    }
+    // No slot — leave it queued (the row's persisted status is already 'queued'); it
+    // launches from pump() when a running review finishes.
+    pending.push(item);
+    return { ok: true, reviewId, queued: true };
+}
+function launch(item) {
+    const { reviewId, prId, ctx } = item;
+    running.add(prId);
     reviewIdByPr.set(prId, reviewId);
     const controller = new AbortController();
     controllers.set(reviewId, controller);
-    // The diff is fetched (and the mode decided) before any clone now, so the first
-    // real phase is always 'fetching_diff' — not 'cloning' (which a diff-only run skips).
+    // The diff is fetched (and the mode decided) before any clone, so the first real
+    // phase is always 'fetching_diff' — not 'cloning' (which a diff-only run skips).
     progressByReview.set(reviewId, { phase: 'fetching_diff' });
     void runReview({
         reviewId,
@@ -56,32 +80,50 @@ export async function startReview(prId, model, requestedMode, log) {
         title: ctx.title,
         body: ctx.body,
         baseRefName: ctx.baseRefName,
-        headSha,
-        model,
-        requestedMode,
+        headSha: item.headSha,
+        model: item.model,
+        requestedMode: item.requestedMode,
         abortController: controller,
         onProgress: (p) => progressByReview.set(reviewId, p),
     })
         .catch((err) => {
-        log.error(`claude review pr ${prId} failed: ${err instanceof Error ? err.message : err}`);
+        item.log.error(`claude review pr ${prId} failed: ${err instanceof Error ? err.message : err}`);
     })
         .finally(() => {
         running.delete(prId);
         reviewIdByPr.delete(prId);
         controllers.delete(reviewId);
         progressByReview.delete(reviewId);
+        claimed.delete(prId);
+        pump(); // a slot freed — start the next queued review
     });
-    return { ok: true, reviewId };
+}
+// Start as many queued reviews as there are free slots (FIFO).
+function pump() {
+    while (running.size < config.reviewConcurrency && pending.length > 0) {
+        launch(pending.shift());
+    }
 }
 export function isReviewRunning(prId) {
     return running.has(prId);
 }
 export function requestReviewCancel(prId) {
+    // Running → abort the SDK run (runReview's finally cleans up + pumps the queue).
     const reviewId = reviewIdByPr.get(prId);
-    if (reviewId == null)
-        return false;
-    controllers.get(reviewId)?.abort();
-    return true;
+    if (running.has(prId) && reviewId != null) {
+        controllers.get(reviewId)?.abort();
+        return true;
+    }
+    // Queued (not yet started) → drop it from the queue and mark the row cancelled.
+    const idx = pending.findIndex((p) => p.prId === prId);
+    if (idx >= 0) {
+        const item = pending.splice(idx, 1)[0];
+        claimed.delete(prId);
+        reviewIdByPr.delete(prId);
+        void markReviewCancelled(item.reviewId).catch(() => { });
+        return true;
+    }
+    return false;
 }
 // Live status when a review is in flight; otherwise the latest persisted run's
 // status (or 'idle' if the PR was never reviewed).
@@ -94,13 +136,16 @@ export async function getReviewStatus(prId) {
             progress: progressByReview.get(reviewId) ?? null,
         };
     }
+    const queued = pending.find((p) => p.prId === prId);
+    if (queued)
+        return { status: 'queued', reviewId: queued.reviewId, progress: null };
     const latest = await getLatestClaudeReview(prId, LOCAL_ACCOUNT_ID);
     if (!latest)
         return { status: 'idle', reviewId: null, progress: null };
     return { status: latest.status, reviewId: latest.id, progress: null };
 }
-// All reviews currently in flight (for the global progress banner), joined with
-// their PR coordinates.
+// All reviews currently in flight OR queued (for the global progress banner),
+// joined with their PR coordinates.
 export async function listActiveReviews() {
     const out = [];
     for (const prId of running) {
@@ -120,6 +165,18 @@ export async function listActiveReviews() {
             phase: progressByReview.get(reviewId)?.phase ?? null,
         });
     }
+    // Queued items use their stored ctx (no extra fetch); the banner shows them too.
+    for (const item of pending) {
+        out.push({
+            reviewId: item.reviewId,
+            prId: item.prId,
+            repoFullName: item.ctx.repoFullName,
+            prNumber: item.ctx.number,
+            prTitle: item.ctx.title,
+            status: 'queued',
+            phase: null,
+        });
+    }
     return out;
 }
 // Heal runs left 'running'/'queued' by a crash (our status is persisted).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pierre-review",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "Dashboard for tracking your team's GitHub PR activity across repos — local (SQLite + gh) or self-hosted multi-tenant cloud (Postgres + GitHub App).",
   "type": "module",
   "author": "Alex Wakeman",