@shivaedev/pr-watch 0.1.2 → 0.3.0

package/src/cli.ts

@@ -1,17 +1,24 @@
 #!/usr/bin/env node
 import process from "node:process";
 import { NodeFileSystem } from "@effect/platform-node";
-import { Config, Effect, Layer } from "effect";
+import { Effect, Layer, Logger } 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";
+import { GitHub as GitHubClient } from "@shivaedev/effect-github/GitHub.ts";
+import { GitHubToken } from "@shivaedev/effect-github/GitHubToken.ts";
+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(
+			StateFile.layer,
+			GitHub.layer.pipe(Layer.provide(GitHubHttp.layer.pipe(Layer.provide(GitHubClient.layer), Layer.provide(GitHubToken.fromEnv)))),
+		),
+	),
 	Layer.provide(
 		Layer.mergeAll(
 			NodeFileSystem.layer,
@@ -31,14 +38,10 @@ 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 },
+		program(process.argv.slice(2), write(process.stdout), write(process.stderr)).pipe(Effect.provide(services), Effect.provide(Logger.layer([]))),
+		{
+			signal: abort.signal,
+		},
 	);
 } catch (cause) {
 	if (!abort.signal.aborted) {

package/src/confirmQueue.ts

@@ -40,8 +40,8 @@ export const confirmQueue = Effect.fn("GitHub.confirmQueue")(function* (
 		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(
+	const response = yield* http.post(url.href, { query, variables: { name, number: snapshot.number, owner } });
+	const body = yield* Schema.decodeUnknownEffect(QueueResponse)(response).pipe(
 		Effect.mapError(() => new WatchError({ message: "Invalid GitHub queue confirmation" })),
 	);
 	const pr = body.data?.repository?.pullRequest;

package/src/events.ts

@@ -1,10 +1,13 @@
-import type { Snapshot } from "./model.ts";
+import type { Snapshot } from "#model.ts";
+
+export const eventKinds = ["merged", "closed", "conflict", "queued", "dequeued", "auto-merge-off", "checks-failed", "stuck"] as const;
+export type EventKind = (typeof eventKinds)[number];
 
 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])[] = [
+function openEvents(before: Snapshot, after: Snapshot): readonly EventKind[] {
+	const transitions: readonly (readonly [boolean, EventKind])[] = [
 		[!before.dirty && after.dirty, "conflict"],
 		[!before.queued && after.queued, "queued"],
 		[before.queued && !after.queued, "dequeued"],
@@ -14,12 +17,12 @@ function openEvents(before: Snapshot, after: Snapshot): readonly string[] {
 	];
 	return transitions.flatMap(([changed, event]) => (changed ? [event] : []));
 }
-export function events(before: Snapshot | undefined, after: Snapshot): readonly string[] {
+export function events(before: Snapshot | undefined, after: Snapshot, selected?: readonly EventKind[]): readonly string[] {
 	if (before === undefined && !stuck(after)) {
 		return [];
 	}
 	const baseline = before ?? { ...after, autoMerge: false, dirty: false, failed: false };
-	const found: string[] = [];
+	const found: EventKind[] = [];
 	if (!baseline.merged && after.merged) {
 		found.push("merged");
 	}
@@ -29,5 +32,7 @@ export function events(before: Snapshot | undefined, after: Snapshot): readonly
 	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 }));
+	return found
+		.filter((event) => selected === undefined || selected.includes(event))
+		.map((event) => JSON.stringify({ branch: after.branch, event, number: after.number, title: after.title }));
 }

package/src/health.ts

@@ -0,0 +1,26 @@
+import { Clock, Effect } from "effect";
+import type { WatchError } from "#model.ts";
+
+export type Emit = (line: string) => Effect.Effect<void, WatchError>;
+export const health = Effect.fnUntraced(function* (
+	emit: Emit,
+	event: "heartbeat" | "cooldown" | "error" | "stopped",
+	fields: Record<string, unknown> = {},
+) {
+	const at = new Date(yield* Clock.currentTimeMillis).toISOString();
+	yield* emit(JSON.stringify({ at, event, ...fields }));
+});
+
+export const waitForPoll = Effect.fnUntraced(function* (emit: Emit, interval: number, delay: number) {
+	const next = (yield* Clock.currentTimeMillis) + delay;
+	const nextPollAt = new Date(next).toISOString();
+	if (delay > interval) {
+		yield* health(emit, "cooldown", { delayMs: delay, message: "GitHub quota pacing", nextPollAt });
+	}
+	let remaining = delay;
+	while (remaining > 0) {
+		yield* health(emit, "heartbeat", { nextPollAt });
+		yield* Effect.sleep(Math.min(interval, remaining));
+		remaining = next - (yield* Clock.currentTimeMillis);
+	}
+});

package/src/model.ts

@@ -1,6 +1,8 @@
 import { Schema } from "effect";
+import type { EventKind } from "#events.ts";
 export class WatchError extends Schema.TaggedError<WatchError>()("WatchError", {
 	message: Schema.String,
+	retryAt: Schema.optionalKey(Schema.Number),
 }) {}
 export const Snapshot = Schema.Struct({
 	autoMerge: Schema.Boolean,
@@ -23,10 +25,10 @@ export const State = Schema.Struct({
 export type State = typeof State.Type;
 export interface Options {
 	readonly apiUrl: string;
+	readonly events?: readonly EventKind[];
 	readonly fleet: boolean;
 	readonly interval: number;
 	readonly numbers: readonly number[];
 	readonly repository: string;
 	readonly stateFile: string;
-	readonly token: string;
 }

package/src/program.ts

@@ -1,34 +1,64 @@
-import { Effect } from "effect";
-import { argumentsFor, help } from "./arguments.ts";
-import type { WatchError } from "./model.ts";
-import { Watcher } from "./Watcher.ts";
+import { Effect, Exit } from "effect";
+import { argumentsFor, help } from "#arguments.ts";
+import { type Emit, health, waitForPoll } from "#health.ts";
+import type { WatchError } from "#model.ts";
+import { Watcher } from "#Watcher.ts";
+
 export const program = Effect.fn("PrWatch.program")(function* (
 	args: readonly string[],
-	token: string,
-	emit: (line: string) => Effect.Effect<void, WatchError>,
+	emit: Emit,
 	diagnostic: (message: string) => Effect.Effect<void, WatchError>,
 ) {
-	const parsed = yield* argumentsFor(args, token);
-	if (parsed.help) {
-		yield* emit(help);
-		return;
-	}
-	const watcher = yield* Watcher;
-	let state = yield* watcher.load(parsed.options);
-	while (true) {
-		const result = yield* Effect.result(watcher.poll(parsed.options, state, emit, diagnostic));
-		if (result._tag === "Success") {
-			state = result.success;
-		} else {
+	let reported: string | undefined;
+	let watching = true;
+	const run = Effect.gen(function* () {
+		const parsed = yield* argumentsFor(args);
+		if (parsed.help) {
+			watching = false;
+			yield* emit(help);
+			return;
+		}
+		const watcher = yield* Watcher;
+		let state = yield* watcher.load(parsed.options);
+		function report(message: string) {
+			return health(emit, "error", { message }).pipe(
+				Effect.tap(
+					Effect.sync(() => {
+						reported = message;
+					}),
+				),
+				Effect.andThen(diagnostic(message)),
+			);
+		}
+		while (true) {
+			reported = undefined;
+			state = yield* watcher.poll(parsed.options, state, emit, report);
 			if (parsed.once) {
-				return yield* Effect.fail(result.failure);
+				return;
 			}
-			yield* diagnostic(result.failure.message);
-			state = yield* watcher.load(parsed.options);
+			yield* waitForPoll(emit, parsed.options.interval, yield* watcher.delay(parsed.options.interval));
 		}
-		if (parsed.once) {
-			return;
-		}
-		yield* Effect.sleep(yield* watcher.delay(parsed.options.interval));
-	}
+	});
+	yield* run.pipe(
+		Effect.tapError((error) =>
+			Effect.gen(function* () {
+				if (reported !== error.message) {
+					yield* health(emit, "error", { message: error.message });
+				}
+				if (error.retryAt !== undefined) {
+					yield* health(emit, "cooldown", { message: error.message, nextPollAt: new Date(error.retryAt).toISOString() });
+				}
+			}),
+		),
+		Effect.onExit((exit) => {
+			if (!watching) {
+				return Effect.void;
+			}
+			let reason = "completed";
+			if (exit._tag === "Failure") {
+				reason = Exit.hasInterrupts(exit) ? "interrupted" : "failed";
+			}
+			return health(emit, "stopped", { reason }).pipe(Effect.orDie);
+		}),
+	);
 });

package/src/quota.ts

@@ -1,42 +1,21 @@
-import type { HttpClientResponse } from "effect/http";
+import { DateTime } from "effect";
+import type { RateLimitObservation } from "@shivaedev/effect-github/rateLimits.ts";
 
-export interface Budget {
-	blockedUntil: number;
-	limit: number;
-	remaining: number;
-	reset: number;
+export function quotaRetryAt(observations: readonly RateLimitObservation[], retryAt = 0): number {
+	return Math.max(retryAt, ...observations.filter((budget) => budget.remaining === 0).map((budget) => DateTime.toEpochMillis(budget.reset)));
 }
-function numeric(headers: Readonly<Record<string, string>>, name: string): number | undefined {
-	const value = headers[name];
-	return value !== undefined && Number.isFinite(Number(value)) ? Number(value) : undefined;
-}
-export function observeBudget(budget: Budget, response: Pick<HttpClientResponse.HttpClientResponse, "headers" | "status">, now: number): void {
-	budget.remaining = numeric(response.headers, "x-ratelimit-remaining") ?? budget.remaining;
-	budget.limit = numeric(response.headers, "x-ratelimit-limit") ?? budget.limit;
-	budget.reset = (numeric(response.headers, "x-ratelimit-reset") ?? budget.reset / 1000) * 1000;
-	if (response.status === 429 || response.status === 403) {
-		const retry = response.headers["retry-after"] ?? null;
-		const until = retryUntil(retry, now);
-		budget.blockedUntil = Math.max(budget.blockedUntil, Number.isFinite(until) ? until : now + 60_000);
-	}
-	if (budget.remaining === 0) {
-		budget.blockedUntil = Math.max(budget.blockedUntil, budget.reset);
-	}
-}
-export function pollDelay(budget: Budget, interval: number, requests: number, now: number): number {
-	const ratio = budget.remaining / Math.max(1, budget.limit);
-	const multiplier = slowdown(ratio);
-	const paced = budget.remaining > 0 && ratio < 0.5 ? Math.ceil((Math.max(0, budget.reset - now) * requests) / budget.remaining) : 0;
-	return Math.max(interval * multiplier, paced, budget.blockedUntil - now);
-}
-function retryUntil(retry: string | null, now: number): number {
-	if (retry === null) {
-		return now + 60_000;
-	}
-	if (Number.isFinite(Number(retry))) {
-		return now + Number(retry) * 1000;
-	}
-	return Date.parse(retry);
+
+export function pollDelay(observations: readonly RateLimitObservation[], interval: number, requests: number, now: number, retryAt = 0): number {
+	return Math.max(
+		interval,
+		quotaRetryAt(observations, retryAt) - now,
+		...observations.map((budget) => {
+			const ratio = budget.remaining / Math.max(1, budget.limit);
+			const reset = DateTime.toEpochMillis(budget.reset);
+			const paced = budget.remaining > 0 && ratio < 0.5 ? Math.ceil((Math.max(0, reset - now) * requests) / budget.remaining) : 0;
+			return Math.max(interval * slowdown(ratio), paced);
+		}),
+	);
 }
 function slowdown(ratio: number): number {
 	if (ratio < 0.1) {

package/dist/httpResponse.d.ts

@@ -1,15 +0,0 @@
-import { Effect } from "effect";
-import { type HttpClient, 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 declare function fetchResponse(client: HttpClient.HttpClient, url: string, token: string, cached: CachedResponse | undefined, body?: unknown): Effect.Effect<HttpClientResponse.HttpClientResponse, import("effect/http/HttpBody").HttpBodyError | import("effect/http/HttpClientError").HttpClientError, never>;
-export declare function decodeResponse(url: string, response: HttpClientResponse.HttpClientResponse): Effect.Effect<{
-    body: import("effect/Schema").Json;
-    etag: string | null;
-    next: string | undefined;
-}, WatchError, never>;
-//# sourceMappingURL=httpResponse.d.ts.map

package/dist/httpResponse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"httpResponse.d.ts","sourceRoot":"","sources":["../src/httpResponse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,KAAK,UAAU,EAAqB,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AACxC,MAAM,WAAW,cAAc;IAC9B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AACD,wBAAgB,aAAa,CAAC,MAAM,EAAE,UAAU,CAAC,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,GAAG,SAAS,EAAE,IAAI,CAAC,EAAE,OAAO,qKAW1I;AACD,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,CAAC,kBAAkB;;;;sBAgB1F"}

package/dist/httpResponse.js

@@ -1,31 +0,0 @@
-import { Effect } from "effect";
-import { HttpClientRequest } from "effect/http";
-import { WatchError } from "./model.js";
-export function fetchResponse(client, url, token, cached, body) {
-    const headers = { 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, response) {
-    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 };
-    }).pipe(Effect.mapError((cause) => (cause instanceof WatchError ? cause : new WatchError({ message: "Invalid GitHub response or pagination URL" }))));
-}
-//# sourceMappingURL=httpResponse.js.map

package/dist/httpResponse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"httpResponse.js","sourceRoot":"","sources":["../src/httpResponse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAmB,iBAAiB,EAA2B,MAAM,aAAa,CAAC;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAMxC,MAAM,UAAU,aAAa,CAAC,MAA6B,EAAE,GAAW,EAAE,KAAa,EAAE,MAAkC,EAAE,IAAc;IAC1I,MAAM,OAAO,GAA2B,EAAE,MAAM,EAAE,6BAA6B,EAAE,sBAAsB,EAAE,YAAY,EAAE,CAAC;IACxH,IAAI,KAAK,EAAE,CAAC;QACX,OAAO,CAAC,aAAa,GAAG,UAAU,KAAK,EAAE,CAAC;IAC3C,CAAC;IACD,IAAI,MAAM,EAAE,IAAI,EAAE,CAAC;QAClB,OAAO,CAAC,eAAe,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC;IACxC,CAAC;IACD,OAAO,IAAI,KAAK,SAAS;QACxB,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC;QAC9B,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;AACpH,CAAC;AACD,MAAM,UAAU,cAAc,CAAC,GAAW,EAAE,QAA+C;IAC1F,OAAO,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QAC1B,IAAI,QAAQ,CAAC,MAAM,GAAG,GAAG,IAAI,QAAQ,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;YACrD,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,EAAE,OAAO,EAAE,eAAe,QAAQ,CAAC,MAAM,QAAQ,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,CAAC;QACvH,CAAC;QACD,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;QAClC,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,8BAA8B,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC;QACvF,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE;YACtB,IAAI,IAAI,KAAK,SAAS,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC;gBACxE,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;YACpD,CAAC;QACF,CAAC,CAAC,CAAC;QACH,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI,EAAE,IAAI,EAA2B,CAAC;IACrF,CAAC,CAAC,CAAC,IAAI,CACN,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,YAAY,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,UAAU,CAAC,EAAE,OAAO,EAAE,2CAA2C,EAAE,CAAC,CAAC,CAAC,CAC5I,CAAC;AACH,CAAC"}

package/src/httpResponse.ts

@@ -1,37 +0,0 @@
-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" }))),
-	);
-}