pierre-review 0.1.23 → 0.1.25

package/dist/api/routes/insights.js

@@ -1,4 +1,4 @@
-import { getInsights } from '../../db/queries.js';
+import { getInsights, getRepoAnalytics } from '../../db/queries.js';
 import { accountIdOf } from '../plugins/auth.js';
 function parseIntList(raw) {
     if (!raw)
@@ -19,5 +19,17 @@ export async function insightsRoutes(app) {
             repoIds: parseIntList(q.repoIds),
         });
     });
+    // Heavier per-repo analytics for the drill-down chart panel — loaded on demand.
+    // Ownership-scoped: a repo not owned by the account 404s.
+    app.get('/api/insights/:repoId/analytics', async (req, reply) => {
+        const { repoId } = req.params;
+        const id = Number.parseInt(repoId, 10);
+        const data = Number.isFinite(id)
+            ? await getRepoAnalytics(accountIdOf(req), id)
+            : null;
+        if (!data)
+            return reply.code(404).send({ error: 'repo not found' });
+        return data;
+    });
 }
 //# sourceMappingURL=insights.js.map

package/dist/api/routes/me.js

@@ -8,7 +8,10 @@ const dismissSchema = {
         required: ['kind', 'refId'],
         additionalProperties: false,
         properties: {
-            kind: { type: 'string', enum: ['review_request', 'thread'] },
+            kind: {
+                type: 'string',
+                enum: ['review_request', 'thread', 'watched_repo_pr', 'claude_review'],
+            },
             refId: { type: 'integer' },
         },
     },
@@ -23,6 +26,7 @@ export async function meRoutes(app) {
                 awaitingReview: myTurn.awaitingReview.length,
                 yourPrsActivity: myTurn.yourPrs.length,
                 threadsAwaiting: myTurn.threadsAwaiting.length,
+                watchedRepoPrs: myTurn.watchedRepoPrs.length,
                 claudeReviewsToAction: myTurn.claudeReviewsToAction.length,
             },
             claudeReviewEnabled: config.claudeReviewEnabled,
@@ -35,7 +39,8 @@ export async function meRoutes(app) {
         await dismissMyTurn(accountIdOf(req), kind, refId);
         return { status: 'ok' };
     });
-    // The "Done" tab: entries dismissed in the past 90 days (review_request + thread).
+    // The "Done" tab: entries dismissed in the past 90 days (review_request + thread
+    // + claude_review).
     app.get('/api/my-turn/done', async (req) => getCompletedDismissals(accountIdOf(req), 90));
     // Un-dismiss: move a completed entry back to the inbox.
     app.post('/api/my-turn/undismiss', { schema: dismissSchema }, async (req) => {

package/dist/api/routes/repos.js

@@ -1,9 +1,9 @@
 import { getGraphqlClientFor } from '../../github/client.js';
 import { getAccessToken } from '../../auth/account.js';
-import { REPO_ID_QUERY, REPO_SEARCH_QUERY, } from '../../github/queries.js';
+import { OWNER_TYPE_QUERY, REPO_ID_QUERY, REPO_SEARCH_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, } from '../../db/queries.js';
+import { deleteRepo, getRepo, getWatchedRepoNodeIds, listRepos, setRepoInboxWatch, } from '../../db/queries.js';
 import { accountIdOf } from '../plugins/auth.js';
 // Local copy of the shared MAX_REPOS_PER_ACCOUNT value. `@pierre-review/shared` is
 // a types-only package (not shipped in the published tarball), so the backend must
@@ -17,6 +17,9 @@ const createRepoSchema = {
         properties: {
             owner: { type: 'string', minLength: 1 },
             name: { type: 'string', minLength: 1 },
+            // When true, also Watch the repo for the inbox on add (the picker passes
+            // true for "yours" repos). Optional; defaults to not-watched.
+            watch: { type: 'boolean' },
         },
     },
 };
@@ -27,6 +30,15 @@ const idParamSchema = {
         properties: { id: { type: 'integer' } },
     },
 };
