@oakgreencc/cambium 0.0.9 → 0.0.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +56 -4
- package/package.json +2 -2
- package/src/config.mjs +17 -3
- package/src/github.mjs +129 -16
- package/src/graphs/release.mjs +438 -0
- package/src/marker.mjs +1 -1
- package/src/phases/release.mjs +1 -0
- package/src/tick.mjs +4 -1
package/README.md
CHANGED
|
@@ -2,7 +2,7 @@
|
|
|
2
2
|
|
|
3
3
|
The scheduler daemon. Every tick it reads the `q:*` queues from GitHub, starts headless `claude -p` workers in their own worktrees up to a cap, watches their PRs through CI and the merge queue, and makes every queue transition itself. GitHub is the truth; local SQLite only remembers which processes it started.
|
|
4
4
|
|
|
5
|
-
This is the **Task phase** MVP. Dispatch
|
|
5
|
+
This is the **Task phase** MVP. Dispatch is a seam; Release runs as graphs on `engine: "graph"` and is a seam on the legacy engine (see [Follow-ups](#follow-ups)).
|
|
6
6
|
|
|
7
7
|
Runtime dependencies: `zod` (the [graph module](#graph-module-preview)) and OpenTelemetry via `@oakgreencc/mycelium` (loaded only when [tracing](#tracing) is on); Node ≥ 22.13 (`node:sqlite`). GitHub access goes through [`graft`](../graft), which must be on `PATH`.
|
|
8
8
|
|
|
@@ -41,10 +41,10 @@ Each step is bounded by `stepTimeoutSeconds`. A step that throws or times out is
|
|
|
41
41
|
3. **Watch** (no agent), for agent PRs whose issue is in no queue: merged → close the issue, delete the branch; red → requeue with the failing checks' summaries; left the merge queue without merging → requeue; not merged `mergeQueueMinutes` after submission → `q:human`.
|
|
42
42
|
4. **Sweep.** An issue labelled `running` with this host (or no host) in its marker and no tracked worker → requeue. This is what makes losing the SQLite file cost one requeue.
|
|
43
43
|
5. **Schedule.** Start Task workers for `q:task` issues without `running`, by priority label then age, up to `phases.task.cap` counted from live workers. A task requeued earlier in the same tick can start in that tick.
|
|
44
|
-
6. **Release.**
|
|
44
|
+
6. **Release.** Legacy: once a day at `release.time` when `release.enabled`; the run itself is a seam. Graph: the [release graphs](#the-release-graphs), per repo.
|
|
45
45
|
7. **Heartbeat.** Write the state file.
|
|
46
46
|
|
|
47
|
-
A requeue is `q:task` with attempt + 1, or, once `maxAttempts` are spent, `q:human` + `why:budget`.
|
|
47
|
+
A requeue is `q:task` with attempt + 1, or, once `maxAttempts` are spent, `q:human` + `why:budget`. The Task phase never merges: the merge queue and auto-merge do. (The one merge cambium asks for is an approved promotion PR, through `graft pr merge`; see [The release graphs](#the-release-graphs).)
|
|
48
48
|
|
|
49
49
|
## State on GitHub
|
|
50
50
|
|
|
@@ -120,6 +120,7 @@ One JSON file. Everything but `repos` is optional; these are the defaults:
|
|
|
120
120
|
- `engine` picks how the Task phase runs: `"legacy"` (the stage tick, the default) or `"graph"` (the [`task` graph](#the-task-graph)). Both make the same moves; see [The task graph](#the-task-graph).
|
|
121
121
|
- Setting `paths.home` moves every default path under it.
|
|
122
122
|
- `release.time` is host-local `HH:MM`.
|
|
123
|
+
- `repos[].release` (`engine: "graph"`): `{ "enabled", "time", "from", "to" }`. `enabled` and `time` default to the top-level `release`, `from` to the repo's `baseBranch`, `to` to `"main"`. A repo whose `from` equals `to` has no promotion PR. Example: `{ "slug": "o/app", "path": "~/app", "baseBranch": "develop", "release": { "enabled": true, "time": "06:00", "from": "develop", "to": "main" } }`.
|
|
123
124
|
|
|
124
125
|
### Target repo convention
|
|
125
126
|
|
|
@@ -274,6 +275,57 @@ Generated by `toMermaid(task)`; a test keeps this copy current. Boxes are step n
|
|
|
274
275
|
- **Markers.** The graph writes marker v2 without `stage`: `node` is where the issue rests. `merge-queue` is the stage tick's `submitted` with `queued: true`, and a stage-era marker in that state resumes at `merge-queue`. A marker whose node the current graph version no longer has restarts at `start-worker` with a `graph-changed` history entry.
|
|
275
276
|
- **Same moves.** Every scenario in `test/tick.test.mjs` runs on both engines; the test compares their GitHub calls in order (markers semantically, not by rendered text), worker starts with their prompts, kills, teardowns and logs.
|
|
276
277
|
|
|
278
|
+
## The release graphs
|
|
279
|
+
|
|
280
|
+
With `"engine": "graph"` the tick's Release step runs two graphs (`src/graphs/release.mjs`) for every repo whose `release` is on. Their subject is the **promotion PR**, which promotes the repo's integration branch to its release branch (`release.from` → `release.to`, e.g. `develop` → `main`). The marker (v2) is cambium's state comment on that PR, written through the same path as an issue's.
|
|
281
|
+
|
|
282
|
+
`release-prepare` has a clock entry: once a day at the repo's `release.time` (`releaseDue`, last run in the store under `release.lastRun:<slug>`).
|
|
283
|
+
|
|
284
|
+
```mermaid
|
|
285
|
+
flowchart TD
|
|
286
|
+
start_(["start"])
|
|
287
|
+
n0["cleanup"]
|
|
288
|
+
n1["prepare"]
|
|
289
|
+
end_(("end"))
|
|
290
|
+
start_ --> n0
|
|
291
|
+
n0 --> n1
|
|
292
|
+
n1 --> end_
|
|
293
|
+
```
|
|
294
|
+
|
|
295
|
+
`release-promote` sits in `q:promote` and enters at `merge` once the promotion PR is approved (`reviewDecision`, or the latest reviews).
|
|
296
|
+
|
|
297
|
+
```mermaid
|
|
298
|
+
flowchart TD
|
|
299
|
+
start_(["q:promote"])
|
|
300
|
+
n0["merge"]
|
|
301
|
+
n1{{"merging"}}
|
|
302
|
+
n2["promoted"]
|
|
303
|
+
n3["abandoned"]
|
|
304
|
+
end_(("end"))
|
|
305
|
+
start_ --> n0
|
|
306
|
+
n0 -->|"armed"| n1
|
|
307
|
+
n0 --> end_
|
|
308
|
+
n1 -->|"merged"| n2
|
|
309
|
+
n1 --> n3
|
|
310
|
+
n2 --> end_
|
|
311
|
+
n3 --> end_
|
|
312
|
+
```
|
|
313
|
+
|
|
314
|
+
Generated by `toMermaid`; a test keeps these copies current.
|
|
315
|
+
|
|
316
|
+
| Node | Graph | Kind | What it does |
|
|
317
|
+
| ----------- | --------------- | ---- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
318
|
+
| `cleanup` | release-prepare | step | Closes, with a comment, every open promotion PR (`from` → `to`, or carrying a release marker) older than 24 h; takes `q:promote` off. |
|
|
319
|
+
| `prepare` | release-prepare | step | `from` ahead of `to`: opens the promotion PR (or refreshes the open one) with the PRs merged into `from` since `to`, labels it `q:promote`, writes the marker. Nothing ahead: a log line. |
|
|
320
|
+
| `merge` | release-promote | step | `graft pr merge <n> --auto`: graft's merge policy, auto-merge, or a merge now when the PR is clean. A refusal is recorded on the marker and not retried on the same head. |
|
|
321
|
+
| `merging` | release-promote | wait | Holds while the PR is open. |
|
|
322
|
+
| `promoted` | release-promote | step | Merged: marker done, `q:promote` off. |
|
|
323
|
+
| `abandoned` | release-promote | step | Closed unmerged: marker done, `q:promote` off. A `q:promote` PR closed or merged before it was approved goes here (or to `promoted`) too. |
|
|
324
|
+
|
|
325
|
+
- **No timeouts.** Neither graph has one; the daily `cleanup` is the only 24 h rule.
|
|
326
|
+
- **Read.** With a repo's release on, the snapshot query also asks (in the same query) for the open PRs from `from` to `to`, the PRs labelled `q:promote`, and `to`'s comparison with `from` (`aheadBy`, and the merged PRs on the last 100 commits ahead).
|
|
327
|
+
- **Legacy.** `engine: "legacy"` keeps the stub.
|
|
328
|
+
|
|
277
329
|
## Graph module (preview)
|
|
278
330
|
|
|
279
331
|
`@oakgreencc/cambium/graph` is the start of typed workflows: nodes with schemas, edges as data, and a loop that advances a position through them. The Task phase runs on it with `engine: "graph"` ([The task graph](#the-task-graph)).
|
|
@@ -450,7 +502,7 @@ Without Jaeger running the collector still writes the files; the Jaeger exporter
|
|
|
450
502
|
Seams that exist, typed, and do nothing yet:
|
|
451
503
|
|
|
452
504
|
- **Dispatch** (`src/phases/dispatch.mjs`): `Dispatch(input: { repo, intake, capacity, now }) → { started }`. Reached only when `phases.dispatch.cap > 0`; the stub starts nothing and logs that `q:intake` waits.
|
|
453
|
-
- **Release
|
|
505
|
+
- **Release**, legacy engine only (`src/phases/release.mjs`): `Release(input: { repo, now }) → { done, note }`. The once-a-day schedule (`releaseDue`) is real and recorded in the store; the run returns `{ done: false }`. The graph engine runs the [release graphs](#the-release-graphs).
|
|
454
506
|
- Conditional (ETag) reads, so an unchanged poll is free against the rate limit; GraphQL has no ETag, so this needs a REST probe in front of the query.
|
|
455
507
|
- More than 100 queued issues or open PRs per repo, and state comments beyond an issue's first 100 comments: the read is one page.
|
|
456
508
|
- Spend caps per worker (turns and wall clock are enforced today).
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@oakgreencc/cambium",
|
|
3
|
-
"version": "0.0.
|
|
3
|
+
"version": "0.0.10",
|
|
4
4
|
"description": "The scheduler daemon: reads the q:* queues from GitHub every tick, runs headless claude workers in their own worktrees up to a cap, and makes every queue transition itself.",
|
|
5
5
|
"license": "AGPL-3.0-only",
|
|
6
6
|
"type": "module",
|
|
@@ -51,7 +51,7 @@
|
|
|
51
51
|
"@opentelemetry/sdk-metrics": "^3.1.1",
|
|
52
52
|
"@opentelemetry/sdk-trace": "^3.1.1",
|
|
53
53
|
"zod": "^4.6.7",
|
|
54
|
-
"@oakgreencc/mycelium": "0.0.
|
|
54
|
+
"@oakgreencc/mycelium": "0.0.0"
|
|
55
55
|
},
|
|
56
56
|
"devDependencies": {
|
|
57
57
|
"@langchain/core": "^1.4.1",
|
package/src/config.mjs
CHANGED
|
@@ -8,7 +8,11 @@ import { homedir, hostname } from 'node:os'
|
|
|
8
8
|
import { join, resolve } from 'node:path'
|
|
9
9
|
|
|
10
10
|
/**
|
|
11
|
-
* @typedef {{
|
|
11
|
+
* @typedef {{ enabled: boolean, time: string, from: string, to: string }} RepoRelease
|
|
12
|
+
* The promotion PR (`engine: "graph"`): `from` (default: the repo's `baseBranch`) is promoted into `to`
|
|
13
|
+
* (default `main`) once a day at `time`. `enabled`/`time` default to the top-level `release`. Off when
|
|
14
|
+
* `from === to`.
|
|
15
|
+
* @typedef {{ slug: string, path: string, baseBranch: string, release: RepoRelease }} Repo
|
|
12
16
|
* @typedef {{ cap: number, wallClockMinutes: number, maxTurns: number, maxAttempts: number }} PhaseCaps
|
|
13
17
|
* @typedef {{
|
|
14
18
|
* host: string,
|
|
@@ -82,15 +86,25 @@ export function resolveConfig(raw = {}) {
|
|
|
82
86
|
/** @type {Config} */
|
|
83
87
|
const config = merge(defaults(home), raw)
|
|
84
88
|
for (const k of /** @type {const} */ (['home', 'db', 'heartbeat', 'logs'])) config.paths[k] = untilde(config.paths[k])
|
|
89
|
+
if (!/^\d{2}:\d{2}$/.test(config.release.time)) throw new Error(`config: release.time must be HH:MM`)
|
|
85
90
|
config.repos = (config.repos ?? []).map((r) => {
|
|
86
91
|
if (!r?.slug || !/^[^/\s]+\/[^/\s]+$/.test(r.slug))
|
|
87
92
|
throw new Error(`config: repo slug must be owner/name, got ${r?.slug}`)
|
|
88
93
|
if (!r.path) throw new Error(`config: repo ${r.slug} needs "path" (a local clone)`)
|
|
89
|
-
|
|
94
|
+
const baseBranch = r.baseBranch ?? 'main'
|
|
95
|
+
/** @type {RepoRelease} */
|
|
96
|
+
const release = {
|
|
97
|
+
enabled: config.release.enabled,
|
|
98
|
+
time: config.release.time,
|
|
99
|
+
from: baseBranch,
|
|
100
|
+
to: 'main',
|
|
101
|
+
...r.release,
|
|
102
|
+
}
|
|
103
|
+
if (!/^\d{2}:\d{2}$/.test(release.time)) throw new Error(`config: repo ${r.slug} release.time must be HH:MM`)
|
|
104
|
+
return { slug: r.slug, path: untilde(r.path), baseBranch, release }
|
|
90
105
|
})
|
|
91
106
|
if (config.engine !== 'legacy' && config.engine !== 'graph')
|
|
92
107
|
throw new Error(`config: engine must be "legacy" or "graph", got ${JSON.stringify(config.engine)}`)
|
|
93
|
-
if (!/^\d{2}:\d{2}$/.test(config.release.time)) throw new Error(`config: release.time must be HH:MM`)
|
|
94
108
|
return config
|
|
95
109
|
}
|
|
96
110
|
|
package/src/github.mjs
CHANGED
|
@@ -7,7 +7,7 @@
|
|
|
7
7
|
*/
|
|
8
8
|
import { spawn } from 'node:child_process'
|
|
9
9
|
import { parseMarker } from './marker.mjs'
|
|
10
|
-
import { QUEUE_LABELS } from './labels.mjs'
|
|
10
|
+
import { Q, QUEUE_LABELS } from './labels.mjs'
|
|
11
11
|
|
|
12
12
|
/**
|
|
13
13
|
* @typedef {{
|
|
@@ -20,13 +20,32 @@ import { QUEUE_LABELS } from './labels.mjs'
|
|
|
20
20
|
* branchExists: boolean, inMergeQueue: boolean, autoMerge: boolean,
|
|
21
21
|
* checks: 'SUCCESS' | 'FAILURE' | 'ERROR' | 'PENDING' | 'EXPECTED' | null, failing: FailingCheck[], closes: number[],
|
|
22
22
|
* }} PullRequest
|
|
23
|
-
* @typedef {{
|
|
23
|
+
* @typedef {{
|
|
24
|
+
* number: number, url: string, title: string, state: 'OPEN' | 'MERGED' | 'CLOSED', createdAt: string,
|
|
25
|
+
* head: string, base: string, headSha: string | null, labels: string[], approved: boolean, autoMerge: boolean,
|
|
26
|
+
* stateComment: { id: number, marker: import('./marker.mjs').Marker } | null,
|
|
27
|
+
* }} PromotionPr
|
|
28
|
+
* A promotion PR (`from` → `to`, or labelled `q:promote`). Its state comment is a PR (issue) comment, so it
|
|
29
|
+
* goes through the same marker read/write path as an issue's. `approved`: `reviewDecision` is APPROVED, or
|
|
30
|
+
* (no decision against it) a latest review approves and none requests changes.
|
|
31
|
+
* @typedef {{
|
|
32
|
+
* from: string, to: string, aheadBy: number | null, merged: { number: number, title: string }[],
|
|
33
|
+
* prs: PromotionPr[],
|
|
34
|
+
* }} Release
|
|
35
|
+
* The repo's promotion state (when its `release` is on): how far `from` is ahead of `to` (null: `to` does not
|
|
36
|
+
* exist), the PRs merged into `from` since `to` (oldest first, from the last 100 commits ahead), and the
|
|
37
|
+
* promotion PRs: open ones from `from` to `to` plus any (open, merged or closed) still labelled `q:promote`.
|
|
38
|
+
* @typedef {{ issues: Map<number, Issue>, prs: PullRequest[], release?: Release | null }} Snapshot
|
|
24
39
|
* @typedef {{
|
|
25
40
|
* read(slug: string): Promise<Snapshot>,
|
|
26
41
|
* label(slug: string, number: number, change: { add: string[], remove: string[] }): Promise<void>,
|
|
27
42
|
* writeState(slug: string, number: number, commentId: number | null, body: string): Promise<number>,
|
|
28
43
|
* close(slug: string, number: number, body: string): Promise<void>,
|
|
29
44
|
* deleteBranch(slug: string, branch: string): Promise<void>,
|
|
45
|
+
* openPull(slug: string, pr: { head: string, base: string, title: string, body: string }): Promise<{ number: number, url: string }>,
|
|
46
|
+
* editPull(slug: string, number: number, change: { title: string, body: string }): Promise<void>,
|
|
47
|
+
* closePull(slug: string, number: number, comment: string): Promise<void>,
|
|
48
|
+
* mergePull(slug: string, number: number): Promise<void>,
|
|
30
49
|
* }} GitHub
|
|
31
50
|
*/
|
|
32
51
|
|
|
@@ -40,39 +59,116 @@ const PR_FIELDS = `number url headRefName state headRefOid isInMergeQueue
|
|
|
40
59
|
... on StatusContext { context state targetUrl description }
|
|
41
60
|
} } } } } }`
|
|
42
61
|
|
|
43
|
-
/**
|
|
44
|
-
|
|
62
|
+
/**
|
|
63
|
+
* One query per repo per tick: the queued issues and the agent PRs with their checks; with `$release`, also the
|
|
64
|
+
* promotion PRs and how far `$from` is ahead of `$to` (see {@link Release}).
|
|
65
|
+
*/
|
|
66
|
+
export const SNAPSHOT_QUERY = `query($owner: String!, $name: String!, $labels: [String!], $release: Boolean!, $from: String!, $to: String!) {
|
|
45
67
|
repository(owner: $owner, name: $name) {
|
|
46
68
|
issues(labels: $labels, states: OPEN, first: 100, orderBy: { field: CREATED_AT, direction: ASC }) { nodes { ...I } }
|
|
47
69
|
open: pullRequests(states: OPEN, first: 100, orderBy: { field: UPDATED_AT, direction: DESC }) { nodes { ${PR_FIELDS} } }
|
|
48
70
|
merged: pullRequests(states: MERGED, first: 30, orderBy: { field: UPDATED_AT, direction: DESC }) { nodes { ${PR_FIELDS} } }
|
|
71
|
+
promoteRef: pullRequests(headRefName: $from, baseRefName: $to, states: OPEN, first: 10) @include(if: $release) { nodes { ...P } }
|
|
72
|
+
promoteLabelled: pullRequests(labels: ["${Q.promote}"], first: 10, orderBy: { field: UPDATED_AT, direction: DESC }) @include(if: $release) { nodes { ...P } }
|
|
73
|
+
toRef: ref(qualifiedName: $to) @include(if: $release) {
|
|
74
|
+
compare(headRef: $from) {
|
|
75
|
+
aheadBy
|
|
76
|
+
commits(last: 100) { nodes { associatedPullRequests(first: 3) { nodes { number title baseRefName state } } } }
|
|
77
|
+
}
|
|
78
|
+
}
|
|
49
79
|
}
|
|
50
80
|
}
|
|
51
81
|
fragment I on Issue {
|
|
52
82
|
number title url state createdAt body
|
|
53
83
|
labels(first: 30) { nodes { name } }
|
|
54
84
|
comments(first: 100) { nodes { databaseId body author { login } } }
|
|
85
|
+
}
|
|
86
|
+
fragment P on PullRequest {
|
|
87
|
+
number url title state createdAt headRefName baseRefName headRefOid reviewDecision
|
|
88
|
+
autoMergeRequest { enabledAt }
|
|
89
|
+
latestReviews(first: 20) { nodes { state } }
|
|
90
|
+
labels(first: 30) { nodes { name } }
|
|
91
|
+
comments(first: 100) { nodes { databaseId body author { login } } }
|
|
55
92
|
}`
|
|
56
93
|
|
|
57
94
|
const FAILED = new Set(['FAILURE', 'ERROR', 'TIMED_OUT', 'CANCELLED', 'ACTION_REQUIRED', 'STARTUP_FAILURE'])
|
|
58
95
|
|
|
96
|
+
/**
|
|
97
|
+
* The first comment holding a marker (from `botLogin` only, when set). Issues and PRs alike.
|
|
98
|
+
* @param {any} n an issue or PR node with `comments` @param {string | null} botLogin
|
|
99
|
+
* @returns {{ id: number, marker: import('./marker.mjs').Marker } | null}
|
|
100
|
+
*/
|
|
101
|
+
function stateCommentOf(n, botLogin) {
|
|
102
|
+
const comment = (n.comments?.nodes ?? []).find(
|
|
103
|
+
(/** @type {any} */ c) => parseMarker(c.body) && (!botLogin || c.author?.login === botLogin),
|
|
104
|
+
)
|
|
105
|
+
return comment ? { id: comment.databaseId, marker: /** @type {any} */ (parseMarker(comment.body)) } : null
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
/** @param {any} n @returns {string[]} */
|
|
109
|
+
const labelsOf = (n) => (n.labels?.nodes ?? []).map((/** @type {any} */ l) => l.name)
|
|
110
|
+
|
|
111
|
+
/**
|
|
112
|
+
* The `$release` part of the answer → {@link Release}.
|
|
113
|
+
* @param {any} repo @param {{ from: string, to: string }} branches @param {string | null} botLogin
|
|
114
|
+
* @returns {Release}
|
|
115
|
+
*/
|
|
116
|
+
function normalizeRelease(repo, { from, to }, botLogin) {
|
|
117
|
+
/** @type {Map<number, PromotionPr>} */
|
|
118
|
+
const prs = new Map()
|
|
119
|
+
for (const p of [...(repo.promoteRef?.nodes ?? []), ...(repo.promoteLabelled?.nodes ?? [])]) {
|
|
120
|
+
if (!p || prs.has(p.number)) continue
|
|
121
|
+
const reviews = (p.latestReviews?.nodes ?? []).map((/** @type {any} */ r) => r.state)
|
|
122
|
+
prs.set(p.number, {
|
|
123
|
+
number: p.number,
|
|
124
|
+
url: p.url ?? '',
|
|
125
|
+
title: p.title ?? '',
|
|
126
|
+
state: p.state,
|
|
127
|
+
createdAt: p.createdAt,
|
|
128
|
+
head: p.headRefName,
|
|
129
|
+
base: p.baseRefName,
|
|
130
|
+
headSha: p.headRefOid ?? null,
|
|
131
|
+
labels: labelsOf(p),
|
|
132
|
+
approved:
|
|
133
|
+
p.reviewDecision === 'APPROVED' ||
|
|
134
|
+
(p.reviewDecision !== 'CHANGES_REQUESTED' &&
|
|
135
|
+
reviews.includes('APPROVED') &&
|
|
136
|
+
!reviews.includes('CHANGES_REQUESTED')),
|
|
137
|
+
autoMerge: Boolean(p.autoMergeRequest),
|
|
138
|
+
stateComment: stateCommentOf(p, botLogin),
|
|
139
|
+
})
|
|
140
|
+
}
|
|
141
|
+
const compare = repo.toRef?.compare ?? null
|
|
142
|
+
/** @type {Map<number, { number: number, title: string }>} */
|
|
143
|
+
const merged = new Map()
|
|
144
|
+
for (const c of compare?.commits?.nodes ?? [])
|
|
145
|
+
for (const p of c?.associatedPullRequests?.nodes ?? [])
|
|
146
|
+
if (p.baseRefName === from && p.state === 'MERGED' && !merged.has(p.number))
|
|
147
|
+
merged.set(p.number, { number: p.number, title: p.title ?? '' })
|
|
148
|
+
return {
|
|
149
|
+
from,
|
|
150
|
+
to,
|
|
151
|
+
aheadBy: compare ? (compare.aheadBy ?? 0) : null,
|
|
152
|
+
merged: [...merged.values()],
|
|
153
|
+
prs: [...prs.values()],
|
|
154
|
+
}
|
|
155
|
+
}
|
|
156
|
+
|
|
59
157
|
/**
|
|
60
158
|
* GraphQL `data` → {@link Snapshot}. Only `agent/*` PRs are kept.
|
|
61
159
|
*
|
|
62
160
|
* @param {any} data
|
|
63
|
-
* @param {{ botLogin?: string | null
|
|
161
|
+
* @param {{ botLogin?: string | null, release?: { from: string, to: string } | null }} [opts]
|
|
162
|
+
* `botLogin`: when set, only that login's markers count. `release`: the branches the query asked about.
|
|
64
163
|
* @returns {Snapshot}
|
|
65
164
|
*/
|
|
66
|
-
export function normalize(data, { botLogin = null } = {}) {
|
|
165
|
+
export function normalize(data, { botLogin = null, release = null } = {}) {
|
|
67
166
|
const repo = (data?.data ?? data)?.repository
|
|
68
167
|
if (!repo) throw new Error('snapshot: no repository in the answer')
|
|
69
168
|
/** @type {Map<number, Issue>} */
|
|
70
169
|
const issues = new Map()
|
|
71
170
|
const addIssue = (/** @type {any} */ n) => {
|
|
72
171
|
if (!issues.has(n.number)) {
|
|
73
|
-
const comment = (n.comments?.nodes ?? []).find(
|
|
74
|
-
(/** @type {any} */ c) => parseMarker(c.body) && (!botLogin || c.author?.login === botLogin),
|
|
75
|
-
)
|
|
76
172
|
issues.set(n.number, {
|
|
77
173
|
number: n.number,
|
|
78
174
|
title: n.title ?? '',
|
|
@@ -80,10 +176,8 @@ export function normalize(data, { botLogin = null } = {}) {
|
|
|
80
176
|
state: n.state,
|
|
81
177
|
createdAt: n.createdAt,
|
|
82
178
|
body: n.body ?? '',
|
|
83
|
-
labels: (n
|
|
84
|
-
stateComment:
|
|
85
|
-
? { id: comment.databaseId, marker: /** @type {any} */ (parseMarker(comment.body)) }
|
|
86
|
-
: null,
|
|
179
|
+
labels: labelsOf(n),
|
|
180
|
+
stateComment: stateCommentOf(n, botLogin),
|
|
87
181
|
})
|
|
88
182
|
}
|
|
89
183
|
return n.number
|
|
@@ -115,7 +209,7 @@ export function normalize(data, { botLogin = null } = {}) {
|
|
|
115
209
|
closes: (p.closingIssuesReferences?.nodes ?? []).map(addIssue),
|
|
116
210
|
})
|
|
117
211
|
}
|
|
118
|
-
return { issues, prs }
|
|
212
|
+
return { issues, prs, ...(release ? { release: normalizeRelease(repo, release, botLogin) } : {}) }
|
|
119
213
|
}
|
|
120
214
|
|
|
121
215
|
/**
|
|
@@ -159,9 +253,12 @@ export function graftGitHub({ config, exec: run = exec }) {
|
|
|
159
253
|
return {
|
|
160
254
|
async read(slug) {
|
|
161
255
|
const [owner, name] = slug.split('/')
|
|
162
|
-
const
|
|
256
|
+
const r = config.repos.find((x) => x.slug === slug)?.release
|
|
257
|
+
const release = r?.enabled && r.from !== r.to ? { from: r.from, to: r.to } : null
|
|
258
|
+
const branches = release ?? { from: '', to: '' }
|
|
259
|
+
const vars = JSON.stringify({ owner, name, labels: QUEUE_LABELS, release: Boolean(release), ...branches })
|
|
163
260
|
const data = await json(graft(slug, ['graphql', SNAPSHOT_QUERY, '--vars', vars]))
|
|
164
|
-
return normalize(data, { botLogin: config.graft.botLogin })
|
|
261
|
+
return normalize(data, { botLogin: config.graft.botLogin, release })
|
|
165
262
|
},
|
|
166
263
|
async label(slug, number, { add, remove }) {
|
|
167
264
|
if (!add.length && !remove.length) return
|
|
@@ -188,5 +285,21 @@ export function graftGitHub({ config, exec: run = exec }) {
|
|
|
188
285
|
async deleteBranch(slug, branch) {
|
|
189
286
|
await graft(slug, ['api', 'DELETE', `/repos/${slug}/git/refs/heads/${branch}`])
|
|
190
287
|
},
|
|
288
|
+
async openPull(slug, { head, base, title, body }) {
|
|
289
|
+
const path = `/repos/${slug}/pulls`
|
|
290
|
+
const made = await json(graft(slug, ['api', 'POST', path, '--body', JSON.stringify({ head, base, title, body })]))
|
|
291
|
+
return { number: made.number, url: made.html_url }
|
|
292
|
+
},
|
|
293
|
+
async editPull(slug, number, { title, body }) {
|
|
294
|
+
await graft(slug, ['api', 'PATCH', `/repos/${slug}/pulls/${number}`, '--body', JSON.stringify({ title, body })])
|
|
295
|
+
},
|
|
296
|
+
async closePull(slug, number, comment) {
|
|
297
|
+
await graft(slug, ['issue', 'comment', String(number), '--body-file', '-'], comment)
|
|
298
|
+
await graft(slug, ['api', 'PATCH', `/repos/${slug}/pulls/${number}`, '--body', '{"state":"closed"}'])
|
|
299
|
+
},
|
|
300
|
+
// Through graft's merge policy, as an agent's merge would: auto-merge, or a merge now when the PR is clean.
|
|
301
|
+
async mergePull(slug, number) {
|
|
302
|
+
await graft(slug, ['pr', 'merge', String(number), '--auto'])
|
|
303
|
+
},
|
|
191
304
|
}
|
|
192
305
|
}
|
|
@@ -0,0 +1,438 @@
|
|
|
1
|
+
// @ts-check
|
|
2
|
+
/**
|
|
3
|
+
* Release as two graphs (`engine: "graph"`), replacing the `phases/release.mjs` stub there. Their subject is the
|
|
4
|
+
* repo's promotion PR, `release.from` → `release.to` (e.g. `develop` → `main`), and the marker (v2) is cambium's
|
|
5
|
+
* state comment on that PR, written through the same path as an issue's (issue-state.mjs).
|
|
6
|
+
*
|
|
7
|
+
* - `release-prepare`: a clock entry, once a day at the repo's `release.time` (`releaseDue`, with the last run in
|
|
8
|
+
* the store). `cleanup` closes, with a comment, every open promotion PR older than 24 h; `prepare` opens the
|
|
9
|
+
* promotion PR (or refreshes the open one) when `from` is ahead of `to`, labels it `q:promote` and exits.
|
|
10
|
+
* - `release-promote`: `q:promote` is its queue. It enters at `merge` once the PR is approved, merges through
|
|
11
|
+
* `graft pr merge --auto` (auto-merge, or a merge now when the PR is clean), waits at `merging`, and exits at
|
|
12
|
+
* `promoted` (merged) or `abandoned` (closed unmerged), taking `q:promote` off.
|
|
13
|
+
*
|
|
14
|
+
* Neither graph has a timeout: the daily cleanup is the only 24 h rule.
|
|
15
|
+
*/
|
|
16
|
+
import { z } from 'zod'
|
|
17
|
+
import { advance, defineGraph, defineNode, defineWait, END } from '../graph/index.mjs'
|
|
18
|
+
import { iso, setLabels, setMarker } from '../issue-state.mjs'
|
|
19
|
+
import { move, Q } from '../labels.mjs'
|
|
20
|
+
import { effectivePosition, newMarker, withHistory } from '../marker.mjs'
|
|
21
|
+
import { releaseDue } from '../phases/release.mjs'
|
|
22
|
+
|
|
23
|
+
/**
|
|
24
|
+
* @typedef {import('../github.mjs').PromotionPr} PromotionPr
|
|
25
|
+
* @typedef {import('../github.mjs').Release} Release
|
|
26
|
+
* @typedef {import('../marker.mjs').Marker} Marker
|
|
27
|
+
* @typedef {{ slug: string, repo: import('../config.mjs').Repo, release: Release, pr?: PromotionPr }} ReleaseSubject
|
|
28
|
+
* One repo's turn; `pr` is the promotion PR a `release-promote` turn is about.
|
|
29
|
+
* @typedef {import('../tick.mjs').Deps & { tick: import('../tick.mjs').Ctx, subject: ReleaseSubject }} ReleaseCtx
|
|
30
|
+
* @typedef {{ queue: string | null, enter?: (input: any, ctx: ReleaseCtx) => Promise<void> }} Declared
|
|
31
|
+
* `queue`: the label a PR resting here carries. `enter`: the write that lands a PR on this wait.
|
|
32
|
+
*/
|
|
33
|
+
|
|
34
|
+
const DAY = 24 * 60 * 60 * 1000
|
|
35
|
+
|
|
36
|
+
/**
|
|
37
|
+
* @template {import('../graph/define.mjs').GraphNode} N @param {N} node @param {Declared} decl
|
|
38
|
+
* @returns {N & Declared}
|
|
39
|
+
*/
|
|
40
|
+
const declare = (node, decl) => Object.freeze({ ...node, ...decl })
|
|
41
|
+
|
|
42
|
+
/** @param {ReleaseCtx} ctx */
|
|
43
|
+
function prOf(ctx) {
|
|
44
|
+
const { pr } = ctx.subject
|
|
45
|
+
if (!pr) throw new Error(`${ctx.subject.slug}: no promotion PR in this turn`)
|
|
46
|
+
return pr
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
/** @param {ReleaseCtx} ctx @param {number} pr */
|
|
50
|
+
const where = (ctx, pr) => ({ repo: ctx.subject.slug, issue: pr })
|
|
51
|
+
|
|
52
|
+
/** A PR's marker, or a fresh one for a release graph. @param {PromotionPr} pr @param {string} graph @param {string} node */
|
|
53
|
+
const markerOn = (pr, graph, node) =>
|
|
54
|
+
pr.stateComment?.marker ?? newMarker({ graph, node, phase: 'release', pr: pr.number })
|
|
55
|
+
|
|
56
|
+
/** Release markers carry none of the stage tick's fields. @param {Marker} m */
|
|
57
|
+
const releaseMarker = (m) =>
|
|
58
|
+
/** @type {Marker} */ (Object.fromEntries(Object.entries(m).filter(([k]) => k !== 'stage')))
|
|
59
|
+
|
|
60
|
+
/**
|
|
61
|
+
* Put `pr` at `node` of `graph`: the marker first, then the labels `node` declares, via `move()`.
|
|
62
|
+
* @param {ReleaseCtx} ctx @param {PromotionPr} pr @param {import('../graph/define.mjs').Graph} graph @param {string} node
|
|
63
|
+
* @param {Marker} marker @param {{ status?: Marker['status'] }} [opts]
|
|
64
|
+
*/
|
|
65
|
+
async function land(ctx, pr, graph, node, marker, { status = 'waiting' } = {}) {
|
|
66
|
+
const { slug } = ctx.subject
|
|
67
|
+
const decl = /** @type {Declared} */ (/** @type {unknown} */ (graph.nodes.find((n) => n.name === node)))
|
|
68
|
+
// The PR's state comment is an issue comment: setMarker / setLabels take the PR as the issue.
|
|
69
|
+
const issue = /** @type {import('../github.mjs').Issue} */ (/** @type {unknown} */ (pr))
|
|
70
|
+
await setMarker(ctx, slug, issue, {
|
|
71
|
+
...releaseMarker(marker),
|
|
72
|
+
graph: graph.name,
|
|
73
|
+
graphVersion: graph.version,
|
|
74
|
+
node,
|
|
75
|
+
status,
|
|
76
|
+
pr: pr.number,
|
|
77
|
+
enteredAt: iso(ctx.tick.now),
|
|
78
|
+
})
|
|
79
|
+
await setLabels(ctx, slug, issue, move(pr.labels, decl.queue))
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
/** Open, and from `from` to `to` or carrying a release marker. @param {Release} r @param {PromotionPr} pr */
|
|
83
|
+
const isPromotion = (r, pr) =>
|
|
84
|
+
(pr.head === r.from && pr.base === r.to) || Boolean(pr.stateComment?.marker.graph.startsWith('release-'))
|
|
85
|
+
|
|
86
|
+
/** The promotion PR's body: what `to` gets. @param {Release} r */
|
|
87
|
+
export function promotionBody(r) {
|
|
88
|
+
const lines = [
|
|
89
|
+
`Promotes \`${r.from}\` → \`${r.to}\`: ${r.aheadBy} commit${r.aheadBy === 1 ? '' : 's'} ahead.`,
|
|
90
|
+
'',
|
|
91
|
+
r.merged.length ? `Merged into \`${r.from}\` since \`${r.to}\`:` : `No merged PRs found in the commits ahead.`,
|
|
92
|
+
...r.merged.map((p) => `- #${p.number} ${p.title}`),
|
|
93
|
+
'',
|
|
94
|
+
'_Opened by cambium (release-prepare). Approve it and cambium merges it (release-promote); ' +
|
|
95
|
+
'an unmerged promotion PR is closed after 24 h._',
|
|
96
|
+
]
|
|
97
|
+
return lines.join('\n')
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
// ---- release-prepare
|
|
101
|
+
|
|
102
|
+
const Empty = z.object({})
|
|
103
|
+
const Closed = z.object({ closed: z.array(z.number().int()) })
|
|
104
|
+
|
|
105
|
+
const cleanup = declare(
|
|
106
|
+
defineNode({
|
|
107
|
+
name: 'cleanup',
|
|
108
|
+
input: Empty,
|
|
109
|
+
output: Closed,
|
|
110
|
+
/** Close every open promotion PR older than 24 h, with a comment. @param {{}} _ @param {ReleaseCtx} ctx */
|
|
111
|
+
run: async (_, ctx) => {
|
|
112
|
+
const { slug, release: r } = ctx.subject
|
|
113
|
+
/** @type {number[]} */
|
|
114
|
+
const closed = []
|
|
115
|
+
for (const pr of r.prs) {
|
|
116
|
+
if (pr.state !== 'OPEN' || !isPromotion(r, pr)) continue
|
|
117
|
+
if (ctx.tick.now - Date.parse(pr.createdAt) <= DAY) continue
|
|
118
|
+
const age = Math.floor((ctx.tick.now - Date.parse(pr.createdAt)) / (60 * 60 * 1000))
|
|
119
|
+
const reason = `not merged within 24 h (opened ${age} h ago); a fresh promotion PR replaces it`
|
|
120
|
+
if (pr.stateComment) {
|
|
121
|
+
const m = pr.stateComment.marker
|
|
122
|
+
await land(
|
|
123
|
+
ctx,
|
|
124
|
+
pr,
|
|
125
|
+
releasePrepare,
|
|
126
|
+
'cleanup',
|
|
127
|
+
withHistory(m, { at: iso(ctx.tick.now), attempt: m.attempt, outcome: 'stale-closed', reason }),
|
|
128
|
+
{ status: 'done' },
|
|
129
|
+
)
|
|
130
|
+
} else if (pr.labels.includes(Q.promote))
|
|
131
|
+
await setLabels(ctx, slug, /** @type {any} */ (pr), move(pr.labels, null))
|
|
132
|
+
await ctx.github.closePull(slug, pr.number, `Closed by cambium: ${reason}.`)
|
|
133
|
+
pr.state = 'CLOSED'
|
|
134
|
+
closed.push(pr.number)
|
|
135
|
+
ctx.log('info', `release: closed stale promotion PR #${pr.number}`, where(ctx, pr.number))
|
|
136
|
+
}
|
|
137
|
+
return { closed }
|
|
138
|
+
},
|
|
139
|
+
}),
|
|
140
|
+
{ queue: null },
|
|
141
|
+
)
|
|
142
|
+
|
|
143
|
+
const prepare = declare(
|
|
144
|
+
defineNode({
|
|
145
|
+
name: 'prepare',
|
|
146
|
+
input: Closed,
|
|
147
|
+
output: z.discriminatedUnion('to', [
|
|
148
|
+
z.object({ to: z.literal('opened'), pr: z.number().int() }),
|
|
149
|
+
z.object({ to: z.literal('updated'), pr: z.number().int() }),
|
|
150
|
+
z.object({ to: z.literal('nothing'), reason: z.string() }),
|
|
151
|
+
]),
|
|
152
|
+
/**
|
|
153
|
+
* `from` ahead of `to`: open the promotion PR (or refresh the open one), label it `q:promote`, write the
|
|
154
|
+
* marker. Nothing ahead: a log line.
|
|
155
|
+
* @param {z.infer<typeof Closed>} _ @param {ReleaseCtx} ctx
|
|
156
|
+
*/
|
|
157
|
+
run: async (_, ctx) => {
|
|
158
|
+
const { slug, release: r } = ctx.subject
|
|
159
|
+
if (!r.aheadBy) {
|
|
160
|
+
const reason =
|
|
161
|
+
r.aheadBy === null
|
|
162
|
+
? `\`${r.to}\` not found; nothing to promote`
|
|
163
|
+
: `\`${r.from}\` is not ahead of \`${r.to}\`; nothing to promote`
|
|
164
|
+
ctx.log('info', `release: ${reason}`, { repo: slug })
|
|
165
|
+
return { to: 'nothing', reason }
|
|
166
|
+
}
|
|
167
|
+
const title = `Promote ${r.from} → ${r.to}`
|
|
168
|
+
const body = promotionBody(r)
|
|
169
|
+
const at = iso(ctx.tick.now)
|
|
170
|
+
const open = r.prs.find((p) => p.state === 'OPEN' && p.head === r.from && p.base === r.to)
|
|
171
|
+
if (open) {
|
|
172
|
+
await ctx.github.editPull(slug, open.number, { title, body })
|
|
173
|
+
const m = markerOn(open, releasePrepare.name, 'prepare')
|
|
174
|
+
const entry = { at, attempt: m.attempt, outcome: 'updated', pr: open.number }
|
|
175
|
+
// Already in release-promote (approved, merging): keep its position, record the refresh.
|
|
176
|
+
if (m.graph === releasePromote.name && m.status !== 'done') {
|
|
177
|
+
await setMarker(ctx, slug, /** @type {any} */ (open), withHistory(m, entry))
|
|
178
|
+
await setLabels(ctx, slug, /** @type {any} */ (open), move(open.labels, Q.promote))
|
|
179
|
+
} else await land(ctx, open, releasePrepare, 'prepare', withHistory(m, entry), { status: 'done' })
|
|
180
|
+
ctx.log('info', `release: refreshed promotion PR #${open.number}`, where(ctx, open.number))
|
|
181
|
+
return { to: 'updated', pr: open.number }
|
|
182
|
+
}
|
|
183
|
+
const made = await ctx.github.openPull(slug, { head: r.from, base: r.to, title, body })
|
|
184
|
+
/** @type {PromotionPr} */
|
|
185
|
+
const pr = {
|
|
186
|
+
number: made.number,
|
|
187
|
+
url: made.url,
|
|
188
|
+
title,
|
|
189
|
+
state: 'OPEN',
|
|
190
|
+
createdAt: at,
|
|
191
|
+
head: r.from,
|
|
192
|
+
base: r.to,
|
|
193
|
+
headSha: null,
|
|
194
|
+
labels: [],
|
|
195
|
+
approved: false,
|
|
196
|
+
autoMerge: false,
|
|
197
|
+
stateComment: null,
|
|
198
|
+
}
|
|
199
|
+
r.prs.push(pr)
|
|
200
|
+
const m = markerOn(pr, releasePrepare.name, 'prepare')
|
|
201
|
+
await land(
|
|
202
|
+
ctx,
|
|
203
|
+
pr,
|
|
204
|
+
releasePrepare,
|
|
205
|
+
'prepare',
|
|
206
|
+
withHistory(m, { at, attempt: m.attempt, outcome: 'opened', pr: pr.number }),
|
|
207
|
+
{ status: 'done' },
|
|
208
|
+
)
|
|
209
|
+
ctx.log('info', `release: opened promotion PR #${pr.number} (${r.from} → ${r.to})`, where(ctx, pr.number))
|
|
210
|
+
return { to: 'opened', pr: pr.number }
|
|
211
|
+
},
|
|
212
|
+
}),
|
|
213
|
+
// The PR it opens waits in `q:promote`, release-promote's queue.
|
|
214
|
+
{ queue: Q.promote },
|
|
215
|
+
)
|
|
216
|
+
|
|
217
|
+
/** Bump `version` when a node is removed or renamed. */
|
|
218
|
+
export const releasePrepare = defineGraph({
|
|
219
|
+
name: 'release-prepare',
|
|
220
|
+
version: 1,
|
|
221
|
+
entry: { node: 'cleanup', input: () => ({}) },
|
|
222
|
+
nodes: [cleanup, prepare],
|
|
223
|
+
edges: [
|
|
224
|
+
['cleanup', 'prepare'],
|
|
225
|
+
['prepare', END],
|
|
226
|
+
],
|
|
227
|
+
})
|
|
228
|
+
|
|
229
|
+
// ---- release-promote
|
|
230
|
+
|
|
231
|
+
const PrIn = z.object({ pr: z.number().int() })
|
|
232
|
+
|
|
233
|
+
const armed = (/** @type {{ to: string }} */ o) => o.to === 'armed'
|
|
234
|
+
const merged = (/** @type {{ to: string }} */ o) => o.to === 'merged'
|
|
235
|
+
|
|
236
|
+
const merge = declare(
|
|
237
|
+
defineNode({
|
|
238
|
+
name: 'merge',
|
|
239
|
+
input: PrIn,
|
|
240
|
+
output: z.discriminatedUnion('to', [
|
|
241
|
+
z.object({ to: z.literal('armed'), pr: z.number().int() }),
|
|
242
|
+
z.object({ to: z.literal('refused'), reason: z.string() }),
|
|
243
|
+
]),
|
|
244
|
+
/**
|
|
245
|
+
* The PR is approved: merge it through `graft pr merge --auto`. A refusal stays here, recorded with the head
|
|
246
|
+
* it was refused on; the gate does not retry that head.
|
|
247
|
+
* @param {z.infer<typeof PrIn>} input @param {ReleaseCtx} ctx
|
|
248
|
+
*/
|
|
249
|
+
run: async (input, ctx) => {
|
|
250
|
+
const pr = prOf(ctx)
|
|
251
|
+
// TRACING (follow-up): a span per merge attempt here, parented on the PR marker's traceparent.
|
|
252
|
+
try {
|
|
253
|
+
await ctx.github.mergePull(ctx.subject.slug, input.pr)
|
|
254
|
+
} catch (err) {
|
|
255
|
+
const reason = `merge refused: ${/** @type {Error} */ (err)?.message ?? err}`
|
|
256
|
+
const m = markerOn(pr, releasePromote.name, 'merge')
|
|
257
|
+
await land(ctx, pr, releasePromote, 'merge', {
|
|
258
|
+
...withHistory(m, { at: iso(ctx.tick.now), attempt: m.attempt, outcome: 'merge-refused', reason }),
|
|
259
|
+
lastFailure: reason,
|
|
260
|
+
failedSha: pr.headSha,
|
|
261
|
+
input: { pr: input.pr },
|
|
262
|
+
})
|
|
263
|
+
ctx.log('warn', `release: ${reason.split('\n')[0]}`, where(ctx, input.pr))
|
|
264
|
+
return { to: 'refused', reason }
|
|
265
|
+
}
|
|
266
|
+
return { to: 'armed', pr: input.pr }
|
|
267
|
+
},
|
|
268
|
+
}),
|
|
269
|
+
{ queue: Q.promote },
|
|
270
|
+
)
|
|
271
|
+
|
|
272
|
+
const merging = declare(
|
|
273
|
+
defineWait({
|
|
274
|
+
name: 'merging',
|
|
275
|
+
input: PrIn,
|
|
276
|
+
output: z.object({ to: z.enum(['merged', 'closed']), pr: z.number().int() }),
|
|
277
|
+
/** Merged or closed unmerged; open: hold (no timeout). @param {z.infer<typeof PrIn>} input @param {ReleaseCtx} ctx */
|
|
278
|
+
poll: async (input, ctx) => {
|
|
279
|
+
const { state } = prOf(ctx)
|
|
280
|
+
if (state === 'MERGED') return { ready: true, output: { to: 'merged', pr: input.pr } }
|
|
281
|
+
if (state === 'CLOSED') return { ready: true, output: { to: 'closed', pr: input.pr } }
|
|
282
|
+
return { ready: false }
|
|
283
|
+
},
|
|
284
|
+
}),
|
|
285
|
+
{
|
|
286
|
+
queue: Q.promote,
|
|
287
|
+
/** @param {{ pr: number }} input @param {ReleaseCtx} ctx */
|
|
288
|
+
enter: async (input, ctx) => {
|
|
289
|
+
const pr = prOf(ctx)
|
|
290
|
+
const m = markerOn(pr, releasePromote.name, 'merging')
|
|
291
|
+
await land(ctx, pr, releasePromote, 'merging', {
|
|
292
|
+
...withHistory(m, { at: iso(ctx.tick.now), attempt: m.attempt, outcome: 'merge-armed', pr: input.pr }),
|
|
293
|
+
lastFailure: null,
|
|
294
|
+
input: { pr: input.pr },
|
|
295
|
+
})
|
|
296
|
+
ctx.log('info', `release: merging promotion PR #${input.pr}`, where(ctx, input.pr))
|
|
297
|
+
},
|
|
298
|
+
},
|
|
299
|
+
)
|
|
300
|
+
|
|
301
|
+
/** @param {'promoted' | 'abandoned'} name @param {string} outcome @param {string} said */
|
|
302
|
+
const exit = (name, outcome, said) =>
|
|
303
|
+
declare(
|
|
304
|
+
defineNode({
|
|
305
|
+
name,
|
|
306
|
+
input: PrIn,
|
|
307
|
+
output: Empty,
|
|
308
|
+
/** @param {z.infer<typeof PrIn>} input @param {ReleaseCtx} ctx */
|
|
309
|
+
run: async (input, ctx) => {
|
|
310
|
+
const pr = prOf(ctx)
|
|
311
|
+
const m = markerOn(pr, releasePromote.name, name)
|
|
312
|
+
await land(
|
|
313
|
+
ctx,
|
|
314
|
+
pr,
|
|
315
|
+
releasePromote,
|
|
316
|
+
name,
|
|
317
|
+
{ ...withHistory(m, { at: iso(ctx.tick.now), attempt: m.attempt, outcome, pr: input.pr }), input: null },
|
|
318
|
+
{ status: 'done' },
|
|
319
|
+
)
|
|
320
|
+
ctx.log('info', `release: promotion PR #${input.pr} ${said}`, where(ctx, input.pr))
|
|
321
|
+
return {}
|
|
322
|
+
},
|
|
323
|
+
}),
|
|
324
|
+
{ queue: null },
|
|
325
|
+
)
|
|
326
|
+
|
|
327
|
+
/** Bump `version` when a node is removed or renamed. */
|
|
328
|
+
export const releasePromote = defineGraph({
|
|
329
|
+
name: 'release-promote',
|
|
330
|
+
version: 1,
|
|
331
|
+
entry: { queue: Q.promote, node: 'merge' },
|
|
332
|
+
nodes: [
|
|
333
|
+
merge,
|
|
334
|
+
merging,
|
|
335
|
+
exit('promoted', 'merged', 'merged'),
|
|
336
|
+
exit('abandoned', 'closed-unmerged', 'closed without merging'),
|
|
337
|
+
],
|
|
338
|
+
edges: [
|
|
339
|
+
['merge', 'merging', armed],
|
|
340
|
+
['merge', END],
|
|
341
|
+
['merging', 'promoted', merged],
|
|
342
|
+
['merging', 'abandoned'],
|
|
343
|
+
['promoted', END],
|
|
344
|
+
['abandoned', END],
|
|
345
|
+
],
|
|
346
|
+
})
|
|
347
|
+
|
|
348
|
+
/** `q:promote` belongs to release-promote. */
|
|
349
|
+
export const RELEASE_QUEUES = {
|
|
350
|
+
[Q.promote]: {
|
|
351
|
+
graph: releasePromote.name,
|
|
352
|
+
entryNode: releasePromote.entry.node,
|
|
353
|
+
nodes: releasePromote.nodes.map((n) => n.name),
|
|
354
|
+
},
|
|
355
|
+
}
|
|
356
|
+
|
|
357
|
+
// ---- Driving them (the tick's Release step)
|
|
358
|
+
|
|
359
|
+
/**
|
|
360
|
+
* Advance `graph` from `at`, one transition at a time, writing a wait's `enter` when an edge lands on it. Stops
|
|
361
|
+
* at END, at a wait that is not ready, or on entering a wait (polled next tick). A node error is rethrown.
|
|
362
|
+
*
|
|
363
|
+
* @param {import('../graph/define.mjs').Graph} graph @param {ReleaseCtx} ctx
|
|
364
|
+
* @param {{ node: string, input: unknown }} at
|
|
365
|
+
*/
|
|
366
|
+
async function drive(graph, ctx, at) {
|
|
367
|
+
let pos = at
|
|
368
|
+
for (;;) {
|
|
369
|
+
// TRACING (follow-up): pass tracing.mjs `advanceHooks` as `instrument` here, as the task graph will.
|
|
370
|
+
const r = await advance(graph, pos, ctx, { maxTransitions: 1 })
|
|
371
|
+
if (r.error) throw r.error.cause instanceof Error ? r.error.cause : r.error
|
|
372
|
+
const t = r.transitions[0]
|
|
373
|
+
const next = /** @type {(import('../graph/define.mjs').GraphNode & Declared) | undefined} */ (
|
|
374
|
+
graph.nodes.find((n) => n.name === r.node)
|
|
375
|
+
)
|
|
376
|
+
if (t && t.to !== END) await next?.enter?.(t.next, ctx)
|
|
377
|
+
if (r.reason !== 'limit' || next?.kind === 'wait') return
|
|
378
|
+
pos = { node: r.node, input: r.input }
|
|
379
|
+
}
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
/**
|
|
383
|
+
* Where a `q:promote` PR's turn starts, or null for none. Merged or closed: `merging`, which exits. Open: the
|
|
384
|
+
* marker's `merging`, else the entry once the PR is approved, unless a merge was already refused on this head.
|
|
385
|
+
* @param {PromotionPr} pr @returns {{ node: string, input: { pr: number } } | null}
|
|
386
|
+
*/
|
|
387
|
+
export function promoteStart(pr) {
|
|
388
|
+
if (!pr.labels.includes(Q.promote)) return null
|
|
389
|
+
const marker = pr.stateComment?.marker ?? null
|
|
390
|
+
const input = { pr: pr.number }
|
|
391
|
+
if (pr.state !== 'OPEN') return { node: 'merging', input }
|
|
392
|
+
const pos = effectivePosition(pr.labels, marker, RELEASE_QUEUES)
|
|
393
|
+
if (pos?.node === 'merging' && !pos.reset) return { node: 'merging', input }
|
|
394
|
+
if (!pr.approved) return null
|
|
395
|
+
const refusedHere = !pos?.reset && pos?.node === 'merge' && marker?.lastFailure && marker.failedSha === pr.headSha
|
|
396
|
+
return refusedHere ? null : { node: releasePromote.entry.node, input }
|
|
397
|
+
}
|
|
398
|
+
|
|
399
|
+
/** The store key for a repo's last release-prepare run. @param {string} slug */
|
|
400
|
+
export const lastRunKey = (slug) => `release.lastRun:${slug}`
|
|
401
|
+
|
|
402
|
+
/**
|
|
403
|
+
* The tick's Release step on `engine: "graph"`, per repo with `release` on (and `from` ≠ `to`): release-prepare
|
|
404
|
+
* when it is due, then a release-promote turn for each `q:promote` PR. One repo's failure is logged; the rest
|
|
405
|
+
* still run.
|
|
406
|
+
*
|
|
407
|
+
* @param {import('../tick.mjs').Deps} deps @param {import('../tick.mjs').Ctx} tick
|
|
408
|
+
*/
|
|
409
|
+
export async function releaseGraphs(deps, tick) {
|
|
410
|
+
for (const repo of deps.config.repos) {
|
|
411
|
+
const { enabled, time, from, to } = repo.release
|
|
412
|
+
const release = tick.snaps.get(repo.slug)?.release
|
|
413
|
+
if (!enabled || from === to || !release) continue
|
|
414
|
+
/** @param {PromotionPr} [pr] @returns {ReleaseCtx} */
|
|
415
|
+
const ctxFor = (pr) => ({ ...deps, tick, subject: { slug: repo.slug, repo, release, pr } })
|
|
416
|
+
try {
|
|
417
|
+
const last = deps.store.get(lastRunKey(repo.slug))
|
|
418
|
+
if (releaseDue(tick.now, last === null ? null : Number(last), time)) {
|
|
419
|
+
deps.store.set(lastRunKey(repo.slug), String(tick.now))
|
|
420
|
+
await drive(releasePrepare, ctxFor(), { node: releasePrepare.entry.node, input: {} })
|
|
421
|
+
}
|
|
422
|
+
} catch (err) {
|
|
423
|
+
deps.log('error', `release-prepare: ${/** @type {Error} */ (err)?.message ?? err}`, { repo: repo.slug })
|
|
424
|
+
}
|
|
425
|
+
for (const pr of [...release.prs]) {
|
|
426
|
+
const at = promoteStart(pr)
|
|
427
|
+
if (!at) continue
|
|
428
|
+
try {
|
|
429
|
+
await drive(releasePromote, ctxFor(pr), at)
|
|
430
|
+
} catch (err) {
|
|
431
|
+
deps.log('error', `release-promote: ${/** @type {Error} */ (err)?.message ?? err}`, {
|
|
432
|
+
repo: repo.slug,
|
|
433
|
+
issue: pr.number,
|
|
434
|
+
})
|
|
435
|
+
}
|
|
436
|
+
}
|
|
437
|
+
}
|
|
438
|
+
}
|
package/src/marker.mjs
CHANGED
package/src/phases/release.mjs
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
// @ts-check
|
|
2
|
+
/** The legacy engine's Release seam. `engine: "graph"` runs graphs/release.mjs instead; `releaseDue` serves both. */
|
|
2
3
|
/** @typedef {(input: { repo: import('../config.mjs').Repo, now: number }) => Promise<{ done: boolean, note: string }>} Release */
|
|
3
4
|
|
|
4
5
|
/** @param {number} now @param {number | null} lastRun @param {string} time host-local HH:MM */
|
package/src/tick.mjs
CHANGED
|
@@ -14,6 +14,7 @@ import { prFor, taskExit, taskPrompt } from './phases/task.mjs'
|
|
|
14
14
|
import { branchName } from './convention.mjs'
|
|
15
15
|
import { PREPARE_FAILED_LINE } from './prepare.mjs'
|
|
16
16
|
import { releaseDue, releaseNotBuilt } from './phases/release.mjs'
|
|
17
|
+
import { releaseGraphs } from './graphs/release.mjs'
|
|
17
18
|
import { DISPATCH_NOT_BUILT, dispatchNotBuilt } from './phases/dispatch.mjs'
|
|
18
19
|
|
|
19
20
|
/**
|
|
@@ -560,10 +561,12 @@ export async function startTask(deps, ctx, slug, issue, snap, { foreground = fal
|
|
|
560
561
|
return { ...started, attempt: marker.attempt }
|
|
561
562
|
}
|
|
562
563
|
|
|
563
|
-
// ---- Release (
|
|
564
|
+
// ---- Release (no agent). Legacy: once a day, the run is a seam. Graph: the release-prepare / release-promote
|
|
565
|
+
// graphs (graphs/release.mjs), per repo.
|
|
564
566
|
|
|
565
567
|
/** @param {Deps} deps @param {Ctx} ctx */
|
|
566
568
|
async function release(deps, ctx) {
|
|
569
|
+
if (deps.config.engine === 'graph') return releaseGraphs(deps, ctx)
|
|
567
570
|
const { config, store } = deps
|
|
568
571
|
if (!config.release.enabled) return
|
|
569
572
|
const last = store.get('release.lastRun')
|