@shivaedev/pr-watch 0.0.0 → 0.1.0

package/package.json

@@ -1,14 +1,80 @@
 {
   "name": "@shivaedev/pr-watch",
-  "version": "0.0.0",
-  "description": "Name reservation. The first release is published from https://github.com/ShivaeDev/platform.",
-  "license": "MIT",
+  "version": "0.1.0",
+  "description": "One REST watcher for pull request transitions across a repository",
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/pr-watch#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShivaeDev/platform.git",
     "directory": "packages/pr-watch"
   },
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "imports": {
+    "#test/*": "./src/test-support/*",
+    "#*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "exports": {
+    "./*.ts": {
+      "types": "./dist/*.d.ts",
+      "source": "./src/*.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "pr-watch": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
+    "!src/**/test-support",
+    "docs",
+    "CHANGELOG.md",
+    "README.md"
+  ],
+  "dependencies": {
+    "@shivaedev/effect-service": "0.3.0"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.0.4",
+    "@effect/platform-node-shared": "4.0.4",
+    "@effect/vitest": "4.0.4",
+    "@shivaedev/effect-test": "0.4.0",
+    "@shivaedev/quality": "0.20.0",
+    "@types/node": "24.19.1",
+    "@typescript/native": "npm:typescript@7.0.2",
+    "effect": "4.0.4",
+    "typescript": "npm:@typescript/typescript6@6.0.2",
+    "vitest": "5.0.3"
+  },
+  "peerDependencies": {
+    "@effect/platform-node": "4.0.4",
+    "@effect/platform-node-shared": "4.0.4",
+    "effect": "4.0.4"
+  },
+  "engines": {
+    "node": ">=24"
+  },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc --project tsconfig.build.json",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
   }
 }

package/src/GitHub.ts

