pierre-review 0.1.0

package/dist/db/run-migrations.js

@@ -0,0 +1,10 @@
+import { resolve } from 'node:path';
+import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
+import { db } from './client.js';
+const migrationsFolder = resolve(import.meta.dirname, 'migrations');
+// Apply pending migrations against the shared connection. Safe to call at
+// server startup -- does not close the connection.
+export function runMigrations() {
+    migrate(db, { migrationsFolder });
+}
+//# sourceMappingURL=run-migrations.js.map

package/dist/db/schema.js

@@ -0,0 +1,248 @@
+import { sqliteTable, text, integer, index, uniqueIndex, } from 'drizzle-orm/sqlite-core';
+import { sql } from 'drizzle-orm';
+export const repos = sqliteTable('repos', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    owner: text('owner').notNull(),
+    name: text('name').notNull(),
+    githubNodeId: text('github_node_id').notNull().unique(),
+    // The repo's default branch (GraphQL defaultBranchRef.name), captured each
+    // activity sync. Used to scope the "maintainer" inference to PRs merged into
+    // the default branch. Null until a sync populates it.
+    defaultBranch: text('default_branch'),
+    backfillUntil: integer('backfill_until', { mode: 'timestamp' }),
+    createdAt: integer('created_at', { mode: 'timestamp' })
+        .notNull()
+        .default(sql `(unixepoch())`),
+}, (t) => ({ ownerNameUx: uniqueIndex('repos_owner_name').on(t.owner, t.name) }));
+export const users = sqliteTable('users', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    githubLogin: text('github_login').notNull().unique(),
+    githubNodeId: text('github_node_id').unique(),
+    displayName: text('display_name'),
+    avatarUrl: text('avatar_url'),
+    isBot: integer('is_bot', { mode: 'boolean' }).notNull().default(false),
+    // Set when a user toggles is_bot by hand; auto-detection won't override it.
+    isBotOverridden: integer('is_bot_overridden', { mode: 'boolean' })
+        .notNull()
+        .default(false),
+});
+export const pullRequests = sqliteTable('pull_requests', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    githubNodeId: text('github_node_id').notNull().unique(),
+    repoId: integer('repo_id')
+        .notNull()
+        .references(() => repos.id),
+    number: integer('number').notNull(),
+    title: text('title').notNull(),
+    body: text('body'),
+    authorId: integer('author_id').references(() => users.id),
+    // Who actually merged the PR (GraphQL `mergedBy`), distinct from the author.
+    // Drives the "has merge rights / maintainer" inference. Null for non-merged
+    // PRs and until a (deep) sync backfills it on already-synced merged PRs.
+    mergedById: integer('merged_by_id').references(() => users.id),
+    // The branch this PR targets (GraphQL `baseRefName`). The maintainer
+    // inference only counts merges into the repo's default branch, so a merge
+    // into a feature/integration branch doesn't elevate the merger. Null until a
+    // (deep) sync backfills it on already-synced PRs.
+    baseRefName: text('base_ref_name'),
+    state: text('state', { enum: ['open', 'merged', 'closed'] }).notNull(),
+    isDraft: integer('is_draft', { mode: 'boolean' }).notNull().default(false),
+    openedAt: integer('opened_at', { mode: 'timestamp' }).notNull(),
+    firstReviewAt: integer('first_review_at', { mode: 'timestamp' }),
+    lastCommitAt: integer('last_commit_at', { mode: 'timestamp' }),
+    mergedAt: integer('merged_at', { mode: 'timestamp' }),
+    closedAt: integer('closed_at', { mode: 'timestamp' }),
+    updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull(),
+    // ---- v1.1: CI / mergeability / labels (head-commit derived) ----
+    headSha: text('head_sha'),
+    ciStatus: text('ci_status', {
+        enum: ['success', 'failure', 'pending', 'error', 'expected', 'unknown'],
+    }),
+    mergeable: text('mergeable', {
+        enum: ['mergeable', 'conflicting', 'unknown'],
+    }),
+    mergeStateStatus: text('merge_state_status', {
+        enum: [
+            'clean',
+            'dirty',
+            'unstable',
+            'blocked',
+            'behind',
+            'has_hooks',
+            'unknown',
+        ],
+    }),
+    labels: text('labels', { mode: 'json' }).$type(),
+    // Per-job CI checks on the head commit (CheckRuns + StatusContexts).
+    checkRuns: text('check_runs', { mode: 'json' }).$type(),
+}, (t) => ({
+    repoIdx: index('pr_repo_idx').on(t.repoId),
+    openedIdx: index('pr_opened_idx').on(t.openedAt),
+}));
+// Outstanding review requests on a PR. GitHub removes a request once the
+// reviewer submits, so presence here == still awaiting. Re-derived each sync
+// (delete + reinsert per PR). `userId` null for team requests (teamName set).
+export const reviewRequests = sqliteTable('review_requests', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    prId: integer('pr_id')
+        .notNull()
+        .references(() => pullRequests.id),
+    userId: integer('user_id').references(() => users.id),
+    teamName: text('team_name'),
+}, (t) => ({
+    prIdx: index('rr_pr_idx').on(t.prId),
+    userIdx: index('rr_user_idx').on(t.userId),
+}));
+// Per-PR "last viewed" state for incremental review. One row per PR.
+export const prViews = sqliteTable('pr_views', {
+    prId: integer('pr_id')
+        .primaryKey()
+        .references(() => pullRequests.id),
+    lastViewedSha: text('last_viewed_sha'),
+    lastViewedAt: integer('last_viewed_at', { mode: 'timestamp' }).notNull(),
+});
+// Manual dismissals of "my turn" entries. `refId` is a PR id (review_request)
+// or a review-thread id (thread). The dismissal is honoured only while no newer
+// activity has happened — getMyTurn compares dismissedAt against the PR's
+// updatedAt / the thread's last reply, so it auto-resurfaces.
+export const myTurnDismissals = sqliteTable('my_turn_dismissals', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    kind: text('kind', { enum: ['review_request', 'thread'] }).notNull(),
+    refId: integer('ref_id').notNull(),
+    dismissedAt: integer('dismissed_at', { mode: 'timestamp' }).notNull(),
+}, (t) => ({ kindRefUx: uniqueIndex('mtd_kind_ref_ux').on(t.kind, t.refId) }));
+// Singleton (id always 1): the locally-authenticated GitHub user, cached from
+// `gh api user` so triage ("my turn") knows who "you" are.
+export const localUser = sqliteTable('local_user', {
+    id: integer('id').primaryKey(),
+    githubLogin: text('github_login').notNull(),
+    githubId: text('github_id').notNull(),
+    avatarUrl: text('avatar_url'),
+    cachedAt: integer('cached_at', { mode: 'timestamp' }).notNull(),
+});
+export const reviewThreads = sqliteTable('review_threads', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    githubNodeId: text('github_node_id').notNull().unique(),
+    prId: integer('pr_id')
+        .notNull()
+        .references(() => pullRequests.id),
+    path: text('path').notNull(),
+    line: integer('line'),
+    isResolved: integer('is_resolved', { mode: 'boolean' }).notNull(),
+    isOutdated: integer('is_outdated', { mode: 'boolean' })
+        .notNull()
+        .default(false),
+    derivedState: text('derived_state', {
+        enum: ['resolved', 'likely_addressed', 'replied_unresolved', 'untouched'],
+    }).notNull(),
+    originalCommenterId: integer('original_commenter_id').references(() => users.id),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+}, (t) => ({ prIdx: index('thread_pr_idx').on(t.prId) }));
+export const reviewComments = sqliteTable('review_comments', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    githubNodeId: text('github_node_id').notNull().unique(),
+    threadId: integer('thread_id')
+        .notNull()
+        .references(() => reviewThreads.id),
+    prId: integer('pr_id')
+        .notNull()
+        .references(() => pullRequests.id),
+    authorId: integer('author_id').references(() => users.id),
+    body: text('body').notNull(),
+    diffHunk: text('diff_hunk'),
+    // GitHub numeric id (fullDatabaseId) for the #discussion_r<id> deep link.
+    databaseId: text('database_id'),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+}, (t) => ({ threadIdx: index('rc_thread_idx').on(t.threadId) }));
+export const prComments = sqliteTable('pr_comments', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    githubNodeId: text('github_node_id').notNull().unique(),
+    prId: integer('pr_id')
+        .notNull()
+        .references(() => pullRequests.id),
+    authorId: integer('author_id').references(() => users.id),
+    body: text('body').notNull(),
+    // GitHub numeric id (fullDatabaseId) for the #issuecomment-<id> deep link.
+    databaseId: text('database_id'),
+    createdAt: integer('created_at', { mode: 'timestamp' }).notNull(),
+}, (t) => ({ prIdx: index('prc_pr_idx').on(t.prId) }));
+export const reviews = sqliteTable('reviews', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    githubNodeId: text('github_node_id').notNull().unique(),
+    prId: integer('pr_id')
+        .notNull()
+        .references(() => pullRequests.id),
+    authorId: integer('author_id').references(() => users.id),
+    state: text('state', {
+        enum: ['approved', 'changes_requested', 'commented', 'dismissed', 'pending'],
+    }).notNull(),
+    body: text('body'),
+    // GitHub numeric id (fullDatabaseId) for the #pullrequestreview-<id> deep link.
+    databaseId: text('database_id'),
+    submittedAt: integer('submitted_at', { mode: 'timestamp' }).notNull(),
+}, (t) => ({ prIdx: index('rv_pr_idx').on(t.prId) }));
+export const commits = sqliteTable('commits', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    sha: text('sha').notNull(),
+    prId: integer('pr_id')
+        .notNull()
+        .references(() => pullRequests.id),
+    authorId: integer('author_id').references(() => users.id),
+    committerId: integer('committer_id').references(() => users.id),
+    message: text('message'),
+    committedAt: integer('committed_at', { mode: 'timestamp' }).notNull(),
+}, (t) => ({
+    prIdx: index('commit_pr_idx').on(t.prId),
+    shaPrUx: uniqueIndex('commit_sha_pr_ux').on(t.sha, t.prId),
+}));
+// SHA -> string[] of changed paths. Cached forever (SHAs are immutable).
+export const commitFiles = sqliteTable('commit_files', {
+    sha: text('sha').primaryKey(),
+    paths: text('paths', { mode: 'json' }).$type().notNull(),
+    fetchedAt: integer('fetched_at', { mode: 'timestamp' })
+        .notNull()
+        .default(sql `(unixepoch())`),
+});
+// Unified events log -- what the timeline reads.
+export const events = sqliteTable('events', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    repoId: integer('repo_id')
+        .notNull()
+        .references(() => repos.id),
+    actorId: integer('actor_id').references(() => users.id),
+    prId: integer('pr_id').references(() => pullRequests.id),
+    type: text('type', {
+        enum: [
+            'pr_opened',
+            'pr_merged',
+            'pr_closed',
+            'pr_reopened',
+            'pr_ready_for_review',
+            'review_submitted',
+            'review_comment',
+            'pr_comment',
+            'commit_pushed',
+        ],
+    }).notNull(),
+    occurredAt: integer('occurred_at', { mode: 'timestamp' }).notNull(),
+    refTable: text('ref_table'),
+    refId: integer('ref_id'),
+    // Stable identity for idempotent upserts: e.g. "pr_opened:<prNodeId>".
+    dedupeKey: text('dedupe_key').notNull().unique(),
+}, (t) => ({
+    timeIdx: index('events_time_idx').on(t.occurredAt),
+    repoTimeIdx: index('events_repo_time_idx').on(t.repoId, t.occurredAt),
+    actorIdx: index('events_actor_idx').on(t.actorId),
+}));
+export const syncState = sqliteTable('sync_state', {
+    repoId: integer('repo_id')
+        .primaryKey()
+        .references(() => repos.id),
+    lastFullSyncAt: integer('last_full_sync_at', { mode: 'timestamp' }),
+    lastIncrementalSyncAt: integer('last_incremental_sync_at', {
+        mode: 'timestamp',
+    }),
+    lastSyncStatus: text('last_sync_status'),
+    lastSyncError: text('last_sync_error'),
+});
+//# sourceMappingURL=schema.js.map

