pierre-review 0.1.49 → 0.1.51

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, rerunWorkflowRun, 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
@@ -106,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
@@ -405,5 +421,56 @@ export async function prRoutes(app) {
             };
         }
     });
+    // 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/db/queries.js

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { and, asc, count, desc, eq, exists, gt, gte, inArray, isNotNull, isNull, lte, ne, notInArray, or, sql, } from 'drizzle-orm';
+import { and, asc, count, desc, eq, exists, gt, gte, inArray, isNotNull, isNull, lt, lte, ne, notInArray, or, sql, } from 'drizzle-orm';
 // Local copy of the shared `REASON_PRIORITY` value constant. `@pierre-review/shared`
 // is a types-only workspace package that is NOT shipped in the published tarball,
 // so the backend must only `import type` from it. Keep in sync with packages/shared.
@@ -18,6 +18,7 @@ import { runTransaction } from './client.js';
 import { config } from '../config.js';
 import { computeApprovalInfoByPr, computeTriage, } from './triage.js';
 import { getAccountUserId } from '../auth/account.js';
+import { ensureRoutingPrFiles } from '../sync/routing-files.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
 // are integer unix-epoch seconds (`mode:'timestamp'`), so we hand it the int.
@@ -1563,6 +1564,337 @@ export async function countNewMyTurnFeedItems(accountId, since) {
     }
     return n;
 }
