pierre-review 0.1.71 → 0.1.73

package/dist/api/routes/bot-triage.js

@@ -0,0 +1,161 @@
+import { addBotMuteRule, deleteBotMuteRule, getBotAnalytics, getBotVendorPrs, getBotDedupClusters, listBotMuteRules, listDetectedReviewers, setReviewerOverride, } from '../../db/queries.js';
+import { accountIdOf } from '../plugins/auth.js';
+// PATCH /api/bot-reviewers/:userId — the two-way manual override. `kind`/`label` are left as
+// open strings (nullable) rather than an enum: AutomatedReviewerKind is defined in the
+// types-only shared package the backend can't import at runtime, and the query layer coerces
+// an unknown kind to a sensible default, so pinning the vendor list here would only add drift.
+const overrideSchema = {
+    params: {
+        type: 'object',
+        required: ['userId'],
+        properties: { userId: { type: 'integer' } },
+    },
+    body: {
+        type: 'object',
+        required: ['automated'],
+        additionalProperties: false,
+        properties: {
+            automated: { type: 'boolean' },
+            kind: { type: ['string', 'null'] },
+            label: { type: ['string', 'null'] },
+        },
+    },
+};
+// GET /api/bot-analytics?window= — the window is a closed 4-value set, safe to enum + default.
+const analyticsSchema = {
+    querystring: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            window: {
+                type: 'string',
+                enum: ['rolling_7', 'rolling_14', 'rolling_30', 'sprint'],
+                default: 'rolling_14',
+            },
+        },
+    },
+};
+// GET /api/bot-analytics/:kind/prs?window= — per-vendor PR drill-down. `kind` is left an open
+// string (AutomatedReviewerKind is types-only shared, unimportable at runtime; the query layer
+// coerces an unknown kind); the window reuses the same closed enum/default as /api/bot-analytics.
+const vendorPrsSchema = {
+    params: {
+        type: 'object',
+        required: ['kind'],
+        properties: { kind: { type: 'string' } },
+    },
+    querystring: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            window: {
+                type: 'string',
+                enum: ['rolling_7', 'rolling_14', 'rolling_30', 'sprint'],
+                default: 'rolling_14',
+            },
+        },
+    },
+};
+const prIdParamSchema = {
+    params: {
+        type: 'object',
+        required: ['id'],
+        properties: { id: { type: 'integer' } },
+    },
+};
+// POST /api/bot-mute-rules — `action` is a closed enum; `autoResolveDays` is floored at 1 so a
+// 0/negative-day auto-resolve rule (which would immediately clear everything) is rejected.
+const muteRuleSchema = {
+    body: {
+        type: 'object',
+        required: ['action'],
+        additionalProperties: false,
+        properties: {
+            vendorKind: { type: ['string', 'null'] },
+            pathGlob: { type: ['string', 'null'] },
+            severity: { type: ['string', 'null'] },
+            action: { type: 'string', enum: ['hide', 'auto_resolve'] },
+            autoResolveDays: { type: ['integer', 'null'], minimum: 1, maximum: 365 },
+        },
+    },
+};
+const ruleIdParamSchema = {
+    params: {
+        type: 'object',
+        required: ['id'],
+        properties: { id: { type: 'integer' } },
+    },
+};
+// Bot-triage platform routes (CORE, always registered). Detection/override, ROI analytics,
+// per-PR cross-bot dedup, and the mute / auto-triage rule store. Every handler is account-
+// scoped via accountIdOf(req); id-addressed reads/writes verify ownership → 404. No AI.
+export async function botTriageRoutes(app) {
+    // Every distinct reviewer in the account (human + automated), classified, with 90-day
+    // volume + a sample body — powers the Settings "Review bots" detected-reviewers table.
+    app.get('/api/bot-reviewers', async (req) => {
+        const resp = await listDetectedReviewers(accountIdOf(req));
+        return resp;
+    });
+    // Two-way manual override: force a reviewer automated (with kind/label) or back to human.
+    // Upserts a source='manual' classification the auto resolver never overwrites. 404 when the
+    // user id is unknown to this account's synced data.
+    app.patch('/api/bot-reviewers/:userId', { schema: overrideSchema }, async (req, reply) => {
+        const { userId } = req.params;
+        const body = req.body;
+        const classification = await setReviewerOverride(accountIdOf(req), userId, body);
+        if (!classification) {
+            reply.status(404);
+            return { error: 'NotFound', message: `Reviewer ${userId} not found` };
+        }
+        return classification;
+    });
+    // Bot ROI / utilisation over a window (default rolling_14): per-vendor threads/acted-on/
+    // untouched + verdict + trend + deterministic tuning suggestions. Cost fields are null here
+    // (the client overlays per-vendor cost from Pro settings).
+    app.get('/api/bot-analytics', { schema: analyticsSchema }, async (req) => {
+        const { window } = req.query;
+        const resp = await getBotAnalytics(accountIdOf(req), window);
+        return resp;
+    });
+    // The per-vendor PR drill-down behind one Bot-ROI row: the PRs that automated reviewer kind
+    // touched in the window (threads/comments/acted-on/untouched/bot-only), newest-activity first.
+    app.get('/api/bot-analytics/:kind/prs', { schema: vendorPrsSchema }, async (req) => {
+        const { kind } = req.params;
+        const { window } = req.query;
+        const resp = await getBotVendorPrs(accountIdOf(req), kind, window);
+        return resp;
+    });
+    // Cross-bot dedup clusters for one PR (≥2 automated reviewers on the same path/line window).
+    // Ownership-scoped → 404 for a PR this account doesn't own.
+    app.get('/api/prs/:id/bot-dedup', { schema: prIdParamSchema }, async (req, reply) => {
+        const { id } = req.params;
+        const resp = await getBotDedupClusters(id, accountIdOf(req));
+        if (!resp) {
+            reply.status(404);
+            return { error: 'NotFound', message: `PR ${id} not found` };
+        }
+        return resp;
+    });
+    // The account's mute / auto-triage rules.
+    app.get('/api/bot-mute-rules', async (req) => {
+        const rules = await listBotMuteRules(accountIdOf(req));
+        const resp = { rules };
+        return resp;
+    });
+    app.post('/api/bot-mute-rules', { schema: muteRuleSchema }, async (req) => {
+        const input = req.body;
+        const rule = await addBotMuteRule(accountIdOf(req), input);
+        return rule;
+    });
+    app.delete('/api/bot-mute-rules/:id', { schema: ruleIdParamSchema }, async (req, reply) => {
+        const { id } = req.params;
+        const ok = await deleteBotMuteRule(accountIdOf(req), id);
+        if (!ok) {
+            reply.status(404);
+            return { error: 'NotFound', message: `Mute rule ${id} not found` };
+        }
+        reply.status(204);
+        return null;
+    });
+}
+//# sourceMappingURL=bot-triage.js.map

