pierre-review 0.1.48 → 0.1.50

package/dist/api/routes/activity.js

@@ -1,4 +1,4 @@
-import { getActivity, getConsolidatedFeed, listClaudeReviewsByRepo } from '../../db/queries.js';
+import { getActivity, getConsolidatedFeed, listClaudeReviewsByRepo, markFeedSeen, } from '../../db/queries.js';
 import { accountIdOf } from '../plugins/auth.js';
 function parseIntList(raw) {
     if (!raw)
@@ -35,6 +35,13 @@ export async function activityRoutes(app) {
             allowBotIds: parseIntList(q.allowBotIds),
         });
     });
+    // Mark the Activity Feed as seen (bumps the account's server-side "seen" marker to
+    // now). Called when the user views the feed; resets the "new FYI since last here"
+    // count that drives the Welcome-back banner. Account-scoped; no body.
+    app.post('/api/activity/feed/mark-seen', async (req) => {
+        const at = await markFeedSeen(accountIdOf(req));
+        return { feedLastSeenAt: at.toISOString() };
+    });
     // Repo-scoped Claude-review history for the Activity single-repo console. Ownership +
     // feature-gating are handled inside the query (an unowned repo / disabled feature
     // both return an empty list), so the caller never leaks another account's data.

package/dist/api/routes/me.js

@@ -2,7 +2,7 @@ import { config } from '../../config.js';
 import { accountToLocalUser } from '../../auth/account.js';
 import { accountIdOf } from '../plugins/auth.js';
 import { getProCapabilities } from '../../pro/contract.js';