+// ---- Team review-intelligence "Insights" (Pro; teamInsights) ----
+const INSIGHT_STALLED_REVIEW_HOURS = 24;
+const INSIGHT_UNTOUCHED_THREAD_HOURS = 24; // "> 1 day"
+const INSIGHT_SPRINT_DAYS = 14; // trailing 2 weeks
+const INSIGHT_ROUTING_MIN_AGE_HOURS = 4; // ignore brand-new PRs
+const INSIGHT_CARD_CAP = 15; // per-kind cap so the board stays digestible
+function topLevelDir(path) {
+    const i = path.indexOf('/');
+    return i === -1 ? '.' : path.slice(0, i);
+}
+// Compute the team review-intelligence cards from already-synced data — NO AI. WATCHED
+// repos (`inboxWatch`) are the team; "sprint" is the trailing 2 weeks. Runs on read (the
+// client refetches on the sync cadence); every query is account-scoped + bounded (watched
+// repos, open PRs, the sprint window, per-kind caps).
+export async function getTeamInsights(accountId) {
+    const now = Date.now();
+    const generatedAt = new Date(now);
+    const sprintFrom = new Date(now - INSIGHT_SPRINT_DAYS * 86_400_000);
+    const sprint = { from: sprintFrom.toISOString(), to: generatedAt.toISOString() };
+    const cards = [];
+    const userIdSet = new Set();
+    const addUser = (id) => {
+        if (id != null)
+            userIdSet.add(id);
+    };
+    const watched = await db
+        .select({ id: repos.id, owner: repos.owner, name: repos.name })
+        .from(repos)
+        .where(and(eq(repos.accountId, accountId), eq(repos.inboxWatch, true)))
+        .execute();
+    const repoName = new Map(watched.map((r) => [r.id, `${r.owner}/${r.name}`]));
+    const repoIds = watched.map((r) => r.id);
+    const finish = async () => {
+        const kindRank = {
+            stalled_review: 0,
+            untouched_thread: 1,
+            reviewer_load: 2,
+            reviewer_routing: 3,
+        };
+        const sevRank = { high: 0, warn: 1, info: 2 };
+        cards.sort((a, b) => sevRank[a.severity] - sevRank[b.severity] || kindRank[a.kind] - kindRank[b.kind]);
+        const userRows = userIdSet.size > 0
+            ? await db.select().from(users).where(inArray(users.id, [...userIdSet])).execute()
+            : [];
+        return {
+            enabled: true,
+            generatedAt: generatedAt.toISOString(),
+            sprint,
+            cards,
+            users: userRows.map(mapUser),
+        };
+    };
+    if (repoIds.length === 0)
+        return finish();
+    const ghUrl = (repoId, number) => `https://github.com/${repoName.get(repoId)}/pull/${number}`;
+    // Open, non-draft PRs in the team's repos.
+    const openPrs = await db
+        .select({
+        id: pullRequests.id,
+        repoId: pullRequests.repoId,
+        number: pullRequests.number,
+        title: pullRequests.title,
+        authorId: pullRequests.authorId,
+        openedAt: pullRequests.openedAt,
+        ciStatus: pullRequests.ciStatus,
+        changedFiles: pullRequests.changedFiles,
+        additions: pullRequests.additions,
+        deletions: pullRequests.deletions,
+        files: pullRequests.files,
+    })
+        .from(pullRequests)
+        .where(and(eq(pullRequests.accountId, accountId), inArray(pullRequests.repoId, repoIds), eq(pullRequests.state, 'open'), eq(pullRequests.isDraft, false)))
+        .execute();
+    const openPrIds = openPrs.map((p) => p.id);
+    const prById = new Map(openPrs.map((p) => [p.id, p]));
+    if (openPrIds.length === 0)
+        return finish();
+    // Pending review requests (GitHub drops the request once a review lands → still-pending).
+    const reqRows = await db
+        .select({ prId: reviewRequests.prId, userId: reviewRequests.userId })
+        .from(reviewRequests)
+        .where(and(inArray(reviewRequests.prId, openPrIds), isNotNull(reviewRequests.userId)))
+        .execute();
+    const pendingByPr = new Map();
+    const pendingByReviewer = new Map();
+    for (const r of reqRows) {
+        if (r.userId == null)
+            continue;
+        const a = pendingByPr.get(r.prId) ?? [];
+        a.push(r.userId);
+        pendingByPr.set(r.prId, a);
+        const b = pendingByReviewer.get(r.userId) ?? [];
+        b.push(r.prId);
+        pendingByReviewer.set(r.userId, b);
+    }
+    // PRs that already have a submitted review (used by the routing "orphan" test).
+    const reviewedPrIds = new Set();
+    for (const r of await db
+        .select({ prId: reviews.prId })
+        .from(reviews)
+        .where(inArray(reviews.prId, openPrIds))
+        .execute())
+        reviewedPrIds.add(r.prId);
+    // Sprint review load per reviewer (reviews submitted on team PRs in the window).
+    const reviewsThisSprint = new Map();
+    for (const r of await db
+        .select({ authorId: reviews.authorId })
+        .from(reviews)
+        .innerJoin(pullRequests, eq(pullRequests.id, reviews.prId))
+        .where(and(eq(pullRequests.accountId, accountId), inArray(pullRequests.repoId, repoIds), gte(reviews.submittedAt, sprintFrom), isNotNull(reviews.authorId)))
+        .execute()) {
+        if (r.authorId != null)
+            reviewsThisSprint.set(r.authorId, (reviewsThisSprint.get(r.authorId) ?? 0) + 1);
+    }
+    // (1) STALLED REVIEWS — open PRs with a still-pending reviewer, open past the threshold.
+    const stalled = openPrs
+        .filter((p) => (pendingByPr.get(p.id)?.length ?? 0) > 0 &&
+        p.openedAt != null &&
+        (now - p.openedAt.getTime()) / 3_600_000 > INSIGHT_STALLED_REVIEW_HOURS)
+        .map((p) => ({ p, ageHours: Math.round((now - p.openedAt.getTime()) / 3_600_000) }))
+        .sort((a, b) => b.ageHours - a.ageHours)
+        .slice(0, INSIGHT_CARD_CAP);
+    for (const { p, ageHours } of stalled) {
+        const reviewers = pendingByPr.get(p.id) ?? [];
+        addUser(p.authorId);
+        reviewers.forEach(addUser);
+        cards.push({
+            id: `stalled:${p.id}`,
+            kind: 'stalled_review',
+            severity: ageHours >= 72 ? 'high' : ageHours >= 48 ? 'warn' : 'info',
+            prId: p.id,
+            repoId: p.repoId,
+            repoFullName: repoName.get(p.repoId) ?? '',
+            prNumber: p.number,
+            prTitle: p.title,
+            authorId: p.authorId,
+            githubUrl: ghUrl(p.repoId, p.number),
+            ciStatus: p.ciStatus,
+            changedFiles: p.changedFiles,
+            additions: p.additions,
+            deletions: p.deletions,
+            ageHours,
+            requestedReviewerIds: reviewers,
+        });
+    }
+    // (2) UNTOUCHED THREADS — derivedState 'untouched', older than a day, on open PRs.
+    const threadRows = await db
+        .select({
+        threadId: reviewThreads.id,
+        path: reviewThreads.path,
+        createdAt: reviewThreads.createdAt,
+        originalCommenterId: reviewThreads.originalCommenterId,
+        prId: pullRequests.id,
+        prNumber: pullRequests.number,
+        prTitle: pullRequests.title,
+        repoId: pullRequests.repoId,
+        authorId: pullRequests.authorId,
+        ciStatus: pullRequests.ciStatus,
+        changedFiles: pullRequests.changedFiles,
+        additions: pullRequests.additions,
+        deletions: pullRequests.deletions,
+    })
+        .from(reviewThreads)
+        .innerJoin(pullRequests, eq(pullRequests.id, reviewThreads.prId))
+        .where(and(eq(pullRequests.accountId, accountId), inArray(pullRequests.repoId, repoIds), eq(pullRequests.state, 'open'), eq(reviewThreads.derivedState, 'untouched'), lt(reviewThreads.createdAt, new Date(now - INSIGHT_UNTOUCHED_THREAD_HOURS * 3_600_000))))
+        .execute();
+    const threads = threadRows
+        .map((t) => ({ t, ageHours: Math.round((now - t.createdAt.getTime()) / 3_600_000) }))
+        .sort((a, b) => b.ageHours - a.ageHours)
+        .slice(0, INSIGHT_CARD_CAP);
+    for (const { t, ageHours } of threads) {
+        addUser(t.originalCommenterId);
+        addUser(t.authorId);
+        cards.push({
+            id: `thread:${t.threadId}`,
+            kind: 'untouched_thread',
+            severity: ageHours >= 96 ? 'high' : ageHours >= 48 ? 'warn' : 'info',
+            prId: t.prId,
+            repoId: t.repoId,
+            repoFullName: repoName.get(t.repoId) ?? '',
+            prNumber: t.prNumber,
+            prTitle: t.prTitle,
+            authorId: t.authorId,
+            githubUrl: ghUrl(t.repoId, t.prNumber),
+            ciStatus: t.ciStatus,
+            changedFiles: t.changedFiles,
+            additions: t.additions,
+            deletions: t.deletions,
+            threadId: t.threadId,
+            path: t.path,
+            ageHours,
+            originalCommenterId: t.originalCommenterId,
+        });
+    }
+    // (3) REVIEWER LOAD — ranked by pending-queue depth, with sprint load alongside.
+    const loadCards = [...pendingByReviewer.keys()]
+        .map((rid) => ({
+        rid,
+        pending: pendingByReviewer.get(rid)?.length ?? 0,
+        sprint: reviewsThisSprint.get(rid) ?? 0,
+    }))
+        .filter((x) => x.pending >= 1)
+        .sort((a, b) => b.pending - a.pending || b.sprint - a.sprint)
+        .slice(0, 8);
+    for (const x of loadCards) {
+        addUser(x.rid);
+        const pendingPrs = (pendingByReviewer.get(x.rid) ?? [])
+            .map((id) => prById.get(id))
+            .filter((p) => p != null)
+            .slice(0, 8)
+            .map((p) => ({
+            prId: p.id,
+            repoFullName: repoName.get(p.repoId) ?? '',
+            prNumber: p.number,
+            prTitle: p.title,
+        }));
+        cards.push({
+            id: `load:${x.rid}`,
+            kind: 'reviewer_load',
+            severity: x.pending >= 4 ? 'high' : x.pending >= 2 ? 'warn' : 'info',
+            reviewerId: x.rid,
+            pendingCount: x.pending,
+            reviewsThisSprint: x.sprint,
+            pendingPrs,
+        });
+    }
+    // (4) REVIEWER ROUTING — orphan PRs (nobody requested, nobody reviewed) + who should review.
+    const orphans = openPrs
+        .filter((p) => (pendingByPr.get(p.id)?.length ?? 0) === 0 &&
+        !reviewedPrIds.has(p.id) &&
+        p.openedAt != null &&
+        (now - p.openedAt.getTime()) / 3_600_000 > INSIGHT_ROUTING_MIN_AGE_HOURS)
+        .slice(0, INSIGHT_CARD_CAP);
+    if (orphans.length > 0) {
+        // Orphan PRs' changed paths come from the always-synced pull_requests.files. A few
+        // stale orphans (old PRs predating the files column) are backfilled once via a
+        // bounded GitHub fetch (cached onto the row), so routing works without depending on
+        // the sparse per-commit commit_files cache.
+        const orphanFiles = new Map(orphans.map((p) => [p.id, (p.files ?? []).map((f) => f.path)]));
+        const missing = orphans.filter((p) => p.files == null).map((p) => p.id);
+        if (missing.length > 0)
+            for (const [prId, paths] of await ensureRoutingPrFiles(accountId, missing))
+                orphanFiles.set(prId, paths);
+        // Repo-wide "who recently worked where": every PR touched in the sprint → its author
+        // × the top-level dirs its files span. Sourced from the always-stored
+        // pull_requests.files (no commit-file dependency), so it reflects real recent
+        // activity in each area of the codebase.
+        const dirAuthors = new Map();
+        for (const pr of await db
+            .select({
+            repoId: pullRequests.repoId,
+            authorId: pullRequests.authorId,
+            files: pullRequests.files,
+        })
+            .from(pullRequests)
+            .where(and(eq(pullRequests.accountId, accountId), inArray(pullRequests.repoId, repoIds), isNotNull(pullRequests.authorId), isNotNull(pullRequests.files), gte(pullRequests.updatedAt, sprintFrom)))
+            .execute()) {
+            if (pr.authorId == null || pr.files == null)
+                continue;
+            for (const d of new Set(pr.files.map((f) => topLevelDir(f.path)))) {
+                const key = `${pr.repoId} ${d}`;
+                const m = dirAuthors.get(key) ?? new Map();
+                m.set(pr.authorId, (m.get(pr.authorId) ?? 0) + 1);
+                dirAuthors.set(key, m);
+            }
+        }
+        const mergers = new Map((await getMergers(accountId)).map((m) => [m.repoId, new Set(m.userIds)]));
+        for (const p of orphans) {
+            const paths = orphanFiles.get(p.id) ?? [];
+            const dirs = [...new Set(paths.map(topLevelDir))];
+            const repoMergers = mergers.get(p.repoId) ?? new Set();
+            // Candidates: mergers who recently worked in the same dirs. Track each one's
+            // most-touched dir to phrase the rationale.
+            const score = new Map();
+            const topDir = new Map();
+            for (const d of dirs) {
+                const m = dirAuthors.get(`${p.repoId} ${d}`);
+                if (!m)
+                    continue;
+                for (const [uid, cnt] of m) {
+                    if (uid === p.authorId || !repoMergers.has(uid))
+                        continue;
+                    score.set(uid, (score.get(uid) ?? 0) + cnt);
+                    const cur = topDir.get(uid);
+                    if (!cur || cnt > cur.cnt)
+                        topDir.set(uid, { dir: d, cnt });
+                }
+            }
+            const dirLabel = (d) => (d === '.' ? 'the repo root' : `${d}/`);
+            let suggested = [...score.entries()]
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 3)
+                .map(([uid]) => {
+                const top = topDir.get(uid);
+                return {
+                    userId: uid,
+                    reason: top ? `recently changed ${dirLabel(top.dir)}` : 'has merge rights here',
+                };
+            });
+            // Fallback: any repo merger who isn't the author.
+            if (suggested.length === 0)
+                suggested = [...repoMergers]
+                    .filter((uid) => uid !== p.authorId)
+                    .slice(0, 3)
+                    .map((uid) => ({ userId: uid, reason: 'has merge rights here' }));
+            if (suggested.length === 0)
+                continue; // nothing useful to suggest
+            addUser(p.authorId);
+            suggested.forEach((s) => addUser(s.userId));
+            cards.push({
+                id: `route:${p.id}`,
+                kind: 'reviewer_routing',
+                severity: 'info',
+                prId: p.id,
+                repoId: p.repoId,
+                repoFullName: repoName.get(p.repoId) ?? '',
+                prNumber: p.number,
+                prTitle: p.title,
+                authorId: p.authorId,
+                githubUrl: ghUrl(p.repoId, p.number),
+                ciStatus: p.ciStatus,
+                changedFiles: p.changedFiles,
+                additions: p.additions,
+                deletions: p.deletions,
+                topPaths: paths.slice(0, 5),
+                suggestedReviewers: suggested,
+            });
+        }
+    }
+    return finish();
+}
 export async function getConsolidatedFeed(accountId, opts = {}) {
     const { repoIds = null, userIds = null, limit = null, offset = 0, excludeBots = false, allowBotIds = null, } = opts;
     // Bot set (only loaded when the filter is on) — drops bot-authored activity, mirroring
@@ -3412,6 +3744,21 @@ export async function getPrWriteContext(prId, accountId) {
         prUrl: `https://github.com/${row.owner}/${row.name}/pull/${row.number}`,
     };
 }
