@preventive/triage 1.0.0-alpha.47 → 1.0.0-alpha.49

package/server-managed/repository-history.ts

@@ -9,11 +9,13 @@
 // read a page from a commit at a time, each page kept by the commit it starts
 // at (historyFrom): a commit's history never changes, and where a commit read
 // starts a page kept, that page glues on, and those after it.
-import { type Coauthor, MAX_COAUTHORS, type Maker, coauthorsOf } from './commit-coauthors.ts'
+import { type Coauthor, MAX_COAUTHORS, type Maker, coauthorTrailers, coauthorsOf } from './commit-coauthors.ts'
 import { GithubApiError, githubJson } from './github-app.ts'
-import { type GraphActor, accountOf, commitAccount } from './github-accounts.ts'
+import { type GraphActor, accountOf, commitAccount, linkNoreplyUsers } from './github-accounts.ts'
+import { githubGraphql } from './github-graphql.ts'
 
-export { ACTOR, type GraphAccount, type GraphActor, type NamedAccount, accountOf, actorOf, commitAccount } from './github-accounts.ts'
+export { ACTOR, type GraphAccount, type GraphActor, type NamedAccount, accountOf, actorOf, commitAccount, linkNoreplyUsers } from './github-accounts.ts'
+export { type GraphqlError, githubGraphql } from './github-graphql.ts'
 
 export const HISTORY_PAGE = 100
 // The deepest page read, as far as Older commits goes.
