pierre-review 0.1.83 → 0.1.85

package/dist/api/routes/activity.js

@@ -27,6 +27,11 @@ export async function activityRoutes(app) {
         const limit = q.limit != null ? Number(q.limit) : null;
         const offset = q.offset != null ? Number(q.offset) : 0;
         const prId = q.prId != null ? Number(q.prId) : null;
+        // Bot-only feed window (days) — clamped to 1..90; only honored on the botsOnly path.
+        const botWindowDaysRaw = q.botWindowDays != null ? Number(q.botWindowDays) : null;
+        const botWindowDays = botWindowDaysRaw != null && Number.isFinite(botWindowDaysRaw)
+            ? Math.min(90, Math.max(1, Math.trunc(botWindowDaysRaw)))
+            : null;
         return getConsolidatedFeed(accountIdOf(req), {
             repoIds: parseIntList(q.repoIds),
             userIds: parseIntList(q.userIds),
@@ -36,6 +41,7 @@ export async function activityRoutes(app) {
             excludeBots: q.excludeBots === 'true',
             allowBotIds: parseIntList(q.allowBotIds),
             botsOnly: q.botsOnly === 'true',
+            botWindowDays,
         });
     });
     // Mark the Activity Feed as seen (bumps the account's server-side "seen" marker to

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

@@ -1,4 +1,5 @@
-import { addBotMuteRule, deleteBotMuteRule, getBotAnalytics, getBotVendorPrs, getBotDedupClusters, listBotMuteRules, listDetectedReviewers, resolveScopeRepoIds, setReviewerOverride, } from '../../db/queries.js';
+import { addBotMuteRule, deleteBotMuteRule, getBotAnalytics, getBotOnlyPrs, getBotVendorPrs, getBotDedupClusters, getResolvableBotThreadPrs, getResolvableBotThreadsForScope, listBotMuteRules, listDetectedReviewers, resolveScopeRepoIds, setReviewerOverride, SCOPE_RESOLVE_THREAD_CAP, } from '../../db/queries.js';
+import { resolveThreadsOnGitHub } from '../../bot-triage/resolve.js';
 import { accountIdOf } from '../plugins/auth.js';
 // Parse a comma-separated id list into a positive-int array, or null when empty/absent (so
 // the query layer treats it as "all repos"). Mirrors the parser in activity.ts.
@@ -51,14 +52,14 @@ const analyticsSchema = {
         },
     },
 };
-// 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.
+// GET /api/bot-analytics/vendor/:key/prs?window= — per-REVIEWER PR drill-down. `key` is the
+// analytics-row identity: `u<userId>` (a single reviewer) or the 'pierre' sentinel; the handler
+// parses it (anything else → 400). The window reuses the same closed enum/default as /api/bot-analytics.
 const vendorPrsSchema = {
     params: {
         type: 'object',
-        required: ['kind'],
-        properties: { kind: { type: 'string' } },
+        required: ['key'],
+        properties: { key: { type: 'string' } },
     },
     querystring: {
         type: 'object',
@@ -104,6 +105,39 @@ const ruleIdParamSchema = {
         properties: { id: { type: 'integer' } },
     },
 };
+// GET /api/bot-threads/resolvable?scope=&repoIds= — the scope-wide review list. Same
+// scope/repoIds resolution as the analytics routes (an explicit `repoIds` wins over `scope`).
+const resolvableSchema = {
+    querystring: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            scope: { type: 'string' },
+            repoIds: { type: 'string' },
+        },
+    },
+};
+// POST /api/bot-threads/resolve — the confirm-gated scope-wide resolve. `threadIds` is the
+// explicit reviewed list (required, non-empty allowed to be [] → no-op), capped at
+// SCOPE_RESOLVE_THREAD_CAP per request (the client chunks a larger selection); `repoIds` is the
+// optional scope the server re-derives eligibility against. maxItems is a hard input guard.
+const scopeResolveSchema = {
+    body: {
+        type: 'object',
+        required: ['threadIds'],
+        additionalProperties: false,
+        properties: {
+            threadIds: {
+                type: 'array',
+                items: { type: 'integer' },
+                maxItems: SCOPE_RESOLVE_THREAD_CAP,
+            },
+            // Bounded like threadIds — an account has ≤100 repos, so 500 is generous headroom; an
+            // unbounded array would only ever be a hand-crafted request heading for a DB error.
+            repoIds: { type: 'array', items: { type: 'integer' }, maxItems: SCOPE_RESOLVE_THREAD_CAP },
+        },
+    },
+};
 // 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.
