pr-merge-queue 0.0.0-stage → 0.0.0

package/src/push-fixed-pr/push-fixed-pr.test.mts

@@ -0,0 +1,228 @@
+import {
+  queueOwner,
+  readQueueComments,
+  writeClaimComment,
+  writeSetAsideComment,
+  type QueueComments,
+  type ReportEntry,
+} from 'pr-report-core';
+import { Arr } from 'ts-data-forge';
+import { decidePush, parsePushArgs } from './push-fixed-pr.mjs';
+
+const HEAD = 'c'.repeat(40);
+
+const FIX = 'f'.repeat(40);
+
+const NOW = Date.parse('2026-10-15T00:30:00Z');
+
+const entry = (fields: Partial<ReportEntry> = {}): ReportEntry =>
+  ({
+    number: 2267,
+    title: 'fix: a thing',
+    body: '',
+    author: 'someone',
+    isDraft: false,
+    labels: [{ name: 'merge-queued', color: '', description: '' }],
+    autoMerge: false,
+    headRef: 'fix/a-thing',
+    headSha: HEAD,
+    baseRef: 'main',
+    fromFork: false,
+    url: '',
+    updatedAt: '2026-10-15T00:00:00Z',
+    headCommittedAt: undefined,
+    comparison: undefined,
+    reported: new Map(),
+    checksRunning: false,
+    linkedIssues: [],
+    mergeAfter: [],
+    stackedOn: undefined,
+    inheritedMergeAfter: [],
+    notStartedIssues: [],
+    blockedBy: [],
+    checks: {
+      verdict: 'paused',
+      passed: [],
+      failed: [],
+      pending: [],
+      skipped: [],
+      missing: [],
+      notRun: [],
+      required: 0,
+    },
+    ...fields,
+  }) as const;
+
+const SET_ASIDE = writeSetAsideComment(
+  { reason: 'rebase-failed', headSha: HEAD, baseSha: 'a'.repeat(40) },
+  'prose',
+);
+
+const claimedBy = (by: string): string =>
+  writeClaimComment({ headSha: HEAD, by, at: '2026-10-15T00:00:00Z' }, 'prose');
+
+const read = (...bodies: readonly string[]): QueueComments =>
+  readQueueComments(
+    bodies.map((body, index) => ({ id: index + 1, body })),
+    { headSha: HEAD, baseTip: 'a'.repeat(40), nowEpochMs: NOW },
+  );
+
+const decide = (
+  entries: readonly ReportEntry[],
+  ...bodies: readonly string[]
+): ReturnType<typeof decidePush> => {
+  const comments = read(...bodies);
+
+  const target = entries.find((e) => e.number === 2267);
+
+  return decidePush({
+    number: 2267,
+    by: 'me',
+    head: FIX,
+    entries,
+    owner:
+      target === undefined
+        ? undefined
+        : queueOwner({
+            number: target.number,
+            labels: target.labels.map(({ name }) => name),
+            isDraft: target.isDraft,
+            fromFork: target.fromFork,
+            headRef: target.headRef,
+            headSha: target.headSha,
+            baseRef: target.baseRef,
+            defaultBranch: 'main',
+            stackedOn: target.stackedOn,
+            inCycle: false,
+            setAside: comments.setAside?.says,
+            claim: comments.claim?.says,
+            nowEpochMs: NOW,
+          }),
+    comments,
+  });
+};
+
+describe(decidePush, () => {
+  test('pushes a claimed fix leased against the claimed head, putting skip-ci on first', () => {
+    assert.deepStrictEqual(decide([entry()], SET_ASIDE, claimedBy('me')), {
+      kind: 'push',
+      pr: {
+        number: 2267,
+        state: 'OPEN',
+        headRefName: 'fix/a-thing',
+        headRefOid: HEAD,
+        baseRefName: 'main',
+        isCrossRepository: false,
+      },
+      head: FIX,
+      addSkipCi: true,
+      layers: [],
+    });
+  });
+
+  test('carries the layers stacked on it along, lowest first', () => {
+    const decided = decide(
+      [
+        entry({
+          labels: Arr.toUnshifted({
+            name: 'skip-ci',
+            color: '',
+            description: '',
+          })(entry().labels),
+        }),
+        entry({
+          number: 2290,
+          headRef: 'feat/top',
+          baseRef: 'feat/middle',
+          stackedOn: 2280,
+        }),
+        entry({
+          number: 2280,
+          headRef: 'feat/middle',
+          baseRef: 'fix/a-thing',
+          stackedOn: 2267,
+        }),
+      ],
+      SET_ASIDE,
+      claimedBy('me'),
+    );
+
+    assert.strictEqual(decided.kind, 'push');
+
+    if (decided.kind !== 'push') {
+      return;
+    }
+
+    assert.isFalse(decided.addSkipCi);
+
+    assert.deepStrictEqual(
+      decided.layers.map(({ number }) => number),
+      [2280, 2290],
+    );
+  });
+
+  test('refuses without a claim of its own', () => {
+    assert.strictEqual(decide([entry()], SET_ASIDE).kind, 'refuse');
+
+    assert.strictEqual(
+      decide([entry()], SET_ASIDE, claimedBy('other')).kind,
+      'refuse',
+    );
+  });
+
+  test('refuses one that is not a skill’s', () => {
+    assert.strictEqual(decide([entry()]).kind, 'refuse');
+  });
+
+  test('refuses a conflict on the dependency update, which is rebuilt instead', () => {
+    const update = entry({ headRef: 'chore/pnpm-update' });
+
+    const decided = decide([update], SET_ASIDE, claimedBy('me'));
+
+    assert.strictEqual(decided.kind, 'refuse');
+
+    assert.include(
+      decided.kind === 'refuse' ? decided.reason : '',
+      'rebuild-pnpm-update',
+    );
+
+    assert.strictEqual(
+      decide(
+        [update],
+        writeSetAsideComment(
+          { reason: 'checks-failed', headSha: HEAD, baseSha: 'a'.repeat(40) },
+          'prose',
+        ),
+        claimedBy('me'),
+      ).kind,
+      'push',
+    );
+  });
+
+  test('refuses one that is not open', () => {
+    assert.strictEqual(decide([], SET_ASIDE, claimedBy('me')).kind, 'refuse');
+  });
+});
+
+describe(parsePushArgs, () => {
+  test('reads the pull request, the claimant and the commit', () => {
+    assert.deepStrictEqual(
+      parsePushArgs(['--', '2267', '--by', 'me', '--head', FIX]),
+      { number: 2267, by: 'me', head: FIX },
+    );
+  });
+
+  test('refuses what it cannot act on', () => {
+    for (const args of [
+      [],
+      ['2267', '--by', 'me'],
+      ['2267', '--head', FIX],
+      ['2267', '--by', 'me', '--head', 'HEAD'],
+      ['2267', '--by', 'me', '--head', `${FIX};rm`],
+      ['x', '--by', 'me', '--head', FIX],
+      ['2267', '2268', '--by', 'me', '--head', FIX],
+    ]) {
+      assert.isString(parsePushArgs(args));
+    }
+  });
+});