package/dist/api/routes/prs.js

@@ -2,11 +2,12 @@ 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, getUsersByLogins, markAllViewed, markPrMergedLocally, markPrViewed, upsertLocalPrComment, upsertLocalReview, } from '../../db/queries.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 { 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';
+import { resolveThreadsOnGitHub } from '../../bot-triage/resolve.js';
 import { accountIdOf } from '../plugins/auth.js';
 // GitHub anchors a file in the PR "Files changed" diff by the SHA-256 of its
 // path (matches db/queries.ts + hydrate-detail.ts's diffAnchorId).
@@ -94,6 +95,19 @@ const approveSchema = {
         properties: { body: { type: 'string' } },
     },
 };
+const resolveBotThreadsSchema = {
+    ...idParamSchema,
+    body: {
+        type: 'object',
+        required: ['threadIds'],
+        additionalProperties: false,
+        properties: {
+            // minItems: 1 rejects `{threadIds: []}` with a 400 — a destructive endpoint should
+            // never be invoked with an empty selection (defence-in-depth with getResolvableBotThreads).
+            threadIds: { type: 'array', items: { type: 'integer' }, minItems: 1, maxItems: 200 },
+        },
+    },
+};
 const mergeSchema = {
     ...idParamSchema,
     body: {
@@ -276,6 +290,25 @@ export async function prRoutes(app) {
         }
         return { status: 'ok' };
     });