+// Resolve a set of user ids to their GitHub logins for a reviewer request. Bots are
+// dropped (GitHub 422s on bot reviewers); the `users` table is global so no account
+// scope is needed (the caller already gated the PR by ownership + write access).
+export async function getReviewerLogins(userIds) {
+    if (userIds.length === 0)
+        return [];
+    const rows = await db
+        .select({ id: users.id, login: users.githubLogin, isBot: users.isBot })
+        .from(users)
+        .where(inArray(users.id, userIds))
+        .execute();
+    return rows
+        .filter((r) => !r.isBot && r.login)
+        .map((r) => ({ userId: r.id, login: r.login }));
+}
 // Subset of getPrWriteContext for the Changes-tab files fetch (owner/name/number
 // + the PR URL for building per-file deep links). Reuses getPrWriteContext so the
 // account-scoped ownership check stays in one place.

package/dist/github/mutations.js

@@ -245,6 +245,15 @@ export async function createPullRequest(token, args) {
     });
     return { number: res.number, url: res.html_url };
 }
+// ---- Request reviewers on a PR (REST) ----
+// Request one or more reviewers on a PR (POST .../pulls/:n/requested_reviewers with
+// { reviewers: [login…] }). Needs a token with write/triage access; GitHub 422s if a
+// login isn't a collaborator or is the PR author (the caller filters the author out).
+// Returns 201 with the updated PR body, which we don't need — the refreshed request
+// state arrives on the next sync (reviewRequests are re-derived each sync).
+export async function requestReviewers(token, owner, name, number, logins) {
+    await ghRestPostFor(token, `/repos/${owner}/${name}/pulls/${number}/requested_reviewers`, { reviewers: logins });
+}
 // ---- Re-trigger a GitHub Actions workflow run ----
 // Re-run a workflow run (per-account). `mode: 'failed'` reruns only the failed jobs
 // (POST .../runs/:runId/rerun-failed-jobs); `mode: 'all'` reruns the whole run

