pierre-review 0.1.75 → 0.1.76

package/dist/api/routes/prs.js

@@ -4,6 +4,7 @@ import { getAccessToken, getAccountUserId } from '../../auth/account.js';
 import { fetchActionsJobLog } from '../../github/actions-logs.js';
 import { getMentionCandidates, getPrDetail, getPrFilesContext, getPrWriteContext, getReviewerLogins, getResolvableBotThreads, getUsersByLogins, markAllViewed, markPrMergedLocally, markPrViewed, upsertLocalPrComment, upsertLocalReview, } from '../../db/queries.js';
 import { getCodeownersMatch } from '../../github/codeowners.js';
+import { suggestTeamsFromHistory } from '../../github/team-reviewers.js';
 import { buildFileAnchors, fallbackAnchor, isFindingAnchored, } from '../../github/diff-anchor.js';
 import { addIssueComment, fetchHeadShaFor, fetchMergeability, fetchPrFilesWithPatch, fetchPrHeadInfo, fetchRepoMergeConfig, mergePullRequest, postInlineComment, requestReviewers, rerunWorkflowRun, submitPrReview, updatePullRequestBranch, } from '../../github/mutations.js';
 import { hydratePrDetail } from '../../sync/hydrate-detail.js';
@@ -154,12 +155,17 @@ const requestReviewersSchema = {
         },
     },
 };