@@ -0,0 +1,102 @@
+import { Effect, Schema } from "effect";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { confirmQueue } from "./confirmQueue.ts";
+import { GitHubHttp } from "./GitHubHttp.ts";
+import { type Options, type Snapshot, WatchError } from "./model.ts";
+
+const Pull = Schema.Struct({
+	autoMerge: Schema.NullOr(Schema.Struct({ mergeMethod: Schema.String }).pipe(Schema.encodeKeys({ mergeMethod: "merge_method" }))),
+	head: Schema.Struct({ ref: Schema.String, sha: Schema.String }),
+	mergeable: Schema.NullOr(Schema.Boolean),
+	mergeableState: Schema.String,
+	merged: Schema.Boolean,
+	number: Schema.Int,
+	state: Schema.Literals(["open", "closed"]),
+	title: Schema.String,
+}).pipe(Schema.encodeKeys({ autoMerge: "auto_merge", mergeableState: "mergeable_state" }));
+const Ref = Schema.Struct({ ref: Schema.String });
+const ListedPull = Schema.Struct({ number: Schema.Int });
+const Check = Schema.Struct({ conclusion: Schema.NullOr(Schema.String), status: Schema.String });
+const Checks = Schema.Struct({ checkRuns: Schema.Array(Check) }).pipe(Schema.encodeKeys({ checkRuns: "check_runs" }));
+const Status = Schema.Struct({ state: Schema.String });
+const failures = new Set(["failure", "timed_out", "cancelled", "action_required", "startup_failure", "stale"]);
+export const GitHub = defineService({
+	id: "@shivaedev/pr-watch/GitHub",
+	initialize: GitHubHttp,
+	methods: (http) => {
+		function decode<TSchema extends Schema.Top>(schema: TSchema, body: unknown) {
+			return Schema.decodeUnknownEffect(schema)(body).pipe(Effect.mapError(() => new WatchError({ message: "Invalid GitHub response" })));
+		}
+		function pages(options: Options, path: string) {
+			return Effect.gen(function* () {
+				const bodies: unknown[] = [];
+				const visited = new Set<string>();
+				let url: string | undefined = `${options.apiUrl}/repos/${options.repository}${path}`;
+				while (url !== undefined) {
+					if (visited.has(url)) {
+						return yield* Effect.fail(new WatchError({ message: "Repeated pagination URL" }));
+					}
+					visited.add(url);
+					const response: Effect.Success<ReturnType<typeof http.get>> = yield* http.get(url, options.token);
+					bodies.push(response.body);
+					url = response.next;
+				}
+				return bodies;
+			});
+		}
+		return {
+			confirmQueue: (options: Options, snapshot: Snapshot) => confirmQueue(http, options, snapshot),
+			delay: http.delay,
+			discover: (options: Options) =>
+				Effect.gen(function* () {
+					const bodies = yield* pages(options, "/pulls?state=open&per_page=100");
+					const lists = yield* Effect.forEach(bodies, (body) => decode(Schema.Array(ListedPull), body));
+					return lists.flat().map((pr) => pr.number);
+				}),
+			queue: (options: Options) =>
+				Effect.gen(function* () {
+					const bodies = yield* pages(options, "/git/matching-refs/heads/gh-readonly-queue/");
+					const lists = yield* Effect.forEach(bodies, (body) => decode(Schema.Array(Ref), body));
+					return new Set(
+						lists.flat().flatMap(({ ref }) => {
+							const number = ref.match(/\/pr-(?<number>\d+)-/u)?.groups?.number;
+							return number === undefined ? [] : [Number(number)];
+						}),
+					);
+				}),
+			snapshot: (options: Options, number: number, queued: ReadonlySet<number>) =>
+				Effect.gen(function* () {
+					const response = yield* http.get(`${options.apiUrl}/repos/${options.repository}/pulls/${number}`, options.token);
+					const pr = yield* decode(Pull, response.body);
+					if (pr.number !== number) {
+						return yield* Effect.fail(new WatchError({ message: "GitHub returned the wrong PR" }));
+					}
+					if (pr.state === "open" && (pr.mergeable === null || pr.mergeableState === "unknown")) {
+						return yield* Effect.fail(new WatchError({ message: `Mergeability pending for PR #${number}` }));
+					}
+					let failed = false;
+					if (pr.state === "open") {
+						const bodies = yield* pages(options, `/commits/${pr.head.sha}/check-runs?per_page=100&filter=latest`);
+						const checks = yield* Effect.forEach(bodies, (body) => decode(Checks, body));
+						const statusResponse = yield* http.get(`${options.apiUrl}/repos/${options.repository}/commits/${pr.head.sha}/status`, options.token);
+						const status = yield* decode(Status, statusResponse.body);
+						failed =
+							checks.some((page) => page.checkRuns.some((check) => check.status === "completed" && failures.has(check.conclusion ?? "")))
+							|| ["failure", "error"].includes(status.state);
+					}
+					return {
+						autoMerge: pr.autoMerge !== null,
+						branch: pr.head.ref,
+						dirty: pr.mergeableState === "dirty",
+						failed,
+						merged: pr.merged,
+						number,
+						queued: queued.has(number),
+						state: pr.state,
+						title: pr.title,
+					} satisfies Snapshot;
+				}),
+		};
+	},
+	requires: [GitHubHttp],
+});

package/src/GitHubHttp.ts