package/dist/pro/bind.js

@@ -41,7 +41,7 @@ export async function bindProPlugin(app) {
     if (!mod)
         return;
     const plugin = (mod.default ?? mod);
-    if (plugin?.apiVersion !== 4 || typeof plugin.register !== 'function') {
+    if (plugin?.apiVersion !== 5 || typeof plugin.register !== 'function') {
         app.log.warn({ apiVersion: plugin?.apiVersion }, 'pro contract mismatch — skipped');
         return;
     }
@@ -77,6 +77,7 @@ export async function bindProPlugin(app) {
                 userIds: null,
             }),
             getActivity: (accountId, repoIds) => hostQueries.getActivity(accountId, repoIds ?? null),
+            getTeamInsights: (accountId) => hostQueries.getTeamInsights(accountId),
         },
         reviewEvents,
         registerLearningsProvider,

package/dist/pro/contract.js

@@ -6,6 +6,7 @@ const EMPTY = {
     reviewMemory: false,
     aiAnalysis: false,
     aiFix: false,
+    teamInsights: false,
 };
 let active = EMPTY;
 export function setProCapabilities(c) {

package/dist/sync/routing-files.js

@@ -0,0 +1,58 @@
+import { and, eq, inArray, isNull } from 'drizzle-orm';
+import { getAccessToken } from '../auth/account.js';
+import { db, schema } from '../db/client.js';
+import { fetchPrFilesWithPatch } from '../github/mutations.js';
+const { pullRequests, repos } = schema;
+// Best-effort, BOUNDED backfill of `pull_requests.files` for reviewer-routing
+// candidates that predate the files column (old open PRs never re-synced). Only PRs
+// whose `files` IS NULL are fetched; the result — even `[]` on failure — is persisted
+// so the same PR isn't refetched on every insights refresh (an [] sentinel means "we
+// tried"). The sprint window's PRs already carry files from sync, so this only ever
+// touches a handful of stale orphans. Returns the resolved paths by prId.
+export async function ensureRoutingPrFiles(accountId, prIds) {
+    const out = new Map();
+    if (prIds.length === 0)
+        return out;
+    const rows = await db
+        .select({
+        id: pullRequests.id,
+        number: pullRequests.number,
+        owner: repos.owner,
+        name: repos.name,
+    })
+        .from(pullRequests)
+        .innerJoin(repos, eq(repos.id, pullRequests.repoId))
+        .where(and(eq(pullRequests.accountId, accountId), inArray(pullRequests.id, prIds), isNull(pullRequests.files)))
+        .execute();
+    if (rows.length === 0)
+        return out;
+    let token;
+    try {
+        token = await getAccessToken(accountId);
+    }
+    catch {
+        return out; // no token (e.g. offline) → leave the fallback rationale in place
+    }
+    for (const r of rows) {
+        let stored = [];
+        try {
+            const { files } = await fetchPrFilesWithPatch(token, r.owner, r.name, r.number, 100);
+            stored = files.map((f) => ({
+                path: f.filename,
+                additions: f.additions,
+                deletions: f.deletions,
+            }));
+        }
+        catch {
+            stored = []; // sentinel — persist [] so we don't refetch this PR every refresh
+        }
+        await db
+            .update(pullRequests)
+            .set({ files: stored })
+            .where(and(eq(pullRequests.id, r.id), eq(pullRequests.accountId, accountId)))
+            .execute();
+        out.set(r.id, stored.map((s) => s.path));
+    }
+    return out;
+}
+//# sourceMappingURL=routing-files.js.map

package/package.json

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