-// Layer CODEOWNERS-derived suggestions on top of the history-based ones getPrDetail already
-// computed. Runs ONLY when the PR still warrants suggestions (same trigger getPrDetail used).
-// Best-effort: any failure (no CODEOWNERS, org wall, parse error) leaves the history
-// suggestions untouched. CODEOWNERS owners (declared ownership) take precedence, then history
-// fills up to a small cap. Mutates + returns the detail.
-async function enrichSuggestionsWithCodeowners(detail, accountId) {
+// Layer network-derived reviewer suggestions on top of the history-USER ones getPrDetail
+// already computed. Runs ONLY when the PR still warrants suggestions (same trigger getPrDetail
+// used). Two best-effort sources, fetched in parallel and both cached per-repo:
+//   • CODEOWNERS — declared ownership for the touched paths (users + teams).
+//   • Team history — which team(s) are usually REQUESTED to review this repo (the behavioural
+//     fallback when CODEOWNERS declares no team; repo-level, so it runs even when the PR
+//     touches no owned path). See github/team-reviewers.ts.
+// Any failure (no CODEOWNERS, org wall, a repo that doesn't use team requests) simply leaves
+// the history-user suggestions untouched. Precedence: declared CODEOWNERS owners, then the
+// inferred team(s), then history users, up to a small cap. Mutates + returns the detail.
+async function enrichSuggestions(detail, accountId) {
     const wants = detail.state === 'open' &&
         !detail.isDraft &&
         detail.requestedReviewers.length === 0 &&
@@ -169,13 +175,19 @@ async function enrichSuggestionsWithCodeowners(detail, accountId) {
     const [owner, name] = detail.repoFullName.split('/');
     if (!owner || !name)
         return detail;
-    const paths = detail.files.map((f) => f.path);
-    if (paths.length === 0)
-        return detail;
     try {
         const token = await getAccessToken(accountId);
-        const match = await getCodeownersMatch(token, owner, name, accountId, paths);
-        if (match.logins.length === 0 && match.teams.length === 0)
+        const paths = detail.files.map((f) => f.path);
+        const emptyMatch = { logins: [], teams: [] };
+        const [match, historyTeams] = await Promise.all([
+            paths.length > 0
+                ? getCodeownersMatch(token, owner, name, accountId, paths)
+                : Promise.resolve(emptyMatch),
+            suggestTeamsFromHistory(token, owner, name, accountId),
+        ]);
+        if (match.logins.length === 0 &&
+            match.teams.length === 0 &&
+            historyTeams.length === 0)
             return detail;
         const authorLogin = detail.authorId != null
             ? detail.users.find((u) => u.id === detail.authorId)?.githubLogin ?? null
@@ -203,12 +215,28 @@ async function enrichSuggestionsWithCodeowners(detail, accountId) {
             reason: 'owns this path (CODEOWNERS)',
             source: 'codeowners',
         }));
-        // Merge: CODEOWNERS users, then teams, then the history suggestions — dedup users by
-        // login and teams by slug, capped so the row stays digestible.
+        const historyTeamSuggestions = historyTeams.map((t) => ({
+            kind: 'team',
+            login: null,
+            userId: null,
+            teamSlug: t.slug,
+            teamName: t.name,
+            reason: `usually requested here (${t.count} recent PR${t.count === 1 ? '' : 's'})`,
+            source: 'history',
+        }));
+        // Merge = precedence: CODEOWNERS users, CODEOWNERS teams (declared), inferred teams, then
+        // the history-user suggestions. Dedup users by login and teams by slug (so a team that's
+        // both a CODEOWNER and historically requested shows once, as the CODEOWNER), capped so the
+        // row stays digestible.
         const seenLogins = new Set();
         const seenTeams = new Set();
         const merged = [];
-        for (const s of [...codeownerUsers, ...codeownerTeams, ...detail.suggestedReviewers]) {
+        for (const s of [
+            ...codeownerUsers,
+            ...codeownerTeams,
+            ...historyTeamSuggestions,
+            ...detail.suggestedReviewers,
+        ]) {
             if (s.kind === 'team') {
                 if (s.teamSlug && !seenTeams.has(s.teamSlug)) {
                     seenTeams.add(s.teamSlug);
@@ -252,9 +280,10 @@ export async function prRoutes(app) {
         // Cloud lean mode: fill in bulky text from GitHub (no-op in local). The client
         // caches the result in IndexedDB keyed by updatedAt so unchanged PRs don't refetch.
         const detail = await hydratePrDetail(pr, accountId);
-        // Layer CODEOWNERS ownership onto the history-based suggestions (best-effort; never
-        // blocks the response). getPrDetail already gated the history part on the same trigger.
-        return enrichSuggestionsWithCodeowners(detail, accountId);
+        // Layer CODEOWNERS ownership + inferred review team(s) onto the history-based suggestions
+        // (best-effort; never blocks the response). getPrDetail already gated the history part on
+        // the same trigger.
+        return enrichSuggestions(detail, accountId);
     });
     // Candidates for an @mention autocomplete, ranked by proximity to this PR
     // (participants first, then repo people), self + bots excluded. Account-scoped:

package/dist/github/team-reviewers.js

@@ -0,0 +1,96 @@
+// History-based TEAM reviewer suggestions (CORE). GitHub lets a PR request an `@org/team` as
+// a reviewer; that request is EPHEMERAL (GitHub drops it from `reviewRequests` once a member
+// reviews), but the PR timeline keeps a permanent `ReviewRequestedEvent` for it. This mines a
+// repo's recent PRs for those team requests, ranks the teams by how often they're asked to
+// review here, and returns the top few — the "which team usually reviews this repo" signal
+// that CODEOWNERS provides statically but many repos never declare.
+//
+// Best-effort throughout: any failure (network, org wall, a repo that simply doesn't use team
+// review-requests) degrades to "no team suggestion", NEVER an error on the PR-detail path.
+//
+// Auth caveat (same reality codeowners.ts notes for the org/teams API): a Team
+// `requestedReviewer` is only visible to a token with org/team visibility — org membership,
+// or a GitHub App installed with org read. For an outside token GitHub returns no team on the
+// event, so this yields nothing. That's fine: it lights up for your own org's repos (the
+// common case — you watch your org's repos with your own token) and stays silent elsewhere.
+import { getGraphqlClientFor } from './client.js';
+// Per-(account, repo) cache. Which team reviews a repo is very stable, so a longish TTL keeps
+// the extra GraphQL call off the hot path. Cached even when EMPTY (the "repo doesn't use team
+// requests" / "token can't see teams" case) so we don't re-query on every PR open. Keyed by
+// account so one tenant's token result never leaks to another.
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+const cache = new Map();
+const PRS_SCANNED = 50; // recent PRs to mine — bounded for GraphQL node cost
+const DEFAULT_MIN_PRS = 2; // ignore a one-off request; require a repeated pattern
+const DEFAULT_TOP_N = 2; // at most this many team suggestions
+const TEAM_HISTORY_QUERY = `
+  query TeamReviewHistory($owner: String!, $name: String!, $prs: Int!) {
+    repository(owner: $owner, name: $name) {
+      pullRequests(first: $prs, orderBy: { field: UPDATED_AT, direction: DESC }) {
+        nodes {
+          number
+          timelineItems(itemTypes: [REVIEW_REQUESTED_EVENT], first: 20) {
+            nodes {
+              ... on ReviewRequestedEvent {
+                createdAt
+                requestedReviewer {
+                  __typename
+                  ... on Team { slug }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }`;
+// Aggregate team review-requests from PR timeline nodes → teams ranked by DISTINCT-PR count
+// then recency, dropping any under `minPrs`. Pure (no network) so it's unit-testable. Counting
+// distinct PRs (not raw events) means a re-request on a single PR isn't double-weighted.
+export function rankTeamRequests(prNodes, owner, minPrs = DEFAULT_MIN_PRS) {
+    const agg = new Map();
+    for (const pr of prNodes) {
+        for (const ev of pr.timelineItems?.nodes ?? []) {
+            const rr = ev.requestedReviewer;
+            if (!rr || rr.__typename !== 'Team' || !rr.slug)
+                continue;
+            const cur = agg.get(rr.slug) ?? { prs: new Set(), lastAt: '' };
+            cur.prs.add(pr.number);
+            const when = ev.createdAt ?? '';
+            if (when > cur.lastAt)
+                cur.lastAt = when;
+            agg.set(rr.slug, cur);
+        }
+    }
+    return [...agg.entries()]
+        .map(([slug, v]) => ({
+        slug,
+        name: `${owner}/${slug}`,
+        count: v.prs.size,
+        lastAt: v.lastAt,
+    }))
+        .filter((t) => t.count >= minPrs)
+        .sort((a, b) => b.count - a.count ||
+        (a.lastAt < b.lastAt ? 1 : a.lastAt > b.lastAt ? -1 : 0));
+}
+// Mine a repo's recent PRs for the team(s) most often requested to review here (cached per
+// repo). Returns the top `topN`. Never throws — a failure/permission-wall yields [].
+export async function suggestTeamsFromHistory(token, owner, name, accountId, opts = {}) {
+    const topN = opts.topN ?? DEFAULT_TOP_N;
+    const key = `${accountId}:${owner}/${name}`;
+    const hit = cache.get(key);
+    if (hit && Date.now() - hit.at < CACHE_TTL_MS)
+        return hit.ranked.slice(0, topN);
+    let ranked = [];
+    try {
+        const client = getGraphqlClientFor(token);
+        const data = await client(TEAM_HISTORY_QUERY, { owner, name, prs: PRS_SCANNED });
+        ranked = rankTeamRequests(data.repository?.pullRequests?.nodes ?? [], owner, opts.minPrs ?? DEFAULT_MIN_PRS);
+    }
+    catch {
+        ranked = [];
+    }
+    cache.set(key, { ranked, at: Date.now() });
+    return ranked.slice(0, topN);
+}
+//# sourceMappingURL=team-reviewers.js.map

package/package.json

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