| 1 | import assert from "node:assert/strict"; |
| 2 | import { test } from "node:test"; |
| 3 | |
| 4 | import { |
| 5 | type Merged, |
| 6 | placePushes, |
| 7 | change, |
| 8 | checksFact, |
| 9 | confidenceAsk, |
| 10 | confidenceLine, |
| 11 | dayKey, |
| 12 | isTestFile, |
| 13 | landedByAgents, |
| 14 | landedToday, |
| 15 | parseSort, |
| 16 | parseTab, |
| 17 | pullFacts, |
| 18 | reachesBack, |
| 19 | reasonFor, |
| 20 | signedPercent, |
| 21 | sortRows, |
| 22 | stallReason, |
| 23 | summaryLine, |
| 24 | pushedByPerson, |
| 25 | pushedCommits, |
| 26 | waitingRows, |
| 27 | weekOf, |
| 28 | whyFor, |
| 29 | withConfidence, |
| 30 | } from "./mission-control.ts"; |
| 31 | |
| 32 | const HOUR = 3_600_000; |
| 33 | const DAY = 24 * HOUR; |
| 34 | // Monday 2026-10-05, 18:00 UTC. |
| 35 | const NOW = Date.parse("2026-10-05T18:00:00Z"); |
| 36 | const repo = { namespace: "acme", name: "web" }; |
| 37 | |
| 38 | test("each kind of need gets its reason chip", () => { |
| 39 | assert.equal(reasonFor({ kind: "deploy", detail: "" }), "blocking"); |
| 40 | assert.equal(reasonFor({ kind: "limit", detail: "" }), "blocking"); |
| 41 | assert.equal(reasonFor({ kind: "review", detail: "" }), "asked_for_you"); |
| 42 | assert.equal(reasonFor({ kind: "invitation", detail: "" }), "asked_for_you"); |
| 43 | assert.equal(reasonFor({ kind: "ready", detail: "" }), "ready_to_merge"); |
| 44 | assert.equal(reasonFor({ kind: "checks", detail: "" }), "checks_failing"); |
| 45 | assert.equal(reasonFor({ kind: "stuck", detail: "" }), "stalled"); |
| 46 | }); |
| 47 | |
| 48 | test("a stopped pull request's reason comes from the sentence g1t stopped with", () => { |
| 49 | assert.equal(stallReason("The required check CI still fails after the agent revised 3 times."), "checks_failing"); |
| 50 | assert.equal(stallReason("The required checks CI and Lint still fail after the agent revised twice."), "checks_failing"); |
| 51 | assert.equal(stallReason("CI / push still fails after the agent revised 2 times."), "checks_failing"); |
| 52 | assert.equal(stallReason("It failed in the merge queue after the agent revised twice."), "checks_failing"); |
| 53 | assert.equal(stallReason("Its checks could not be run."), "checks_failing"); |
| 54 | assert.equal( |
| 55 | stallReason("g1t stopped the agent's implement run when it reached its cost cap. Raise the cap under Settings, Guardrails."), |
| 56 | "outside_guardrails", |
| 57 | ); |
| 58 | assert.equal(stallReason("g1t stopped the agent's review run when it reached its time cap."), "outside_guardrails"); |
| 59 | assert.equal(stallReason("g1t could not merge this: the branch moved"), "blocking"); |
| 60 | assert.equal(stallReason("Needs 1 approving review from someone with write access."), "needs_review"); |
| 61 | assert.equal(stallReason("The review still asks for changes after the agent revised 3 times."), "needs_review"); |
| 62 | assert.equal(stallReason("alex asked for changes, and the agent has already revised 3 times."), "needs_review"); |
| 63 | assert.equal(stallReason("syntaqx stopped the agent's implement run."), "stalled"); |
| 64 | assert.equal(stallReason("g1t could not start the next step: no slot"), "stalled"); |
| 65 | }); |
| 66 | |
| 67 | test("why a need needs a person is said for every reason", () => { |
| 68 | for (const kind of ["deploy", "limit", "invitation", "review", "stuck", "checks", "ready", "conflict"] as const) { |
| 69 | const need = { kind, detail: "" }; |
| 70 | assert.ok(whyFor(reasonFor(need), need).length > 20, kind); |
| 71 | } |
| 72 | const stalled = { kind: "stalled" as const, detail: "It reached its cost cap." }; |
| 73 | assert.match(whyFor(reasonFor(stalled), stalled), /Guardrails/); |
| 74 | }); |
| 75 | |
| 76 | test("what the agent knows lists only what is known", () => { |
| 77 | const facts = pullFacts({ |
| 78 | checkStatus: "failed", |
| 79 | files: [ |
| 80 | { path: "src/retry.ts", additions: 40, deletions: 2 }, |
| 81 | { path: "src/retry.test.ts", additions: 60, deletions: 0 }, |
| 82 | ], |
| 83 | lifecycle: { revisions: 2 }, |
| 84 | runs: [ |
| 85 | { kind: "implement", costUsd: 0.5 }, |
| 86 | { kind: "revise", costUsd: 0.25 }, |
| 87 | { kind: "checks", costUsd: null }, |
| 88 | ], |
| 89 | }); |
| 90 | const by = Object.fromEntries(facts.map((f) => [f.label, f])); |
| 91 | assert.equal(by["Required checks"].value, "Failed in the merge queue"); |
| 92 | assert.equal(by["Required checks"].tone, "bad"); |
| 93 | assert.equal(by["Files changed"].value, "2"); |
| 94 | assert.equal(by.Lines.value, "+100 −2"); |
| 95 | assert.equal(by.Tests.value, "1 file"); |
| 96 | assert.equal(by["Sent back"].value, "2 times"); |
| 97 | assert.equal(by["Agent runs"].value, "2 · $0.75"); |
| 98 | |
| 99 | const bare = pullFacts({ checkStatus: null, files: [] }); |
| 100 | assert.deepEqual(bare, [{ label: "Required checks", value: "Not known yet", tone: null }]); |
| 101 | }); |
| 102 | |
| 103 | test("the required checks are read from where the agent's pull request stands", () => { |
| 104 | const at = (stage: Parameters<typeof checksFact>[1] extends infer L ? NonNullable<L>["stage"] : never, detail: string) => |
| 105 | checksFact(null, { stage, detail }); |
| 106 | assert.deepEqual(at("checking", "Waiting for CI / pull_request to finish."), { label: "Required checks", value: "Running", tone: null }); |
| 107 | assert.equal(at("checking", "Waiting for the required check Deploy to report on its latest commit.").value, "Not reported yet"); |
| 108 | assert.equal(at("revising", "CI / pull_request failed. The agent is being sent back to fix it.").value, "Failing"); |
| 109 | assert.equal(at("needs_you", "The required check CI still fails after the agent revised twice.").value, "Failing"); |
| 110 | // Past the checks: a review, an approval or a person's decision holds it, not them. |
| 111 | assert.equal(at("revising", "The review asked for changes. The agent is being sent back to make them.").value, "Passing"); |
| 112 | assert.equal(at("needs_you", "This repository requires 1 approving review before a pull request merges; this one has 0.").value, "Passing"); |
| 113 | assert.equal(at("ready", "Everything this repository asks for is met. Ready to merge.").tone, "good"); |
| 114 | assert.equal(at("working", "g1t is making the change.").value, "Not run yet"); |
| 115 | assert.equal(checksFact("failed", { stage: "revising", detail: "It failed in the merge queue." }).value, "Failed in the merge queue"); |
| 116 | }); |
| 117 | |
| 118 | test("a change held for low confidence is its own reason, ahead of what it would read as", () => { |
| 119 | const held = |
| 120 | "The agent's confidence in this change is low (checks failing, tests not added). This repository asks a person before merging it: approve it to let it land, or ask for changes."; |
| 121 | // Its reasons name checks and approval, but it is held for its confidence. |
| 122 | assert.equal(stallReason(held), "low_confidence"); |
| 123 | assert.equal(reasonFor({ kind: "stalled", detail: held }), "low_confidence"); |
| 124 | |
| 125 | const low = { level: "low" as const, reasons: ["tests not added", "3 revisions"], uncertainAbout: ["the retry limit"] }; |
| 126 | assert.equal(withConfidence("ready_to_merge", low), "low_confidence"); |
| 127 | assert.equal(withConfidence("needs_review", low), "low_confidence"); |
| 128 | // A failure that needs someone anyway keeps its own chip. |
| 129 | assert.equal(withConfidence("checks_failing", low), "checks_failing"); |
| 130 | assert.equal(withConfidence("ready_to_merge", { level: "medium" }), "ready_to_merge"); |
| 131 | assert.equal(withConfidence("ready_to_merge", null), "ready_to_merge"); |
| 132 | |
| 133 | assert.equal(confidenceLine(low), "Low — tests not added, 3 revisions"); |
| 134 | assert.equal(confidenceLine({ level: "high", reasons: [] }), "High"); |
| 135 | assert.match(confidenceAsk(low), /not sure of the change: tests not added, 3 revisions\. Approve it/); |
| 136 | |
| 137 | const why = whyFor("low_confidence", { kind: "stalled", detail: held }, low); |
| 138 | assert.match(why, /from tests not added, 3 revisions\./); |
| 139 | assert.match(why, /unsure about the retry limit/); |
| 140 | assert.match(why, /nothing merges it until you approve it/); |
| 141 | // Ready, not held: it says to look before merging. |
| 142 | assert.match(whyFor("low_confidence", { kind: "ready", detail: "" }, low), /Look at it before you merge it/); |
| 143 | }); |
| 144 | |
| 145 | test("what the agent knows gains its confidence, across the row", () => { |
| 146 | const facts = pullFacts({ |
| 147 | checkStatus: "passed", |
| 148 | files: [{ path: "src/retry.ts", additions: 40, deletions: 2 }], |
| 149 | lifecycle: { revisions: 3 }, |
| 150 | confidence: { level: "low", reasons: ["tests not added", "3 revisions"] }, |
| 151 | }); |
| 152 | const fact = facts.find((f) => f.label === "Confidence"); |
| 153 | assert.deepEqual(fact, { label: "Confidence", value: "Low — tests not added, 3 revisions", tone: "bad", wide: true }); |
| 154 | assert.equal(facts.at(-1)?.label, "Confidence"); |
| 155 | }); |
| 156 | |
| 157 | test("test files are recognised by the names test runners use", () => { |
| 158 | assert.ok(isTestFile("src/a.test.ts")); |
| 159 | assert.ok(isTestFile("src/__tests__/a.ts")); |
| 160 | assert.ok(isTestFile("tests/api.rs")); |
| 161 | assert.ok(isTestFile("pkg/store_test.go")); |
| 162 | assert.ok(!isTestFile("src/testing-utils.ts")); |
| 163 | assert.ok(!isTestFile("src/contest.ts")); |
| 164 | assert.ok(isTestFile("test.js")); |
| 165 | assert.ok(isTestFile("lib/spec.rb")); |
| 166 | }); |
| 167 | |
| 168 | const merged = (daysAgo: number, mergedBy: string | null, number = 1, authoredByAgent = true): Merged => ({ |
| 169 | repo, |
| 170 | number, |
| 171 | title: `Change ${number}`, |
| 172 | agent: "g1t", |
| 173 | authoredByAgent, |
| 174 | mergedBy, |
| 175 | mergedAt: new Date(NOW - daysAgo * DAY).toISOString(), |
| 176 | files: [], |
| 177 | }); |
| 178 | |
| 179 | test("a push to the default branch counts a person's own commits, not merges or g1t's", () => { |
| 180 | const c = (hash: string, email: string, parents = 1) => ({ hash, author: { name: "g1t", email }, parents: Array(parents).fill("p") }); |
| 181 | // Every commit is named "g1t": the name decides nothing, the address does. |
| 182 | const history = [c("e", "chase@example.com"), c("d", "agent@g1t.sh"), c("m", "chase@example.com", 2), c("b", "chase@example.com"), c("a", "chase@example.com")]; |
| 183 | const byG1t = (commit: { author: { email: string } }) => commit.author.email === "agent@g1t.sh"; |
| 184 | assert.deepEqual(pushedCommits(history, "a", byG1t).map((x) => x.hash), ["e", "b"]); |
| 185 | // Where it pointed before was not read: everything read counts. |
| 186 | assert.deepEqual(pushedCommits(history, "zz", byG1t).map((x) => x.hash), ["e", "b", "a"]); |
| 187 | }); |
| 188 | |
| 189 | test("who pushed is the account that signed in, not the name on the commits", () => { |
| 190 | assert.ok(pushedByPerson({ actor: "usr_chase", data: {} })); |
| 191 | assert.ok(pushedByPerson({ actor: null, data: {} })); |
| 192 | assert.ok(!pushedByPerson({ actor: "usr_g1t_agent", data: {} })); |
| 193 | assert.ok(!pushedByPerson({ actor: "g1t_policy", data: {} })); |
| 194 | // A workflow job's own token is not a person either. |
| 195 | assert.ok(!pushedByPerson({ actor: "usr_chase", data: { causedByJob: "run_1" } })); |
| 196 | |
| 197 | const c = (hash: string, name: string) => ({ hash, parents: ["p"], author: { name, email: `${hash}@example.com` } }); |
| 198 | // A person whose git name is "g1t" pushed m1; g1t pushed w1 under a person's name. |
| 199 | const history = [c("w1", "Chase Pierce"), c("m1", "g1t"), c("old", "Chase Pierce")]; |
| 200 | const pushes = [ |
| 201 | { time: "2026-10-07T12:00:00Z", actor: "usr_g1t_agent", data: { after: "w1", before: "m1" } }, |
| 202 | { time: "2026-10-05T12:00:00Z", actor: "usr_chase", data: { after: "m1", before: "old" } }, |
| 203 | ]; |
| 204 | assert.deepEqual(placePushes(history, pushes), [{ hash: "m1", at: "2026-10-05T12:00:00Z" }]); |
| 205 | }); |
| 206 | |
| 207 | test("a change landed without a person when g1t merged it", () => { |
| 208 | assert.ok(landedByAgents({ mergedBy: "g1t" })); |
| 209 | assert.ok(landedByAgents({ mergedBy: "g1t" })); |
| 210 | assert.ok(landedByAgents({ mergedBy: null })); |
| 211 | assert.ok(!landedByAgents({ mergedBy: "syntaqx" })); |
| 212 | }); |
| 213 | |
| 214 | test("the week is seven days, each split by who did the work, with the week before", () => { |
| 215 | const week = weekOf( |
| 216 | [ |
| 217 | merged(0, "g1t"), |
| 218 | merged(0, "syntaqx"), |
| 219 | // A person's own change, merged by them and auto-merged by g1t: both theirs. |
| 220 | merged(0, "syntaqx", 2, false), |
| 221 | merged(1, "g1t", 3, false), |
| 222 | merged(1, "g1t"), |
| 223 | merged(6, "g1t"), |
| 224 | merged(8, "g1t"), |
| 225 | merged(10, "alex"), |
| 226 | merged(20, "g1t"), |
| 227 | ], |
| 228 | NOW, |
| 229 | "UTC", |
| 230 | ); |
| 231 | assert.equal(week.days.length, 7); |
| 232 | assert.equal(week.days[6].key, "2026-10-05"); |
| 233 | assert.equal(week.days[6].label, "Mon"); |
| 234 | assert.deepEqual( |
| 235 | week.days.map((d) => [d.agents, d.assisted, d.people]), |
| 236 | [[1, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [1, 0, 1], [1, 1, 1]], |
| 237 | ); |
| 238 | assert.equal(week.total, 6); |
| 239 | assert.equal(week.byAgents, 3); |
| 240 | assert.equal(week.agentChanges, 4); |
| 241 | assert.equal(week.people, 2); |
| 242 | assert.equal(week.previous, 2); |
| 243 | // Not knowing the week before is not the same as nothing in it. |
| 244 | assert.equal(weekOf([merged(0, "g1t")], NOW, "UTC", false).previous, null); |
| 245 | }); |
| 246 | |
| 247 | test("days follow the viewer's time zone", () => { |
| 248 | // 02:00 UTC on the 5th is still the 4th in Los Angeles. |
| 249 | const late = Date.parse("2026-10-05T02:00:00Z"); |
| 250 | assert.equal(dayKey(late, "America/Los_Angeles"), "2026-10-04"); |
| 251 | assert.equal(dayKey(late, "UTC"), "2026-10-05"); |
| 252 | assert.equal(dayKey(late, "Not/AZone"), "2026-10-05"); |
| 253 | const week = weekOf([{ mergedAt: new Date(late).toISOString(), mergedBy: "g1t", authoredByAgent: true }], NOW, "America/Los_Angeles"); |
| 254 | assert.equal(week.days.find((d) => d.key === "2026-10-04")?.agents, 1); |
| 255 | }); |
| 256 | |
| 257 | test("the change from last week, and how it reads", () => { |
| 258 | assert.equal(change(12, 10), 0.2); |
| 259 | assert.equal(change(5, 0), null); |
| 260 | assert.equal(change(5, null), null); |
| 261 | assert.equal(signedPercent(0.2), "+20%"); |
| 262 | assert.equal(signedPercent(-0.054), "−5%"); |
| 263 | assert.equal(signedPercent(0.001), "0%"); |
| 264 | }); |
| 265 | |
| 266 | test("a repository's merged list reaches back when it is not full or its oldest is old enough", () => { |
| 267 | const since = NOW - 14 * DAY; |
| 268 | const at = (days: number) => ({ mergedAt: new Date(NOW - days * DAY).toISOString(), updatedAt: new Date(NOW).toISOString() }); |
| 269 | assert.ok(reachesBack([at(1), at(2)], since, 100)); |
| 270 | assert.ok(reachesBack([at(1), at(20)], since, 2)); |
| 271 | assert.ok(!reachesBack([at(1), at(3)], since, 2)); |
| 272 | }); |
| 273 | |
| 274 | test("landed today is the viewer's calendar day, newest first", () => { |
| 275 | const rows = landedToday([merged(0.1, "g1t", 3), merged(0.5, "syntaqx", 4), merged(1, "g1t", 2)], NOW, "UTC"); |
| 276 | assert.deepEqual( |
| 277 | rows.map((r) => [r.ref, r.byAgents]), |
| 278 | [ |
| 279 | ["#3", true], |
| 280 | ["#4", false], |
| 281 | ], |
| 282 | ); |
| 283 | assert.equal(rows[1].by?.name, "syntaqx"); |
| 284 | }); |
| 285 | |
| 286 | test("waiting on agents holds each pull request once, running ones first, and nothing that needs you", () => { |
| 287 | const pull = (number: number, minutesAgo: number) => ({ |
| 288 | number, |
| 289 | title: `Pull ${number}`, |
| 290 | agent: "g1t", |
| 291 | updatedAt: new Date(NOW - minutesAgo * 60_000).toISOString(), |
| 292 | checkStatus: null, |
| 293 | files: [], |
| 294 | }); |
| 295 | const rows = waitingRows({ |
| 296 | active: [ |
| 297 | { pull: pull(1, 30), lifecycle: { stage: "checking", detail: "Waiting for CI / pull_request to finish.", revisions: 0 }, repo }, |
| 298 | { pull: pull(2, 5), lifecycle: { stage: "needs_you", detail: "Stopped.", revisions: 0 }, repo }, |
| 299 | { pull: pull(3, 50), lifecycle: { stage: "queued", detail: "In the merge queue.", revisions: 0 }, repo }, |
| 300 | { pull: pull(9, 1), lifecycle: { stage: "reviewing", detail: "Reviewing.", revisions: 0 }, repo }, |
| 301 | ], |
| 302 | live: [ |
| 303 | { |
| 304 | id: "r1", |
| 305 | repo, |
| 306 | number: 3, |
| 307 | title: "Pull 3", |
| 308 | kind: "update", |
| 309 | agent: "g1t", |
| 310 | step: "Merging main in", |
| 311 | costUsd: 0.1, |
| 312 | startedAt: new Date(NOW - 60_000).toISOString(), |
| 313 | createdAt: new Date(NOW - 60_000).toISOString(), |
| 314 | updatedAt: new Date(NOW - 10_000).toISOString(), |
| 315 | }, |
| 316 | { |
| 317 | id: "r2", |
| 318 | repo, |
| 319 | number: null, |
| 320 | title: null, |
| 321 | kind: "plan", |
| 322 | agent: "g1t", |
| 323 | step: null, |
| 324 | costUsd: null, |
| 325 | startedAt: null, |
| 326 | createdAt: new Date(NOW - 120_000).toISOString(), |
| 327 | updatedAt: new Date(NOW - 120_000).toISOString(), |
| 328 | }, |
| 329 | ], |
| 330 | drafts: [ |
| 331 | { ...pull(1, 30), repo }, |
| 332 | { ...pull(4, 20), repo }, |
| 333 | { ...pull(5, 20), agent: "syntaqx", repo }, |
| 334 | ], |
| 335 | needKeys: new Set(["acme/web#9"]), |
| 336 | }); |
| 337 | assert.deepEqual( |
| 338 | rows.map((r) => [r.ref, r.chip, r.live]), |
| 339 | [ |
| 340 | ["#3", "In queue", true], |
| 341 | [null, "Planning", true], |
| 342 | ["#4", "Working", false], |
| 343 | ["#1", "Checking", false], |
| 344 | ], |
| 345 | ); |
| 346 | assert.equal(rows[0].detail, "Merging main in"); |
| 347 | assert.equal(rows[0].run, "/acme/web/agents/runs/r1"); |
| 348 | assert.equal(rows[1].title, "Planning in web"); |
| 349 | }); |
| 350 | |
| 351 | test("tabs and sorting come from the address", () => { |
| 352 | assert.equal(parseTab("waiting"), "waiting"); |
| 353 | assert.equal(parseTab("nope"), null); |
| 354 | assert.equal(parseSort("newest"), "newest"); |
| 355 | assert.equal(parseSort(null), "impact"); |
| 356 | const rows = [{ at: 1 }, { at: 3 }, { at: 2 }]; |
| 357 | assert.deepEqual(sortRows(rows, "impact"), rows); |
| 358 | assert.deepEqual( |
| 359 | sortRows(rows, "newest").map((r) => r.at), |
| 360 | [3, 2, 1], |
| 361 | ); |
| 362 | }); |
| 363 | |
| 364 | test("the summary says the week honestly", () => { |
| 365 | const none = { total: 0, byAgents: 0, agentChanges: 0, people: 0, live: 0, needs: 0 }; |
| 366 | assert.equal( |
| 367 | summaryLine({ ...none, total: 47, byAgents: 39, agentChanges: 47 }), |
| 368 | "Agents landed 39 of their 47 changes this week without you.", |
| 369 | ); |
| 370 | assert.equal( |
| 371 | summaryLine({ ...none, total: 3, byAgents: 3, agentChanges: 3 }), |
| 372 | "Agents landed all 3 changes of theirs this week without you.", |
| 373 | ); |
| 374 | assert.equal( |
| 375 | summaryLine({ ...none, total: 2, agentChanges: 2 }), |
| 376 | "Agents made 2 changes this week, each merged by a person.", |
| 377 | ); |
| 378 | // People's own work is counted as theirs, never as agents' that needed help. |
| 379 | assert.equal( |
| 380 | summaryLine({ ...none, total: 7, byAgents: 4, agentChanges: 5, people: 2 }), |
| 381 | "Agents landed 4 of their 5 changes this week without you, and people landed 2 changes of their own.", |
| 382 | ); |
| 383 | assert.equal(summaryLine({ ...none, total: 3, people: 3 }), "People landed 3 changes this week; none were agents'."); |
| 384 | assert.equal(summaryLine({ ...none, live: 1 }), "1 agent is at work. Nothing has landed this week yet."); |
| 385 | assert.match(summaryLine(none), /Assign an issue/); |
| 386 | }); |
| 387 | |
| 388 | test("a job waiting for a self-hosted runner says so, not that an agent went quiet", () => { |
| 389 | const runner = { kind: "runner" as const, detail: "No runner with labels self-hosted, docker is online." }; |
| 390 | assert.equal(reasonFor(runner), "stalled"); |
| 391 | const why = whyFor(reasonFor(runner), runner); |
| 392 | assert.match(why, /self-hosted runner/); |
| 393 | assert.doesNotMatch(why, /agent/); |
| 394 | }); |
| 395 | |
| 396 | test("each push to the default branch places the commits it brought, at its time, from one read of the history", () => { |
| 397 | const c = (hash: string, parents = ["p"], email = "chase@example.com") => ({ hash, parents, author: { name: "Chase Pierce", email } }); |
| 398 | // Newest first: a Wednesday push of two, a Monday push of one, a merge, and g1t's own commit. |
| 399 | const history = [c("w2"), c("w1"), c("m1"), c("merge", ["a", "b"]), c("bot", ["p"], "g1t@users.noreply.g1t.sh"), c("old")]; |
| 400 | const pushes = [ |
| 401 | { time: "2026-10-07T12:00:00Z", actor: "usr_chase", data: { after: "w2", before: "m1" } }, |
| 402 | { time: "2026-10-05T12:00:00Z", actor: "usr_chase", data: { after: "m1", before: "old" } }, |
| 403 | { time: "2026-10-01T12:00:00Z", actor: "usr_chase", data: { after: "gone", before: "older" } }, |
| 404 | ]; |
| 405 | const byG1t = (commit: { author: { email: string } }) => commit.author.email.endsWith("@users.noreply.g1t.sh"); |
| 406 | assert.deepEqual(placePushes(history, pushes, byG1t), [ |
| 407 | { hash: "m1", at: "2026-10-05T12:00:00Z" }, |
| 408 | { hash: "w2", at: "2026-10-07T12:00:00Z" }, |
| 409 | { hash: "w1", at: "2026-10-07T12:00:00Z" }, |
| 410 | ]); |
| 411 | }); |