package/src/report-unowned-prs/index.mts

@@ -0,0 +1 @@
+export * from './report-unowned-prs.mjs';

package/src/report-unowned-prs/report-unowned-prs.mts

@@ -0,0 +1,190 @@
+import type { QueueComments, QueueOwner, ReportEntry } from 'pr-report-core';
+import { Arr, Result } from 'ts-data-forge';
+import * as t from 'ts-fortress';
+import { resolveApiContext, rest, viewerLogin } from '../lib/index.mjs';
+import { readQueueState } from '../pr-report/index.mjs';
+
+/** What `report-unowned-prs --help` prints. */
+export const REPORT_UNOWNED_PRS_HELP = [
+  'Usage: report-unowned-prs [--dry-run]',
+  '',
+  'Files an issue for each queued pull request nobody owns: one the',
+  'worker, a skill and a person are all waiting on someone else for.',
+  'Once per pull request; an open issue this account filed is not filed again.',
+  '',
+  'Options:',
+  '  --dry-run   say what it would file, and file nothing',
+  '  -h, --help  show this help',
+].join('\n');
+
+/**
+ * Files an issue for each queued pull request nobody owns.
+ *
+ * Every pull request in the queue is the worker's, a skill's or a person's
+ * (`pr-report-core`'s `queue-owner.mts`); `none` means the rules met a state
+ * they do not cover, and a pull request in it waits for nothing that will
+ * come. That is a bug in the queue's tooling, not in the pull request, so it
+ * is reported as one — once per pull request, found again by a hidden line
+ * in the body of an open issue this account wrote — rather than left for
+ * someone to notice the queue has stopped.
+ *
+ * ```sh
+ * report-unowned-prs            # file what is not filed yet
+ * report-unowned-prs --dry-run  # say what it would file
+ * ```
+ *
+ * The `/unblock-prs` skill runs it on every round. It reads the owners as
+ * every other command does (`pr-report/queue.mts`) and writes as the token's
+ * account, which has to be the one `unblock-prs` runs as.
+ */
+export const reportUnownedPrs = async (
+  dryRun: boolean,
+): Promise<Result<string, string>> => {
+  const state = await readQueueState();
+
+  if (Result.isErr(state)) {
+    return Result.err(`cannot read the queue: ${state.value}`);
+  }
+
+  const { decided, owners, queue } = state.value;
+
+  const unowned = decided.entries.filter(
+    (entry) => owners.get(entry.number)?.owner === 'none',
+  );
+
+  if (!Arr.isNonEmpty(unowned)) {
+    return Result.ok('Every queued pull request has an owner.');
+  }
+
+  const api = await resolveApiContext();
+
+  if (Result.isErr(api)) {
+    return api;
+  }
+
+  const viewer = await viewerLogin(api.value.token);
+
+  if (Result.isErr(viewer)) {
+    return Result.err(`cannot read who the token is: ${viewer.value}`);
+  }
+
+  // Issues and pull requests come from one endpoint; a pull request has no
+  // body this marker could be in that this account wrote as an issue.
+  const listed = await rest(api.value, 'GET', '/issues', IssueListSchema, {
+    query: { state: 'open', creator: viewer.value, per_page: '100' },
+  });
+
+  if (Result.isErr(listed)) {
+    return Result.err(`cannot list the open issues: ${listed.value}`);
+  }
+
+  const plan = planUnownedReports(
+    unowned.map((entry) => ({
+      entry,
+      owner: owners.get(entry.number),
+      comments: queue.get(entry.number),
+    })),
+    listed.value.map(({ number, body }) => ({ number, body: body ?? '' })),
+  );
+
+  const mut_lines = plan.reported.map(
+    ({ pr, issue }) => `#${pr}: already reported in #${issue}.`,
+  );
+
+  for (const report of plan.toFile) {
+    if (dryRun) {
+      mut_lines.push(`#${report.pr}: would file "${report.title}".`);
+
+      continue;
+    }
+
+    const filed = await rest(
+      api.value,
+      'POST',
+      '/issues',
+      t.record({ number: t.number() }),
+      { body: { title: report.title, body: report.body } },
+    );
+
+    mut_lines.push(
+      Result.isErr(filed)
+        ? `#${report.pr}: could not file an issue: ${filed.value}`
+        : `#${report.pr}: filed #${filed.value.number}.`,
+    );
+  }
+
+  return Result.ok(mut_lines.join('\n'));
+};
+
+/**
+ * What to file for each pull request nobody owns, given the open issues this
+ * account wrote: one already carrying the pull request's marker is reported
+ * and not filed again.
+ */
+export const planUnownedReports = (
+  unowned: readonly Readonly<{
+    entry: ReportEntry;
+    owner: QueueOwner | undefined;
+    comments: QueueComments | undefined;
+  }>[],
+  openIssues: readonly Readonly<{ number: number; body: string }>[],
+): Readonly<{
+  toFile: readonly Readonly<{ pr: number; title: string; body: string }>[];
+  reported: readonly Readonly<{ pr: number; issue: number }>[];
+}> => {
+  const issueOf = (pr: number): number | undefined =>
+    openIssues.find(({ body }) => body.includes(markerOf(pr)))?.number;
+
+  return {
+    reported: Arr.generate(function* () {
+      for (const { entry } of unowned) {
+        const issue = issueOf(entry.number);
+
+        if (issue !== undefined) {
+          yield { pr: entry.number, issue };
+        }
+      }
+    }),
+    toFile: unowned
+      .filter(({ entry }) => issueOf(entry.number) === undefined)
+      .map(({ entry, owner, comments }) => ({
+        pr: entry.number,
+        title: `unblock-prs: #${entry.number} is in the queue with no owner`,
+        body: reportBody(entry, owner, comments),
+      })),
+  };
+};
+
+const markerOf = (pr: number): string =>
+  `<!-- unblock-prs:unowned pr=${pr} -->` as const;
+
+const reportBody = (
+  entry: ReportEntry,
+  owner: QueueOwner | undefined,
+  comments: QueueComments | undefined,
+): string =>
+  [
+    markerOf(entry.number),
+    '',
+    `#${entry.number} is in the merge queue, and \`queueOwner\` (\`libs/pr-report-core/src/queue-owner.mts\`) gives it to nobody: the worker, the skills and the people working the queue each leave it to the others.`,
+    '',
+    `- Why: ${owner?.reason ?? 'no owner was returned'}`,
+    `- Labels: ${Arr.isNonEmpty(entry.labels) ? entry.labels.map(({ name }) => `\`${name}\``).join(', ') : 'none'}`,
+    `- Head: \`${entry.headRef}\` at \`${entry.headSha}\`, onto \`${entry.baseRef}\`${entry.stackedOn === undefined ? '' : ` (stacked on #${entry.stackedOn})`}`,
+    `- Set-aside comment: ${describeComment(comments?.setAside?.says)}`,
+    `- Claim: ${describeComment(comments?.claim?.says)}`,
+    '',
+    'Give the state an owner in `queue-owner.mts` (with a test), or make the writer that produced it stop producing it. Then the pull request needs whatever its new owner does; until then a person moves it by hand.',
+    '',
+    'Filed by `report-unowned-prs`.',
+  ].join('\n');
+
+const describeComment = (says: unknown): string =>
+  says === undefined ? 'none' : (`\`${JSON.stringify(says)}\`` as const);
+
+const IssueListSchema = t.array(
+  t.record({
+    number: t.number(),
+    body: t.union([t.string(), t.nullType]),
+  }),
+);