@@ -0,0 +1,55 @@
+import { Clock, Effect } from "effect";
+import { HttpClient } from "effect/http";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { type CachedResponse, decodeResponse, fetchResponse } from "./httpResponse.ts";
+import { WatchError } from "./model.ts";
+import { type Budget, observeBudget, pollDelay } from "./quota.ts";
+export const GitHubHttp = defineService({
+	id: "@shivaedev/pr-watch/GitHubHttp",
+	initialize: Effect.gen(function* () {
+		return {
+			budget: { blockedUntil: 0, limit: 5000, remaining: 5000, reset: 0 } satisfies Budget,
+			cache: new Map<string, CachedResponse>(),
+			client: yield* HttpClient.HttpClient,
+			requests: 0,
+		};
+	}),
+	methods: (state) => {
+		function request(url: string, token: string, body?: unknown) {
+			return Effect.gen(function* () {
+				const now = yield* Clock.currentTimeMillis;
+				if (state.budget.blockedUntil > now) {
+					return yield* Effect.fail(new WatchError({ message: "GitHub quota cooldown" }));
+				}
+				const cached = body === undefined ? state.cache.get(url) : undefined;
+				state.requests += 1;
+				const response = yield* fetchResponse(state.client, url, token, cached, body);
+				observeBudget(state.budget, response, yield* Clock.currentTimeMillis);
+				if (response.status === 304 && cached !== undefined) {
+					return cached;
+				}
+				const result = yield* decodeResponse(url, response);
+				if (body === undefined) {
+					state.cache.set(url, result);
+				}
+				return result;
+			}).pipe(
+				Effect.scoped,
+				Effect.timeout("30 seconds"),
+				Effect.mapError((cause) => (cause instanceof WatchError ? cause : new WatchError({ message: cause.message }))),
+			);
+		}
+		return {
+			delay: (interval: number) =>
+				Effect.gen(function* () {
+					const now = yield* Clock.currentTimeMillis;
+					const delay = pollDelay(state.budget, interval, Math.max(1, state.requests), now);
+					state.requests = 0;
+					return delay;
+				}),
+			get: (url: string, token: string) => request(url, token),
+			post: (url: string, token: string, body: unknown) => request(url, token, body),
+		};
+	},
+	requires: [HttpClient.HttpClient],
+});

package/src/StateFile.ts

@@ -0,0 +1,38 @@
+import { dirname } from "node:path";
+import process from "node:process";
+import { Effect, FileSystem, Schema } from "effect";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { State, WatchError } from "./model.ts";
+
+function failure(cause: unknown) {
+	return new WatchError({ message: cause instanceof Error ? cause.message : "State file operation failed" });
+}
+export const StateFile = defineService({
+	id: "@shivaedev/pr-watch/StateFile",
+	initialize: FileSystem.FileSystem,
+	methods: (fs) => ({
+		load: (path: string, repository: string) =>
+			Effect.gen(function* () {
+				const text = yield* fs.readFileString(path).pipe(
+					Effect.catchTag("PlatformError", (error) => (error.reason._tag === "NotFound" ? Effect.succeed(undefined) : Effect.fail(error))),
+					Effect.mapError(failure),
+				);
+				if (text === undefined) {
+					return { prs: {}, repository, version: 1 } satisfies State;
+				}
+				const state = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(State))(text).pipe(Effect.mapError(failure));
+				if (state.repository !== repository) {
+					return yield* Effect.fail(new WatchError({ message: "State file belongs to a different repository" }));
+				}
+				return state;
+			}),
+		save: (path: string, state: State) =>
+			Effect.gen(function* () {
+				yield* fs.makeDirectory(dirname(path), { recursive: true });
+				const temporary = `${path}.${process.pid}.tmp`;
+				yield* fs.writeFileString(temporary, `${JSON.stringify(state)}\n`, { mode: 0o600 });
+				yield* fs.rename(temporary, path);
+			}).pipe(Effect.mapError(failure)),
+	}),
+	requires: [FileSystem.FileSystem],
+});

package/src/Watcher.ts