+    // Bulk-resolve the review-BOT threads a later commit has likely addressed — Pierre's
+    // "clear the bot backlog in one click." NEVER automatic: the client sends the explicit
+    // reviewed list of thread ids; the server RE-DERIVES the eligible set (owned + bot-
+    // originated + `likely_addressed`), intersects it with that list, and resolves only that
+    // — so a stale client can never resolve a thread the server wouldn't itself offer. Each
+    // thread is resolved on GitHub + locally stamped; per-thread failures are reported, not fatal.
+    app.post('/api/prs/:id/resolve-bot-threads', { schema: resolveBotThreadsSchema }, async (req) => {
+        const { id } = req.params;
+        const { threadIds } = req.body;
+        const accountId = accountIdOf(req);
+        // Server RE-DERIVES the eligible set (owned + automated-reviewer-originated +
+        // `likely_addressed` + unresolved) ∩ the client's reviewed list, then resolves each via
+        // the shared helper (the SAME code path the standing auto-triage job uses). An empty
+        // eligible set — PR not owned / no such threads / a fully-stale client list — is a no-op,
+        // not an error (the helper short-circuits before any token fetch). Status stays 200 even
+        // on partial failure; the body carries per-thread outcomes.
+        const eligible = await getResolvableBotThreads(id, accountId, threadIds);
+        return resolveThreadsOnGitHub(accountId, eligible);
+    });
     // Post a new issue-level (general) PR comment, then optimistically stamp it
     // locally so it shows before the next sync.
     app.post('/api/prs/:id/comment', { schema: commentSchema }, async (req, reply) => {

package/dist/app.js

@@ -20,6 +20,7 @@ import { mergersRoutes } from './api/routes/mergers.js';
 import { insightsRoutes } from './api/routes/insights.js';
 import { activityRoutes } from './api/routes/activity.js';
 import { billingRoutes } from './api/routes/billing.js';
+import { botTriageRoutes } from './api/routes/bot-triage.js';
 export async function buildApp() {
     const app = Fastify({
         // In production (the installed CLI) the per-request "incoming request" /
@@ -132,6 +133,9 @@ export async function buildApp() {
     await app.register(mergersRoutes);
     await app.register(insightsRoutes);
     await app.register(activityRoutes);
+    // Bot-triage platform (CORE, always registered): detection/override, ROI analytics,
+    // cross-bot dedup, mute / auto-triage rules. Account-scoped; no AI.
+    await app.register(botTriageRoutes);
     // Stripe billing seam (checkout redirect + webhook). Registered in both modes;
     // inert until the STRIPE_* env vars are set (webhook 501s unconfigured).
     await app.register(billingRoutes);

package/dist/bot-triage/auto-triage.js

@@ -0,0 +1,63 @@
+import { eq } from 'drizzle-orm';
+import { config } from '../config.js';
+import { db, schema } from '../db/client.js';
+import { getAutoResolveCandidates, getResolvableBotThreads } from '../db/queries.js';
+import { resolveThreadsOnGitHub } from './resolve.js';
+const { botMuteRules } = schema;
+// Accounts that have at least one standing `auto_resolve` rule. The sweep only touches
+// these — with zero rules the whole feature is inert (this returns []). Distinct, portable.
+async function accountsWithAutoResolveRules() {
+    const rows = await db
+        .select({ accountId: botMuteRules.accountId })
+        .from(botMuteRules)
+        .where(eq(botMuteRules.action, 'auto_resolve'))
+        .groupBy(botMuteRules.accountId)
+        .execute();
+    return rows.map((r) => r.accountId);
+}
+// Standing bot auto-triage sweep (CORE, deterministic, rule-gated). Registered on a cron by
+// the scheduler; runs local + cloud. For each account with an `auto_resolve` rule it asks the
+// engine for the candidate threads (rule-gated by vendor/path/severity AND age > rule.days,
+// only `likely_addressed` + unresolved), RE-DERIVES eligibility exactly as the manual route
+// does (`getResolvableBotThreads` → owned + automated-originated + `likely_addressed` +
+// unresolved + node id, mapped to node ids), then resolves each via the SHARED helper.
+//
+// Guardrails (all load-bearing): opt-in (inert with zero rules); only `likely_addressed`;
+// age-gated; NEVER a merge (resolve only); a structured pino line per resolved thread; errors
+// caught per-account so one bad token doesn't abort the sweep, and per-thread inside the
+// shared helper so one bad thread doesn't abort the account. Undoable = unresolve on GitHub
+// (no local hard state beyond the derivedState the next sync recomputes).
+export async function runAutoTriageSweep(log) {
+    // Defensive: the scheduler only schedules this when scheduling is enabled, but honour the
+    // gate directly too so a stray caller can never bypass it.
+    if (config.disableScheduler)
+        return;
+    const accountIds = await accountsWithAutoResolveRules();
+    if (accountIds.length === 0)
+        return;
+    for (const accountId of accountIds) {
+        try {
+            const candidates = await getAutoResolveCandidates(accountId);
+            for (const { prId, threadIds } of candidates) {
+                // Re-derive from scratch — the candidate set is rule/age-gated; this maps thread ids to
+                // GitHub node ids AND re-confirms the (owned + automated + likely_addressed + unresolved)
+                // predicate, so a thread whose state changed since the candidate query is dropped.
+                const eligible = await getResolvableBotThreads(prId, accountId, threadIds);
+                if (eligible.length === 0)
+                    continue;
+                const result = await resolveThreadsOnGitHub(accountId, eligible);
+                for (const r of result.results) {
+                    if (r.ok)
+                        log.info({ accountId, prId, threadId: r.threadId }, 'bot auto-resolved');
+                    else
+                        log.warn({ accountId, prId, threadId: r.threadId }, 'bot auto-resolve failed');
+                }
+            }
+        }
+        catch (err) {
+            // One account's failure (e.g. an expired/absent token) must not abort the others.
+            log.error({ err, accountId }, 'bot auto-triage sweep failed for account');
+        }
+    }
+}
+//# sourceMappingURL=auto-triage.js.map

package/dist/bot-triage/resolve.js

@@ -0,0 +1,37 @@
+import { getAccessToken } from '../auth/account.js';
+import { setReviewThreadResolved } from '../github/mutations.js';
+import { stampThreadResolved } from '../db/queries.js';
+// Resolve a batch of already-eligible review threads on GitHub AND stamp them resolved
+// locally. This is the ONE place the GitHub `resolveReviewThread` mutation is driven for
+// bot-thread triage — shared verbatim by BOTH the manual `POST /api/prs/:id/resolve-bot-
+// threads` route and the standing auto-triage scheduled job, so their behaviour can't drift.
+//
+// Callers own eligibility: both `getResolvableBotThreads` and `getAutoResolveCandidates`
+// return ONLY owned + automated-reviewer-originated + `likely_addressed` + unresolved threads
+// (with a GitHub node id), so this helper never has to re-derive it. It NEVER merges — it only
+// resolves. Sequential (not Promise.all) to stay gentle on the GraphQL rate limit (a bot
+// backlog is a handful of threads); per-thread try/catch so one bad thread or a moved head
+// never aborts the batch. The token is fetched once per batch from the OWNING account, so a
+// bad/absent token throws BEFORE the loop — the caller (route or job) decides how to surface it.
+export async function resolveThreadsOnGitHub(accountId, threads) {
+    const out = { resolved: 0, failed: 0, results: [] };
+    // Empty selection → a no-op (never even fetch a token) — matches the manual route's
+    // "stale client list / no eligible threads is a no-op, not an error" contract.
+    if (threads.length === 0)
+        return out;
+    const token = await getAccessToken(accountId);
+    for (const t of threads) {
+        try {
+            await setReviewThreadResolved(token, t.threadNodeId, true);
+            const derivedState = await stampThreadResolved(t.id, true, accountId);
+            out.results.push({ threadId: t.id, ok: true, derivedState: derivedState ?? 'resolved' });
+            out.resolved += 1;
+        }
+        catch {
+            out.results.push({ threadId: t.id, ok: false, derivedState: null });
+            out.failed += 1;
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=resolve.js.map

package/dist/db/migrations/0027_user_github_type.sql

@@ -0,0 +1,6 @@
+-- Bot-Triage Platform (WS1): capture the GitHub GraphQL __typename of an actor
+-- ('Bot' | 'User' | 'Organization' | …) on the global users table. Plain text (no
+-- enum — the __typename set varies), nullable. A 'Bot' typename is a hard
+-- automated-reviewer signal for the classifier. users stays GLOBAL (no account_id).
+-- The Postgres baseline is regenerated separately via `pnpm db:generate:pg`.
+ALTER TABLE `users` ADD `github_type` text;

package/dist/db/migrations/0028_bot_review_classification.sql

@@ -0,0 +1,21 @@
+-- Bot-Triage Platform (WS1): account-scoped classification cache for automated
+-- reviewers. One row per (account, author); AUTO rows written by the layered resolver,
+-- MANUAL rows (source='manual') by the override route and never overwritten by auto.
+-- Merged with the global vendor login map on read. Account-scoped isolation.
+-- The Postgres baseline is regenerated separately via `pnpm db:generate:pg`.
+CREATE TABLE `bot_review_classification` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`author_user_id` integer NOT NULL,
+	`automated` integer NOT NULL,
+	`kind` text,
+	`label` text,
+	`confidence` text NOT NULL,
+	`source` text NOT NULL,
+	`reasons_json` text,
+	`updated_at` integer DEFAULT (unixepoch()) NOT NULL,
+	FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON UPDATE no action ON DELETE no action,
+	FOREIGN KEY (`author_user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `brc_account_author` ON `bot_review_classification` (`account_id`,`author_user_id`);

package/dist/db/migrations/0029_bot_mute_rules.sql

@@ -0,0 +1,19 @@
+-- Bot-Triage Platform (WS6): account-scoped mute / auto-triage rules. A rule matches
+-- automated-reviewer threads by vendor_kind × path_glob × severity (null = any) and
+-- either 'hide's them from the noise counts/feed or (with auto_resolve_days) marks
+-- likely_addressed threads older than N days for the standing auto-resolve job.
+-- Account-scoped isolation. The Postgres baseline is regenerated separately via
+-- `pnpm db:generate:pg`.
+CREATE TABLE `bot_mute_rules` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`account_id` integer NOT NULL,
+	`vendor_kind` text,
+	`path_glob` text,
+	`severity` text,
+	`action` text NOT NULL,
+	`auto_resolve_days` integer,
+	`created_at` integer DEFAULT (unixepoch()) NOT NULL,
+	FOREIGN KEY (`account_id`) REFERENCES `accounts`(`id`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE INDEX `bmr_account_idx` ON `bot_mute_rules` (`account_id`);

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

@@ -190,6 +190,27 @@
       "when": 1783382400000,
       "tag": "0026_ai_credit_allowance",
       "breakpoints": true
+    },
+    {
+      "idx": 27,
+      "version": "6",
+      "when": 1783820880000,
+      "tag": "0027_user_github_type",
+      "breakpoints": true
+    },
+    {
+      "idx": 28,
+      "version": "6",
+      "when": 1783820880001,
+      "tag": "0028_bot_review_classification",
+      "breakpoints": true
+    },
+    {
+      "idx": 29,
+      "version": "6",
+      "when": 1783820880002,
+      "tag": "0029_bot_mute_rules",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/migrations-pg/0016_cute_ghost_rider.sql

@@ -0,0 +1,30 @@
+CREATE TABLE "bot_mute_rules" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"account_id" integer NOT NULL,
+	"vendor_kind" text,
+	"path_glob" text,
+	"severity" text,
+	"action" text NOT NULL,
+	"auto_resolve_days" integer,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "bot_review_classification" (
+	"id" serial PRIMARY KEY NOT NULL,
+	"account_id" integer NOT NULL,
+	"author_user_id" integer NOT NULL,
+	"automated" boolean NOT NULL,
+	"kind" text,
+	"label" text,
+	"confidence" text NOT NULL,
+	"source" text NOT NULL,
+	"reasons_json" jsonb,
+	"updated_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+ALTER TABLE "users" ADD COLUMN "github_type" text;--> statement-breakpoint
+ALTER TABLE "bot_mute_rules" ADD CONSTRAINT "bot_mute_rules_account_id_accounts_id_fk" FOREIGN KEY ("account_id") REFERENCES "public"."accounts"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "bot_review_classification" ADD CONSTRAINT "bot_review_classification_account_id_accounts_id_fk" FOREIGN KEY ("account_id") REFERENCES "public"."accounts"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "bot_review_classification" ADD CONSTRAINT "bot_review_classification_author_user_id_users_id_fk" FOREIGN KEY ("author_user_id") REFERENCES "public"."users"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "bmr_account_idx" ON "bot_mute_rules" USING btree ("account_id");--> statement-breakpoint
+CREATE UNIQUE INDEX "brc_account_author" ON "bot_review_classification" USING btree ("account_id","author_user_id");