package/src/report-unowned-prs/report-unowned-prs.test.mts

@@ -0,0 +1,87 @@
+import type { ReportEntry } from 'pr-report-core';
+import { planUnownedReports } from './report-unowned-prs.mjs';
+
+const entry = (number: number): ReportEntry =>
+  ({
+    number,
+    title: 'fix: a thing',
+    body: '',
+    author: 'someone',
+    isDraft: false,
+    labels: [{ name: 'merge-queued', color: '', description: '' }],
+    autoMerge: false,
+    headRef: `fix/${number}`,
+    headSha: 'c'.repeat(40),
+    baseRef: 'main',
+    fromFork: false,
+    url: '',
+    updatedAt: '2026-10-15T00:00:00Z',
+    headCommittedAt: undefined,
+    comparison: undefined,
+    reported: new Map(),
+    checksRunning: false,
+    linkedIssues: [],
+    mergeAfter: [],
+    stackedOn: undefined,
+    inheritedMergeAfter: [],
+    notStartedIssues: [],
+    blockedBy: [],
+    checks: {
+      verdict: 'paused',
+      passed: [],
+      failed: [],
+      pending: [],
+      skipped: [],
+      missing: [],
+      notRun: [],
+      required: 0,
+    },
+  }) as const;
+
+const unowned = (number: number) =>
+  ({
+    entry: entry(number),
+    owner: { owner: 'none', reason: 'set aside for `mystery`' },
+    comments: undefined,
+  }) as const;
+
+describe(planUnownedReports, () => {
+  test('files one issue per pull request, marked so it is found again', () => {
+    const plan = planUnownedReports([unowned(2267)], []);
+
+    assert.deepStrictEqual(plan.reported, []);
+
+    assert.lengthOf(plan.toFile, 1);
+
+    const [report] = plan.toFile;
+
+    assert.strictEqual(
+      report?.title,
+      'unblock-prs: #2267 is in the queue with no owner',
+    );
+
+    assert.match(
+      report?.body ?? '',
+      /^<!-- unblock-prs:unowned pr=2267 -->\n/u,
+    );
+
+    assert.include(report?.body ?? '', 'set aside for `mystery`');
+  });
+
+  test('does not file again what an open issue already reports', () => {
+    const plan = planUnownedReports(
+      [unowned(2267), unowned(2273)],
+      [
+        { number: 2300, body: '<!-- unblock-prs:unowned pr=2267 -->\n\nprose' },
+        { number: 2301, body: '<!-- unblock-prs:unowned pr=22670 -->' },
+      ],
+    );
+
+    assert.deepStrictEqual(plan.reported, [{ pr: 2267, issue: 2300 }]);
+
+    assert.deepStrictEqual(
+      plan.toFile.map(({ pr }) => pr),
+      [2273],
+    );
+  });
+});