@@ -139,15 +173,40 @@ export async function botTriageRoutes(app) {
         const resp = await getBotAnalytics(accountId, window, scopeRepoIds);
         return resp;
     });
-    // The per-vendor PR drill-down behind one Bot-ROI row: the PRs that automated reviewer kind
+    // The exact PR list behind the analytics totals.botOnlyPrs count — "only a bot reviewed these".
+    // Same window/scope resolution as /api/bot-analytics (a specific `repoIds` wins over `scope`) so
+    // the amber caption's number and this expandable list are computed identically and can't drift.
+    // Unbounded but small (real bot-only PRs); no pagination.
+    app.get('/api/bot-analytics/bot-only-prs', { schema: analyticsSchema }, async (req) => {
+        const { window, scope, repoIds } = req.query;
+        const accountId = accountIdOf(req);
+        const explicit = parseIntList(repoIds);
+        const scopeRepoIds = explicit ?? (scope ? await resolveScopeRepoIds(accountId, scope) : null);
+        const { window: win, prs } = await getBotOnlyPrs(accountId, window, scopeRepoIds);
+        const resp = { window: win, prs, generatedAt: new Date().toISOString() };
+        return resp;
+    });
+    // The per-REVIEWER PR drill-down behind one Bot-ROI row: the PRs that one automated reviewer
     // 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;
+    // `key` is the analytics row identity — `u<userId>` (a single reviewer) or the 'pierre' sentinel;
+    // anything else is a client bug → 400.
+    app.get('/api/bot-analytics/vendor/:key/prs', { schema: vendorPrsSchema }, async (req, reply) => {
+        const { key } = req.params;
         const { window, scope, repoIds } = req.query;
+        const m = /^u(\d+)$/.exec(key);
+        const target = m
+            ? { userId: Number(m[1]) }
+            : key === 'pierre'
+                ? { kind: 'pierre' }
+                : null;
+        if (!target) {
+            reply.status(400);
+            return { error: 'BadRequest', message: `Invalid vendor key: ${key}` };
+        }
         const accountId = accountIdOf(req);
         const explicit = parseIntList(repoIds);
         const scopeRepoIds = explicit ?? (scope ? await resolveScopeRepoIds(accountId, scope) : null);
-        const resp = await getBotVendorPrs(accountId, kind, window, scopeRepoIds);
+        const resp = await getBotVendorPrs(accountId, target, window, scopeRepoIds);
         return resp;
     });
     // Cross-bot dedup clusters for one PR (≥2 automated reviewers on the same path/line window).
@@ -182,5 +241,46 @@ export async function botTriageRoutes(app) {
         reply.status(204);
         return null;
     });