package/dist/db/triage.js

@@ -0,0 +1,168 @@
+import { inArray } from 'drizzle-orm';
+import { db, schema } from './client.js';
+import { getLocalUserId } from '../github/local-user.js';
+const { reviewRequests, prViews, events, reviews } = schema;
+function emptyNew() {
+    return { commits: 0, comments: 0, reviews: 0 };
+}
+/** Per-author latest review state → is the PR approved with no blocking review? */
+function computeApprovedByPr(prIds) {
+    const approved = new Set();
+    if (prIds.length === 0)
+        return approved;
+    const rows = db
+        .select({
+        prId: reviews.prId,
+        authorId: reviews.authorId,
+        state: reviews.state,
+        submittedAt: reviews.submittedAt,
+    })
+        .from(reviews)
+        .where(inArray(reviews.prId, prIds))
+        .all();
+    // latest review state per (pr, author), ignoring pure "commented" reviews.
+    const latest = new Map();
+    for (const r of rows) {
+        if (r.state !== 'approved' && r.state !== 'changes_requested')
+            continue;
+        const key = `${r.prId}:${r.authorId}`;
+        const at = r.submittedAt.getTime();
+        const prev = latest.get(key);
+        if (!prev || at > prev.at)
+            latest.set(key, { state: r.state, at });
+    }
+    const byPr = new Map();
+    for (const [key, v] of latest) {
+        const prId = Number.parseInt(key.split(':')[0], 10);
+        const entry = byPr.get(prId) ?? { approvals: 0, blocks: 0 };
+        if (v.state === 'approved')
+            entry.approvals += 1;
+        else
+            entry.blocks += 1;
+        byPr.set(prId, entry);
+    }
+    for (const [prId, e] of byPr) {
+        if (e.approvals > 0 && e.blocks === 0)
+            approved.add(prId);
+    }
+    return approved;
+}
+/**
+ * Compute triage fields (reason tag, review-requested-from-me, new-since
+ * counts) for a batch of PRs. All supporting data is loaded in a handful of
+ * batched queries — safe to call on the hot timeline path.
+ */
+export function computeTriage(prs) {
+    const out = new Map();
+    const prIds = prs.map((p) => p.id);
+    const localUserId = getLocalUserId();
+    // ---- review requests (user-type) by PR ----
+    const reqByPr = new Map();
+    if (prIds.length > 0) {
+        const rows = db
+            .select({ prId: reviewRequests.prId, userId: reviewRequests.userId })
+            .from(reviewRequests)
+            .where(inArray(reviewRequests.prId, prIds))
+            .all();
+        for (const r of rows) {
+            if (r.userId == null)
+                continue; // team requests don't map to "me"
+            const entry = reqByPr.get(r.prId) ?? { mine: false, others: 0 };
+            if (localUserId != null && r.userId === localUserId)
+                entry.mine = true;
+            else
+                entry.others += 1;
+            reqByPr.set(r.prId, entry);
+        }
+    }
+    // ---- last-viewed per PR ----
+    const viewedAtByPr = new Map();
+    if (prIds.length > 0) {
+        const rows = db
+            .select({ prId: prViews.prId, lastViewedAt: prViews.lastViewedAt })
+            .from(prViews)
+            .where(inArray(prViews.prId, prIds))
+            .all();
+        for (const r of rows)
+            viewedAtByPr.set(r.prId, r.lastViewedAt.getTime());
+    }
+    // ---- events per PR (for new-since counts) ----
+    const newByPr = new Map();
+    if (prIds.length > 0 && viewedAtByPr.size > 0) {
+        const rows = db
+            .select({
+            prId: events.prId,
+            type: events.type,
+            occurredAt: events.occurredAt,
+        })
+            .from(events)
+            .where(inArray(events.prId, prIds))
+            .all();
+        for (const r of rows) {
+            if (r.prId == null)
+                continue;
+            const threshold = viewedAtByPr.get(r.prId);
+            if (threshold == null)
+                continue;
+            if (r.occurredAt.getTime() <= threshold)
+                continue;
+            const n = newByPr.get(r.prId) ?? emptyNew();
+            if (r.type === 'commit_pushed')
+                n.commits += 1;
+            else if (r.type === 'pr_comment' || r.type === 'review_comment')
+                n.comments += 1;
+            else if (r.type === 'review_submitted')
+                n.reviews += 1;
+            newByPr.set(r.prId, n);
+        }
+    }
+    const approvedByPr = computeApprovedByPr(prIds);
+    for (const pr of prs) {
+        const req = reqByPr.get(pr.id);
+        const reviewRequestedFromMe = req?.mine ?? false;
+        const otherReviewersRequested = req?.others ?? 0;
+        // No "new" badges on closed/merged PRs — done is done.
+        const newSinceLastViewed = pr.state === 'open' && viewedAtByPr.has(pr.id)
+            ? (newByPr.get(pr.id) ?? emptyNew())
+            : null;
+        out.set(pr.id, {
+            reviewRequestedFromMe,
+            otherReviewersRequested,
+            newSinceLastViewed,
+            reasonTag: deriveReasonTag(pr, {
+                reviewRequestedFromMe,
+                localUserId,
+                newComments: newSinceLastViewed?.comments ?? 0,
+                approvedReady: approvedByPr.has(pr.id),
+            }),
+        });
+    }
+    return out;
+}
+function deriveReasonTag(pr, ctx) {
+    // The cascade only really applies to open PRs; closed/merged fall through to
+    // the default.
+    if (pr.state === 'open') {
+        // Actionable-by-you reasons win — "awaiting your review" beats CI failing
+        // because only you can clear it.
+        if (ctx.reviewRequestedFromMe)
+            return 'awaiting_your_review';
+        if (ctx.localUserId != null &&
+            pr.authorId === ctx.localUserId &&
+            ctx.newComments > 0)
+            return 'your_pr_new_comments';
+        if (pr.ciStatus === 'failure' || pr.ciStatus === 'error')
+            return 'ci_failing';
+        if (pr.mergeable === 'conflicting' || pr.mergeStateStatus === 'dirty')
+            return 'merge_conflicts';
+        // CI is known-not-failing here (failing CI returned above).
+        if (ctx.approvedReady && pr.mergeable === 'mergeable')
+            return 'approved_ready';
+        if (pr.isStalled)
+            return 'stalled';
+        if (pr.threadCounts.untouched > 0)
+            return 'untouched_threads';
+    }
+    return 'in_progress';
+}
+//# sourceMappingURL=triage.js.map

