pr-merge-queue 0.0.0-stage → 0.0.0

package/dist/unblock-prs/index.d.mts

@@ -0,0 +1,25 @@
+export * from './auto-fix.mjs';
+export * from './checks.mjs';
+export * from './claims.mjs';
+export * from './config.mjs';
+export * from './constants.mjs';
+export * from './demotions.mjs';
+export * from './github.mjs';
+export * from './labels.mjs';
+export * from './main.mjs';
+export * from './merge-after.mjs';
+export * from './options.mjs';
+export * from './owner.mjs';
+export * from './quiet.mjs';
+export * from './rebase.mjs';
+export * from './release.mjs';
+export * from './set-aside-comment.mjs';
+export * from './set-aside-detail.mjs';
+export * from './skips.mjs';
+export * from './stack.mjs';
+export * from './triage.mjs';
+export * from './types.mjs';
+export * from './util.mjs';
+export * from './version-pr.mjs';
+export * from './watch.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/unblock-prs/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../src/unblock-prs/index.mts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC"}

package/dist/unblock-prs/index.mjs

@@ -0,0 +1,25 @@
+export * from './auto-fix.mjs';
+export * from './checks.mjs';
+export * from './claims.mjs';
+export * from './config.mjs';
+export * from './constants.mjs';
+export * from './demotions.mjs';
+export * from './github.mjs';
+export * from './labels.mjs';
+export * from './main.mjs';
+export * from './merge-after.mjs';
+export * from './options.mjs';
+export * from './owner.mjs';
+export * from './quiet.mjs';
+export * from './rebase.mjs';
+export * from './release.mjs';
+export * from './set-aside-comment.mjs';
+export * from './set-aside-detail.mjs';
+export * from './skips.mjs';
+export * from './stack.mjs';
+export * from './triage.mjs';
+export * from './types.mjs';
+export * from './util.mjs';
+export * from './version-pr.mjs';
+export * from './watch.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/unblock-prs/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/unblock-prs/index.mts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC"}

package/dist/unblock-prs/labels.d.mts

@@ -0,0 +1,49 @@
+/**
+ * What the labels this script reads say about one pull request.
+ * `merge-queued` decides whether a pull request is looked at, `skip-ci`
+ * decides whether it has been released yet, and `blocks-release` decides
+ * whether the version pull request may go at all, `auto-rebase` asks for a
+ * paused pull request to be kept on the tip, and `priority:high` /
+ * `priority:low` move one within the pick order. The strings themselves are
+ * `pr-report-core`'s, because the Pull Requests Manager page reads them too.
+ */
+import { type QueuePriority } from 'pr-report-core';
+import type { PullRequest } from './types.mjs';
+/**
+ * Whether the pull request carries the `skip-ci` label, which is what this
+ * repository uses to say "not yet": the check workflows skip while it is on
+ * and `skip-ci-label.yml` holds the merge with a `pending` `no-skip-ci-label` status,
+ * so there is nothing here to unblock.
+ */
+export declare const isSkipCiLabelled: (pr: PullRequest) => boolean;
+/**
+ * Whether the pull request has been put in the queue — reviewed, and waiting
+ * for its turn rather than for someone to look at it. This is the scope rule:
+ * a pull request without the label is not this script's business, whatever
+ * else it carries.
+ */
+export declare const isMergeQueued: (pr: PullRequest) => boolean;
+/**
+ * Whether the pull request declares that the release must wait for it. A
+ * draft counts: holding a release for something that is not ready yet is the
+ * case the label is for.
+ */
+export declare const blocksRelease: (pr: PullRequest) => boolean;
+/**
+ * Whether the pull request asked to be kept on the tip of the default branch
+ * while it waits, by `auto-rebase`, or by being queued: either way the author
+ * wants it rebased, and while `skip-ci` is on a rebase before its turn costs
+ * nothing and makes its diff easier to read.
+ */
+export declare const wantsAutoRebase: (pr: PullRequest) => boolean;
+/**
+ * Which priority label the pull request carries (`priorityOfLabels`): `both`
+ * is the two at once, which contradict each other and so count as neither.
+ */
+export declare const priorityOf: (pr: PullRequest) => QueuePriority;
+/**
+ * Where {@link priorityOf} puts the pull request in the pick order, as a sort
+ * key: `high` before the rest, `low` after them.
+ */
+export declare const priorityRank: (pr: PullRequest) => 0 | 1 | 2;
+//# sourceMappingURL=labels.d.mts.map