@@ -0,0 +1,92 @@
+import { Effect } from "effect";
+import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import { events } from "./events.ts";
+import { GitHub } from "./GitHub.ts";
+import type { Options, Snapshot, State, WatchError } from "./model.ts";
+import { StateFile } from "./StateFile.ts";
+
+function activeNumbers(options: Options, state: State) {
+	return [...new Set([...options.numbers, ...(state.openNumbers ?? []), ...Object.keys(state.prs).map(Number)])].filter((number) => {
+		const saved = state.prs[String(number)];
+		return saved === undefined || (saved.state === "open" && !saved.merged);
+	});
+}
+export const Watcher = defineService({
+	id: "@shivaedev/pr-watch/Watcher",
+	initialize: Effect.gen(function* () {
+		return { file: yield* StateFile, github: yield* GitHub };
+	}),
+	methods: ({ file, github }) => {
+		function commit(state: State, snapshot: Snapshot, options: Options, emit: (line: string) => Effect.Effect<void, WatchError>) {
+			return Effect.uninterruptible(
+				Effect.gen(function* () {
+					const before = state.prs[String(snapshot.number)];
+					const baseline =
+						before === undefined && snapshot.state === "closed" && state.openNumbers?.includes(snapshot.number)
+							? { ...snapshot, merged: false, state: "open" as const }
+							: before;
+					for (const line of events(baseline, snapshot)) {
+						yield* emit(line);
+					}
+					const next = {
+						...state,
+						openNumbers: (state.openNumbers ?? []).filter((number) => number !== snapshot.number),
+						prs: { ...state.prs, [String(snapshot.number)]: snapshot },
+					};
+					yield* file.save(options.stateFile, next);
+					return next;
+				}),
+			);
+		}
+		function observe(options: Options, number: number, queue: ReadonlySet<number>, before: Snapshot | undefined) {
+			return Effect.gen(function* () {
+				const snapshot = yield* github.snapshot(options, number, queue);
+				return before?.queued === true && snapshot.state === "open" && !snapshot.queued ? yield* github.confirmQueue(options, snapshot) : snapshot;
+			});
+		}
+		function targets(options: Options, state: State) {
+			return Effect.gen(function* () {
+				const discovered = options.fleet ? yield* github.discover(options) : [];
+				const openNumbers = [...new Set([...(state.openNumbers ?? []), ...discovered])].filter((number) => state.prs[String(number)] === undefined);
+				const next = openNumbers.length === (state.openNumbers?.length ?? 0) ? state : { ...state, openNumbers };
+				if (next !== state) {
+					yield* Effect.uninterruptible(file.save(options.stateFile, next));
+				}
+				const numbers = activeNumbers(options, next);
+				const queue = numbers.length > 0 ? yield* github.queue(options) : new Set<number>();
+				return { numbers, queue, state: next };
+			});
+		}
+		return {
+			delay: github.delay,
+			load: (options: Options) => file.load(options.stateFile, options.repository),
+			poll: (
+				options: Options,
+				previous: State,
+				emit: (line: string) => Effect.Effect<void, WatchError>,
+				diagnostic: (message: string) => Effect.Effect<void, WatchError>,
+			) =>
+				Effect.gen(function* () {
+					let state: State = { ...previous, prs: { ...previous.prs } };
+					const targetsForRound = yield* targets(options, state);
+					const { numbers, queue } = targetsForRound;
+					state = targetsForRound.state;
+					let failure: WatchError | undefined;
+					for (const number of numbers) {
+						const result = yield* Effect.result(observe(options, number, queue, state.prs[String(number)]));
+						if (result._tag === "Failure") {
+							yield* diagnostic(result.failure.message);
+							failure = result.failure;
+							continue;
+						}
+						state = yield* commit(state, result.success, options, emit);
+					}
+					if (failure !== undefined) {
+						return yield* Effect.fail(failure);
+					}
+					return state;
+				}),
+		};
+	},
+	requires: [GitHub, StateFile],
+});

package/src/arguments.ts