+    // The scope-wide review list: every PR with ≥1 `likely_addressed` automated-reviewer thread
+    // across the account (or a repo scope), UNCAPPED, newest-thread-first, each row carrying all
+    // its resolvable thread ids + a bot thread-state mix + `totalThreads` (the whole backlog). The
+    // client sorts / paginates / "Select all"s across pages and chunks the resolve. Read-only.
+    app.get('/api/bot-threads/resolvable', { schema: resolvableSchema }, async (req) => {
+        const { scope, repoIds } = req.query;
+        const accountId = accountIdOf(req);
+        const explicit = parseIntList(repoIds);
+        const scopeRepoIds = explicit ?? (scope ? await resolveScopeRepoIds(accountId, scope) : null);
+        const { prs, totalThreads } = await getResolvableBotThreadPrs(accountId, scopeRepoIds);
+        const resp = {
+            prs,
+            totalThreads,
+            generatedAt: new Date().toISOString(),
+        };
+        return resp;
+    });
+    // The confirm-gated scope-wide resolve. NEVER blind: the server RE-DERIVES the eligible set
+    // (owned + automated-reviewer-originated + `likely_addressed` + unresolved) ∩ the client's
+    // explicit reviewed ids, scoped to `repoIds`, then resolves each via the SAME shared helper the
+    // per-PR route + the standing auto-triage job use. An empty list is a no-op (not an error);
+    // per-thread failures are reported, not fatal. The re-derive path passes `threadIds` so the
+    // page cap is bypassed — no requested-and-eligible id is silently dropped.
+    app.post('/api/bot-threads/resolve', { schema: scopeResolveSchema }, async (req) => {
+        const { threadIds, repoIds } = req.body;
+        const accountId = accountIdOf(req);
+        if (threadIds.length === 0) {
+            const noop = { resolved: 0, failed: 0, results: [] };
+            return noop;
+        }
+        const { threads: eligible } = await getResolvableBotThreadsForScope(accountId, repoIds ?? null, threadIds);
+        const result = await resolveThreadsOnGitHub(accountId, eligible.map((t) => ({ id: t.threadId, threadNodeId: t.threadNodeId })));
+        req.log.info({
+            accountId,
+            requested: threadIds.length,
+            eligible: eligible.length,
+            resolved: result.resolved,
+            failed: result.failed,
+        }, 'scope-wide bot-thread resolve');
+        return result;
+    });
 }
 //# sourceMappingURL=bot-triage.js.map

package/dist/api/routes/repos.js

@@ -1,6 +1,6 @@
-import { getGraphqlClientFor } from '../../github/client.js';
+import { getGraphqlClientFor, graphqlTolerant } from '../../github/client.js';
 import { getAccessToken } from '../../auth/account.js';
-import { OWNER_TYPE_QUERY, REPO_ID_QUERY, REPO_SEARCH_QUERY, } from '../../github/queries.js';
+import { OWNER_TYPE_QUERY, REPO_ID_QUERY, REPO_SEARCH_QUERY, VIEWER_REPOS_QUERY, } from '../../github/queries.js';
 import { upsertRepo } from '../../sync/upsert.js';
 import { getSyncStatus, isSyncRunning, requestSyncCancel, runSyncForRepo, waitForSyncToStop, } from '../../sync/sync-manager.js';
 import { deleteRepo, getRepo, getWatchedRepoNodeIds, listRepos, setRepoInboxWatch, } from '../../db/queries.js';
@@ -188,6 +188,77 @@ export async function repoRoutes(app) {
         };
         return body;
     });