-import { dismissMyTurn, getCompletedDismissals, getMyTurn, undismissMyTurn, } from '../../db/queries.js';
+import { countNewMyTurnFeedItems, dismissMyTurn, getCompletedDismissals, getFeedLastSeenAt, getMyTurn, markFeedSeen, undismissMyTurn, } from '../../db/queries.js';
 const dismissSchema = {
     body: {
         type: 'object',
@@ -19,8 +19,16 @@ const dismissSchema = {
 };
 export async function meRoutes(app) {
     app.get('/api/me', async (req) => {
+        const accountId = accountIdOf(req);
         const user = accountToLocalUser(req.account);
-        const myTurn = await getMyTurn(accountIdOf(req));
+        const myTurn = await getMyTurn(accountId);
+        // Feed "seen" marker + how many FYI items are new since. Only counted once a
+        // baseline exists (feedLastSeenAt set by the first feed view) so a fresh account
+        // never sees a scary first-load number.
+        const feedLastSeen = await getFeedLastSeenAt(accountId);
+        const newFeedItems = feedLastSeen
+            ? await countNewMyTurnFeedItems(accountId, feedLastSeen)
+            : 0;
         return {
             user,
             counts: {
@@ -31,6 +39,8 @@ export async function meRoutes(app) {
                 watchedRepoPrs: myTurn.watchedRepoPrs.length,
                 claudeReviewsToAction: myTurn.claudeReviewsToAction.length,
             },
+            feedLastSeenAt: feedLastSeen ? feedLastSeen.toISOString() : null,
+            newFeedItems,
             claudeReviewEnabled: config.claudeReviewEnabled,
             deploymentMode: config.deploymentMode,
             pro: getProCapabilities(),

package/dist/api/routes/prs.js

@@ -1,9 +1,9 @@
 import { createHash } from 'node:crypto';
 import { getAccessToken, getAccountUserId } from '../../auth/account.js';
 import { fetchActionsJobLog } from '../../github/actions-logs.js';
-import { getMentionCandidates, getPrDetail, getPrFilesContext, getPrWriteContext, markAllViewed, markPrViewed, upsertLocalPrComment, upsertLocalReview, } from '../../db/queries.js';
+import { getMentionCandidates, getPrDetail, getPrFilesContext, getPrWriteContext, getReviewerLogins, 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';
+import { addIssueComment, fetchHeadShaFor, fetchPrFilesWithPatch, postInlineComment, requestReviewers, rerunWorkflowRun, submitPrReview, } from '../../github/mutations.js';
 import { hydratePrDetail } from '../../sync/hydrate-detail.js';
 import { accountIdOf } from '../plugins/auth.js';
 // GitHub anchors a file in the PR "Files changed" diff by the SHA-256 of its
@@ -56,6 +56,18 @@ const markViewedSchema = {
         properties: { sha: { type: 'string' } },
     },
 };
+const ciRerunSchema = {
+    ...idParamSchema,
+    body: {
+        type: 'object',
+        required: ['runId', 'mode'],
+        additionalProperties: false,
+        properties: {
+            runId: { type: 'integer', minimum: 1 },
+            mode: { type: 'string', enum: ['failed', 'all'] },
+        },
+    },
+};
 const markAllViewedSchema = {
     body: {
         type: 'object',
@@ -94,6 +106,22 @@ const reviewCommentSchema = {
         },
     },
 };
+const requestReviewersSchema = {
+    ...idParamSchema,
+    body: {
+        type: 'object',
+        required: ['userIds'],
+        additionalProperties: false,
+        properties: {
+            userIds: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 15,
+                items: { type: 'integer' },
+            },
+        },
+    },
+};
 export async function prRoutes(app) {
     // Bulk "mark all seen": stamp every open PR (optionally scoped to repoIds) viewed
     // at its head, clearing all new-since badges at once. Static path — no :id — so it
@@ -357,5 +385,92 @@ export async function prRoutes(app) {
         const result = await fetchActionsJobLog(token, ctx.owner, ctx.name, jobId, tail ?? 200);
         return result;
     });
+    // Re-trigger a GitHub Actions workflow run for this PR. The `runId` comes from
+    // CheckRun.runId (Actions checks only). Server re-checks write access (WRITE/
+    // MAINTAIN/ADMIN, matching viewerCanPush — no author exclusion, unlike approve),
+    // then queues the rerun via the per-account token (local + cloud). GitHub runs it
+    // asynchronously; the refreshed check states arrive on the next sync.
+    app.post('/api/prs/:id/ci/rerun', { schema: ciRerunSchema }, async (req, reply) => {
+        const { id } = req.params;
+        const { runId, mode } = req.body;
+        const accountId = accountIdOf(req);
+        const ctx = await getPrWriteContext(id, accountId);
+        if (!ctx) {
+            reply.status(404);
+            return { error: 'NotFound', message: `PR ${id} not found` };
+        }
+        const canRerun = ['WRITE', 'MAINTAIN', 'ADMIN'].includes(ctx.viewerPermission ?? '');
+        if (!canRerun) {
+            reply.status(403);
+            return {
+                error: 'NotPermitted',
+                message: 'You need write access to this repo to re-run CI.',
+            };
+        }
+        try {
+            const token = await getAccessToken(accountId);
+            await rerunWorkflowRun(token, ctx.owner, ctx.name, runId, mode);
+            const result = { status: 'queued', runId, mode };
+            return result;
+        }
+        catch (err) {
+            reply.status(502);
+            return {
+                error: 'GitHubError',
+                message: err instanceof Error ? err.message : String(err),
+            };
+        }
+    });
+    // Request reviewers on a PR (powers the Insights "Assign reviewers" action). Server
+    // re-checks write access (WRITE/MAINTAIN/ADMIN — push-style, no author exclusion:
+    // an author may request reviewers on their own PR). The given user ids are resolved
+    // to GitHub logins (the PR author + bots + unknown ids dropped); GitHub itself gates
+    // that each login is a repo collaborator. The refreshed request state arrives on the
+    // next sync (reviewRequests are re-derived each pass).
+    app.post('/api/prs/:id/request-reviewers', { schema: requestReviewersSchema }, async (req, reply) => {
+        const { id } = req.params;
+        const { userIds } = req.body;
+        const accountId = accountIdOf(req);
+        const ctx = await getPrWriteContext(id, accountId);
+        if (!ctx) {
+            reply.status(404);
+            return { error: 'NotFound', message: `PR ${id} not found` };
+        }
+        const canRequest = ['WRITE', 'MAINTAIN', 'ADMIN'].includes(ctx.viewerPermission ?? '');
+        if (!canRequest) {
+            reply.status(403);
+            return {
+                error: 'NotPermitted',
+                message: 'You need write access to this repo to request reviewers.',
+            };
+        }
+        // Drop the PR author (GitHub rejects self-review requests), then resolve to
+        // logins (also drops bots + unknown ids).
+        const wanted = userIds.filter((uid) => uid !== ctx.authorId);
+        const logins = (await getReviewerLogins(wanted)).map((r) => r.login);
+        if (logins.length === 0) {
+            reply.status(400);
+            return {
+                error: 'NoReviewers',
+                message: 'None of the selected users can be requested as reviewers.',
+            };
+        }
+        try {
+            const token = await getAccessToken(accountId);
+            await requestReviewers(token, ctx.owner, ctx.name, ctx.number, logins);
+            const result = {
+                status: 'ok',
+                requestedLogins: logins,
+            };
+            return result;
+        }
+        catch (err) {
+            reply.status(502);
+            return {
+                error: 'GitHubError',
+                message: err instanceof Error ? err.message : String(err),
+            };
+        }
+    });
 }
 //# sourceMappingURL=prs.js.map

package/dist/config.js

@@ -99,6 +99,16 @@ export const config = {
     // this entirely (one always-on account). SYNC_ACTIVE_WINDOW_MINUTES overrides.
     syncActiveWindowMinutes: intFromEnv('SYNC_ACTIVE_WINDOW_MINUTES', 15),
     stallThresholdDays: intFromEnv('STALL_THRESHOLD_DAYS', 3),
+    // ---- Retention / TTL ----
+    // Per-account server data doesn't grow forever: a periodic sweep prunes PRs (and their
+    // whole subtree) whose `updatedAt` is older than this many days. 0 disables it. The
+    // effective cutoff is clamped to at least `backfillDays`, so a forced full sync (which
+    // re-walks `now − backfillDays`) can never re-fetch (resurrect) a just-deleted PR.
+    // Runs in BOTH modes (local + cloud). RETENTION_DAYS overrides.
+    retentionDays: intFromEnv('RETENTION_DAYS', 180),
+    // When the retention sweep runs (node-cron). Daily at 03:00 by default; off-peak so a
+    // large delete doesn't contend with the 5-minute sync. RETENTION_CRON overrides.
+    retentionCron: process.env.RETENTION_CRON ?? '0 3 * * *',
     // Disable the periodic scheduler (used by scripts/tests).
     disableScheduler: process.env.DISABLE_SCHEDULER === 'true',
     // ---- Cloud (Railway) — GitHub App OAuth + sessions + token encryption ----

package/dist/db/migrations/0021_account_feed_last_seen.sql

@@ -0,0 +1,7 @@
+-- Server-side Activity-Feed "seen" marker (additive). `feed_last_seen_at` records the
+-- last time this account viewed the consolidated feed, so "new FYI since you were last
+-- here" is server-truth (consistent across devices) instead of a client localStorage
+-- heuristic — the successor to the removed per-item "Done". Nullable; existing rows stay
+-- NULL (no baseline yet → nothing counts as new until the first feed view sets it).
+-- The Postgres baseline is regenerated separately via `pnpm db:generate:pg`.
+ALTER TABLE `accounts` ADD `feed_last_seen_at` integer;

package/dist/db/migrations/meta/_journal.json

@@ -148,6 +148,13 @@
       "when": 1780800000011,
       "tag": "0020_claude_review_cost_telemetry",
       "breakpoints": true
+    },
+    {
+      "idx": 21,
+      "version": "6",
+      "when": 1780800000012,
+      "tag": "0021_account_feed_last_seen",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/migrations-pg/0010_late_hammerhead.sql

@@ -0,0 +1 @@
+ALTER TABLE "accounts" ADD COLUMN "feed_last_seen_at" timestamp with time zone;