package/dist/github/auth.js

@@ -0,0 +1,19 @@
+import { execFileSync } from 'node:child_process';
+// One-shot at startup. Shell out to the gh CLI so we inherit its SSO/keyring
+// handling rather than managing a PAT in-app. Fail loud if gh isn't set up.
+export function getGithubToken() {
+    try {
+        const token = execFileSync('gh', ['auth', 'token'], {
+            encoding: 'utf-8',
+        }).trim();
+        if (!token)
+            throw new Error('empty token');
+        return token;
+    }
+    catch {
+        throw new Error('gh CLI not authenticated. Run `gh auth login` first, then restart the app.\n' +
+            'For org repos behind SSO you may also need:\n' +
+            '  gh auth refresh -h github.com -s read:org');
+    }
+}
+//# sourceMappingURL=auth.js.map

package/dist/github/client.js

@@ -0,0 +1,30 @@
+import { graphql } from '@octokit/graphql';
+import { getGithubToken } from './auth.js';
+let token = null;
+function authToken() {
+    token ??= getGithubToken();
+    return token;
+}
+let graphqlClient = null;
+export function getGraphqlClient() {
+    graphqlClient ??= graphql.defaults({
+        headers: { authorization: `token ${authToken()}` },
+    });
+    return graphqlClient;
+}
+// REST GET helper, used for per-commit changed-files (no GraphQL path for it).
+export async function ghRestGet(path) {
+    const res = await fetch(`https://api.github.com${path}`, {
+        headers: {
+            authorization: `token ${authToken()}`,
+            accept: 'application/vnd.github+json',
+            'x-github-api-version': '2022-11-28',
+        },
+    });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new Error(`GitHub REST ${path} -> ${res.status}: ${body.slice(0, 200)}`);
+    }
+    return res.json();
+}
+//# sourceMappingURL=client.js.map