@@ -0,0 +1,83 @@
+import { parseArgs } from "node:util";
+import { Effect } from "effect";
+import { type Options, WatchError } from "./model.ts";
+export const help = `pr-watch --repo OWNER/REPO [--fleet | PR_NUMBER ...]
+  --state PATH       Snapshot file (default .pr-watch/OWNER-REPO.json)
+  --interval SECONDS Poll interval (default 60; slows as quota falls)
+  --once             Poll once and exit
+  --api-url URL      GitHub REST base URL (default https://api.github.com)
+  --help             Show this help
+Authentication: GH_TOKEN or GITHUB_TOKEN`;
+export function argumentsFor(args: readonly string[], token: string) {
+	return Effect.try({
+		catch: (cause) => new WatchError({ message: cause instanceof Error ? cause.message : "Invalid arguments" }),
+		try: () => {
+			const { values, positionals } = parseArgs({
+				allowPositionals: true,
+				args: [...args],
+				options: {
+					"api-url": { type: "string" },
+					fleet: { type: "boolean" },
+					help: { type: "boolean" },
+					interval: { type: "string" },
+					once: { type: "boolean" },
+					repo: { type: "string" },
+					state: { type: "string" },
+				},
+			});
+			if (values.help) {
+				return { help: true as const };
+			}
+			const repository = values.repo ?? "";
+			if (repository.match(/^[\w.-]+\/[\w.-]+$/u) === null) {
+				throw new Error("--repo OWNER/REPO is required");
+			}
+			const numbers = numbersFor(positionals, values.fleet ?? false);
+			const interval = intervalFor(values.interval);
+			const apiUrl = apiUrlFor(values["api-url"]);
+			return {
+				help: false as const,
+				once: values.once ?? false,
+				options: {
+					apiUrl,
+					fleet: values.fleet ?? false,
+					interval,
+					numbers,
+					repository,
+					stateFile: values.state ?? `.pr-watch/${repository.replace("/", "-")}.json`,
+					token,
+				} satisfies Options,
+			};
+		},
+	});
+}
+function numbersFor(positionals: readonly string[], fleet: boolean): readonly number[] {
+	if (positionals.some((value) => value.match(/^[1-9]\d*$/u) === null)) {
+		throw new Error("PR numbers must be positive integers");
+	}
+	const numbers = [...new Set(positionals.map(Number))];
+	if (numbers.some((number) => !Number.isSafeInteger(number))) {
+		throw new Error("Invalid PR number");
+	}
+	if (fleet ? numbers.length > 0 : numbers.length === 0) {
+		throw new Error("Choose --fleet or one or more PR numbers");
+	}
+	return numbers;
+}
+function intervalFor(value: string | undefined): number {
+	const interval = Number(value ?? 60) * 1000;
+	if (!Number.isFinite(interval) || interval < 1000) {
+		throw new Error("--interval must be at least one second");
+	}
+	return interval;
+}
+function apiUrlFor(value: string | undefined): string {
+	const apiUrl = (value ?? "https://api.github.com").replace(/\/$/u, "");
+	const url = new URL(apiUrl);
+	const secure = url.protocol === "https:";
+	const loopback = url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+	if (!(secure || loopback) || url.username || url.password || url.search || url.hash) {
+		throw new Error("--api-url requires HTTPS (or loopback HTTP)");
+	}
+	return apiUrl;
+}

package/src/cli.ts

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { NodeFileSystem } from "@effect/platform-node";
+import { Config, Effect, Layer } from "effect";
+import { FetchHttpClient } from "effect/http";
+import { GitHub } from "./GitHub.ts";
+import { GitHubHttp } from "./GitHubHttp.ts";
+import { WatchError } from "./model.ts";
+import { program } from "./program.ts";
+import { StateFile } from "./StateFile.ts";
+import { Watcher } from "./Watcher.ts";
+
+const services = Watcher.layer.pipe(
+	Layer.provide(Layer.mergeAll(StateFile.layer, GitHub.layer.pipe(Layer.provide(GitHubHttp.layer)))),
+	Layer.provide(
+		Layer.mergeAll(
+			NodeFileSystem.layer,
+			FetchHttpClient.layer.pipe(Layer.provide(Layer.succeed(FetchHttpClient.RequestInit)({ redirect: "error" }))),
+		),
+	),
+);
+function write(stream: NodeJS.WriteStream) {
+	return (line: string) =>
+		Effect.tryPromise({
+			catch: () => new WatchError({ message: "Output stream failed" }),
+			try: () => new Promise<void>((resolve, reject) => stream.write(`${line}\n`, (error) => (error ? reject(error) : resolve()))),
+		});
+}
+const abort = new AbortController();
+process.once("SIGINT", () => abort.abort());
+process.once("SIGTERM", () => abort.abort());
+try {
+	await Effect.runPromise(
+		Effect.gen(function* () {
+			const token = yield* Config.String("GH_TOKEN").pipe(
+				Config.orElse(() => Config.String("GITHUB_TOKEN")),
+				Config.withDefault(""),
+			);
+			yield* program(process.argv.slice(2), token, write(process.stdout), write(process.stderr));
+		}).pipe(Effect.provide(services)),
+		{ signal: abort.signal },
+	);
+} catch (cause) {
+	if (!abort.signal.aborted) {
+		process.stderr.write(`${cause instanceof Error ? cause.message : "Watcher failed"}\n`);
+		process.exitCode = 1;
+	}
+}