@@ -79,19 +81,27 @@ function historyCommit(sha: unknown, parents: unknown[], message: unknown, autho
 
 type RestCommit = { sha?: unknown; parents?: { sha?: unknown }[]; author?: { login?: unknown; id?: unknown } | null
   commit?: { message?: unknown; author?: { name?: unknown; email?: unknown } | null; committer?: { date?: unknown } | null } }
-const restCommit = (item: RestCommit) => historyCommit(item?.sha, Array.isArray(item?.parents) ? item.parents.map(parent => parent?.sha) : [],
-  item?.commit?.message, { name: item?.commit?.author?.name, email: item?.commit?.author?.email, account: accountOf(item?.author) }, item?.commit?.committer?.date)
+// Its co-authors (`listed`) by its trailers, with the accounts of their addresses.
+const restCommit = (item: RestCommit, listed: Maker[] | null = null) => historyCommit(item?.sha, Array.isArray(item?.parents) ? item.parents.map(parent => parent?.sha) : [],
+  item?.commit?.message, { name: item?.commit?.author?.name, email: item?.commit?.author?.email, account: accountOf(item?.author) }, item?.commit?.committer?.date,
+  null, listed)
 
 const repoApi = (fullName: string) => `https://api.github.com/repos/${fullName.split('/').map(encodeURIComponent).join('/')}`
 
 // A page of the commits `commit` reaches, newest first as GitHub lists them,
 // those touching `path` alone where it names a directory; `more` where a
-// full page leaves some for the next, one that may be read.
+// full page leaves some for the next, one that may be read. GitHub links
+// each's author to its account; with a token, its co-authors by GitHub's older
+// no-reply address too (linkNoreplyUsers).
 export async function repositoryHistory(fullName: string, token: string | null, commit: string, path: string, page: number, fetchImpl: typeof fetch = globalThis.fetch) {
   const params = new URLSearchParams({ sha: commit, per_page: String(HISTORY_PAGE), page: String(page), ...path ? { path } : {} })
   const data = await githubJson(`${repoApi(fullName)}/commits?${params}`, token, fetchImpl)
   if (!Array.isArray(data)) throw new GithubApiError(502, 'github-malformed')
-  return { commits: data.flatMap(item => restCommit(item as RestCommit) ?? []), more: data.length >= HISTORY_PAGE && page < MAX_HISTORY_PAGE }
+  const items = data as RestCommit[]
+  const trailers = items.map(item => coauthorTrailers(item?.commit?.message).map(({ name, email }): GraphActor & { name: string } => ({ name, email, user: null })))
+  if (token) await linkNoreplyUsers(trailers.flat(), token, fetchImpl)
+  return { commits: items.flatMap((item, at) => restCommit(item, token ? trailers[at]!.map(actor => ({ name: actor.name, email: actor.email, account: commitAccount(actor) })) : null) ?? []),
+    more: data.length >= HISTORY_PAGE && page < MAX_HISTORY_PAGE }
 }
 
 // The commits the repository's branches and tags point at, as GitHub's
@@ -104,41 +114,8 @@ export async function repositoryRefTips(fullName: string, token: string | null,
   return { branches: tips(branches), tags: tips(tags) }
 }
 
-export type GraphqlError = { type?: unknown; path?: unknown; message?: unknown }
-
-const NAMED_ERRORS = new Set(['RATE_LIMITED', 'NOT_FOUND', 'FORBIDDEN'])
-// GitHub's own words for a query it stopped past its time (ten seconds):
-// "Something went wrong while executing your query. This may be the result
-// of a timeout, …", with no type.
-const TIMED_OUT = /\btimeout\b/iu
-
-// One GraphQL query with `token`, answered with its `data`: one GitHub answers
-// with errors, but for those the caller reads past (`tolerated`, the fields
-// they name then null), is rate limited, names what isn't there, is refused,
-// as one a GitHub App lacks the permission for is, or a token the scope for
-// (`INSUFFICIENT_SCOPES`, a sign-in's having none), took GitHub too long, or
-// else is malformed, as one GitHub rejects unread is (a field or type its API
-// doesn't know). GitHub's words for errors of none of those first three types
-// are logged, those read past too.
-export async function githubGraphql(query: string, variables: Record<string, unknown>, token: string, fetchImpl: typeof fetch,
-  tolerated: (error: GraphqlError) => boolean = () => false) {
-  const body = await githubJson('https://api.github.com/graphql', token, fetchImpl, 'POST', { query, variables }, true) as { data?: unknown; errors?: GraphqlError[] } | null
-  const all = Array.isArray(body?.errors) ? body.errors : []
-  const unnamed = all.filter(error => !NAMED_ERRORS.has(String(error?.type)))
-  if (unnamed.length > 0) {
-    console.warn('managed: GitHub answered a query with errors:', JSON.stringify(unnamed.slice(0, 3)
-      .map(error => ({ type: error?.type, message: String(error?.message).slice(0, 300), path: error?.path }))))
-  }
-  const errors = all.filter(error => !tolerated(error))
-  if (errors.length > 0) {
-    if (errors.some(error => error?.type === 'RATE_LIMITED')) throw new GithubApiError(429, 'github-rate-limited', 60)
-    if (errors.some(error => error?.type === 'NOT_FOUND')) throw new GithubApiError(404, 'github-not-found')
-    if (errors.some(error => error?.type === 'FORBIDDEN' || error?.type === 'INSUFFICIENT_SCOPES')) throw new GithubApiError(502, 'github-status-403')
-    if (errors.some(error => typeof error?.message === 'string' && TIMED_OUT.test(error.message))) throw new GithubApiError(502, 'github-timeout')
-    throw new GithubApiError(502, 'github-malformed')
-  }
-  return body?.data
-}
+// A commit's author and those GitHub lists beside it.
+export const commitActors = (node: GraphCommit | null | undefined) => [node?.author, ...node?.authors?.nodes ?? []]
 
 // A tag's target, an annotated tag's own target in turn, through as many as
 // MAX_TAG_DEPTH annotated tags, each object's type naming what it is.
@@ -179,10 +156,10 @@ export interface HistoryPages {
 }
 
 // What a commit is read by in GraphQL.
-const COMMIT_FRAGMENT = `fragment historyCommit on Commit { oid message committedDate additions deletions author { name email date user { login databaseId } }
+export const COMMIT_FRAGMENT = `fragment historyCommit on Commit { oid message committedDate additions deletions author { name email date user { login databaseId } }
   authors(first: ${MAX_COAUTHORS + 1}) { nodes { name email user { login databaseId } } } parents(first: ${MAX_PARENTS}) { nodes { oid } } }`
 // A query's variables `$<prefix><n>` of `type`, as many as `count`.
-const variablesOf = (prefix: string, count: number, type: string) => Array.from({ length: count }, (_, at) => `$${prefix}${at}: ${type}`).join(', ')
+export const variablesOf = (prefix: string, count: number, type: string) => Array.from({ length: count }, (_, at) => `$${prefix}${at}: ${type}`).join(', ')
 
 // The latest commits of each tip, by its id, `b<n>` the `n`th's.
 const historiesQuery = (count: number) => `query($owner: String!, $name: String!, ${variablesOf('o', count, 'GitObjectID!')}) {
@@ -192,7 +169,7 @@ const historiesQuery = (count: number) => `query($owner: String!, $name: String!
 }
 ${COMMIT_FRAGMENT}`
 
-type GraphCommit = { oid?: unknown; message?: unknown; committedDate?: unknown; additions?: unknown; deletions?: unknown
+export type GraphCommit = { oid?: unknown; message?: unknown; committedDate?: unknown; additions?: unknown; deletions?: unknown
   author?: ({ name?: unknown; date?: unknown } & GraphActor) | null; authors?: { nodes?: (({ name?: unknown } & GraphActor) | null)[] } | null
   parents?: { nodes?: { oid?: unknown }[] } }
 type GraphTarget = { __typename?: unknown; oid?: unknown; committedDate?: unknown; target?: GraphTarget | null }
@@ -224,20 +201,37 @@ async function repositoryHeads(owner: string, name: string, token: string, fetch
   return { heads, repository: first, cut: true }
 }
 
-// The first page of the history from each of `tops`, by its top: with a
-// token, in one GraphQL query; without, a REST list each.
-async function readPages(fullName: string, token: string | null, tops: string[], fetchImpl: typeof fetch) {
+// Histories read in a GraphQL query, and queries at once: each counts its
+// commits' lines, which GitHub works out as it answers, stopping a query
+// past ten seconds.
+const PAGES_PER_QUERY = 5
+const PAGES_PARALLEL = 5
+
+// The first page of the history from each of `tops`, by its top, each told
+// to `keep` as it is read, so those read stay kept where another fails: with
+// a token, in GraphQL queries of PAGES_PER_QUERY (inBatches); without, a
+// REST list each.
+async function readPages(fullName: string, token: string | null, tops: string[], fetchImpl: typeof fetch,
+  keep: (top: string, commits: HistoryCommit[]) => Promise<void>) {
+  const read = new Map<string, HistoryCommit[]>()
+  const got = (top: string, commits: HistoryCommit[]) => { read.set(top, commits); return keep(top, commits) }
   if (!token) {
-    return new Map(await Promise.all(tops.map(async top => [top, (await repositoryHistory(fullName, null, top, '', 1, fetchImpl)).commits] as const)))
+    await Promise.all(tops.map(async top => got(top, (await repositoryHistory(fullName, null, top, '', 1, fetchImpl)).commits)))
+    return read
   }
   const [owner, name] = fullName.split('/') as [string, string]
-  const data = await githubGraphql(historiesQuery(tops.length), { owner, name, ...Object.fromEntries(tops.map((sha, at) => [`o${at}`, sha])) }, token, fetchImpl) as Histories
-  return new Map(tops.map((top, at) => [top, (data?.repository?.[`b${at}`]?.history?.nodes ?? []).flatMap(node => graphCommit(node) ?? [])]))
+  await inBatches(tops, PAGES_PER_QUERY, PAGES_PARALLEL, async batch => {
+    const data = await githubGraphql(historiesQuery(batch.length), { owner, name, ...Object.fromEntries(batch.map((sha, at) => [`o${at}`, sha])) }, token, fetchImpl) as Histories
+    const nodes = batch.map((_, at) => data?.repository?.[`b${at}`]?.history?.nodes ?? [])
+    await linkNoreplyUsers(nodes.flat().flatMap(commitActors), token, fetchImpl)
+    await Promise.all(batch.map((top, at) => got(top, nodes[at]!.flatMap(node => graphCommit(node) ?? []))))
+  })
+  return read
 }
 
 // Its authors past the first, the git author, GitHub lists from its
 // `Co-authored-by:` trailers.
-const graphCommit = (node: GraphCommit | null | undefined) => historyCommit(node?.oid, (node?.parents?.nodes ?? []).map(parent => parent?.oid),
+export const graphCommit = (node: GraphCommit | null | undefined) => historyCommit(node?.oid, (node?.parents?.nodes ?? []).map(parent => parent?.oid),
   node?.message, { name: node?.author?.name, email: node?.author?.email, account: commitAccount(node?.author) }, node?.committedDate,
   { additions: node?.additions, deletions: node?.deletions, authoredAt: node?.author?.date },
   Array.isArray(node?.authors?.nodes) ? node.authors.nodes.slice(1).map(actor => ({ name: actor?.name, email: actor?.email, account: commitAccount(actor) })) : null)
@@ -257,9 +251,9 @@ const graphCommit = (node: GraphCommit | null | undefined) => historyCommit(node
 export async function historyFrom(fullName: string, token: string | null, starts: string[], pages: HistoryPages, fetchImpl: typeof fetch = globalThis.fetch) {
   const kept = await pages.read(starts)
   const unread = starts.filter(top => !kept.has(top))
-  const read = unread.length > 0 ? await readPages(fullName, token, unread, fetchImpl) : new Map<string, HistoryCommit[]>()
   // Kept only as GitHub listed it from its top: none for a commit it named nothing of.
-  await Promise.all([...read].flatMap(([top, commits]) => commits[0]?.sha === top ? [pages.write(top, commits)] : []))
+  const keep = (top: string, commits: HistoryCommit[]) => commits[0]?.sha === top ? pages.write(top, commits) : Promise.resolve()
+  const read = unread.length > 0 ? await readPages(fullName, token, unread, fetchImpl, keep) : new Map<string, HistoryCommit[]>()
   const listed = new Map<string, HistoryCommit>()
   const add = (commits: HistoryCommit[]) => { for (const commit of commits) if (!listed.has(commit.sha)) listed.set(commit.sha, commit) }
   for (const top of starts) add(kept.get(top) ?? read.get(top) ?? [])
@@ -334,106 +328,45 @@ export async function repositoryAllHistory(fullName: string, token: string, { he
   return { commits: read.commits, branches, tags, defaultBranch, unread, cut, more }
 }
 
-// A pull request squashed into a commit of the default branch's history
-// (`merge`): its number, the commit its head was at when merged (`head`,
-// GitHub's own of it, which a branch reused or pushed over since never
-// moves), and its own commits, the latest MAX_SQUASHED of them, `more`
-// where it had more. Drawn as the merge it was, its commits on a lane of
-// their own (repository-history.js).
-export interface SquashedPull { merge: string; number: number; head: string; commits: HistoryCommit[]; more: boolean }
-// The pull requests squashed into commits, kept by each commit (a merged pull
-// request's commits never change); null for a commit none was.
-export interface Squashes {
-  read(shas: string[]): Promise<Map<string, SquashedPull | null>>
-  write(sha: string, pull: SquashedPull | null): Promise<void>
-}
-
-const MAX_SQUASHED = 100
-// Looked up of an answer's commits not yet kept, at most, the newest first;
-// in queries of as many commits, or pull requests, as many at once.
-export const MAX_SQUASH_LOOKUPS = 500
-const SQUASH_COMMITS = 100
-const SQUASH_PULLS = 20
-const SQUASH_PARALLEL = 4
-
-// The merged pull request that brought each commit in, `c<n>` the `n`th's.
-const mergedPullsQuery = (count: number) => `query($owner: String!, $name: String!, ${variablesOf('o', count, 'GitObjectID!')}) {
-  repository(owner: $owner, name: $name) {
-    ${Array.from({ length: count }, (_, at) => `c${at}: object(oid: $o${at}) { ... on Commit { associatedPullRequests(first: 1) { nodes { number mergeCommit { oid } } } } }`).join('\n    ')}
+const chunked = <T>(items: T[], size: number) => Array.from({ length: Math.ceil(items.length / size) }, (_, at) => items.slice(at * size, (at + 1) * size))
+// GitHub stopping a query past its time: in its answer's errors, or as a 502
+// or 504 of its own.
+const SLOW = new Set(['github-timeout', 'github-status-502', 'github-status-504'])
+// `run` for `items` in batches of `size`, as many at once as `parallel`; a
+// batch GitHub stops past its time run again in halves, down to one alone,
+// so that one too slow to read fails alone, the others read. The halves
+// wait their turn with the rest, and as many batches are halved as run at
+// once twice over at most, GitHub slow throughout past that. Where one
+// fails, none more is run, those running done before its error is thrown,
+// so that what they read is kept.
+export async function inBatches<T>(items: T[], size: number, parallel: number, run: (batch: T[]) => Promise<void>) {
+  const failed: unknown[] = []
+  const waiting: (() => void)[] = []
+  let halved = 0, running = 0
+  const turn = () => {
+    if (running < parallel) { running++; return Promise.resolve() }
+    return new Promise<void>(resolve => { waiting.push(resolve) })
   }
-}`
-// Each pull request's head when merged and its latest commits, `p<n>` the `n`th's.
-const squashedQuery = (count: number) => `query($owner: String!, $name: String!, ${variablesOf('n', count, 'Int!')}) {
-  repository(owner: $owner, name: $name) {
-    ${Array.from({ length: count }, (_, at) => `p${at}: pullRequest(number: $n${at}) { headRefOid commits(last: ${MAX_SQUASHED}) { totalCount nodes { commit { ...historyCommit } } } }`).join('\n    ')}
+  // A turn done, handed to the batch waiting longest.
+  const done = () => {
+    const next = waiting.shift()
+    if (next) next()
+    else running--
   }
-}
-${COMMIT_FRAGMENT}`
-
-type MergedPulls = { repository?: Record<string, { associatedPullRequests?: { nodes?: ({ number?: unknown; mergeCommit?: { oid?: unknown } | null } | null)[] } } | null> | null }
-type SquashedPage = { repository?: Record<string, { headRefOid?: unknown; commits?: { totalCount?: unknown; nodes?: ({ commit?: GraphCommit | null } | null)[] } } | null> | null }
-
-const chunked = <T>(items: T[], size: number) => Array.from({ length: Math.ceil(items.length / size) }, (_, at) => items.slice(at * size, (at + 1) * size))
-// `run` for each of `items`, as many at once as `parallel`.
-async function eachOf<T>(items: T[], parallel: number, run: (item: T) => Promise<void>) {
-  let next = 0
-  await Promise.all(Array.from({ length: Math.min(parallel, items.length) }, async () => { while (next < items.length) await run(items[next++]!) }))
-}
-// A pull request or commit GitHub has none of, as one deleted: its field null.
-const notFound = (error: GraphqlError) => error?.type === 'NOT_FOUND'
-
-// The pull requests squashed into `commits`, a merged pull request's merge
-// commit of one parent, not one rebased (its commits copied onto the branch,
-// told by their subjects), kept by each commit (`squashes`), those not yet
-// kept looked up with GraphQL, as many as MAX_SQUASH_LOOKUPS an answer.
-export async function squashedPulls(fullName: string, token: string, commits: HistoryCommit[], squashes: Squashes,
-  fetchImpl: typeof fetch = globalThis.fetch): Promise<SquashedPull[]> {
-  const [owner, name] = fullName.split('/') as [string, string]
-  const single = commits.filter(commit => commit.parents.length === 1)
-  const listed = new Map(commits.map(commit => [commit.sha, commit]))
-  const kept = await squashes.read(single.map(commit => commit.sha))
-  const unknown = single.filter(commit => !kept.has(commit.sha)).slice(0, MAX_SQUASH_LOOKUPS)
-  const merged: { commit: HistoryCommit; number: number }[] = []
-  const found = new Map<string, SquashedPull | null>()
-  await eachOf(chunked(unknown, SQUASH_COMMITS), SQUASH_PARALLEL, async batch => {
-    const data = await githubGraphql(mergedPullsQuery(batch.length), { owner, name, ...Object.fromEntries(batch.map((commit, at) => [`o${at}`, commit.sha])) },
-      token, fetchImpl, notFound) as MergedPulls
-    for (const [at, commit] of batch.entries()) {
-      const node = data?.repository?.[`c${at}`]
-      if (!node) continue
-      const pull = node.associatedPullRequests?.nodes?.[0]
-      const number = pull?.mergeCommit?.oid === commit.sha && Number.isSafeInteger(pull.number) && (pull.number as number) > 0 ? pull.number as number : null
-      if (number === null) { found.set(commit.sha, null); await squashes.write(commit.sha, null) }
-      else merged.push({ commit, number })
-    }
-  })
-  await eachOf(chunked(merged, SQUASH_PULLS), SQUASH_PARALLEL, async batch => {
-    const data = await githubGraphql(squashedQuery(batch.length), { owner, name, ...Object.fromEntries(batch.map(({ number }, at) => [`n${at}`, number])) },
-      token, fetchImpl, notFound) as SquashedPage
-    for (const [at, { commit, number }] of batch.entries()) {
-      const node = data?.repository?.[`p${at}`]
-      if (!node) continue
-      const own = (node.commits?.nodes ?? []).flatMap(item => graphCommit(item?.commit) ?? [])
-      const head = typeof node.headRefOid === 'string' && SHA.test(node.headRefOid) ? node.headRefOid : own.at(-1)?.sha
-      // Fast-forwarded, its last commit the merge's own; or rebased, its
-      // commits, more than one, copied onto the branch: the merge and those
-      // below it on their first parents, by their subjects, its commits'
-      // (one squashed is told by its commit's title too, by default, and
-      // drawn as it was either way).
-      const below = [commit]
-      for (let next = listed.get(commit.parents[0] ?? ''); next && below.length < own.length; next = listed.get(next.parents[0] ?? '')) below.push(next)
-      const copies = own.toReversed().slice(0, below.length).every((item, step) => below[step]!.subject === item.subject)
-      // Its commits' copies as far as those listed go, but not all of them
-      // listed: told, and kept, once they are.
-      if (own.length > 1 && copies && below.length < own.length) continue
-      const rebased = own.length > 1 && copies
-      const squashed = head !== undefined && head !== commit.sha && own.length > 0 && !own.some(item => item.sha === commit.sha) && !rebased
-      const pull = squashed ? { merge: commit.sha, number, head, commits: own, more: Number(node.commits?.totalCount) > own.length } : null
-      found.set(commit.sha, pull)
-      await squashes.write(commit.sha, pull)
-    }
-  })
-  return single.flatMap(commit => kept.get(commit.sha) ?? found.get(commit.sha) ?? [])
+  const attempt = async (batch: T[]): Promise<void> => {
+    await turn()
+    try {
+      if (failed.length === 0) await run(batch)
+      return
+    } catch (err) {
+      if (batch.length === 1 || halved >= 2 * parallel || !(err instanceof GithubApiError && SLOW.has(err.message))) { failed.push(err); return }
+      halved++
+    } finally { done() }
+    const half = Math.ceil(batch.length / 2)
+    await Promise.all([attempt(batch.slice(0, half)), attempt(batch.slice(half))])
+  }
+  await Promise.all(chunked(items, size).map(attempt))
+  if (failed.length > 0) throw failed[0]
 }
 
 // The open pull requests most recently updated, each by the commit its head

package/server-managed/repository-issues.ts

@@ -6,9 +6,11 @@
 // review and its checks, which GraphQL alone gives, so it needs a token; an
 // open one's, and its popup's, whether it changes a lockfile whose new
 // packages are told (pull-dependencies.ts touchesLockfile), and its reviews
-// (pull-reviews.ts), each reviewer's. A nonpublic repository's are read with
-// its GitHub App's installation, which reads pull requests only with their
-// own permission (README).
+// (pull-reviews.ts), each reviewer's; and an open one's base's and head's
+// commits, kept with its page but never told, by which what its lockfiles
+// add is read (http.ts teamRepositoryDependencies). A nonpublic repository's
+// are read with its GitHub App's installation, which reads pull requests only
+// with their own permission (doc/code-viewer.md).
 import { GithubApiError } from './github-app.ts'
 import { touchesLockfile } from './pull-dependencies.ts'
 import { ACTOR, type GraphAccount, type GraphqlError, actorOf, githubGraphql } from './repository-history.ts'
@@ -16,11 +18,12 @@ import { ITEM_THREADS, type ReviewNode, TILE_THREADS, pullReviews, reviewFields,
 
 export const ISSUES_PAGE = 50
 // What a kept page or item was read as: kept ones read before differ.
-export const ISSUES_READ_VERSION = 3
+export const ISSUES_READ_VERSION = 4
 const MAX_LABELS = 20
 const MAX_TITLE = 1000
 const MAX_NAME = 256
 const COLOR = /^[a-f\d]{6}$/iu
+const SHA = /^[a-f\d]{40}$/u
 // A page's cursor as GitHub gives it, to read on from: opaque, base64 or
 // base64url as it is now (`…rOrK_u7Q==`), passed back to GitHub alone, so any
 // printable one is, but none with spaces or control characters.
@@ -43,21 +46,22 @@ const connection = { issues: 'issues', pulls: 'pullRequests' }
 const states = { issues: { open: '[OPEN]', closed: '[CLOSED]' }, pulls: { open: '[OPEN]', closed: '[CLOSED, MERGED]' } }
 
 // A page of `kind`, those in `state`, after the page `after` ends, and how
-// many of each state there are; open pull requests with their reviews.
+// many of each state there are; open pull requests with their commits and
+// their reviews.
 const pageQuery = (kind: IssuesKind, state: IssuesState) => `query($owner: String!, $name: String!, $after: String) {
   repository(owner: $owner, name: $name) {
     open: ${connection[kind]}(states: ${states[kind].open}) { totalCount }
     closed: ${connection[kind]}(states: ${states[kind].closed}) { totalCount }
     page: ${connection[kind]}(states: ${states[kind][state]}, first: ${ISSUES_PAGE}, after: $after, orderBy: { field: UPDATED_AT, direction: DESC }) {
       pageInfo { hasNextPage endCursor }
-      nodes { ${fields[kind]}${kind === 'pulls' && state === 'open' ? ` ${files} ${reviewFields(TILE_THREADS, false)}` : ''} }
+      nodes { ${fields[kind]}${kind === 'pulls' && state === 'open' ? ` baseRefOid headRefOid ${files} ${reviewFields(TILE_THREADS, false)}` : ''} }
     }
   }
 }`
 
 type Node = ReviewNode & { number?: unknown; title?: unknown; createdAt?: unknown; updatedAt?: unknown; closedAt?: unknown; mergedAt?: unknown; author?: GraphAccount
   comments?: { totalCount?: unknown }; labels?: { totalCount?: unknown; nodes?: { name?: unknown; color?: unknown }[] }; state?: unknown; stateReason?: unknown
-  isDraft?: unknown; reviewDecision?: unknown; additions?: unknown; deletions?: unknown; headRefName?: unknown; baseRefName?: unknown
+  isDraft?: unknown; reviewDecision?: unknown; additions?: unknown; deletions?: unknown; headRefName?: unknown; baseRefName?: unknown; baseRefOid?: unknown
   commits?: { nodes?: { commit?: { statusCheckRollup?: { state?: unknown } | null } | null }[] }
   files?: { totalCount?: unknown; nodes?: ({ path?: unknown } | null)[] } | null }
 type Page = { repository?: { open?: { totalCount?: unknown }; closed?: { totalCount?: unknown }
@@ -159,9 +163,17 @@ export async function repositoryItem(fullName: string, token: string, number: nu
       mergedBy: merger.login, mergedById: merger.id, reviews: pullReviews(node, tile.author, true) }
 }
 
+// An open pull request's base's and head's commits, by its number, as GitHub
+// has them now: those its REST API names `base.sha` and `head.sha`
+// (pull-dependencies.ts pullCommits). None where either isn't a commit's id.
+const commitsOf = (number: number, { baseRefOid: base, headRefOid: head }: Node) =>
+  typeof base === 'string' && SHA.test(base) && typeof head === 'string' && SHA.test(head) ? [{ number, base, head }] : []
+
 // A page of the repository's issues or pull requests in `state`, after the
 // page `after` ended (null for the first): its `items`, how many are open and
-// closed (`counts`), and, where more follow, the cursor reading them (`after`).
+// closed (`counts`), and, where more follow, the cursor reading them
+// (`after`); open pull requests' commits (`commits`, commitsOf) too, which
+// the code viewer is never told (http.ts handleRepositoryIssues).
 export async function repositoryIssues(fullName: string, token: string, kind: IssuesKind, state: IssuesState, after: string | null, fetchImpl: typeof fetch = globalThis.fetch) {
   const [owner, name] = fullName.split('/') as [string, string]
   const data = await githubGraphql(pageQuery(kind, state), { owner, name, after }, token, fetchImpl, partRefused) as Page
@@ -169,13 +181,15 @@ export async function repositoryIssues(fullName: string, token: string, kind: Is
   if (!repository) throw new GithubApiError(404, 'github-not-found')
   const info = repository.page?.pageInfo
   const next = info?.hasNextPage === true && typeof info.endCursor === 'string' && ISSUES_CURSOR.test(info.endCursor) ? info.endCursor : null
+  const open = kind === 'pulls' && state === 'open'
+  const tiles = (repository.page?.nodes ?? []).flatMap(node => {
+    const tile = item(kind, node)
+    return tile && node ? [{ node, tile }] : []
+  })
   return {
-    items: (repository.page?.nodes ?? []).flatMap(node => {
-      const tile = item(kind, node)
-      if (!tile) return []
-      return kind === 'pulls' && state === 'open' && node ? [{ ...tile, reviews: pullReviews(node, tile.author) }] : [tile]
-    }),
+    items: tiles.map(({ node, tile }) => open ? { ...tile, reviews: pullReviews(node, tile.author) } : tile),
     counts: { open: count(repository.open?.totalCount), closed: count(repository.closed?.totalCount) },
     more: next !== null, after: next,
+    ...open ? { commits: tiles.flatMap(({ node, tile }) => commitsOf(tile.number, node)) } : {},
   }
 }

package/server-managed/repository-pulse.ts

@@ -20,7 +20,7 @@ import { ACTOR, type GraphAccount, type HistoryCommit, type HistoryPages, accoun
 export const PULSE_WEEKS = [1, 4, 13, 52]
 // What a year counted from its commits holds, its version: kept years of
 // another are counted again.
-export const PULSE_YEAR_VERSION = 9
+export const PULSE_YEAR_VERSION = 11
 const WEEK_MS = 7 * 24 * 60 * 60_000
 const DAY_MS = 24 * 60 * 60_000
 const MAX_CONTRIBUTORS = 100
@@ -76,18 +76,21 @@ export interface PulseCommit { sha: string; at: number; subject: string; login:
 // each commit's own time zone, and, counted from its commits, each period's
 // (`punches`, by its weeks); `lines` false where GitHub counts none, null
 // while it is counting them; counted from its commits, the latest pushed to
-// the branch directly (`directCommits`, as many as DIRECT_LISTED).
+// the branch directly (`directCommits`, as many as DIRECT_LISTED); and,
+// counted from its commits read no further back than a period needed, when
+// from it is counted whole (`from`), absent for the year whole.
 export interface PulseStats { weeks: PulseWeek[]; contributors: PulseContributor[]; punch: number[][]; punches?: Record<number, number[][]>; lines: boolean | null
-  directCommits?: PulseCommit[] }
+  directCommits?: PulseCommit[]; from?: number }
 // The lines added and removed a week, and each contributor's, as GitHub's
 // statistics count them, `lines` false where it counts none.
 export interface PulseLines { weeks: [number, number, number][]; contributors: { login: string; weeks: [number, number, number][] }[]; lines: boolean }
 // The days (`from`, `to`, both days, UTC; `to` none, on) and the authors (GitHub
 // logins, any of them) a period's pull requests and issues are narrowed to.
 export interface PulseNarrowing { from: number; to: number | null; authors: string[] }
-// The year's commits read so far: all of them (`commits`), else how many
-// (`read`), and whether past YEAR_COMMITS (`tooMany`).
-export type YearCommits = { complete: true; commits: HistoryCommit[]; passed: HistoryCommit[] } | { complete: false; read: number; tooMany: boolean }
+// The year's commits read so far: all of them, or as far back as asked
+// (`commits`, `from`), else how many (`read`), and whether past
+// YEAR_COMMITS (`tooMany`).
+export type YearCommits = { complete: true; commits: HistoryCommit[]; passed: HistoryCommit[]; from: number | null } | { complete: false; read: number; tooMany: boolean }
 
 const count = (value: unknown) => Number.isSafeInteger(value) && (value as number) >= 0 ? value as number : 0
 const timeOf = (value: unknown) => {
@@ -204,17 +207,28 @@ export async function defaultHead(fullName: string, token: string, fetchImpl: ty
 // YEAR_QUERIES, the rest left for the next to ask (`complete` false, how
 // many are `read`); more than YEAR_COMMITS, too many (`tooMany`). Read
 // whole, those it was read on past besides (`passed`): undated, or dated
-// before it, a clock behind, the branch's commits since beneath them.
+// before it, a clock behind, the branch's commits since beneath them. Read
+// no further than `need` asks, those since it read whole (`complete`, `from`
+// the newest of those read whose parents are not, every commit after it
+// read; null, the year read whole).
 export async function yearCommits(fullName: string, token: string, head: string, since: number, pages: HistoryPages,
-  fetchImpl: typeof fetch = globalThis.fetch): Promise<YearCommits> {
+  fetchImpl: typeof fetch = globalThis.fetch, need = since): Promise<YearCommits> {
   const found = new Map<string, HistoryCommit>()
   const tried = new Set<string>()
   const within = (commit: HistoryCommit) => commit.committedAt === null || commit.committedAt >= since - YEAR_SKEW_MS
   const dated = (commit: HistoryCommit) => commit.committedAt !== null && commit.committedAt >= since
   const read = () => [...found.values()].filter(dated).length
+  const passed = () => [...found.values()].filter(commit => !dated(commit) && within(commit))
   let queries = 0
   let starts = [head]
   while (starts.length > 0) {
+    // Those not read yet, the head before any, else the parents of those
+    // read, no later than the newest of them (but for a clock behind): read
+    // whole after it.
+    const unread = new Set(starts)
+    const from = found.size === 0 ? Number.POSITIVE_INFINITY : Math.max(Number.NEGATIVE_INFINITY, ...[...found.values()]
+      .filter(commit => commit.parents.some(sha => unread.has(sha))).map(commit => commit.committedAt ?? Number.POSITIVE_INFINITY))
+    if (need > since && from < need) return { complete: true, commits: [...found.values()].filter(dated), passed: passed(), from }
     if (queries >= YEAR_QUERIES) return { complete: false, read: read(), tooMany: false }
     const batch = starts.slice(0, YEAR_STARTS)
     for (const sha of batch) tried.add(sha)
@@ -224,18 +238,24 @@ export async function yearCommits(fullName: string, token: string, head: string,
     if (read() > YEAR_COMMITS) return { complete: false, read: read(), tooMany: true }
     starts = [...new Set([...found.values()].filter(within).flatMap(commit => commit.parents))].filter(sha => !found.has(sha) && !tried.has(sha))
   }
-  return { complete: true, commits: [...found.values()].filter(dated), passed: [...found.values()].filter(commit => !dated(commit) && within(commit)) }
+  return { complete: true, commits: [...found.values()].filter(dated), passed: passed(), from: null }
 }
 
+// Whether an author is a GitHub App's bot: by its login (`<app>[bot]`, as a
+// commit's no-reply address names it, github-accounts.ts commitAccount),
+// else, for one GitHub names no account for, by the name it commits as.
+const bot = (login: string | null | undefined, name: string | null | undefined) => /\[bot\]$/iu.test(login ?? name ?? '')
+
 // Whether an agent made `commit` or co-authored it: its author one of
 // GitHub's agents (common/managed/github-agents.ts githubAgent), or any of
 // its co-authors an agent (commit-coauthors.ts coauthorsOf), as Commits
-// marks them; or one an agent's pull request brought (`merges`,
+// marks them, or any bot, whichever GitHub App's; or one an agent's pull request brought (`merges`,
 // agent-merges.ts agentCommits); or one an account agents work as pushed to
 // the branch directly (`direct`, github-agents.ts agentOperated).
 const withAgent = (commit: HistoryCommit, merges: ReadonlySet<string>, direct: ReadonlySet<string>) => merges.has(commit.sha)
   || (direct.has(commit.sha) && agentOperated(commit.authorLogin, commit.authorId ?? null))
-  || githubAgent(commit.authorLogin, commit.authorId ?? null, commit.authorName) !== null || (commit.coauthors ?? []).some(coauthor => coauthor.agent)
+  || githubAgent(commit.authorLogin, commit.authorId ?? null, commit.authorName) !== null || bot(commit.authorLogin, commit.authorName)
+  || (commit.coauthors ?? []).some(coauthor => Boolean(coauthor.agent) || bot(coauthor.login, coauthor.name))
 
 // The year from `first` (pulseSince(52, …)) of `commits`, as GitHub's
 // statistics count them, merges left out: a week a row, its commits each day