+const watchSchema = {
+    ...idParamSchema,
+    body: {
+        type: 'object',
+        required: ['inboxWatch'],
+        additionalProperties: false,
+        properties: { inboxWatch: { type: 'boolean' } },
+    },
+};
 const syncSchema = {
     ...idParamSchema,
     querystring: {
@@ -60,13 +72,50 @@ export async function repoRoutes(app) {
             return { error: 'BadRequest', message: 'Search query must not be empty' };
         }
         const accountId = accountIdOf(req);
+        // Translate the user term into a literal GitHub search query. An `owner/...`
+        // prefix scopes results to that owner (org:/user: qualifier — resolved by type);
+        // the remainder (or the whole term) is matched against the repo NAME only
+        // (`in:name`), and `needle` drives the literal re-rank below.
+        const client = getGraphqlClientFor(await getAccessToken(accountId));
+        const slash = term.indexOf('/');
+        const owner = slash >= 0 ? term.slice(0, slash).trim() : '';
+        const rest = slash >= 0 ? term.slice(slash + 1).trim() : term;
+        let searchQuery;
+        let needle;
+        if (owner) {
+            // `owner/...` → scope to that owner. Note a stray leading slash ("/foo") leaves
+            // owner empty and falls through to the plain branch (no malformed `user:` query).
+            needle = rest;
+            let qualifier = `user:${owner}`;
+            try {
+                const ownerResp = await client(OWNER_TYPE_QUERY, {
+                    login: owner,
+                });
+                const kind = ownerResp.repositoryOwner?.__typename ?? null;
+                if (kind == null) {
+                    // Owner login doesn't exist → no possible matches.
+                    return { results: [], hasNextPage: false, cursor: null };
+                }
+                qualifier = kind === 'Organization' ? `org:${owner}` : `user:${owner}`;
+            }
+            catch (err) {
+                // Lookup failed (network / rate limit) — default to user: scoping and run the
+                // search anyway. Logged so a wrong-scope result is diagnosable.
+                req.log.warn({ err, owner }, 'repo search: owner-type lookup failed; defaulting to user: scope');
+            }
+            searchQuery = rest ? `${qualifier} ${rest} in:name` : qualifier;
+        }
+        else {
+            // Plain term (or a stray leading slash) → literal repo-name search.
+            needle = rest;
+            searchQuery = rest ? `${rest} in:name` : term;
+        }
         let resp;
         try {
-            const client = getGraphqlClientFor(await getAccessToken(accountId));
             // NB: the GraphQL variable is `searchQuery`, not `query` — @octokit/graphql
             // reserves `query` for the document body and rejects it as a variable name.
             resp = await client(REPO_SEARCH_QUERY, {
-                searchQuery: term,
+                searchQuery,
                 first: limit,
                 cursor: cursor ?? null,
             });
@@ -103,9 +152,31 @@ export async function repoRoutes(app) {
                     orgLogins.has(ownerLogin.toLowerCase()),
             };
         });
-        // Float owned/member repos to the top, preserving GitHub's best-match order
-        // within each group (Array.prototype.sort is stable on Node ≥ 12).
-        results.sort((a, b) => Number(b.isOwnedOrMember) - Number(a.isOwnedOrMember));
+        // Re-rank for literal matching: closest name match first (exact < prefix <
+        // substring < other), then your own/org repos, then stars. Array.prototype.sort
+        // is stable (Node ≥ 12), so GitHub's best-match order breaks remaining ties.
+        const lc = needle.toLowerCase();
+        const nameTier = (name) => {
+            if (!lc)
+                return 0;
+            const n = name.toLowerCase();
+            if (n === lc)
+                return 0;
+            if (n.startsWith(lc))
+                return 1;
+            if (n.includes(lc))
+                return 2;
+            return 3;
+        };
+        results.sort((a, b) => {
+            const t = nameTier(a.name) - nameTier(b.name);
+            if (t !== 0)
+                return t;
+            const own = Number(b.isOwnedOrMember) - Number(a.isOwnedOrMember);
+            if (own !== 0)
+                return own;
+            return b.stargazerCount - a.stargazerCount;
+        });
         const body = {
             results,
             hasNextPage: resp.search.pageInfo.hasNextPage,
@@ -114,7 +185,7 @@ export async function repoRoutes(app) {
         return body;
     });
     app.post('/api/repos', { schema: createRepoSchema }, async (req, reply) => {
-        const { owner, name } = req.body;
+        const { owner, name, watch } = req.body;
         const accountId = accountIdOf(req);
         let resp;
         try {
@@ -150,11 +221,28 @@ export async function repoRoutes(app) {
         const canonOwner = resp.repository.owner.login;
         const canonName = resp.repository.name;
         const repoId = await upsertRepo(canonOwner, canonName, resp.repository.id, null, accountId);
+        // Auto-watch "yours" repos for the inbox. Idempotent on re-add and preserves an
+        // existing watch-start (setRepoInboxWatch only stamps the start when unset).
+        if (watch === true)
+            await setRepoInboxWatch(accountId, repoId, true);
         // Kick off the initial backfill in the background.
         runSyncForRepo(repoId, app.log, { background: true });
         reply.status(201);
         return getRepo(repoId, accountId);
     });
+    // Toggle "Watch for inbox" on a repo. Inbox-only: it does not affect timeline
+    // visibility or syncing. Ownership-scoped → 404 for a repo this account doesn't own.
+    app.patch('/api/repos/:id', { schema: watchSchema }, async (req, reply) => {
+        const { id } = req.params;
+        const { inboxWatch } = req.body;
+        const accountId = accountIdOf(req);
+        const ok = await setRepoInboxWatch(accountId, id, inboxWatch);
+        if (!ok) {
+            reply.status(404);
+            return { error: 'NotFound', message: `Repo ${id} not found` };
+        }
+        return getRepo(id, accountId);
+    });
     app.delete('/api/repos/:id', { schema: idParamSchema }, async (req, reply) => {
         const { id } = req.params;
         const accountId = accountIdOf(req);

package/dist/db/migrations/0015_repos_inbox_watch.sql

@@ -0,0 +1,9 @@
+-- "Watch for inbox" per repo (additive). When `inbox_watch` is true, new open PRs by
+-- others (opened on/after `inbox_watch_started_at`) surface in the My Turn inbox —
+-- independent of timeline visibility and of removing the repo. `inbox_watch_started_at`
+-- is set on the first watch and preserved across unwatch, so re-watching restores the
+-- same window. Existing repos default to NOT watched (opt-in); new "yours" repos are
+-- watched on add by the picker. Postgres baseline is regenerated separately via
+-- db:generate:pg.
+ALTER TABLE `repos` ADD `inbox_watch` integer DEFAULT false NOT NULL;--> statement-breakpoint
+ALTER TABLE `repos` ADD `inbox_watch_started_at` integer;

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

@@ -106,6 +106,13 @@
       "when": 1780800000005,
       "tag": "0014_account_last_active",
       "breakpoints": true
+    },
+    {
+      "idx": 15,
+      "version": "6",
+      "when": 1780800000006,
+      "tag": "0015_repos_inbox_watch",
+      "breakpoints": true
     }
   ]
 }

package/dist/db/migrations-pg/0005_thick_blockbuster.sql

@@ -0,0 +1,2 @@
+ALTER TABLE "repos" ADD COLUMN "inbox_watch" boolean DEFAULT false NOT NULL;--> statement-breakpoint
+ALTER TABLE "repos" ADD COLUMN "inbox_watch_started_at" timestamp with time zone;