pierre-review 0.1.67 → 0.1.68

package/dist/api/routes/prs.js

@@ -2,7 +2,8 @@ import { createHash } from 'node:crypto';
 import { config } from '../../config.js';
 import { getAccessToken, getAccountUserId } from '../../auth/account.js';
 import { fetchActionsJobLog } from '../../github/actions-logs.js';
-import { getMentionCandidates, getPrDetail, getPrFilesContext, getPrWriteContext, getReviewerLogins, markAllViewed, markPrMergedLocally, markPrViewed, upsertLocalPrComment, upsertLocalReview, } from '../../db/queries.js';
+import { getMentionCandidates, getPrDetail, getPrFilesContext, getPrWriteContext, getReviewerLogins, getUsersByLogins, markAllViewed, markPrMergedLocally, markPrViewed, upsertLocalPrComment, upsertLocalReview, } from '../../db/queries.js';
+import { getCodeownersMatch } from '../../github/codeowners.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';
@@ -128,18 +129,95 @@ const requestReviewersSchema = {
     ...idParamSchema,
     body: {
         type: 'object',
-        required: ['userIds'],
         additionalProperties: false,
+        // All three are optional; the handler 400s if the combined set is empty. `userIds`
+        // are resolved to logins; `logins` pass through (suggested reviewers we haven't synced);
+        // `teamSlugs` become team review requests (CODEOWNERS @org/team).
         properties: {
-            userIds: {
-                type: 'array',
-                minItems: 1,
-                maxItems: 15,
-                items: { type: 'integer' },
-            },
+            userIds: { type: 'array', maxItems: 15, items: { type: 'integer' } },
+            logins: { type: 'array', maxItems: 15, items: { type: 'string' } },
+            teamSlugs: { type: 'array', maxItems: 15, items: { type: 'string' } },
         },
     },
 };
+// 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) {
+    const wants = detail.state === 'open' &&
+        !detail.isDraft &&
+        detail.requestedReviewers.length === 0 &&
+        detail.reviews.length === 0;
+    if (!wants)
+        return detail;
+    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)
+            return detail;
+        const authorLogin = detail.authorId != null
+            ? detail.users.find((u) => u.id === detail.authorId)?.githubLogin ?? null
+            : null;
+        // Resolve @user owners to synced users (avatar/link); unsynced owners show login-only.
+        // Exclude the PR author (GitHub rejects self-review requests).
+        const uniqueLogins = [...new Set(match.logins)].filter((l) => l !== authorLogin);
+        const resolved = await getUsersByLogins(uniqueLogins);
+        const byLogin = new Map(resolved.map((u) => [u.githubLogin, u]));
+        const codeownerUsers = uniqueLogins.map((login) => ({
+            kind: 'user',
+            login,
+            userId: byLogin.get(login)?.id ?? null,
+            teamSlug: null,
+            teamName: null,
+            reason: 'owns this path (CODEOWNERS)',
+            source: 'codeowners',
+        }));
+        const codeownerTeams = match.teams.map((t) => ({
+            kind: 'team',
+            login: null,
+            userId: null,
+            teamSlug: t.slug,
+            teamName: t.name,
+            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 seenLogins = new Set();
+        const seenTeams = new Set();
+        const merged = [];
+        for (const s of [...codeownerUsers, ...codeownerTeams, ...detail.suggestedReviewers]) {
+            if (s.kind === 'team') {
+                if (s.teamSlug && !seenTeams.has(s.teamSlug)) {
+                    seenTeams.add(s.teamSlug);
+                    merged.push(s);
+                }
+            }
+            else if (s.login && !seenLogins.has(s.login)) {
+                seenLogins.add(s.login);
+                merged.push(s);
+            }
+        }
+        detail.suggestedReviewers = merged.slice(0, 5);
+        // Surface any newly-resolved codeowner users so the client can render avatars/links.
+        const known = new Set(detail.users.map((u) => u.id));
+        for (const u of resolved)
+            if (!known.has(u.id))
+                detail.users.push(u);
+    }
+    catch {
+        /* best-effort: keep the history suggestions */
+    }
+    return detail;
+}
 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
@@ -159,7 +237,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.
-        return hydratePrDetail(pr, accountId);
+        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);
     });
     // Candidates for an @mention autocomplete, ranked by proximity to this PR
     // (participants first, then repo people), self + bots excluded. Account-scoped:
@@ -628,7 +709,7 @@ export async function prRoutes(app) {
     // 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 { userIds = [], logins: directLogins = [], teamSlugs = [], } = req.body;
         const accountId = accountIdOf(req);
         const ctx = await getPrWriteContext(id, accountId);
         if (!ctx) {
@@ -643,20 +724,23 @@ export async function prRoutes(app) {
                 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).
+        // Drop the PR author from the id set (GitHub rejects self-review requests), then
+        // resolve to logins (also drops bots + unknown ids). Union with any direct logins
+        // (suggested reviewers we haven't synced as users), deduped.
         const wanted = userIds.filter((uid) => uid !== ctx.authorId);
-        const logins = (await getReviewerLogins(wanted)).map((r) => r.login);
-        if (logins.length === 0) {
+        const resolvedLogins = (await getReviewerLogins(wanted)).map((r) => r.login);
+        const logins = [...new Set([...resolvedLogins, ...directLogins])];
+        const teams = [...new Set(teamSlugs)];
+        if (logins.length === 0 && teams.length === 0) {
             reply.status(400);
             return {
                 error: 'NoReviewers',
-                message: 'None of the selected users can be requested as reviewers.',
+                message: 'None of the selected users or teams can be requested as reviewers.',
             };
         }
         try {
             const token = await getAccessToken(accountId);
-            await requestReviewers(token, ctx.owner, ctx.name, ctx.number, logins);
+            await requestReviewers(token, ctx.owner, ctx.name, ctx.number, logins, teams);
             const result = {
                 status: 'ok',
                 requestedLogins: logins,

package/dist/db/queries.js

@@ -3329,6 +3329,108 @@ async function getThreadsAwaiting(localUserId, accountId, repoNameById) {
     out.sort((a, b) => b.lastReplyAt.localeCompare(a.lastReplyAt));
     return out;
 }
+// Recent-activity window for the CORE reviewer suggester (both the dir-overlap authorship
+// signal and the "reviews here often" pool). 90d = the board's max range; beyond it a
+// contributor is off the radar.
+const REVIEWER_SUGGEST_WINDOW_MS = 90 * 86_400_000;
+// Suggest reviewers for a PR that has NONE assigned, from ALREADY-SYNCED data only (no
+// GitHub calls). Candidate pool = people with merge rights in the repo ∪ people who review
+// it often; ranked by how much they've recently worked in the top-level dirs this PR
+// touches. The PR author + bots are excluded. Returns up to 3 user suggestions
+// (source 'history'). CODEOWNERS suggestions are layered on top in the route (they need a
+// token + network); this is the always-available core signal.
+async function suggestReviewersFromHistory(accountId, repoId, authorId, changedPaths) {
+    const since = new Date(Date.now() - REVIEWER_SUGGEST_WINDOW_MS);
+    const dirs = [...new Set(changedPaths.map(topLevelDir))];
+    // Repo-wide "who recently worked where" (author × top-level dir), from the always-stored
+    // pull_requests.files — real recent activity per area, no commit-file dependency.
+    const dirCount = new Map(); // dir -> uid -> #PRs
+    for (const pr of await db
+        .select({ authorId: pullRequests.authorId, files: pullRequests.files })
+        .from(pullRequests)
+        .where(and(eq(pullRequests.accountId, accountId), eq(pullRequests.repoId, repoId), isNotNull(pullRequests.authorId), isNotNull(pullRequests.files), gte(pullRequests.updatedAt, since)))
+        .execute()) {
+        if (pr.authorId == null || pr.files == null)
+            continue;
+        for (const d of new Set(pr.files.map((f) => topLevelDir(f.path)))) {
+            const m = dirCount.get(d) ?? new Map();
+            m.set(pr.authorId, (m.get(pr.authorId) ?? 0) + 1);
+            dirCount.set(d, m);
+        }
+    }
+    // Merge-rights set for this repo.
+    const repoMergers = new Set((await getMergers(accountId)).find((m) => m.repoId === repoId)?.userIds ?? []);
+    // Frequent reviewers of this repo (review count per author, recent window).
+    const reviewCount = 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), eq(pullRequests.repoId, repoId), isNotNull(reviews.authorId), gte(reviews.submittedAt, since)))
+        .execute()) {
+        if (r.authorId == null)
+            continue;
+        reviewCount.set(r.authorId, (reviewCount.get(r.authorId) ?? 0) + 1);
+    }
+    // Candidate pool = mergers ∪ frequent reviewers, minus the author.
+    const pool = new Set([...repoMergers, ...reviewCount.keys()]);
+    if (authorId != null)
+        pool.delete(authorId);
+    if (pool.size === 0)
+        return [];
+    // Score by dir-overlap; track each candidate's most-touched matching dir for the reason.
+    const overlap = new Map();
+    const topDir = new Map();
+    for (const d of dirs) {
+        const m = dirCount.get(d);
+        if (!m)
+            continue;
+        for (const [uid, cnt] of m) {
+            if (!pool.has(uid))
+                continue;
+            overlap.set(uid, (overlap.get(uid) ?? 0) + cnt);
+            const cur = topDir.get(uid);
+            if (!cur || cnt > cur.cnt)
+                topDir.set(uid, { dir: d, cnt });
+        }
+    }
+    // Resolve to logins (drops bots + null logins), then rank.
+    const resolved = await getReviewerLogins([...pool]);
+    const dirLabel = (d) => (d === '.' ? 'the repo root' : `${d}/`);
+    const ranked = resolved
+        .sort((a, b) => {
+        const ov = (overlap.get(b.userId) ?? 0) - (overlap.get(a.userId) ?? 0);
+        if (ov !== 0)
+            return ov;
+        const rv = (reviewCount.get(b.userId) ?? 0) - (reviewCount.get(a.userId) ?? 0);
+        if (rv !== 0)
+            return rv;
+        return (repoMergers.has(b.userId) ? 1 : 0) - (repoMergers.has(a.userId) ? 1 : 0);
+    })
+        .slice(0, 3);
+    return ranked.map(({ userId, login }) => {
+        const top = topDir.get(userId);
+        const reason = top && (overlap.get(userId) ?? 0) > 0
+            ? `recently changed ${dirLabel(top.dir)}`
+            : (reviewCount.get(userId) ?? 0) > 0
+                ? 'reviews here often'
+                : 'has merge rights here';
+        return { kind: 'user', login, userId, teamSlug: null, teamName: null, reason, source: 'history' };
+    });
+}
+// Resolve GitHub logins to synced User rows (for CODEOWNERS suggestion enrichment in the
+// route — an @user owner may or may not be someone we've synced). Case-insensitive on
+// login is unnecessary: GitHub logins in CODEOWNERS match the stored githubLogin exactly.
+export async function getUsersByLogins(logins) {
+    if (logins.length === 0)
+        return [];
+    const rows = await db
+        .select()
+        .from(users)
+        .where(inArray(users.githubLogin, logins))
+        .execute();
+    return rows.map(mapUser);
+}
 export async function getPrDetail(id, accountId) {
     const rows = await db
         .select()
@@ -3449,6 +3551,17 @@ export async function getPrDetail(id, accountId) {
         userId: r.userId,
         teamName: r.teamName,
     }));