package/dist/unblock-prs/labels.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.d.mts","sourceRoot":"","sources":["../../src/unblock-prs/labels.mts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAOL,KAAK,aAAa,EACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,OAAQ,WAAW,KAAG,OACM,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,aAAa,OAAQ,WAAW,KAAG,OACc,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,aAAa,OAAQ,WAAW,KAAG,OACgB,CAAC;AAEjE;;;;;GAKG;AACH,eAAO,MAAM,eAAe,OAAQ,WAAW,KAAG,OAEW,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,UAAU,OAAQ,WAAW,KAAG,aACQ,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,YAAY,OAAQ,WAAW,KAAG,CAAC,GAAG,CAAC,GAAG,CACE,CAAC"}

package/dist/unblock-prs/labels.mjs

@@ -0,0 +1,49 @@
+
+
+
+
+
+
+
+
+
+import { AUTO_REBASE_LABEL, BLOCKS_RELEASE_LABEL, MERGE_QUEUED_LABEL, priorityOfLabels, priorityRankOfLabels, SKIP_CI_LABEL, } from 'pr-report-core';
+
+
+
+
+
+
+export const isSkipCiLabelled = (pr) => pr.labels.some((label) => label.name === SKIP_CI_LABEL);
+
+
+
+
+
+
+export const isMergeQueued = (pr) => pr.labels.some((label) => label.name === MERGE_QUEUED_LABEL);
+
+
+
+
+
+export const blocksRelease = (pr) => pr.labels.some((label) => label.name === BLOCKS_RELEASE_LABEL);
+
+
+
+
+
+
+export const wantsAutoRebase = (pr) => isMergeQueued(pr) ||
+    pr.labels.some((label) => label.name === AUTO_REBASE_LABEL);
+
+
+
+
+export const priorityOf = (pr) => priorityOfLabels(pr.labels.map(({ name }) => name));
+
+
+
+
+export const priorityRank = (pr) => priorityRankOfLabels(pr.labels.map(({ name }) => name));
+//# sourceMappingURL=labels.mjs.map

package/dist/unblock-prs/labels.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.mjs","sourceRoot":"","sources":["../../src/unblock-prs/labels.mts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,GAEd,MAAM,gBAAgB,CAAC;AAGxB;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,EAAe,EAAW,EAAE,CAC3D,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,aAAa,CAAC,CAAC;AAE1D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,EAAe,EAAW,EAAE,CACxD,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,kBAAkB,CAAC,CAAC;AAE/D;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,EAAe,EAAW,EAAE,CACxD,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,oBAAoB,CAAC,CAAC;AAEjE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,EAAe,EAAW,EAAE,CAC1D,aAAa,CAAC,EAAE,CAAC;IACjB,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,iBAAiB,CAAC,CAAC;AAE9D;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,EAAe,EAAiB,EAAE,CAC3D,gBAAgB,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;AAEtD;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,EAAe,EAAa,EAAE,CACzD,oBAAoB,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC"}

package/dist/unblock-prs/main.d.mts