+    // First-run onboarding: the viewer's recently-active repositories, detected from their
+    // GitHub activity (recent pushes + contributions). Same token idiom as /search; already-
+    // watched repos filtered out; mapped to the picker's RepoSearchResult shape and ordered
+    // most-recently-pushed first, capped at 30. Detail comes straight from GitHub — nothing
+    // persisted. Local's broad `gh` token surfaces private + org repos; a scoped cloud token
+    // surfaces only what it can read (both are handled by the same null-tolerant merge below).
+    app.get('/api/repos/suggested', async (req, reply) => {
+        const accountId = accountIdOf(req);
+        const client = getGraphqlClientFor(await getAccessToken(accountId));
+        let resp;
+        try {
+            // Tolerate PARTIAL GraphQL errors (a scoped cloud token forbidden one sub-field answers
+            // 200 + partial data) — the null-drop merge below is built for exactly that. Only a
+            // response with NO usable data (auth failure, rate limit, network) 502s.
+            resp = await graphqlTolerant(client, VIEWER_REPOS_QUERY, {}, (errors) => req.log.warn({ errors }, 'partial viewer-repos response'));
+        }
+        catch (err) {
+            reply.status(502);
+            return {
+                error: 'GitHubError',
+                message: err instanceof Error ? err.message : 'GitHub request failed',
+            };
+        }
+        if (resp?.viewer == null)
+            return { results: [] };
+        const me = resp.viewer.login.toLowerCase();
+        const orgLogins = new Set(resp.viewer.organizations.nodes
+            .filter((o) => o != null)
+            .map((o) => o.login.toLowerCase()));
+        // Merge the two recency-ordered lists, deduping by repo node id and keeping the more
+        // recent pushedAt. Null node arrays (scoped token) and null nodes are dropped BEFORE any
+        // field read (ISO-8601 pushedAt strings compare lexically; a null pushedAt sorts last).
+        const byId = new Map();
+        const merged = [
+            ...(resp.viewer.repositories.nodes ?? []),
+            ...(resp.viewer.repositoriesContributedTo.nodes ?? []),
+        ];
+        for (const n of merged) {
+            if (n == null || typeof n.id !== 'string')
+                continue;
+            const existing = byId.get(n.id);
+            if (existing == null || (n.pushedAt ?? '') > (existing.pushedAt ?? '')) {
+                byId.set(n.id, n);
+            }
+        }
+        const watched = await getWatchedRepoNodeIds(accountId);
+        const results = [...byId.values()]
+            .filter((n) => !watched.has(n.id))
+            // Most-recently-pushed first; a missing pushedAt sorts to the bottom.
+            .sort((a, b) => (b.pushedAt ?? '').localeCompare(a.pushedAt ?? ''))
+            .slice(0, 30)
+            .map((n) => {
+            const ownerLogin = n.owner.login;
+            return {
+                githubNodeId: n.id,
+                owner: ownerLogin,
+                name: n.name,
+                fullName: n.nameWithOwner,
+                description: n.description,
+                ownerAvatarUrl: n.owner.avatarUrl,
+                stargazerCount: n.stargazerCount,
+                openPrCount: n.pullRequests.totalCount,
+                url: n.url,
+                isPrivate: n.isPrivate,
+                isOwnedOrMember: ownerLogin.toLowerCase() === me ||
+                    orgLogins.has(ownerLogin.toLowerCase()),
+            };
+        });
+        const body = { results };
+        return body;
+    });
     app.post('/api/repos', { schema: createRepoSchema }, async (req, reply) => {
         const { owner, name } = req.body;
         const accountId = accountIdOf(req);

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { execFile, execFileSync } from 'node:child_process';
-import { mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 // ── tiny ANSI helpers (degrade gracefully when not a TTY) ──────────────────
 const useColor = process.stdout.isTTY && process.env.NO_COLOR === undefined;
 const paint = (code, s) => useColor ? `[${code}m${s}` : s;
@@ -66,6 +66,11 @@ function printUsage() {
 Usage:
   pierre [options]
   pierre-review [options]
+  pierre status [options]
+
+Commands:
+  status           Your cross-repo "my turn" queue in the terminal, with
+                   clickable links (see \`pierre status --help\`)
 
 Options:
   --no-open        Don't open the browser (also honours NO_OPEN env)
@@ -98,17 +103,157 @@ function openBrowser(url) {
         /* ignore */
     });
 }
+// The default local SQLite location — a user-writable home dir, never the (possibly
+// read-only) install dir. Shared by the server boot and `pierre status`.
+function defaultLocalDbPath() {
+    return join(homedir(), '.pierre-review', 'pierre-review.sqlite');
+}
+// Fail fast with a friendly message when the GitHub CLI isn't installed / authed.
+// Both the local server boot and `pierre status` need a working `gh` token.
+function ghAuthPreCheck() {
+    try {
+        execFileSync('gh', ['auth', 'token'], { stdio: 'ignore' });
+    }
+    catch {
+        console.error('');
+        console.error(bold('GitHub CLI not found or not authenticated.'));
+        console.error('Install the GitHub CLI (https://cli.github.com) and run `gh auth login`.');
+        console.error('');
+        process.exit(1);
+    }
+}
+function parseStatusArgs(argv) {
+    const opts = {
+        watch: false,
+        sync: false,
+        intervalSeconds: 60,
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        switch (arg) {
+            case '--watch':
+                opts.watch = true;
+                break;
+            case '--sync':
+                opts.sync = true;
+                break;
+            case '--interval': {
+                const v = argv[++i];
+                const n = v ? Number.parseInt(v, 10) : NaN;
+                if (!Number.isFinite(n)) {
+                    console.error('--interval requires a number of seconds');
+                    process.exit(1);
+                }
+                opts.intervalSeconds = Math.max(10, n);
+                break;
+            }
+            case '--db': {
+                const v = argv[++i];
+                if (!v) {
+                    console.error('--db requires a path');
+                    process.exit(1);
+                }
+                opts.db = v;
+                break;
+            }
+            case '--help':
+            case '-h':
+                opts.help = true;
+                break;
+            default:
+                console.error(`Unknown argument: ${arg}`);
+                console.error('Run `pierre status --help` for usage.');
+                process.exit(1);
+        }
+    }
+    return opts;
+}
+function printStatusUsage() {
+    console.log(`pierre status — your cross-repo "my turn" queue in the terminal
+
+Usage:
+  pierre status [options]
+
+Options:
+  --sync           Fetch fresh state from GitHub first (otherwise shows data as of
+                   the last sync). Under --watch, re-syncs at most every 5 minutes.
+  --watch          Repaint on an interval until you quit (Ctrl-C)
+  --interval <n>   Seconds between repaints under --watch (default 60, min 10)
+  --db <path>      SQLite DB path (also DATABASE_URL env)
+  -h, --help       Show this help
+
+Reads the local pierre database. Without --sync it shows data as of the last sync
+— run it alongside \`pierre\`, or pass --sync to fetch fresh state first. Links are
+clickable in terminals that support OSC-8 hyperlinks.
+`);
+}
+async function runStatusCommand(argv) {
+    const opts = parseStatusArgs(argv);
+    if (opts.help) {
+        printStatusUsage();
+        process.exit(0);
+    }
+    // status is LOCAL-only — it reads your on-disk SQLite database directly.
+    if (process.env.DEPLOYMENT_MODE === 'cloud') {
+        console.error('`pierre status` is local-only — it reads your local SQLite database.');
+        process.exit(1);
+    }
+    // Pin local BEFORE the dynamic import: config.ts loads .env files on import, and
+    // process.loadEnvFile never overrides an already-set var — so an .env-declared
+    // DEPLOYMENT_MODE=cloud can't flip status onto the Postgres driver after the guard.
+    process.env.DEPLOYMENT_MODE = 'local';
+    // ── map flags → env BEFORE any dynamic import (config/db snapshot env on load) ──
+    // resolve() the --db flag against the CWD (what the user means by a relative path);
+    // config.ts resolves relative paths against the INSTALL dir, so an unresolved value
+    // would make this guard check one file while the DB opens another.
+    process.env.NODE_ENV ??= 'production';
+    if (opts.db !== undefined)
+        process.env.DATABASE_URL = resolve(opts.db);
+    if (!process.env.DATABASE_URL)
+        process.env.DATABASE_URL = defaultLocalDbPath();
+    try {
+        mkdirSync(dirname(process.env.DATABASE_URL), { recursive: true });
+    }
+    catch {
+        /* best-effort; client.ts also mkdirs */
+    }
+    // Friendlier than the server path: don't silently create an empty DB just to show
+    // an empty queue. --sync legitimately bootstraps a fresh DB, so skip the guard then.
+    if (!opts.sync && !existsSync(process.env.DATABASE_URL)) {
+        console.error(`No pierre database found at ${process.env.DATABASE_URL} — run \`pierre\` first to sync, or pass --db.`);
+        process.exit(1);
+    }
+    // ensureLocalAccount (`gh api user`) and --sync both need a working gh token.
+    ghAuthPreCheck();
+    const { runStatus } = await import('./status.js');
+    await runStatus({
+        watch: opts.watch,
+        sync: opts.sync,
+        intervalSeconds: opts.intervalSeconds,
+    });
+}
 async function main() {
-    const opts = parseArgs(process.argv.slice(2));
+    const argv = process.argv.slice(2);
+    // `pierre status` — a read-only subcommand with its own parser, usage, and env
+    // mapping. Peeled off BEFORE parseArgs (whose default case rejects any bare token),
+    // and it never reaches the server boot below.
+    if (argv[0] === 'status') {
+        await runStatusCommand(argv.slice(1));
+        return;
+    }
+    const opts = parseArgs(argv);
     if (opts.help) {
         printUsage();
         process.exit(0);
     }
     // ── map flags → env BEFORE importing config/app (config reads these) ──────
+    // --db is resolved against the CWD (config.ts resolves relative paths against the
+    // install dir, which is never what a user typing a relative path means).
     if (opts.port !== undefined)
         process.env.PORT = String(opts.port);
     if (opts.db !== undefined)
-        process.env.DATABASE_URL = opts.db;
+        process.env.DATABASE_URL = resolve(opts.db);
     if (opts.open === false)
         process.env.NO_OPEN = '1';
     if (opts.cloud)
@@ -120,8 +265,7 @@ async function main() {
         // ── local: default the DB to a user-writable home location (mkdir -p) ────
         // The package dir is read-only for global installs, so never write there.
         if (!process.env.DATABASE_URL) {
-            const dbPath = join(homedir(), '.pierre-review', 'pierre-review.sqlite');
-            process.env.DATABASE_URL = dbPath;
+            process.env.DATABASE_URL = defaultLocalDbPath();
         }
         try {
             mkdirSync(dirname(process.env.DATABASE_URL), { recursive: true });
@@ -130,16 +274,7 @@ async function main() {
             /* best-effort; client.ts also mkdirs */
         }
         // ── pre-check gh auth with a friendly message (contract §6) ─────────────
-        try {
-            execFileSync('gh', ['auth', 'token'], { stdio: 'ignore' });
-        }
-        catch {
-            console.error('');
-            console.error(bold('GitHub CLI not found or not authenticated.'));
-            console.error('Install the GitHub CLI (https://cli.github.com) and run `gh auth login`.');
-            console.error('');
-            process.exit(1);
-        }
+        ghAuthPreCheck();
     }
     // Cloud mode: no gh pre-check (each account brings its own OAuth token) and no
     // SQLite home default (DATABASE_URL must be a Postgres URL). config.ts /

package/dist/db/migrations/0033_thread_addressed_confidence.sql

@@ -0,0 +1,9 @@
+-- Part A: deterministic "was this thread addressed?" upgrade. Store a graded addressed-confidence
+-- + a machine reason tag + who resolved the thread, alongside the existing derivedState. All
+-- additive (defaulted / nullable) so the backfill is a no-op — the next sync recomputes them.
+-- The Postgres baseline is regenerated separately via `pnpm db:generate:pg`.
+ALTER TABLE `review_threads` ADD `addressed_confidence` text DEFAULT 'none' NOT NULL;
+--> statement-breakpoint
+ALTER TABLE `review_threads` ADD `addressed_reason` text;
+--> statement-breakpoint
+ALTER TABLE `review_threads` ADD `resolved_by_login` text;

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

@@ -232,6 +232,13 @@
       "when": 1783820880005,
       "tag": "0032_benchmark_contributions",
       "breakpoints": true
+    },
+    {
+      "idx": 33,
+      "version": "6",
+      "when": 1784200000000,
+      "tag": "0033_thread_addressed_confidence",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/migrations-pg/0020_majestic_edwin_jarvis.sql

@@ -0,0 +1,3 @@
+ALTER TABLE "review_threads" ADD COLUMN "addressed_confidence" text DEFAULT 'none' NOT NULL;--> statement-breakpoint
+ALTER TABLE "review_threads" ADD COLUMN "addressed_reason" text;--> statement-breakpoint
+ALTER TABLE "review_threads" ADD COLUMN "resolved_by_login" text;