dsh-pstack 0.2.0-beta.1 → 0.2.0-beta.3

package/dist/pstack/skills/poteto-mode/scripts/watch-pr/policy.mjs

@@ -0,0 +1,657 @@
+import { nonEmpty } from "./types.mjs";
+import { WatcherQueryError, resolveChecks, resolveReviewThreads } from "./github.mjs";
+// runtime/skills/poteto-mode/scripts/watch-pr/policy.ts
+function assessGitHubMerge(args) {
+	if (args.mergeStateStatus === "BLOCKED") {
+		if (args.headRollupState === "ERROR" || args.headRollupState === "FAILURE") return {
+			kind: "refused",
+			mergeStateStatus: args.mergeStateStatus,
+			headRollupState: args.headRollupState
+		};
+		return {
+			kind: "allowed",
+			basis: "rollup",
+			mergeStateStatus: args.mergeStateStatus,
+			headRollupState: args.headRollupState
+		};
+	}
+	return {
+		kind: "allowed",
+		basis: "merge-state",
+		mergeStateStatus: args.mergeStateStatus,
+		headRollupState: args.headRollupState
+	};
+}
+async function mergeAssessment(reader, facts) {
+	const commits = await reader.commitRollups(facts.context);
+	const headRollupState = facts.headRefOid === null ? null : commits.find((commit) => commit.oid === facts.headRefOid)?.state ?? null;
+	return {
+		hadPreviousPassingCi: commits.some((commit) => commit.oid !== facts.headRefOid && commit.state === "SUCCESS"),
+		github: assessGitHubMerge({
+			mergeStateStatus: facts.mergeStateStatus,
+			headRollupState
+		})
+	};
+}
+const AUTOMATION_TOKENS = [
+	"bugbot",
+	"security review",
+	"pr review automation",
+	"review automation"
+];
+async function readSnapshot(args) {
+	const facts = await args.reader.pullRequest(args.context);
+	if (facts.state === "MERGED" || facts.mergedAt !== null) return {
+		kind: "merged",
+		context: args.context,
+		facts
+	};
+	if (facts.state === "CLOSED") return {
+		kind: "closed",
+		context: args.context,
+		facts
+	};
+	const threads = await resolveReviewThreads(args.reader, args.context);
+	const checks = await resolveChecks(args.reader, args.context);
+	const failed = nonEmpty(checks.checks.filter((check) => check.kind === "failed"));
+	const pending = nonEmpty(checks.checks.filter((check) => check.kind === "pending"));
+	let ci;
+	if (failed === null && pending !== null && args.pendingHistory === "omit") ci = {
+		kind: "ci-pending",
+		source: checks.source,
+		all: checks.checks,
+		failed: [],
+		pending,
+		hadPreviousPassingCi: false
+	};
+	else {
+		const merge = await mergeAssessment(args.reader, facts);
+		const base = {
+			source: checks.source,
+			all: checks.checks,
+			hadPreviousPassingCi: merge.hadPreviousPassingCi
+		};
+		if (failed !== null) ci = {
+			...base,
+			kind: "ci-failing",
+			failed,
+			pending: pending ?? [],
+			github: merge.github
+		};
+		else if (merge.github.kind === "refused") ci = {
+			...base,
+			kind: "ci-github-rejected",
+			failed: [],
+			pending: pending ?? [],
+			github: merge.github
+		};
+		else if (pending !== null) ci = {
+			...base,
+			kind: "ci-pending",
+			failed: [],
+			pending
+		};
+		else ci = {
+			...base,
+			kind: "ci-clean",
+			failed: [],
+			pending: [],
+			github: merge.github
+		};
+	}
+	return {
+		kind: "open",
+		context: args.context,
+		facts,
+		threads,
+		ci,
+		reviewAutomationRunning: checks.checks.some((check) => check.kind === "pending" && AUTOMATION_TOKENS.some((token) => check.name.toLowerCase().includes(token)))
+	};
+}
+const conflictBlocker = (row) => row.kind === "open" && (row.facts.mergeable === "CONFLICTING" || row.facts.mergeStateStatus === "DIRTY" || row.facts.mergeStateStatus === "CONFLICTING") ? {
+	kind: "merge-conflicts",
+	pr: row.context,
+	facts: row.facts
+} : null;
+function threadBlocker(row) {
+	if (row.kind !== "open") return null;
+	const threads = nonEmpty(row.threads);
+	return threads === null ? null : {
+		kind: "review-threads",
+		pr: row.context,
+		threads
+	};
+}
+const ciBlocker = (row) => row.kind === "open" && (row.ci.kind === "ci-failing" || row.ci.kind === "ci-github-rejected") ? {
+	kind: "failing-checks",
+	pr: row.context,
+	ci: row.ci
+} : null;
+function gateReason(row, allowDraft) {
+	if (row.kind === "merged") return null;
+	if (row.kind === "closed") return "closed-without-merge";
+	if (row.facts.isDraft && !allowDraft) return "draft-pr";
+	return row.facts.reviewDecision === "CHANGES_REQUESTED" ? "changes-requested" : null;
+}
+function gateBlocker(row, allowDraft) {
+	const reason = gateReason(row, allowDraft);
+	return reason === null || reason === "draft-pr" && row.kind === "open" && row.ci.kind === "ci-pending" ? null : {
+		kind: "merge-gate",
+		pr: row.context,
+		reason
+	};
+}
+function readyContribution(row, allowDraft) {
+	if (row.kind === "merged") return {
+		kind: "merged-pr",
+		context: row.context,
+		mergedAt: row.facts.mergedAt
+	};
+	if (row.kind !== "open" || row.ci.kind !== "ci-clean" || row.threads.length !== 0 || conflictBlocker(row) !== null || gateReason(row, allowDraft) !== null) return null;
+	const reviewDecision = row.facts.reviewDecision;
+	if (reviewDecision === "CHANGES_REQUESTED") return null;
+	return {
+		kind: "ready-pr",
+		context: row.context,
+		proof: {
+			mergeability: "clear",
+			threads: [],
+			ci: row.ci,
+			gate: {
+				state: "OPEN",
+				reviewDecision,
+				draft: row.facts.isDraft ? "draft-allowed" : "not-draft"
+			}
+		}
+	};
+}
+function classifyPr(row, allowDraft = false) {
+	for (const blocker of [
+		conflictBlocker(row),
+		threadBlocker(row),
+		ciBlocker(row),
+		gateBlocker(row, allowDraft)
+	]) if (blocker !== null) return {
+		kind: "blocker",
+		blocker
+	};
+	if (row.kind === "open" && row.ci.kind === "ci-pending") return {
+		kind: "waiting",
+		frontier: row.context,
+		pending: row.ci.pending
+	};
+	const ready = readyContribution(row, allowDraft);
+	if (ready === null) throw new Error("snapshot has no classified decision");
+	return ready.kind === "merged-pr" ? {
+		kind: "merged",
+		pr: ready
+	} : {
+		kind: "ready",
+		pr: ready
+	};
+}
+function selectTierMajorStackDecision(rows, allowDraft = false) {
+	for (const tier of [
+		conflictBlocker,
+		threadBlocker,
+		ciBlocker
+	]) for (const row of rows) {
+		const blocker = tier(row);
+		if (blocker !== null) return {
+			kind: "blocker",
+			blocker
+		};
+	}
+	for (const row of rows) {
+		const blocker = gateBlocker(row, allowDraft);
+		if (blocker !== null) return {
+			kind: "blocker",
+			blocker
+		};
+	}
+	for (const row of rows) if (row.kind === "open" && row.ci.kind === "ci-pending") return {
+		kind: "waiting",
+		frontier: row.context,
+		pending: row.ci.pending
+	};
+	const prs = nonEmpty(rows.map((row) => readyContribution(row, allowDraft)).filter((row) => row !== null));
+	if (prs === null || prs.length !== rows.length) throw new Error("stack has no classified decision");
+	return {
+		kind: "clear",
+		prs
+	};
+}
+const queryBackoffSeconds = (interval, failures) => Math.min(Math.max(interval, 60) * 2 ** (failures - 1), 300);
+function verdictFactory(clock, mode) {
+	let sequence = 0;
+	function stamp(payload, override) {
+		return {
+			schemaVersion: 1,
+			sequence: sequence += 1,
+			observedAt: clock.observedAt(),
+			mode: override ?? mode,
+			...payload
+		};
+	}
+	return stamp;
+}
+function blockerVerdict(stamp, blocker) {
+	switch (blocker.kind) {
+		case "merge-conflicts": return stamp({
+			kind: "BLOCKER",
+			terminal: true,
+			exitCode: 2,
+			blocker
+		});
+		case "review-threads": return stamp({
+			kind: "BLOCKER",
+			terminal: true,
+			exitCode: 3,
+			blocker
+		});
+		case "failing-checks": return stamp({
+			kind: "BLOCKER",
+			terminal: true,
+			exitCode: 4,
+			blocker
+		});
+		case "merge-gate": return stamp({
+			kind: "BLOCKER",
+			terminal: true,
+			exitCode: 6,
+			blocker
+		});
+		default: return blocker;
+	}
+}
+function statusQueryVerdict(stamp, failures, failure) {
+	return stamp({
+		kind: "BLOCKER",
+		terminal: true,
+		exitCode: 7,
+		blocker: {
+			kind: "status-query",
+			failures,
+			failure
+		}
+	});
+}
+const deadlinePassed = (started, options, now) => options.timeout > 0 && now - started >= options.timeout;
+async function pollUntilTerminal(args) {
+	let failures = 0;
+	const started = args.dependencies.clock.now();
+	const sleep = async (seconds) => {
+		const remaining = args.options.timeout > 0 ? Math.max(0, args.options.timeout - (args.dependencies.clock.now() - started)) : seconds;
+		await args.dependencies.clock.sleep(Math.min(seconds, remaining));
+	};
+	while (true) {
+		let result;
+		try {
+			result = await args.step();
+			failures = 0;
+		} catch (error) {
+			if (!(error instanceof WatcherQueryError)) throw error;
+			failures += 1;
+			if (!error.failure.retryable || failures >= args.options.maxQueryErrors) return statusQueryVerdict(args.stamp, failures, error.failure);
+			const retryInSeconds = queryBackoffSeconds(args.options.interval, failures);
+			args.dependencies.emit(args.stamp({
+				kind: "RETRY",
+				terminal: false,
+				failure: error.failure,
+				consecutiveFailures: failures,
+				retryInSeconds
+			}));
+			if (deadlinePassed(started, args.options, args.dependencies.clock.now())) return args.stamp({
+				kind: "TIMEOUT",
+				terminal: true,
+				exitCode: 5,
+				reason: {
+					kind: "status-unavailable",
+					failure: error.failure
+				}
+			});
+			await sleep(retryInSeconds);
+			continue;
+		}
+		if (result.kind === "terminal") return result.verdict;
+		if (result.kind === "sleep") {
+			if (result.onDeadline !== void 0 && deadlinePassed(started, args.options, args.dependencies.clock.now())) return result.onDeadline();
+			await sleep(result.seconds);
+		}
+	}
+}
+async function runSimple(args) {
+	const stamp = verdictFactory(args.dependencies.clock, args.mode);
+	const step = async () => {
+		const rows = [];
+		for (const context of args.contexts) rows.push(await readSnapshot({
+			reader: args.dependencies.reader,
+			context,
+			pendingHistory: "include",
+			allowDraft: args.options.allowDraft
+		}));
+		const complete = nonEmpty(rows);
+		if (complete === null) throw new Error("watch context cannot be empty");
+		if (args.statusOnly) return {
+			kind: "terminal",
+			verdict: stamp({
+				kind: "STATUS",
+				terminal: true,
+				exitCode: 0,
+				reason: "status-only",
+				rows: complete
+			})
+		};
+		if (args.mode === "queued-stack") throw new Error("queued-stack requires status-only in the simple runner");
+		if (args.mode === "stack") args.dependencies.emit(stamp({
+			kind: "STATUS",
+			terminal: false,
+			reason: "poll",
+			rows: complete
+		}, args.mode));
+		const decision = args.mode === "single" ? classifyPr(complete[0], args.options.allowDraft) : selectTierMajorStackDecision(complete, args.options.allowDraft);
+		if (decision.kind === "blocker") return {
+			kind: "terminal",
+			verdict: blockerVerdict(stamp, decision.blocker)
+		};
+		if (decision.kind === "ready" || decision.kind === "merged") return {
+			kind: "terminal",
+			verdict: stamp({
+				kind: "READY",
+				terminal: true,
+				exitCode: 0,
+				scope: {
+					kind: "single",
+					pr: decision.pr
+				}
+			}, args.mode)
+		};
+		if (decision.kind === "clear") return {
+			kind: "terminal",
+			verdict: stamp({
+				kind: "READY",
+				terminal: true,
+				exitCode: 0,
+				scope: {
+					kind: "stack",
+					prs: decision.prs
+				}
+			}, args.mode)
+		};
+		args.dependencies.emit(stamp({
+			kind: "WAITING",
+			terminal: false,
+			frontier: decision.frontier,
+			reason: {
+				kind: "pending-checks",
+				pending: decision.pending
+			}
+		}));
+		return {
+			kind: "sleep",
+			seconds: args.options.interval,
+			onDeadline: () => stamp({
+				kind: "TIMEOUT",
+				terminal: true,
+				exitCode: 5,
+				reason: {
+					kind: "pending-checks",
+					pending: decision.pending
+				}
+			})
+		};
+	};
+	return pollUntilTerminal({
+		dependencies: args.dependencies,
+		options: args.options,
+		stamp,
+		step
+	});
+}
+const createQueueState = (queue, now) => ({
+	queue,
+	snapshots: /* @__PURE__ */ new Map(),
+	work: {
+		kind: "whole-stack-sweep",
+		remaining: queue
+	},
+	nextSweepAt: now,
+	frontier: null,
+	lastWaitKey: null,
+	startedAt: now
+});
+const orderedRows = (state) => state.queue.flatMap((context) => {
+	const row = state.snapshots.get(context.number);
+	return row === void 0 ? [] : [row];
+});
+const activeRows = (state) => orderedRows(state).filter((row) => row.kind !== "merged");
+function planQueue(state, now) {
+	if (state.work !== null) return state;
+	if (state.snapshots.size === 0 || now >= state.nextSweepAt) {
+		const remaining = nonEmpty(state.queue.filter((context) => state.snapshots.get(context.number)?.kind !== "merged"));
+		if (remaining !== null) return {
+			...state,
+			work: {
+				kind: "whole-stack-sweep",
+				remaining
+			}
+		};
+	}
+	const frontier = activeRows(state)[0]?.context;
+	return frontier === void 0 ? state : {
+		...state,
+		work: {
+			kind: "frontier-poll",
+			frontier
+		}
+	};
+}
+function applyQueueSnapshot(state, snapshot, now, options) {
+	if (state.work === null) throw new Error("queue has no read in flight");
+	const snapshots = new Map(state.snapshots);
+	snapshots.set(snapshot.context.number, snapshot);
+	const base = {
+		...state,
+		snapshots
+	};
+	if (state.work.kind === "frontier-poll") return {
+		state: {
+			...base,
+			work: null
+		},
+		completedSweepRows: null
+	};
+	const [head, ...tail] = state.work.remaining;
+	if (head.number !== snapshot.context.number) throw new Error("snapshot does not match sweep head");
+	const remaining = nonEmpty(tail);
+	if (remaining !== null) return {
+		state: {
+			...base,
+			work: {
+				kind: "whole-stack-sweep",
+				remaining
+			}
+		},
+		completedSweepRows: null
+	};
+	const rows = nonEmpty(state.queue.flatMap((context) => {
+		const row = snapshots.get(context.number);
+		return row === void 0 ? [] : [row];
+	}));
+	if (rows === null || rows.length !== state.queue.length) throw new Error("sweep completed without every snapshot");
+	return {
+		state: {
+			...base,
+			work: null,
+			nextSweepAt: now + options.sweepInterval
+		},
+		completedSweepRows: rows
+	};
+}
+function evaluateQueue(state, now, options) {
+	const active = activeRows(state);
+	if (active.length === 0) {
+		const merged = nonEmpty(orderedRows(state).flatMap((row) => row.kind === "merged" ? [{
+			kind: "merged-pr",
+			context: row.context,
+			mergedAt: row.facts.mergedAt
+		}] : []));
+		if (merged === null) throw new Error("empty queue cannot complete");
+		return {
+			kind: "complete",
+			state,
+			merged
+		};
+	}
+	const rows = nonEmpty(active);
+	if (rows === null) throw new Error("active queue cannot be empty");
+	const decision = selectTierMajorStackDecision(rows, options.allowDraft);
+	if (decision.kind === "blocker") return {
+		kind: "blocker",
+		state,
+		blocker: decision.blocker
+	};
+	const frontier = rows[0].context;
+	if (state.frontier !== null && state.frontier.number !== frontier.number) return {
+		kind: "advance",
+		state: {
+			...state,
+			frontier,
+			lastWaitKey: null
+		},
+		merged: state.frontier,
+		frontier,
+		remaining: active.length
+	};
+	if (deadlinePassed(state.startedAt, options, now)) return {
+		kind: "timeout",
+		state: {
+			...state,
+			frontier
+		},
+		frontier,
+		unmergedCount: active.length
+	};
+	const row = rows[0];
+	const pending = row.kind === "open" && row.ci.kind === "ci-pending" ? row.ci.pending : null;
+	const reason = pending === null ? {
+		kind: "merge-queue",
+		unmergedCount: active.length
+	} : {
+		kind: "pending-checks",
+		pending
+	};
+	const key = reason.kind === "pending-checks" ? `pending:${frontier.number}:${reason.pending.length}` : `queue:${frontier.number}:${reason.unmergedCount}`;
+	return {
+		kind: "waiting",
+		state: {
+			...state,
+			frontier,
+			lastWaitKey: key
+		},
+		frontier,
+		reason,
+		emit: state.lastWaitKey !== key
+	};
+}
+async function runQueued(args) {
+	let state = createQueueState(args.contexts, args.dependencies.clock.now());
+	const stamp = verdictFactory(args.dependencies.clock, "queued-stack");
+	args.dependencies.emit(stamp({
+		kind: "QUEUE",
+		terminal: false,
+		queue: args.contexts
+	}));
+	const step = async () => {
+		state = planQueue(state, args.dependencies.clock.now());
+		if (state.work === null) {
+			const complete = evaluateQueue(state, args.dependencies.clock.now(), args.options);
+			if (complete.kind !== "complete") throw new Error("queue has no work while active");
+			return {
+				kind: "terminal",
+				verdict: stamp({
+					kind: "COMPLETE",
+					terminal: true,
+					exitCode: 0,
+					queue: state.queue,
+					merged: complete.merged
+				})
+			};
+		}
+		const context = state.work.kind === "whole-stack-sweep" ? state.work.remaining[0] : state.work.frontier;
+		const snapshot = await readSnapshot({
+			reader: args.dependencies.reader,
+			context,
+			pendingHistory: "omit",
+			allowDraft: args.options.allowDraft
+		});
+		const applied = applyQueueSnapshot(state, snapshot, args.dependencies.clock.now(), args.options);
+		state = applied.state;
+		if (applied.completedSweepRows !== null) args.dependencies.emit(stamp({
+			kind: "STATUS",
+			terminal: false,
+			reason: "whole-stack-sweep",
+			rows: applied.completedSweepRows
+		}));
+		if (state.work !== null) return { kind: "continue" };
+		const evaluation = evaluateQueue(state, args.dependencies.clock.now(), args.options);
+		state = evaluation.state;
+		switch (evaluation.kind) {
+			case "complete": return {
+				kind: "terminal",
+				verdict: stamp({
+					kind: "COMPLETE",
+					terminal: true,
+					exitCode: 0,
+					queue: state.queue,
+					merged: evaluation.merged
+				})
+			};
+			case "blocker": return {
+				kind: "terminal",
+				verdict: blockerVerdict(stamp, evaluation.blocker)
+			};
+			case "advance":
+				args.dependencies.emit(stamp({
+					kind: "ADVANCE",
+					terminal: false,
+					merged: evaluation.merged,
+					frontier: evaluation.frontier,
+					remaining: evaluation.remaining
+				}));
+				return { kind: "continue" };
+			case "timeout": return {
+				kind: "terminal",
+				verdict: stamp({
+					kind: "TIMEOUT",
+					terminal: true,
+					exitCode: 5,
+					reason: {
+						kind: "queued-stack",
+						frontier: evaluation.frontier,
+						unmergedCount: evaluation.unmergedCount
+					}
+				})
+			};
+			case "waiting":
+				if (evaluation.emit) args.dependencies.emit(stamp({
+					kind: "WAITING",
+					terminal: false,
+					frontier: evaluation.frontier,
+					reason: evaluation.reason
+				}));
+				return {
+					kind: "sleep",
+					seconds: args.options.interval
+				};
+			default: return evaluation;
+		}
+	};
+	return pollUntilTerminal({
+		dependencies: args.dependencies,
+		options: args.options,
+		stamp,
+		step
+	});
+}
+export { applyQueueSnapshot, assessGitHubMerge, classifyPr, createQueueState, evaluateQueue, planQueue, queryBackoffSeconds, readSnapshot, runQueued, runSimple, selectTierMajorStackDecision, statusQueryVerdict, verdictFactory };