@@ -0,0 +1,179 @@
+import { Result } from 'ts-data-forge';
+import type { Options } from './options.mjs';
+/**
+ * Keeps the pull requests labelled `merge-queued` moving, one at a time, by
+ * rebasing the one that is out-of-date with the default branch, arming its
+ * auto-merge, and waiting for GitHub to merge it.
+ *
+ * The `/unblock-prs` skill fixes what this script sets aside — a failing check
+ * that needs reading, a conflict — after claiming it, so that this script
+ * leaves it alone meanwhile (`claims.mts`). This script fixes only the one
+ * kind that needs no reading — a fixer's diff, see step 4 — and it never
+ * merges anything: auto-merge does that once the checks are green.
+ *
+ * One cycle:
+ *
+ * 1. List the open pull requests labelled `merge-queued` whose base is the
+ *    default branch. Everything else is not this script's business: an
+ *    unlabelled pull request is passed over in silence, and a labelled one
+ *    that cannot be acted on — a draft, a base that is neither the default
+ *    branch nor another open pull request's — is reported, because the label
+ *    asked for something and the answer is no. A stacked one waits for the
+ *    layer below it (`stack.mts`). Auto-merge is this script's to arm, when
+ *    it picks a pull request (`armOnPick` in `rebase.mts`), whether or not
+ *    it was armed before: the label is the only permission read. Drafts and
+ *    anything a previous cycle gave up on are set aside, and so is one whose
+ *    review holds its merge — a code owner has not approved it, or a
+ *    conversation is unresolved — because no check reports that, and
+ *    releasing it would only run a matrix to sit green. One whose waiting
+ *    paths only its author owns is the exception, since no approval will
+ *    ever come: it is released and watched with auto-merge left off, and
+ *    once its checks are green it is set aside `awaiting-bypass` for a
+ *    person to merge by a ruleset bypass (`pr-report-core`'s
+ *    `review-hold.mts`). The one thing done without the label comes first:
+ *    a layer GitHub moved onto the default branch when the one below it
+ *    merged, still carrying that one's commits, is rebased off them and the
+ *    list read again (`stack.mts`).
+ * 2. If one of them is already up to date and its checks are running, or it
+ *    is clean and about to merge, watch that one instead of rebasing another:
+ *    the merge will move `main` and put every other branch back to `BEHIND`,
+ *    so a second rebase now would only run a CI matrix to throw it away.
+ * 3. Otherwise take the lowest-numbered pull request that is `BEHIND` —
+ *    or, once those are exhausted, one GitHub calls `DIRTY`, then the version
+ *    pull request, then one a watch saw sit green — rebase it onto
+ *    `origin/<default branch>` in a throwaway worktree, and push with
+ *    `--force-with-lease` against the head the survey saw, carrying the
+ *    layers stacked on it along. A rebase that conflicts, or a push that is
+ *    refused, drops that pull request for as long as its head and the base
+ *    stay where they are, and the next
+ *    candidate is tried in the same cycle. A branch that moved under the
+ *    rebase is not one of those: someone else — the skill, or a person — is
+ *    moving it, so nothing is recorded and the cycle surveys again rather
+ *    than start a second matrix on the next candidate.
+ *    When there is no candidate and nothing in flight, a pull request paused
+ *    by `skip-ci` and labelled `auto-rebase` or `merge-queued` that is behind
+ *    is rebased onto the tip instead, with its layers — under the label the
+ *    push runs no checks, and it keeps the diff under review its own. Anything
+ *    that moved sends the cycle back to the survey.
+ * 4. Poll the rebased pull request until it merges, or until something says
+ *    it will not: a required check failed, auto-merge was switched off, the
+ *    `skip-ci` label went on, the branch was pushed by someone else, or every
+ *    required context reported
+ *    green and it still did not merge. "Green" means the whole list the
+ *    ruleset requires, not the part of it that has reported — a required
+ *    context with no check run on the head commit is absent from the
+ *    head's checks rather than pending in them, so reading its absence as
+ *    success is what used to write a pull request off three minutes into a
+ *    twenty-five minute matrix.
+ *    When a required check failed and every job that failed under it is a
+ *    `fix:` or `gen:` entry of the check matrices, run those commands, amend
+ *    what they wrote onto the branch's one commit, push, and watch the new
+ *    head instead — once, and only for the pull request this cycle is
+ *    watching, never the others that are failing.
+ * 5. Remember the verdict against the head *and* the base it was reached on,
+ *    so the pull request is left alone until someone pushes to it or the
+ *    base moves, and say so in its one set-aside comment: a person ticks the
+ *    retry box there to have it tried anyway, the comment is rewritten as
+ *    resolved once the verdict ends, and a later run takes up a verdict it
+ *    finds still standing (`settleSkips`). A pull request that sat green
+ *    without merging is also picked last from then on, until someone else
+ *    pushes to it: the base moving makes it `BEHIND` and a candidate again,
+ *    but whatever held it is something triage could not read, and it would
+ *    otherwise go first each time anything else merged.
+ * 6. Survey again, saying what became of the pull requests this run has
+ *    touched. One that merges after the watch gave up simply stops appearing
+ *    in the list, and this is the only place that gets recorded. When there
+ *    is nothing to do the script sleeps before looking again —
+ *    `--active-interval` seconds while the list keeps changing, so a pull
+ *    request queued a moment ago is not left for minutes, and
+ *    `--idle-interval` once `--idle-after` surveys in a row have seen the
+ *    same list — and keeps going until it is interrupted or `--once` was
+ *    given.
+ *
+ * The rebase happens in a `git worktree` under the OS temp directory, so the
+ * checkout this runs from is never touched — its working tree may be dirty,
+ * and the pull request's branch may even be checked out somewhere else.
+ *
+ * ## The order, and `skip-ci`
+ *
+ * Five things the pull requests themselves declare shape that loop.
+ *
+ * - **A base that is another open pull request's branch** stacks the pull
+ *   request on that one: it is not picked while that one is open, exactly as
+ *   if it had declared `Merge-After:` on it. `stack.mts` says what happens
+ *   when the layer below moves, and when it merges.
+ * - **`Merge-After: #1234` in the body** adds an ordering constraint: the
+ *   pull request is not *picked* while any pull request it names is still
+ *   open. It constrains picking and nothing else — one that is already up to
+ *   date and merging is watched as ever, because auto-merge is going to merge
+ *   it whatever this script thinks, and passing it over would only send the
+ *   cycle off to rebase a branch that merge is about to invalidate. Several
+ *   numbers may be named, on one line or several, so the declarations form a
+ *   graph rather than a chain; a cycle in it is reported by name and
+ *   everything caught in it is left alone, because nothing here can move it.
+ * - **The `skip-ci` label** pauses a queued pull request rather than removing
+ *   it: every check workflow skips while it is on and `no-skip-ci-label`
+ *   holds the merge, so taking it off is the action, and it is taken off one
+ *   pull request at a time. The rebase comes *first* and the label removal
+ *   *second*: while the label is on, the push fires a `synchronize` whose
+ *   every check is skipped, and taking the label off then fires `unlabeled`,
+ *   which runs the matrix once, on the head that will actually be merged. The
+ *   other order starts a full matrix on the pre-rebase head and has the push
+ *   cancel it.
+ * - **The `blocks-release` label** says the next release must contain this
+ *   pull request: while it is open the version pull request — the one
+ *   `changesets/action` opens from `changeset-release/<base>` — is not
+ *   picked. It exists because that is the one pull request whose body cannot
+ *   declare anything: its title and body are overwritten on every push to the
+ *   base, so a `Merge-After:` written there is wiped exactly while several
+ *   queued pull requests made it matter. The same branch is rebuilt from the
+ *   tip and force-pushed by the same workflow, so nothing here rebases it
+ *   either: taking `skip-ci` off, once the release workflow has rebuilt it on
+ *   the current tip, is all it is ever given, and it is picked last so that a
+ *   queued change goes into the release rather than after it.
+ * - **The `auto-rebase` label** asks for a pull request paused by `skip-ci`
+ *   to be kept on the tip while it waits, as a queued one is (step 3). It is
+ *   opt-in so that a branch left to sleep is never moved for want of a label.
+ *
+ * Releasing one is as far as it goes. From there it is an ordinary queued
+ * pull request, and if its checks fail it is set aside like any other — with
+ * its `skip-ci` off. Everything that declared `Merge-After` on it then waits,
+ * because it has not merged, which is what a declared order is for.
+ *
+ * **One queued pull request is released at a time, from this side only.**
+ * Nothing is picked while one is in flight, and after releasing it looks
+ * again: when another the worker owns was released in the same moment and
+ * goes first, it gives back the `skip-ci` it has just taken off its own. It
+ * puts the label on no other pull request (`release.mts`).
+ *
+ * ## Where the rest of it is
+ *
+ * This file is the loop and the command line. Reading order, roughly outside
+ * in:
+ *
+ * - `triage.mts` — what one survey says about each pull request, and why.
+ * - `pr-report-core`'s `review-hold.mts` — whether a pull request's own review
+ *   holds its merge.
+ * - `merge-after.mts` — the declared order: the trailer parser and the cycle
+ *   detection.
+ * - `stack.mts` — stacked pull requests: when they wait, when they are armed,
+ *   and what moves with them.
+ * - `version-pr.mts` — the version pull request, and what holds it back.
+ * - `rebase.mts` — moving a branch: the rebase in a throwaway worktree, and
+ *   taking `skip-ci` off.
+ * - `release.mts` — holding the queue to one released pull request.
+ * - `watch.mts` — polling one pull request until it merges, or until it will
+ *   not.
+ * - `auto-fix.mts` — running the fixer a failed check names, and pushing
+ *   what it wrote.
+ * - `quiet.mts` — how long to sleep when there is nothing to do.
+ * - `checks.mts` — what the merge is waiting for, judged against the contexts
+ *   the ruleset requires.
+ * - `github.mts` — everything that reads or writes GitHub or `git`, and
+ *   nothing that decides. The API client, the runner and the quoting are
+ *   `tools/scripts/lib/`'s.
+ * - `labels.mts`, `skips.mts`, `demotions.mts`, `options.mts`, `types.mts`,
+ *   `constants.mts`, `util.mts` — the vocabulary.
+ */
+export declare const unblockPrs: (options: Options) => Promise<Result<undefined, string>>;
+//# sourceMappingURL=main.d.mts.map

package/dist/unblock-prs/main.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.mts","sourceRoot":"","sources":["../../src/unblock-prs/main.mts"],"names":[],"mappings":"AAQA,OAAO,EAAO,MAAM,EAAE,MAAM,eAAe,CAAC;AAgB5C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAiD7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8KG;AACH,eAAO,MAAM,UAAU,YACZ,OAAO,KACf,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAyEnC,CAAC"}