package/src/confirmQueue.ts

@@ -0,0 +1,52 @@
+import { type Context, Effect, Schema } from "effect";
+import type { GitHubHttp } from "./GitHubHttp.ts";
+import { type Options, type Snapshot, WatchError } from "./model.ts";
+
+const QueueResponse = Schema.Struct({
+	data: Schema.NullOr(
+		Schema.Struct({
+			repository: Schema.NullOr(
+				Schema.Struct({
+					pullRequest: Schema.NullOr(
+						Schema.Struct({
+							autoMergeRequest: Schema.NullOr(Schema.Struct({ enabledAt: Schema.String })),
+							mergeQueueEntry: Schema.NullOr(Schema.Struct({ id: Schema.String })),
+							state: Schema.Literals(["OPEN", "CLOSED", "MERGED"]),
+						}),
+					),
+				}),
+			),
+		}),
+	),
+	errors: Schema.optionalKey(Schema.Array(Schema.Unknown)),
+});
+const query = `query QueueEntry($owner: String!, $name: String!, $number: Int!) {
+	repository(owner: $owner, name: $name) {
+		pullRequest(number: $number) {
+			state
+			autoMergeRequest { enabledAt }
+			mergeQueueEntry { id }
+		}
+	}
+}`;
+export const confirmQueue = Effect.fn("GitHub.confirmQueue")(function* (
+	http: Context.Service.Shape<typeof GitHubHttp>,
+	options: Options,
+	snapshot: Snapshot,
+) {
+	const url = new URL(options.apiUrl);
+	url.pathname = url.pathname.replace(/\/api\/v3\/?$/u, "/api/graphql");
+	if (!url.pathname.endsWith("/api/graphql")) {
+		url.pathname = `${url.pathname.replace(/\/$/u, "")}/graphql`;
+	}
+	const [owner, name] = options.repository.split("/");
+	const response = yield* http.post(url.href, options.token, { query, variables: { name, number: snapshot.number, owner } });
+	const body = yield* Schema.decodeUnknownEffect(QueueResponse)(response.body).pipe(
+		Effect.mapError(() => new WatchError({ message: "Invalid GitHub queue confirmation" })),
+	);
+	const pr = body.data?.repository?.pullRequest;
+	if ((body.errors?.length ?? 0) > 0 || pr === undefined || pr === null || pr.state !== "OPEN") {
+		return yield* Effect.fail(new WatchError({ message: `Queue confirmation unavailable for PR #${snapshot.number}` }));
+	}
+	return { ...snapshot, autoMerge: pr.autoMergeRequest !== null, queued: pr.mergeQueueEntry !== null || pr.autoMergeRequest !== null };
+});

package/src/events.ts

