limn-review 0.1.123

package/dist/db/triage.js

@@ -0,0 +1,320 @@
+import { inArray } from 'drizzle-orm';
+import { db, schema } from './client.js';
+import { getAccountUserId } from '../auth/account.js';
+const { reviewRequests, prViews, events, reviews } = schema;
+// The merge-state values that mean "GitHub would let this land right now". Mirrors the
+// `canMerge` half of the frontend's `mergeVerdict()` resolver (lib/ui.ts) — the two must
+// agree, or a PR reads "approved & ready" in the triage queue and "blocked" on the PR itself.
+export const READY_MERGE_STATES = new Set([
+    'clean',
+    'has_hooks',
+    'unstable',
+]);
+function emptyNew() {
+    return { commits: 0, comments: 0, reviews: 0 };
+}
+/** Tier of a review state for the standing pick — LOWER WINS, regardless of timestamp.
+ *
+ *  Tier 0 is the VERDICT tier and is the ONLY tier the approval count reads, which is what makes
+ *  this rule a strict superset of its predecessor (below). Tiers 1 and 2 exist so a reviewer who
+ *  never filed a verdict still appears on the card with an honest label instead of vanishing.
+ *  A dismissal outranks a bare comment: it is a verdict-shaped fact about the review, and a
+ *  reviewer who was dismissed and then commented has not gone back to saying nothing. */
+function standingTier(state) {
+    if (state === 'approved' || state === 'changes_requested')
+        return 0;
+    if (state === 'dismissed')
+        return 1;
+    if (state === 'commented')
+        return 2;
+    // 'pending' — a review draft that was never submitted. Not a review; it says nothing about
+    // where the reviewer stands, and showing it as one would name someone who has not spoken.
+    return null;
+}
+/**
+ * Per-PR reviewer standings: ONE indexed read of `reviews` over the given PR ids, grouped per
+ * (pr, author) in memory.
+ *
+ * THE RULE — a reviewer's standing is their latest VERDICT (approved / changes_requested) if they
+ * ever filed one; failing that their latest dismissal; failing that their latest comment.
+ *
+ * ⚠ THIS IS A STRICT SUPERSET OF THE OLD APPROVAL FOLD, BY CONSTRUCTION, AND HAS TO STAY ONE.
+ * `approvals` is hashed into stored Pro work plans (`db/work-plan.ts` → `payloadHashFor`), so a
+ * count that moves flips every stored plan on an affected workspace permanently `stale` and
+ * re-bills it. The predecessor picked the latest row whose state was `approved` or
+ * `changes_requested` and ignored every other row; tier 0 is that pick, unchanged, and tiers 1-2
+ * can only add reviewers the old rule dropped entirely — reviewers who count for nothing. Pinned
+ * in `triage-reviewers.test.ts`.
+ *
+ * ⚠ KNOWN DIVERGENCE FROM THE STANDING A HUMAN WOULD READ, KEPT DELIBERATELY: a reviewer who
+ * approved and was LATER DISMISSED (a fresh review node whose state is DISMISSED, which is how
+ * GitHub records a revoked approval) still reads `approved`, because tier 0 outranks tier 1
+ * whatever the clock says. Demoting them would be the honest label — and would also drop the
+ * approval, moving the hashed count. MEASURED on this repo's real data: 2 reviewer-PR pairs
+ * account-wide, 1 of them on an open PR (sourcery-ai). So it is a decision to take with the hash
+ * consequence in hand, not a patch: change the tier of `dismissed` to 0 and every stored plan on
+ * an affected workspace re-bills.
+ *
+ * ⚠ A NULL `authorId` IS ONE PSEUDO-REVIEWER PER PR, AND IT COUNTS. `reviews.authorId` is
+ * nullable (a deleted GitHub account), the old key was the string `${prId}:${authorId}`, so every
+ * ghost review on a PR collapsed into one slot and its verdict counted toward `approvals`. Both
+ * are preserved exactly. Zero such rows exist today, which is precisely why dropping them here
+ * would look safe and would silently move a count the day one appears.
+ *
+ * COST: one indexed scan (`rv_pr_idx` on `pr_id`), the same query the predecessor ran with `id`
+ * added to the select list — no second query, no per-PR fetch. Measured on real data: the 50
+ * most-recently-updated open PRs carry 147 review rows and 45 reviewers (max 4 on one PR); the 50
+ * BUSIEST open PRs carry 1,362 rows and 233 reviewers (max 10). The rows were always read; what
+ * changed is that they are no longer thrown away.
+ */
+export async function computeReviewStandingsByPr(prIds) {
+    const out = new Map();
+    if (prIds.length === 0)
+        return out;
+    const rows = await db
+        .select({
+        id: reviews.id,
+        prId: reviews.prId,
+        authorId: reviews.authorId,
+        state: reviews.state,
+        submittedAt: reviews.submittedAt,
+    })
+        .from(reviews)
+        .where(inArray(reviews.prId, prIds))
+        .execute();
+    // One winner per (pr, author). ⚠ The tiebreak is EXPLICIT — a later `submittedAt`, then the
+    // higher `id` — because rows arrive in heap order, which on Postgres flips after any UPDATE to
+    // the table. The predecessor's bare `>` handed a same-second tie to whichever row the heap
+    // offered first, so the same PR could resolve two ways between two identical reads. Measured:
+    // 35 (pr, author, submitted_at) ties exist in real data and NOT ONE disagrees on state, so
+    // making this deterministic moves no count today — it just stops the day one would.
+    const best = new Map();
+    for (const r of rows) {
+        const tier = standingTier(r.state);
+        if (tier == null)
+            continue;
+        const key = `${r.prId}:${r.authorId}`;
+        const prev = best.get(key);
+        if (prev != null) {
+            if (tier > prev.tier)
+                continue;
+            if (tier === prev.tier) {
+                const dt = r.submittedAt.getTime() - prev.at.getTime();
+                if (dt < 0 || (dt === 0 && r.id <= prev.id))
+                    continue;
+            }
+        }
+        best.set(key, {
+            prId: r.prId,
+            userId: r.authorId,
+            tier,
+            state: r.state,
+            at: r.submittedAt,
+            id: r.id,
+        });
+    }
+    const byPr = new Map();
+    for (const v of best.values()) {
+        const list = byPr.get(v.prId) ?? [];
+        list.push({
+            userId: v.userId,
+            standing: v.state,
+            standingAt: v.at,
+        });
+        byPr.set(v.prId, list);
+    }
+    for (const [prId, list] of byPr) {
+        // Deterministic for the same reason the tiebreak is: a card's chips must not reshuffle
+        // because Postgres handed back the same rows in a different order. Newest standing first is
+        // also the order a caller capping to three wants.
+        list.sort((a, b) => b.standingAt.getTime() - a.standingAt.getTime() || (a.userId ?? 0) - (b.userId ?? 0));
+        out.set(prId, { reviewers: list, total: list.length });
+    }
+    return out;
+}
+/**
+ * The approval standing of a PR, folded from its reviewer list — the ONE place the counts come
+ * from, so the chips on a card and the "approved by N" beside them cannot disagree. `dismissed`
+ * and `commented` count as nothing, exactly as the predecessor's skipped rows did.
+ */
+export function approvalInfoFromStandings(standings) {
+    let approvals = 0;
+    let blocks = 0;
+    let latestApprovalAt = null;
+    for (const r of standings.reviewers) {
+        if (r.standing === 'approved') {
+            approvals += 1;
+            if (!latestApprovalAt || r.standingAt.getTime() > latestApprovalAt.getTime()) {
+                latestApprovalAt = r.standingAt;
+            }
+        }
+        else if (r.standing === 'changes_requested') {
+            blocks += 1;
+        }
+    }
+    return {
+        approved: approvals > 0 && blocks === 0,
+        changesRequested: blocks > 0,
+        approvals,
+        latestApprovalAt,
+    };
+}
+/**
+ * Per-PR approval standing: at least one reviewer's standing decision is approved and none is
+ * changes_requested. Drives the `approved_ready` reason tag, the green/red review outline on
+ * timeline bars, the "your PR was approved" My Turn section and the Pro work plan's `approvals`.
+ *
+ * Now a projection of `computeReviewStandingsByPr` rather than a second fold over the same rows —
+ * a caller wanting the reviewers as well should call that once and pass the result through
+ * `approvalInfoFromStandings`, not run both.
+ */
+export async function computeApprovalInfoByPr(prIds) {
+    const out = new Map();
+    for (const [prId, standings] of await computeReviewStandingsByPr(prIds)) {
+        const info = approvalInfoFromStandings(standings);
+        // ⚠ THE EMISSION SET IS PRESERVED, not just the values. The predecessor built its map from
+        // the decisive picks alone, so a PR whose only reviews are comments had NO ENTRY — not a
+        // zeroed one. Every caller today reads `.get(id)?.field ?? default` and cannot tell, but a
+        // future `.has()` could, and this fold is the one whose output is hashed.
+        if (info.approvals === 0 && !info.changesRequested)
+            continue;
+        out.set(prId, info);
+    }
+    return out;
+}
+/**
+ * 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 async function computeTriage(prs, accountId) {
+    const out = new Map();
+    const prIds = prs.map((p) => p.id);
+    const localUserId = await getAccountUserId(accountId);
+    // ---- review requests (user-type) by PR ----
+    const reqByPr = new Map();
+    if (prIds.length > 0) {
+        const rows = await db
+            .select({ prId: reviewRequests.prId, userId: reviewRequests.userId })
+            .from(reviewRequests)
+            .where(inArray(reviewRequests.prId, prIds))
+            .execute();
+        for (const r of rows) {
+            // A null userId means the request went to a GITHUB team — a group of people on GitHub,
+            // NOT one of this app's workspaces — so it names no single person and can't be "me".
+            if (r.userId == null)
+                continue;
+            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 = await db
+            .select({ prId: prViews.prId, lastViewedAt: prViews.lastViewedAt })
+            .from(prViews)
+            .where(inArray(prViews.prId, prIds))
+            .execute();
+        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 = await db
+            .select({
+            prId: events.prId,
+            type: events.type,
+            occurredAt: events.occurredAt,
+        })
+            .from(events)
+            .where(inArray(events.prId, prIds))
+            .execute();
+        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 approvalByPr = await computeApprovalInfoByPr(prIds);
+    for (const pr of prs) {
+        const req = reqByPr.get(pr.id);
+        const reviewRequestedFromMe = req?.mine ?? false;
+        const otherReviewersRequested = req?.others ?? 0;
+        const approval = approvalByPr.get(pr.id);
+        // 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,
+            isApproved: approval?.approved ?? false,
+            isChangesRequested: approval?.changesRequested ?? false,
+            newSinceLastViewed,
+            reasonTag: deriveReasonTag(pr, {
+                reviewRequestedFromMe,
+                localUserId,
+                newComments: newSinceLastViewed?.comments ?? 0,
+                approvedReady: approval?.approved ?? false,
+            }),
+        });
+    }
+    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).
+        //
+        // `mergeable` ONLY reports merge-CONFLICT state (MERGEABLE / CONFLICTING / UNKNOWN) — it
+        // says nothing about branch protection. Testing it alone tagged PRs "approved & ready"
+        // while their REQUIRED checks were red or a second required review was outstanding, which
+        // is the same blindness the merge surfaces had. `mergeStateStatus` is the protection-aware
+        // field, so gate on it too:
+        //   clean      — mergeable and passing
+        //   has_hooks  — mergeable, just has a pre-receive hook to run
+        //   unstable   — NON-required checks are red; GitHub will still merge it, so it IS ready
+        // Everything else (blocked / behind / dirty / unknown) is not ready by definition.
+        if (ctx.approvedReady &&
+            pr.mergeable === 'mergeable' &&
+            READY_MERGE_STATES.has(pr.mergeStateStatus))
+            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/db/usage.js

@@ -0,0 +1,63 @@
+import { and, eq, gte } from 'drizzle-orm';
+import { db, schema } from './client.js';
+const { aiUsage } = schema;
+// Append one usage row. Best-effort + non-fatal: a ledger write must never break the
+// feature that spent the money, so callers `.catch()` or await-in-try. Drops rows with
+// no real cost (a $0 ambient-session completion isn't worth a row).
+export async function recordAiUsage(row) {
+    if (!Number.isFinite(row.costUsd) || row.costUsd <= 0)
+        return;
+    await db
+        .insert(aiUsage)
+        .values({
+        accountId: row.accountId,
+        seam: row.seam,
+        feature: row.feature,
+        model: row.model,
+        costUsd: row.costUsd,
+        inputTokens: row.inputTokens ?? null,
+        outputTokens: row.outputTokens ?? null,
+        prId: row.prId ?? null,
+        repoId: row.repoId ?? null,
+        occurredAt: new Date(),
+    })
+        .execute();
+}
+// Sum recorded AI spend for an account since `sinceMs`, split by seam. Rows are small
+// (per account, per month) so we fetch + reduce in JS — portable across both dialects.
+export async function getAiUsageSummary(accountId, sinceMs) {
+    const rows = await db
+        .select({ seam: aiUsage.seam, costUsd: aiUsage.costUsd })
+        .from(aiUsage)
+        .where(and(eq(aiUsage.accountId, accountId), gte(aiUsage.occurredAt, new Date(sinceMs))))
+        .execute();
+    let summaryUsd = 0;
+    let agentUsd = 0;
+    for (const r of rows) {
+        if (r.seam === 'agent')
+            agentUsd += r.costUsd;
+        else
+            summaryUsd += r.costUsd;
+    }
+    return { summaryUsd, agentUsd, totalUsd: summaryUsd + agentUsd };
+}
+// Auxiliary summary sub-calls that belong to a SINGLE user-initiated turn and must NOT count as
+// their own turn — e.g. the insights-chat CHART is a second Haiku call rendering the SAME
+// question, so one charted question is still one turn. Their $ cost stays on the ledger (COGS
+// visibility); only the turn TALLY excludes them.
+const NON_TURN_SUMMARY_FEATURES = new Set(['sprint_chat_chart']);
+// Count the SUMMARY-seam turns an account has spent since `sinceMs` (month-to-date). One
+// recorded ledger row = one turn, EXCEPT auxiliary sub-calls (above); a $0 cache hit /
+// ambient-session completion isn't recorded, so it's free and doesn't count (recordAiUsage
+// drops non-positive-cost rows). A summary turn limit caps this. Portable across both dialects
+// (fetch + reduce in JS; the row set is bounded by ~the monthly limit — same pattern as
+// getAiUsageSummary).
+export async function getSummaryTurnCount(accountId, sinceMs) {
+    const rows = await db
+        .select({ feature: aiUsage.feature })
+        .from(aiUsage)
+        .where(and(eq(aiUsage.accountId, accountId), eq(aiUsage.seam, 'summary'), gte(aiUsage.occurredAt, new Date(sinceMs))))
+        .execute();
+    return rows.filter((r) => !NON_TURN_SUMMARY_FEATURES.has(r.feature)).length;
+}
+//# sourceMappingURL=usage.js.map