+    // Suggested reviewers (CORE) — only when the PR warrants them: open, non-draft, and
+    // nobody's been requested OR has reviewed yet. The route layers CODEOWNERS suggestions
+    // on top (they need a token + network); this is the history-based signal from synced
+    // data alone. Keep this trigger in lockstep with the route's CODEOWNERS gate.
+    const wantsSuggestions = pr.state === 'open' &&
+        !pr.isDraft &&
+        requestedReviewers.length === 0 &&
+        reviewsOut.length === 0;
+    const suggestedReviewers = wantsSuggestions
+        ? await suggestReviewersFromHistory(accountId, pr.repoId, pr.authorId, (pr.files ?? []).map((f) => f.path))
+        : [];
     // Gather referenced users for client-side lookup.
     const userIds = new Set();
     if (pr.authorId)
@@ -3474,6 +3587,9 @@ export async function getPrDetail(id, accountId) {
     for (const r of reviewerRows)
         if (r.userId)
             userIds.add(r.userId);
+    for (const s of suggestedReviewers)
+        if (s.userId != null)
+            userIds.add(s.userId);
     // A maintainer who only merged the PR (never authored/reviewed/commented) is
     // otherwise absent from userList, leaving "Merged by" unresolved.
     if (pr.mergedById)
@@ -3581,6 +3697,7 @@ export async function getPrDetail(id, accountId) {
         changedFilesCount: pr.changedFiles,
         files: filesOut,
         requestedReviewers,
+        suggestedReviewers,
         viewerCanApprove,
         viewerCanPush,
         viewerHasApprovedStanding,

package/dist/github/client.js

@@ -112,6 +112,22 @@ export async function ghRestGetText(token, path) {
     const text = await res.text().catch(() => '');
     return { status: res.status, ok: res.ok, text };
 }
+// REST GET a repo file's RAW contents (Accept: application/vnd.github.raw), NOT throwing
+// on a non-2xx — returns the status + body so the caller can branch. Used to fetch a
+// repo's CODEOWNERS file (404 when absent → degrade to no CODEOWNERS suggestions). The
+// raw media type returns the file bytes directly (no base64/JSON envelope to decode).
+export async function ghRestGetContentRaw(token, path) {
+    const res = await fetch(`https://api.github.com${path}`, {
+        method: 'GET',
+        headers: {
+            authorization: `token ${token}`,
+            accept: 'application/vnd.github.raw',
+            'x-github-api-version': '2022-11-28',
+        },
+    });
+    const text = await res.text().catch(() => '');
+    return { status: res.status, ok: res.ok, text };
+}
 // REST GET in GitHub's raw `diff` media type (Accept: application/vnd.github.diff),
 // NOT throwing on a non-2xx — returns the status + body so the caller can branch. GitHub
 // caps this media type at 20,000 lines and 406s past it (a huge PR), which the caller

package/dist/github/codeowners.js

@@ -0,0 +1,163 @@
+// CODEOWNERS-based reviewer suggestions (CORE). Fetches a repo's CODEOWNERS file via the
+// contents API, parses it, and — given a PR's changed paths — returns the owning users +
+// teams. Best-effort throughout: any failure (no file, token can't read the repo, a parse
+// hiccup) degrades to "no CODEOWNERS suggestions", NEVER an error on the PR-detail path.
+//
+// Why CODEOWNERS and not the org/teams API: the contents API is reachable in every auth
+// mode (local gh token, cloud OAuth `public_repo`, GitHub App with contents:read), and a
+// `@org/team` owner is directly requestable as a review via `team_reviewers` — no need to
+// expand team membership (which needs `read:org` + org membership and is unreliable under
+// the cloud GitHub App). Individual `@user` owners become user suggestions directly.
+import { ghRestGetContentRaw } from './client.js';
+// The candidate file locations GitHub honours, in the order it resolves them.
+const CODEOWNERS_PATHS = ['.github/CODEOWNERS', 'CODEOWNERS', 'docs/CODEOWNERS'];
+// Per-(account, repo) cache. CODEOWNERS changes rarely, so a short TTL keeps the extra
+// contents-API call off the hot path while staying reasonably fresh. A `null` rules value
+// is cached too (the common "repo has no CODEOWNERS" case) so we don't refetch a 404 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();
+// Convert a CODEOWNERS (gitignore-style) path pattern into a regex over POSIX file paths.
+// A best-effort subset matching GitHub's documented CODEOWNERS semantics: `*` matches
+// within a single segment (NOT across `/`), `**` across segments, `?` one non-slash char;
+// a leading `/` or any internal `/` anchors to the repo root, otherwise the pattern may
+// match at any directory depth; a trailing `/` (or a bare directory name) owns everything
+// under that directory. Exported for the unit test that locks these semantics.
+export function globToRegExp(raw) {
+    let p = raw.trim();
+    const dirOnly = p.endsWith('/');
+    if (dirOnly)
+        p = p.slice(0, -1);
+    const startSlash = p.startsWith('/');
+    if (startSlash)
+        p = p.slice(1);
+    // Git: a pattern with a slash anywhere but the end is relative to the root (anchored);
+    // a pattern with no internal slash matches by name at any level.
+    const anchored = startSlash || p.includes('/');
+    let re = '';
+    for (let i = 0; i < p.length; i++) {
+        const c = p[i];
+        if (c === '*') {
+            if (p[i + 1] === '*') {
+                // `**` spans path segments. A segment-aligned `**/` becomes OPTIONAL leading
+                // directories that preserve the `/` boundary (so `**/logs` matches `a/logs` but
+                // NOT `mylogs`); a trailing/standalone `**` matches anything.
+                if (p[i + 2] === '/') {
+                    re += '(?:.*/)?';
+                    i += 2; // consume the second '*' and the '/'
+                }
+                else {
+                    re += '.*';
+                    i += 1; // consume the second '*'
+                }
+            }
+            else {
+                re += '[^/]*';
+            }
+        }
+        else if (c === '?') {
+            re += '[^/]';
+        }
+        else if ('.+^${}()|[]\\'.includes(c)) {
+            re += `\\${c}`;
+        }
+        else {
+            re += c;
+        }
+    }
+    // A trailing-slash directory (or a bare literal path) OWNS everything under it, so it
+    // gets a "…/.*" / "(?:/.*)?" tail. A wildcard-TERMINATED pattern (e.g. `docs/*`) is
+    // single-level per GitHub — it must NOT gain that tail, or it would over-match nested
+    // files (`docs/*` matches `docs/a.md` but not `docs/sub/a.md`).
+    const endsWithWildcard = /[*?]$/.test(p);
+    const body = dirOnly ? `${re}/.*` : endsWithWildcard ? re : `${re}(?:/.*)?`;
+    const full = anchored ? `^${body}$` : `^(?:.*/)?${body}$`;
+    return new RegExp(full);
+}
+// Parse CODEOWNERS text into ordered rules (order matters: the LAST matching rule wins).
+function parseCodeowners(text) {
+    const rules = [];
+    for (const line of text.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        // Strip an inline comment, then split on whitespace: first token = pattern, rest = owners.
+        const noComment = trimmed.split('#')[0].trim();
+        if (!noComment)
+            continue;
+        const parts = noComment.split(/\s+/);
+        const pattern = parts[0];
+        // Owners are the @-prefixed tokens (drop bare emails — not requestable as reviewers).
+        const owners = parts.slice(1).filter((o) => o.startsWith('@'));
+        if (owners.length === 0)
+            continue;
+        try {
+            rules.push({ re: globToRegExp(pattern), owners });
+        }
+        catch {
+            /* skip an un-compilable pattern rather than fail the whole file */
+        }
+    }
+    return rules;
+}
+// Fetch + parse a repo's CODEOWNERS (cached). Returns null when there's no file / it can't
+// be read. Never throws.
+async function loadRules(token, owner, name, accountId) {
+    const key = `${accountId}:${owner}/${name}`;
+    const hit = cache.get(key);
+    if (hit && Date.now() - hit.at < CACHE_TTL_MS)
+        return hit.rules;
+    let rules = null;
+    try {
+        for (const path of CODEOWNERS_PATHS) {
+            const res = await ghRestGetContentRaw(token, `/repos/${owner}/${name}/contents/${path}`);
+            if (res.ok && res.text) {
+                rules = parseCodeowners(res.text);
+                break;
+            }
+            // Any non-404 (403 org wall / 401) also means "give up on CODEOWNERS" — stop trying.
+            if (res.status !== 404)
+                break;
+        }
+    }
+    catch {
+        rules = null;
+    }
+    cache.set(key, { rules, at: Date.now() });
+    return rules;
+}
+// Given a PR's changed paths, return the CODEOWNERS-derived owners (users + teams). The
+// LAST matching rule for each file wins (git semantics); owners are unioned across files.
+export async function getCodeownersMatch(token, owner, name, accountId, changedPaths) {
+    const empty = { logins: [], teams: [] };
+    if (changedPaths.length === 0)
+        return empty;
+    const rules = await loadRules(token, owner, name, accountId);
+    if (!rules || rules.length === 0)
+        return empty;
+    const ownerTokens = new Set();
+    for (const path of changedPaths) {
+        let last = null;
+        for (const r of rules)
+            if (r.re.test(path))
+                last = r; // last match wins
+        if (last)
+            for (const o of last.owners)
+                ownerTokens.add(o);
+    }
+    const logins = [];
+    const teams = [];
+    for (const tok of ownerTokens) {
+        const handle = tok.slice(1); // drop '@'
+        if (handle.includes('/')) {
+            const slug = handle.slice(handle.indexOf('/') + 1);
+            if (slug)
+                teams.push({ slug, name: handle });
+        }
+        else if (handle) {
+            logins.push(handle);
+        }
+    }
+    return { logins, teams };
+}
+//# sourceMappingURL=codeowners.js.map

package/dist/github/mutations.js

@@ -336,12 +336,17 @@ export async function createPullRequest(token, args) {
 }
 // ---- 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).
+// { reviewers: [login…], team_reviewers: [slug…] }). 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). `teamSlugs` requests a whole team (a CODEOWNERS `@org/team`)
+// WITHOUT expanding its membership — GitHub resolves the slug against the repo's org.
 // 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 });
+export async function requestReviewers(token, owner, name, number, logins, teamSlugs = []) {
+    const body = { reviewers: logins };
+    if (teamSlugs.length > 0)
+        body.team_reviewers = teamSlugs;
+    await ghRestPostFor(token, `/repos/${owner}/${name}/pulls/${number}/requested_reviewers`, body);
 }
 // ---- Re-trigger a GitHub Actions workflow run ----
 // Re-run a workflow run (per-account). `mode: 'failed'` reruns only the failed jobs

package/package.json

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