@@ -0,0 +1,33 @@
+import type { Snapshot } from "./model.ts";
+
+function stuck(pr: Snapshot): boolean {
+	return pr.state === "open" && pr.autoMerge && (pr.dirty || pr.failed);
+}
+function openEvents(before: Snapshot, after: Snapshot): readonly string[] {
+	const transitions: readonly (readonly [boolean, string])[] = [
+		[!before.dirty && after.dirty, "conflict"],
+		[!before.queued && after.queued, "queued"],
+		[before.queued && !after.queued, "dequeued"],
+		[(before.autoMerge || before.queued) && !after.autoMerge && !after.queued, "auto-merge-off"],
+		[!before.failed && after.failed, "checks-failed"],
+		[!stuck(before) && stuck(after), "stuck"],
+	];
+	return transitions.flatMap(([changed, event]) => (changed ? [event] : []));
+}
+export function events(before: Snapshot | undefined, after: Snapshot): readonly string[] {
+	if (before === undefined && !stuck(after)) {
+		return [];
+	}
+	const baseline = before ?? { ...after, autoMerge: false, dirty: false, failed: false };
+	const found: string[] = [];
+	if (!baseline.merged && after.merged) {
+		found.push("merged");
+	}
+	if (baseline.state === "open" && after.state === "closed" && !after.merged) {
+		found.push("closed");
+	}
+	if (after.state === "open") {
+		found.push(...openEvents(baseline, after));
+	}
+	return found.map((event) => JSON.stringify({ branch: after.branch, event, number: after.number, title: after.title }));
+}

package/src/httpResponse.ts

@@ -0,0 +1,37 @@
+import { Effect } from "effect";
+import { type HttpClient, HttpClientRequest, type HttpClientResponse } from "effect/http";
+import { WatchError } from "./model.ts";
+export interface CachedResponse {
+	readonly body: unknown;
+	readonly etag: string | null;
+	readonly next: string | undefined;
+}
+export function fetchResponse(client: HttpClient.HttpClient, url: string, token: string, cached: CachedResponse | undefined, body?: unknown) {
+	const headers: Record<string, string> = { Accept: "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28" };
+	if (token) {
+		headers.Authorization = `Bearer ${token}`;
+	}
+	if (cached?.etag) {
+		headers["If-None-Match"] = cached.etag;
+	}
+	return body === undefined
+		? client.get(url, { headers })
+		: HttpClientRequest.post(url, { headers }).pipe(HttpClientRequest.bodyJson(body), Effect.flatMap(client.execute));
+}
+export function decodeResponse(url: string, response: HttpClientResponse.HttpClientResponse) {
+	return Effect.gen(function* () {
+		if (response.status < 200 || response.status >= 300) {
+			return yield* Effect.fail(new WatchError({ message: `GitHub HTTP ${response.status} for ${new URL(url).pathname}` }));
+		}
+		const body = yield* response.json;
+		const next = response.headers.link?.match(/<(?<url>[^>]+)>; rel="next"/u)?.groups?.url;
+		yield* Effect.try(() => {
+			if (next !== undefined && new URL(next).origin !== new URL(url).origin) {
+				throw new Error("Cross-origin pagination refused");
+			}
+		});
+		return { body, etag: response.headers.etag ?? null, next } satisfies CachedResponse;
+	}).pipe(
+		Effect.mapError((cause) => (cause instanceof WatchError ? cause : new WatchError({ message: "Invalid GitHub response or pagination URL" }))),
+	);
+}

package/src/model.ts

@@ -0,0 +1,32 @@
+import { Schema } from "effect";
+export class WatchError extends Schema.TaggedError<WatchError>()("WatchError", {
+	message: Schema.String,
+}) {}
+export const Snapshot = Schema.Struct({
+	autoMerge: Schema.Boolean,
+	branch: Schema.String,
+	dirty: Schema.Boolean,
+	failed: Schema.Boolean,
+	merged: Schema.Boolean,
+	number: Schema.Int,
+	queued: Schema.Boolean,
+	state: Schema.Literals(["open", "closed"]),
+	title: Schema.String,
+});
+export type Snapshot = typeof Snapshot.Type;
+export const State = Schema.Struct({
+	openNumbers: Schema.optionalKey(Schema.Array(Schema.Int)),
+	prs: Schema.Record(Schema.String, Snapshot),
+	repository: Schema.String,
+	version: Schema.Literal(1),
+});
+export type State = typeof State.Type;
+export interface Options {
+	readonly apiUrl: string;
+	readonly fleet: boolean;
+	readonly interval: number;
+	readonly numbers: readonly number[];
+	readonly repository: string;
+	readonly stateFile: string;
+	readonly token: string;
+}