package/dist/github/local-user.js

@@ -0,0 +1,92 @@
+import { execFileSync } from 'node:child_process';
+import { eq } from 'drizzle-orm';
+import { db, schema } from '../db/client.js';
+const { localUser, users } = schema;
+const STALE_MS = 24 * 60 * 60 * 1000; // re-fetch once a day
+function fetchFromGh() {
+    try {
+        const out = execFileSync('gh', ['api', 'user'], { encoding: 'utf-8' });
+        const parsed = JSON.parse(out);
+        if (!parsed.login || !parsed.node_id)
+            return null;
+        return {
+            login: parsed.login,
+            node_id: parsed.node_id,
+            avatar_url: parsed.avatar_url ?? null,
+        };
+    }
+    catch {
+        // gh missing / not authed / offline — non-fatal; my-turn just stays empty.
+        return null;
+    }
+}
+/**
+ * Ensure the locally-authenticated GitHub user is cached. Refetches via
+ * `gh api user` on first run and once per day; otherwise returns the cached
+ * row. Never throws — failure leaves "you" unknown and triage degrades
+ * gracefully to empty.
+ */
+export function ensureLocalUser() {
+    const existing = db.select().from(localUser).where(eq(localUser.id, 1)).get();
+    const fresh = existing && Date.now() - existing.cachedAt.getTime() < STALE_MS;
+    if (existing && fresh) {
+        return {
+            login: existing.githubLogin,
+            githubId: existing.githubId,
+            avatarUrl: existing.avatarUrl,
+        };
+    }
+    const gh = fetchFromGh();
+    if (!gh) {
+        // Fall back to a stale cached value if we have one.
+        return existing
+            ? {
+                login: existing.githubLogin,
+                githubId: existing.githubId,
+                avatarUrl: existing.avatarUrl,
+            }
+            : null;
+    }
+    db.insert(localUser)
+        .values({
+        id: 1,
+        githubLogin: gh.login,
+        githubId: gh.node_id,
+        avatarUrl: gh.avatar_url,
+        cachedAt: new Date(),
+    })
+        .onConflictDoUpdate({
+        target: localUser.id,
+        set: {
+            githubLogin: gh.login,
+            githubId: gh.node_id,
+            avatarUrl: gh.avatar_url,
+            cachedAt: new Date(),
+        },
+    })
+        .run();
+    return { login: gh.login, githubId: gh.node_id, avatarUrl: gh.avatar_url };
+}
+/** Cached local user without triggering a network fetch. */
+export function getLocalUser() {
+    const row = db.select().from(localUser).where(eq(localUser.id, 1)).get();
+    return row
+        ? { login: row.githubLogin, githubId: row.githubId, avatarUrl: row.avatarUrl }
+        : null;
+}
+/**
+ * Resolve the local user to a row in `users` (by login) if they've appeared in
+ * any synced repo. Returns null when "you" haven't authored/acted anywhere yet.
+ */
+export function getLocalUserId() {
+    const local = getLocalUser();
+    if (!local)
+        return null;
+    const row = db
+        .select({ id: users.id })
+        .from(users)
+        .where(eq(users.githubLogin, local.login))
+        .get();
+    return row?.id ?? null;
+}
+//# sourceMappingURL=local-user.js.map