pierre-review 0.1.33 → 0.1.35

package/dist/api/routes/me.js

@@ -10,7 +10,7 @@ const dismissSchema = {
         properties: {
             kind: {
                 type: 'string',
-                enum: ['review_request', 'thread', 'watched_repo_pr', 'claude_review'],
+                enum: ['review_request', 'thread', 'watched_repo_pr', 'pr_approved', 'claude_review'],
             },
             refId: { type: 'integer' },
         },
@@ -25,6 +25,7 @@ export async function meRoutes(app) {
             counts: {
                 awaitingReview: myTurn.awaitingReview.length,
                 yourPrsActivity: myTurn.yourPrs.length,
+                approvedPrs: myTurn.approvedPrs.length,
                 threadsAwaiting: myTurn.threadsAwaiting.length,
                 watchedRepoPrs: myTurn.watchedRepoPrs.length,
                 claudeReviewsToAction: myTurn.claudeReviewsToAction.length,

package/dist/api/routes/prs.js

@@ -1,5 +1,6 @@
 import { createHash } from 'node:crypto';
 import { getAccessToken, getAccountUserId } from '../../auth/account.js';
+import { ghRestGetText } from '../../github/client.js';
 import { getPrDetail, getPrFilesContext, getPrWriteContext, markAllViewed, markPrViewed, upsertLocalPrComment, upsertLocalReview, } from '../../db/queries.js';
 import { buildFileAnchors, fallbackAnchor, isFindingAnchored, } from '../../github/diff-anchor.js';
 import { addIssueComment, fetchHeadShaFor, fetchPrFilesWithPatch, postInlineComment, submitPrReview, } from '../../github/mutations.js';
@@ -33,6 +34,20 @@ const idParamSchema = {
         properties: { id: { type: 'integer' } },
     },
 };
+const checkLogsSchema = {
+    params: {
+        type: 'object',
+        required: ['id', 'jobId'],
+        properties: {
+            id: { type: 'integer' },
+            jobId: { type: 'integer', minimum: 1 },
+        },
+    },
+    querystring: {
+        type: 'object',
+        properties: { tail: { type: 'integer', minimum: 1, maximum: 1000 } },
+    },
+};
 const markViewedSchema = {
     ...idParamSchema,
     body: {
@@ -312,5 +327,56 @@ export async function prRoutes(app) {
             return result;
         }
     });
+    // Failed-check logs: the tail of a GitHub Actions job's log, fetched live (never
+    // stored). The jobId comes from CheckRun.jobId (parsed from the Actions detailsUrl);
+    // only Actions checks have one, so the frontend offers this on failed Actions rows.
+    // Degrades to {available:false, reason} on any GitHub error (expired logs, no
+    // actions:read, network) instead of 500ing.
+    app.get('/api/prs/:id/checks/:jobId/logs', { schema: checkLogsSchema }, async (req, reply) => {
+        const { id, jobId } = req.params;
+        const { tail } = req.query;
+        const accountId = accountIdOf(req);
+        const ctx = await getPrWriteContext(id, accountId);
+        if (!ctx) {
+            reply.status(404);
+            return { error: 'NotFound', message: `PR ${id} not found` };
+        }
+        const tailLines = Math.min(Math.max(tail ?? 200, 1), 1000);
+        const unavailable = (reason) => ({
+            available: false,
+            reason,
+            text: '',
+            totalLines: 0,
+            returnedLines: 0,
+        });
+        try {
+            const token = await getAccessToken(accountId);
+            const res = await ghRestGetText(token, `/repos/${ctx.owner}/${ctx.name}/actions/jobs/${jobId}/logs`);
+            if (!res.ok) {
+                const reason = res.status === 404 || res.status === 410
+                    ? 'Logs are no longer available (expired, or the job was re-run).'
+                    : res.status === 403
+                        ? 'No permission to read GitHub Actions logs for this repo.'
+                        : `Couldn't fetch logs (GitHub returned ${res.status}).`;
+                return unavailable(reason);
+            }
+            // A job log can be many MB — normalise line endings, drop a trailing blank,
+            // and tail server-side so only the last N lines reach the browser. Guard the
+            // empty/blank body so it reports 0 lines (not [''] → a misleading "1 of 1").
+            const trimmed = res.text.replace(/\r\n/g, '\n').replace(/\n+$/, '');
+            const lines = trimmed === '' ? [] : trimmed.split('\n');
+            const tailed = lines.slice(-tailLines);
+            const result = {
+                available: true,
+                text: tailed.join('\n'),
+                totalLines: lines.length,
+                returnedLines: tailed.length,
+            };
+            return result;
+        }
+        catch {
+            return unavailable("Couldn't reach GitHub to fetch the logs.");
+        }
+    });
 }
 //# sourceMappingURL=prs.js.map

package/dist/db/queries.js

@@ -16,7 +16,7 @@ const REASON_PRIORITY = [
 import { db, schema, isPg } from './client.js';
 import { runTransaction } from './client.js';
 import { config } from '../config.js';
-import { computeTriage } from './triage.js';
+import { computeApprovalInfoByPr, computeTriage, } from './triage.js';
 import { getAccountUserId } from '../auth/account.js';
 // Bind a JS Date into a raw-`sql` epoch comparison portably: Postgres columns are
 // timestamptz (drizzle binds the Date through the codec), whereas SQLite columns
@@ -1073,8 +1073,10 @@ export async function markAllViewed(accountId, repoIds) {
 // doesn't own (refId is a local PR/thread id). Defense-in-depth; the read path is
 // already account-scoped.
 async function ownsDismissRef(accountId, kind, refId) {
-    if (kind === 'review_request' || kind === 'watched_repo_pr') {
-        // Both reference a PR id directly.
+    if (kind === 'review_request' ||
+        kind === 'watched_repo_pr' ||
+        kind === 'pr_approved') {
+        // All three reference a PR id directly.
         const rows = await db
             .select({ id: pullRequests.id })
             .from(pullRequests)
@@ -1146,6 +1148,7 @@ export async function getCompletedDismissals(accountId, daysBefore = 90) {
     const reviewDismissals = dismissals.filter((d) => d.kind === 'review_request');
     const threadDismissals = dismissals.filter((d) => d.kind === 'thread');
     const watchedDismissals = dismissals.filter((d) => d.kind === 'watched_repo_pr');
+    const approvedDismissals = dismissals.filter((d) => d.kind === 'pr_approved');
     const claudeDismissals = dismissals.filter((d) => d.kind === 'claude_review');
     const items = [];
     const referencedUsers = new Set();
@@ -1223,6 +1226,42 @@ export async function getCompletedDismissals(accountId, daysBefore = 90) {
             });
         }
     }
+    // pr_approved dismissals → their PRs (account-scoped). Same shape as a
+    // review_request dismissal, a different kind tag.
+    if (approvedDismissals.length > 0) {
+        const prRows = await db
+            .select()
+            .from(pullRequests)
+            .innerJoin(repos, eq(repos.id, pullRequests.repoId))
+            .where(and(eq(pullRequests.accountId, accountId), inArray(pullRequests.id, approvedDismissals.map((d) => d.refId))))
+            .execute();
+        const byId = new Map(prRows.map((r) => [r.pull_requests.id, r]));
+        for (const d of approvedDismissals) {
+            const row = byId.get(d.refId);
+            if (!row)
+                continue;
+            const { pull_requests: pr, repos: repo } = row;
+            if (pr.authorId != null)
+                referencedUsers.add(pr.authorId);
+            const restorable = actionable.approvedPrIds.has(pr.id);
+            items.push({
+                kind: 'pr_approved',
+                prId: pr.id,
+                repoFullName: `${repo.owner}/${repo.name}`,
+                number: pr.number,
+                title: pr.title,
+                authorId: pr.authorId,
+                state: pr.state,
+                openedAt: pr.openedAt.toISOString(),
+                githubUrl: `https://github.com/${repo.owner}/${repo.name}/pull/${pr.number}`,
+                dismissedAt: d.dismissedAt.toISOString(),
+                restorable,
+                ...(restorable
+                    ? {}
+                    : { reason: prClosedReason(pr.state) ?? 'No longer approved' }),
+            });
+        }
+    }
     // thread dismissals → their review threads + parent PR + last reply.
     if (threadDismissals.length > 0) {
         const threadIds = threadDismissals.map((d) => d.refId);
@@ -1396,6 +1435,7 @@ async function getActionableInboxIds(accountId) {
     const empty = {
         reviewRequestPrIds: new Set(),
         watchedPrIds: new Set(),
+        approvedPrIds: new Set(),
         threadIds: new Set(),
         claudeReviewIds: new Set(),
     };
@@ -1409,6 +1449,12 @@ async function getActionableInboxIds(accountId) {
     const open = await buildTimelinePrs(openRows, accountId);
     const reviewRequestPrIds = new Set(open.filter((t) => t.reviewRequestedFromMe).map((t) => t.id));
     const watchedPrIds = await getWatchedActionablePrIds(accountId, localUserId, open, openRows);
+    // Your authored, open PRs with a standing approval (restorability source for the
+    // pr_approved Done entries).
+    const approvalInfo = await computeApprovalInfoByPr(open.map((t) => t.id));
+    const approvedPrIds = new Set(open
+        .filter((t) => t.authorId === localUserId && !t.isDraft && approvalInfo.get(t.id)?.approved)
+        .map((t) => t.id));
     const repoNameById = new Map();
     for (const r of await listRepos(accountId))
         repoNameById.set(r.id, r.fullName);
@@ -1416,13 +1462,14 @@ async function getActionableInboxIds(accountId) {
     const claudeReviewIds = config.claudeReviewEnabled
         ? new Set((await getUnactionedClaudeReviews(accountId)).map((c) => c.reviewId))
         : new Set();
-    return { reviewRequestPrIds, watchedPrIds, threadIds, claudeReviewIds };
+    return { reviewRequestPrIds, watchedPrIds, approvedPrIds, threadIds, claudeReviewIds };
 }
 export async function getMyTurn(accountId) {
     const localUserId = await getAccountUserId(accountId);
     const empty = {
         awaitingReview: [],
         yourPrs: [],
+        approvedPrs: [],
         threadsAwaiting: [],
         watchedRepoPrs: [],
         claudeReviewsToAction: [],
@@ -1449,6 +1496,9 @@ export async function getMyTurn(accountId) {
         .execute();
     const reviewDismissedAt = new Map();
     const threadDismissedAt = new Map();
+    // Dismissed "your PR was approved" entries. Keyed by PR id; honoured until a NEWER
+    // approval lands (compared against the latest approving review's timestamp below).
+    const approvedDismissedAt = new Map();
     // Dismissed Claude-review run ids. Keyed by run id (not PR id): a fresh run gets
     // a new id, so it naturally re-appears without a timestamp comparison.
     const claudeDismissedIds = new Set();
@@ -1460,6 +1510,8 @@ export async function getMyTurn(accountId) {
             reviewDismissedAt.set(d.refId, d.dismissedAt);
         else if (d.kind === 'thread')
             threadDismissedAt.set(d.refId, d.dismissedAt);
+        else if (d.kind === 'pr_approved')
+            approvedDismissedAt.set(d.refId, d.dismissedAt);
         else if (d.kind === 'claude_review')
             claudeDismissedIds.add(d.refId);
         else if (d.kind === 'watched_repo_pr')
@@ -1496,9 +1548,38 @@ export async function getMyTurn(accountId) {
         const others = await countOtherReviewers(t.id, localUserId);
         return { ...toMyTurnPr(t), alsoRequested: others };
     }));
-    // 2. Your PRs with new activity since you last looked.
+    // 2. Your authored, open PRs that have a standing approval (likely ready to merge).
+    //    An approving review lands them here; a "Done" dismissal hides them until a
+    //    NEWER approval arrives (compared against the latest approving review's
+    //    timestamp — not the PR's updatedAt, which any commit would bump and re-nag).
+    //    They leave automatically once the PR is merged/closed (drops out of `open`).
+    const approvalInfo = await computeApprovalInfoByPr(open.map((t) => t.id));
+    const approvedPrs = open
+        .filter((t) => {
+        // Drafts can't merge even when approved — don't claim "ready to merge".
+        if (t.authorId !== localUserId || t.isDraft)
+            return false;
+        const info = approvalInfo.get(t.id);
+        if (!info?.approved)
+            return false;
+        const dismissedAt = approvedDismissedAt.get(t.id);
+        if (!dismissedAt)
+            return true;
+        const latest = info.latestApprovalAt?.getTime() ?? 0;
+        return latest > dismissedAt.getTime();
+    })
+        .map((t) => ({
+        ...toMyTurnPr(t),
+        approvals: approvalInfo.get(t.id)?.approvals ?? 0,
+        mergeable: t.mergeable,
+        mergeStateStatus: t.mergeStateStatus,
+    }));
+    const approvedShownIds = new Set(approvedPrs.map((i) => i.prId));
+    // 3. Your PRs with new activity since you last looked — excluding ones already shown
+    //    under "approved" (the stronger, more actionable signal wins).
     const yourPrs = open
         .filter((t) => t.authorId === localUserId &&
+        !approvedShownIds.has(t.id) &&
         t.newSinceLastViewed != null &&
         (t.newSinceLastViewed.comments > 0 ||
             t.newSinceLastViewed.reviews > 0 ||
@@ -1517,6 +1598,7 @@ export async function getMyTurn(accountId) {
     const inOtherSections = new Set([
         ...awaitingReview.map((i) => i.prId),
         ...yourPrs.map((i) => i.prId),
+        ...approvedPrs.map((i) => i.prId),
     ]);
     const watchedRepoPrs = open
         .filter((t) => watchedEligible.has(t.id) &&
@@ -1549,6 +1631,7 @@ export async function getMyTurn(accountId) {
     return {
         awaitingReview,
         yourPrs,
+        approvedPrs,
         threadsAwaiting,
         watchedRepoPrs,
         claudeReviewsToAction,

package/dist/db/schema.pg.js

@@ -167,7 +167,7 @@ export const myTurnDismissals = pgTable('my_turn_dismissals', {
         .notNull()
         .references(() => accounts.id),
     kind: text('kind', {
-        enum: ['review_request', 'thread', 'watched_repo_pr', 'claude_review'],
+        enum: ['review_request', 'thread', 'watched_repo_pr', 'pr_approved', 'claude_review'],
     }).notNull(),
     refId: integer('ref_id').notNull(),
     dismissedAt: timestamp('dismissed_at', {

package/dist/db/schema.sqlite.js

@@ -193,7 +193,7 @@ export const myTurnDismissals = sqliteTable('my_turn_dismissals', {
         .notNull()
         .references(() => accounts.id),
     kind: text('kind', {
-        enum: ['review_request', 'thread', 'watched_repo_pr', 'claude_review'],
+        enum: ['review_request', 'thread', 'watched_repo_pr', 'pr_approved', 'claude_review'],
     }).notNull(),
     refId: integer('ref_id').notNull(),
     dismissedAt: integer('dismissed_at', { mode: 'timestamp' }).notNull(),

package/dist/db/triage.js

@@ -5,11 +5,17 @@ const { reviewRequests, prViews, events, reviews } = schema;
 function emptyNew() {
     return { commits: 0, comments: 0, reviews: 0 };
 }
-/** Per-author latest review state → is the PR approved with no blocking review? */
-async function computeApprovedByPr(prIds) {
-    const approved = new Set();
+/**
+ * Per-author latest review state → per-PR approval standing. A reviewer's standing
+ * decision is their latest non-"commented" review (approved / changes_requested);
+ * a PR is "approved" when at least one reviewer's standing decision is approved and
+ * none is changes_requested. Used both for the `approved_ready` reason tag and the
+ * "your PR was approved" My Turn section.
+ */
+export async function computeApprovalInfoByPr(prIds) {
+    const out = new Map();
     if (prIds.length === 0)
-        return approved;
+        return out;
     const rows = await db
         .select({
         prId: reviews.prId,
@@ -26,25 +32,41 @@ async function computeApprovedByPr(prIds) {
         if (r.state !== 'approved' && r.state !== 'changes_requested')
             continue;
         const key = `${r.prId}:${r.authorId}`;
-        const at = r.submittedAt.getTime();
         const prev = latest.get(key);
-        if (!prev || at > prev.at)
-            latest.set(key, { state: r.state, at });
+        if (!prev || r.submittedAt.getTime() > prev.at.getTime()) {
+            latest.set(key, { prId: r.prId, state: r.state, at: r.submittedAt });
+        }
     }
     const byPr = new Map();
-    for (const [key, v] of latest) {
-        const prId = Number.parseInt(key.split(':')[0], 10);
-        const entry = byPr.get(prId) ?? { approvals: 0, blocks: 0 };
-        if (v.state === 'approved')
+    for (const v of latest.values()) {
+        const entry = byPr.get(v.prId) ?? { approvals: 0, blocks: 0, latestApprovalAt: null };
+        if (v.state === 'approved') {
             entry.approvals += 1;
-        else
+            if (!entry.latestApprovalAt || v.at.getTime() > entry.latestApprovalAt.getTime()) {
+                entry.latestApprovalAt = v.at;
+            }
+        }
+        else {
             entry.blocks += 1;
-        byPr.set(prId, entry);
+        }
+        byPr.set(v.prId, entry);
     }
     for (const [prId, e] of byPr) {
-        if (e.approvals > 0 && e.blocks === 0)
-            approved.add(prId);
+        out.set(prId, {
+            approved: e.approvals > 0 && e.blocks === 0,
+            approvals: e.approvals,
+            latestApprovalAt: e.latestApprovalAt,
+        });
     }
+    return out;
+}
+/** Per-author latest review state → is the PR approved with no blocking review? */
+async function computeApprovedByPr(prIds) {
+    const info = await computeApprovalInfoByPr(prIds);
+    const approved = new Set();
+    for (const [prId, e] of info)
+        if (e.approved)
+            approved.add(prId);
     return approved;
 }
 /**

package/dist/github/client.js

@@ -29,6 +29,23 @@ async function ghRest(token, method, path, body) {
 export function ghRestGetFor(token, path) {
     return ghRest(token, 'GET', path);
 }
+// REST GET returning the raw response TEXT (not JSON), for endpoints with a plain-text
+// body — notably the Actions job-logs endpoint, which 302-redirects to a signed
+// download URL. fetch follows the redirect automatically AND strips the Authorization
+// header on the cross-origin hop, so our token is never sent to the signed URL. Does
+// NOT throw on a non-2xx status — returns it so the caller can degrade gracefully
+// (logs expire after ~90 days / on a re-run → 404/410; missing actions:read → 403).
+export async function ghRestGetText(token, path) {
+    const res = await fetch(`https://api.github.com${path}`, {
+        method: 'GET',
+        headers: {
+            authorization: `token ${token}`,
+            'x-github-api-version': '2022-11-28',
+        },
+    });
+    const text = await res.text().catch(() => '');
+    return { status: res.status, ok: res.ok, text };
+}
 // REST POST (submitting a PR review — inline line comments require the REST
 // reviews endpoint) for a specific account's token.
 export function ghRestPostFor(token, path, body) {

package/dist/sync/upsert.js

@@ -185,13 +185,30 @@ function checkContextState(c) {
             return 'unknown';
     }
 }
+// A GitHub Actions check's detailsUrl is .../actions/runs/<runId>/job/<jobId> — parse
+// the two ids so the frontend can fetch that job's logs on demand. Third-party CI
+// (StatusContext / external CheckRuns) has a detailsUrl pointing elsewhere; no match →
+// null, and the UI keeps it as a plain external link (logs aren't retrievable).
+const ACTIONS_JOB_RE = /\/actions\/runs\/(\d+)\/job\/(\d+)/;
+function parseActionsIds(url) {
+    const m = url ? ACTIONS_JOB_RE.exec(url) : null;
+    if (!m)
+        return { runId: null, jobId: null };
+    return { runId: Number(m[1]), jobId: Number(m[2]) };
+}
 export function checkRunsFrom(head) {
     const nodes = head?.statusCheckRollup?.contexts?.nodes ?? [];
-    return nodes.map((c) => ({
-        name: c.__typename === 'CheckRun' ? c.name : c.context,
-        state: checkContextState(c),
-        url: c.__typename === 'CheckRun' ? c.detailsUrl : c.targetUrl,
-    }));
+    return nodes.map((c) => {
+        const url = c.__typename === 'CheckRun' ? c.detailsUrl : c.targetUrl;
+        const { runId, jobId } = c.__typename === 'CheckRun' ? parseActionsIds(url) : { runId: null, jobId: null };
+        return {
+            name: c.__typename === 'CheckRun' ? c.name : c.context,
+            state: checkContextState(c),
+            url,
+            runId,
+            jobId,
+        };
+    });
 }
 const REVIEW_STATES = new Set([
     'approved',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pierre-review",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "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",