dsh-pstack 0.3.0-beta.1 → 0.3.1

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

@@ -1,523 +0,0 @@
-import { expect } from "../expect.mjs";
-import "../support.mjs";
-import { parsePrNumber } from "./types.mjs";
-import { WatcherQueryError } from "./github.mjs";
-import { applyQueueSnapshot, assessGitHubMerge, classifyPr, createQueueState, evaluateQueue, planQueue, queryBackoffSeconds, readSnapshot, runQueued, runSimple, selectTierMajorStackDecision } from "./policy.mjs";
-import { failedCheck, fakeReader, passingCheck, pendingCheck } from "./fakes.test-helper.mjs";
-import { describe, it } from "node:test";
-// runtime/skills/poteto-mode/scripts/watch-pr/policy.test.ts
-const context = (number) => ({
-	owner: "owner",
-	repo: "repo",
-	number: parsePrNumber(number)
-});
-const options = {
-	interval: 10,
-	sweepInterval: 300,
-	timeout: 0,
-	maxQueryErrors: 5,
-	allowDraft: false
-};
-describe("readiness truth table", () => {
-	it("covers every specified row and every UNKNOWN rollup value", () => {
-		for (const [mergeStateStatus, headRollupState, expected] of [
-			[
-				"BLOCKED",
-				"FAILURE",
-				"refused"
-			],
-			[
-				"BLOCKED",
-				"ERROR",
-				"refused"
-			],
-			[
-				"BLOCKED",
-				"PENDING",
-				"allowed"
-			],
-			[
-				"UNSTABLE",
-				"FAILURE",
-				"allowed"
-			],
-			[
-				"UNKNOWN",
-				"ERROR",
-				"allowed"
-			],
-			[
-				"UNKNOWN",
-				"EXPECTED",
-				"allowed"
-			],
-			[
-				"UNKNOWN",
-				"FAILURE",
-				"allowed"
-			],
-			[
-				"UNKNOWN",
-				"PENDING",
-				"allowed"
-			],
-			[
-				"UNKNOWN",
-				"SUCCESS",
-				"allowed"
-			],
-			[
-				"UNKNOWN",
-				null,
-				"allowed"
-			],
-			[
-				"CLEAN",
-				"SUCCESS",
-				"allowed"
-			]
-		]) expect(assessGitHubMerge({
-			mergeStateStatus,
-			headRollupState
-		}).kind).toBe(expected);
-	});
-	it("turns a clean visible list plus GitHub refusal into an explicit CI blocker", async () => {
-		const reader = fakeReader({
-			facts: { mergeStateStatus: "BLOCKED" },
-			fastPath: {
-				kind: "checks",
-				checks: [passingCheck()]
-			},
-			commitRollups: [{
-				oid: "head",
-				state: "FAILURE"
-			}]
-		});
-		const snapshot = await readSnapshot({
-			reader,
-			context: context(1),
-			pendingHistory: "include",
-			allowDraft: false
-		});
-		expect(snapshot.kind).toBe("open");
-		if (snapshot.kind !== "open") throw new Error("expected open snapshot");
-		expect(snapshot.ci.kind).toBe("ci-github-rejected");
-		expect(classifyPr(snapshot)).toMatchObject({
-			kind: "blocker",
-			blocker: { kind: "failing-checks" }
-		});
-	});
-});
-describe("snapshot query planning", () => {
-	it("does not query commit rollups while queued checks are pending", async () => {
-		const reader = fakeReader({ fastPath: {
-			kind: "checks",
-			checks: [pendingCheck()]
-		} });
-		const snapshot = await readSnapshot({
-			reader,
-			context: context(2),
-			pendingHistory: "omit",
-			allowDraft: false
-		});
-		expect(snapshot.kind).toBe("open");
-		if (snapshot.kind !== "open") throw new Error("expected open snapshot");
-		expect(snapshot.ci.kind).toBe("ci-pending");
-		expect(reader.calls).toEqual([
-			"pullRequest",
-			"reviewThreadPage:null",
-			"checksFastPath"
-		]);
-	});
-	it("queries rollups for settled and failed lists", async () => {
-		const settled = fakeReader();
-		await readSnapshot({
-			reader: settled,
-			context: context(3),
-			pendingHistory: "omit",
-			allowDraft: false
-		});
-		expect(settled.calls).toContain("commitRollups");
-		const failed = fakeReader({ fastPath: {
-			kind: "checks",
-			checks: [failedCheck()]
-		} });
-		await readSnapshot({
-			reader: failed,
-			context: context(4),
-			pendingHistory: "omit",
-			allowDraft: false
-		});
-		expect(failed.calls).toContain("commitRollups");
-	});
-	it("short-circuits merged rows before threads and checks", async () => {
-		const reader = fakeReader({ facts: {
-			state: "MERGED",
-			mergedAt: "2026-07-26T00:00:00Z"
-		} });
-		expect((await readSnapshot({
-			reader,
-			context: context(5),
-			pendingHistory: "include",
-			allowDraft: false
-		})).kind).toBe("merged");
-		expect(reader.calls).toEqual(["pullRequest"]);
-	});
-});
-it("scans stacks tier-major so an upstack conflict outranks frontier CI", async () => {
-	const frontier = await readSnapshot({
-		reader: fakeReader({
-			fastPath: {
-				kind: "checks",
-				checks: [failedCheck()]
-			},
-			commitRollups: [{
-				oid: "head",
-				state: "FAILURE"
-			}]
-		}),
-		context: context(10),
-		pendingHistory: "omit",
-		allowDraft: false
-	});
-	const upstack = await readSnapshot({
-		reader: fakeReader({ facts: { mergeable: "CONFLICTING" } }),
-		context: context(11),
-		pendingHistory: "omit",
-		allowDraft: false
-	});
-	const decision = selectTierMajorStackDecision([frontier, upstack]);
-	expect(decision).toMatchObject({
-		kind: "blocker",
-		blocker: {
-			kind: "merge-conflicts",
-			pr: { number: 11 }
-		}
-	});
-});
-it("attributes a stack wait to the PR whose checks are pending, not the bottom", async () => {
-	const readyBottom = await readSnapshot({
-		reader: fakeReader(),
-		context: context(20),
-		pendingHistory: "omit",
-		allowDraft: false
-	});
-	const pendingUpstack = await readSnapshot({
-		reader: fakeReader({ fastPath: {
-			kind: "checks",
-			checks: [pendingCheck("upstack-build")]
-		} }),
-		context: context(21),
-		pendingHistory: "omit",
-		allowDraft: false
-	});
-	const decision = selectTierMajorStackDecision([readyBottom, pendingUpstack]);
-	expect(decision).toMatchObject({
-		kind: "waiting",
-		frontier: { number: 21 },
-		pending: [{ name: "upstack-build" }]
-	});
-});
-it("waits on a draft while checks are pending, then reports the draft gate", async () => {
-	const pending = await readSnapshot({
-		reader: fakeReader({
-			facts: { isDraft: true },
-			fastPath: {
-				kind: "checks",
-				checks: [pendingCheck()]
-			}
-		}),
-		context: context(12),
-		pendingHistory: "omit",
-		allowDraft: false
-	});
-	expect(classifyPr(pending).kind).toBe("waiting");
-	const settled = await readSnapshot({
-		reader: fakeReader({ facts: { isDraft: true } }),
-		context: context(12),
-		pendingHistory: "omit",
-		allowDraft: false
-	});
-	expect(classifyPr(settled)).toMatchObject({
-		kind: "blocker",
-		blocker: {
-			kind: "merge-gate",
-			reason: "draft-pr"
-		}
-	});
-});
-describe("queued-stack cadence", () => {
-	async function openSnapshot(pr) {
-		return readSnapshot({
-			reader: fakeReader(),
-			context: pr,
-			pendingHistory: "omit",
-			allowDraft: false
-		});
-	}
-	it("drops a sweep head only after its snapshot succeeds", async () => {
-		const queue = [
-			context(20),
-			context(21),
-			context(22)
-		];
-		let state = createQueueState(queue, 0);
-		const first = await openSnapshot(queue[0]);
-		state = applyQueueSnapshot(state, first, 0, options).state;
-		expect(state.work).toMatchObject({
-			kind: "whole-stack-sweep",
-			remaining: [{ number: 21 }, { number: 22 }]
-		});
-		const second = await openSnapshot(queue[1]);
-		state = applyQueueSnapshot(state, second, 60, options).state;
-		expect(state.work).toMatchObject({
-			kind: "whole-stack-sweep",
-			remaining: [{ number: 22 }]
-		});
-	});
-	it("resumes the sweep at the PR whose read failed", async () => {
-		const middle = context(21);
-		const base = fakeReader();
-		let failNext = true;
-		const timeline = [];
-		const reader = {
-			...base,
-			async pullRequest(pr) {
-				if (pr.number === middle.number && failNext) {
-					failNext = false;
-					timeline.push(`fail:${pr.number}`);
-					throw new WatcherQueryError({
-						kind: "command-exit",
-						retryable: true,
-						detail: "rate limited",
-						code: 1
-					});
-				}
-				timeline.push(`read:${pr.number}`);
-				return base.pullRequest(pr);
-			}
-		};
-		let now = 0;
-		let sleeps = 0;
-		const running = runQueued({
-			dependencies: {
-				reader,
-				clock: {
-					now: () => now,
-					observedAt: () => "2026-07-26T00:00:00.000Z",
-					async sleep(seconds) {
-						timeline.push("sleep");
-						now += seconds;
-						sleeps += 1;
-						if (sleeps === 2) throw new Error("stop after resume proof");
-					}
-				},
-				emit(verdict) {
-					timeline.push(`emit:${verdict.kind}`);
-				}
-			},
-			contexts: [
-				context(20),
-				middle,
-				context(22)
-			],
-			options
-		});
-		await expect(running).rejects.toThrow("stop after resume proof");
-		expect(timeline).toEqual([
-			"emit:QUEUE",
-			"read:20",
-			"fail:21",
-			"emit:RETRY",
-			"sleep",
-			"read:21",
-			"read:22",
-			"emit:STATUS",
-			"emit:WAITING",
-			"sleep"
-		]);
-	});
-	it("emits a completed sweep only after its final successful snapshot", async () => {
-		const queue = [context(30), context(31)];
-		let state = createQueueState(queue, 0);
-		const first = applyQueueSnapshot(state, await openSnapshot(queue[0]), 0, options);
-		expect(first.completedSweepRows).toBeNull();
-		state = first.state;
-		const second = applyQueueSnapshot(state, await openSnapshot(queue[1]), 5, options);
-		expect(second.completedSweepRows?.map((row) => Number(row.context.number))).toEqual([30, 31]);
-		expect(second.state.nextSweepAt).toBe(305);
-	});
-	it("ADVANCE continues directly to the new frontier without sleeping", async () => {
-		const one = context(40);
-		const two = context(41);
-		const base = fakeReader();
-		const reads = /* @__PURE__ */ new Map();
-		const timeline = [];
-		const reader = {
-			...base,
-			async pullRequest(pr) {
-				timeline.push(`read:${pr.number}`);
-				const facts = await base.pullRequest(pr);
-				const count = (reads.get(pr.number) ?? 0) + 1;
-				reads.set(pr.number, count);
-				return pr.number === one.number && count > 1 ? {
-					...facts,
-					state: "MERGED",
-					mergedAt: "2026-07-26T00:00:00Z"
-				} : facts;
-			}
-		};
-		let now = 0;
-		let sleeps = 0;
-		const emitted = [];
-		const running = runQueued({
-			dependencies: {
-				reader,
-				clock: {
-					now: () => now,
-					observedAt: () => "2026-07-26T00:00:00.000Z",
-					async sleep(seconds) {
-						timeline.push("sleep");
-						now += seconds;
-						sleeps += 1;
-						if (sleeps === 2) throw new Error("stop after advance proof");
-					}
-				},
-				emit(verdict) {
-					emitted.push(verdict);
-					timeline.push(`emit:${verdict.kind}`);
-				}
-			},
-			contexts: [one, two],
-			options
-		});
-		await expect(running).rejects.toThrow("stop after advance proof");
-		expect(emitted.some((event) => event.kind === "ADVANCE")).toBe(true);
-		const firstSleep = timeline.indexOf("sleep");
-		expect(timeline.slice(firstSleep, firstSleep + 5)).toEqual([
-			"sleep",
-			"read:40",
-			"emit:ADVANCE",
-			"read:41",
-			"emit:WAITING"
-		]);
-	});
-	it("deduplicates identical waits and schedules the next due sweep", async () => {
-		const queue = [context(50)];
-		let state = createQueueState(queue, 0);
-		state = applyQueueSnapshot(state, await openSnapshot(queue[0]), 0, options).state;
-		const first = evaluateQueue(state, 0, options);
-		expect(first.kind).toBe("waiting");
-		if (first.kind !== "waiting") throw new Error("expected waiting");
-		expect(first.emit).toBe(true);
-		const second = evaluateQueue(first.state, 10, options);
-		expect(second.kind).toBe("waiting");
-		if (second.kind !== "waiting") throw new Error("expected waiting");
-		expect(second.emit).toBe(false);
-		expect(planQueue(second.state, 300).work?.kind).toBe("whole-stack-sweep");
-	});
-});
-it("uses the specified retry floor and cap", () => {
-	expect(queryBackoffSeconds(1, 1)).toBe(60);
-	expect(queryBackoffSeconds(1, 2)).toBe(120);
-	expect(queryBackoffSeconds(60, 4)).toBe(300);
-});
-describe("polling deadline sleeps", () => {
-	for (const mode of [
-		"single",
-		"queued-stack",
-		"query-retry"
-	]) it(`caps ${mode} sleeps at the configured deadline`, async () => {
-		let now = 0;
-		const sleeps = [];
-		const pending = fakeReader({ fastPath: {
-			kind: "checks",
-			checks: [pendingCheck()]
-		} });
-		const dependencies = {
-			reader: mode === "query-retry" ? {
-				...pending,
-				async pullRequest() {
-					throw new WatcherQueryError({
-						kind: "command-exit",
-						retryable: true,
-						code: 1,
-						detail: "temporary failure"
-					});
-				}
-			} : pending,
-			clock: {
-				now: () => now,
-				observedAt: () => "2026-07-26T00:00:00.000Z",
-				async sleep(seconds) {
-					sleeps.push(seconds);
-					now += seconds;
-				}
-			},
-			emit() {}
-		};
-		const polling = {
-			...options,
-			interval: 60,
-			timeout: 5
-		};
-		const result = mode === "queued-stack" ? await runQueued({
-			dependencies,
-			contexts: [context(1)],
-			options: polling
-		}) : await runSimple({
-			dependencies,
-			contexts: [context(1)],
-			mode: "single",
-			statusOnly: false,
-			options: polling
-		});
-		expect(result.kind).toBe("TIMEOUT");
-		expect(sleeps).toEqual([5]);
-		expect(now).toBe(5);
-	});
-	it("preserves the polling interval when the deadline is disabled", async () => {
-		let now = 0;
-		let reads = 0;
-		const sleeps = [];
-		const pending = fakeReader({ fastPath: {
-			kind: "checks",
-			checks: [pendingCheck()]
-		} });
-		const passed = fakeReader({ fastPath: {
-			kind: "checks",
-			checks: [passingCheck()]
-		} });
-		const result = await runSimple({
-			dependencies: {
-				reader: {
-					...pending,
-					async checksFastPath(pr) {
-						reads += 1;
-						return reads === 1 ? pending.checksFastPath(pr) : passed.checksFastPath(pr);
-					}
-				},
-				clock: {
-					now: () => now,
-					observedAt: () => "2026-07-26T00:00:00.000Z",
-					async sleep(seconds) {
-						sleeps.push(seconds);
-						now += seconds;
-					}
-				},
-				emit() {}
-			},
-			contexts: [context(1)],
-			mode: "single",
-			statusOnly: false,
-			options: {
-				...options,
-				interval: 60,
-				timeout: 0
-			}
-		});
-		expect(result.kind).toBe("READY");
-		expect(sleeps).toEqual([60]);
-	});
-});
-export {};

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

@@ -1,106 +0,0 @@
-// runtime/skills/poteto-mode/scripts/watch-pr/render.ts
-const renderJson = (verdict) => `${JSON.stringify(verdict)}\n`;
-function ciCell(row) {
-	if (row.kind !== "open") return "—";
-	const was = row.ci.hadPreviousPassingCi ? ", was ✅" : "";
-	switch (row.ci.kind) {
-		case "ci-clean": return "✅";
-		case "ci-pending": return `⏳ ${row.ci.pending.length} pending${was}`;
-		case "ci-failing": return `❌ ${row.ci.failed.length} failed${row.ci.pending.length ? `, ${row.ci.pending.length} pending` : ""}${was}`;
-		case "ci-github-rejected": return `❌ GitHub reports failing checks${was}`;
-		default: return row.ci;
-	}
-}
-function reviewCell(row) {
-	if (row.kind !== "open") return "—";
-	const open = row.threads.length;
-	return row.reviewAutomationRunning ? open ? `🤖 running, ${open} open` : "🤖 running" : open ? `📝 ${open} open` : "✅";
-}
-function mergeCell(row) {
-	if (row.kind === "merged") return "✅ merged";
-	if (row.kind === "closed") return "❌ closed";
-	if (row.facts.isDraft) return "⏸ draft";
-	if (row.facts.reviewDecision === "CHANGES_REQUESTED") return "⚠️ changes requested";
-	return row.facts.mergeable === "CONFLICTING" || row.facts.mergeStateStatus === "DIRTY" || row.facts.mergeStateStatus === "CONFLICTING" ? "⚠️ conflict" : "✅";
-}
-function renderStatusTable(rows) {
-	const lines = ["| PR | CI | Review | Merge |", "| --- | --- | --- | --- |"];
-	for (const row of rows) {
-		const url = `https://github.com/${row.context.owner}/${row.context.repo}/pull/${row.context.number}`;
-		lines.push(`| [#${row.context.number}](${url}) | ${ciCell(row)} | ${reviewCell(row)} | ${mergeCell(row)} |`);
-	}
-	return `${lines.join("\n")}\n`;
-}
-function threadLine(thread) {
-	const comment = thread.firstComment;
-	return [
-		thread.id,
-		comment?.path ?? "None",
-		comment?.line ?? "None",
-		comment?.authorLogin ?? "None",
-		`isBugBot=${thread.isBugbot}`,
-		`bugbotReviewPasses=${thread.bugbotReviewPasses}`,
-		(comment?.body ?? "").split(/\r?\n/, 1)[0]?.slice(0, 180) ?? ""
-	].join(" ");
-}
-function renderBlocker(blocker) {
-	switch (blocker.kind) {
-		case "merge-conflicts": return [
-			"BLOCKER: merge-conflicts",
-			`pr=${blocker.pr.number}`,
-			`mergeable=${blocker.facts.mergeable}`,
-			`mergeStateStatus=${blocker.facts.mergeStateStatus}`,
-			"action=resolve merge conflicts before waiting for CI"
-		].join("\n");
-		case "review-threads": return [
-			"BLOCKER: review-threads",
-			`pr=${blocker.pr.number}`,
-			`unresolved=${blocker.threads.length}`,
-			...blocker.threads.map(threadLine)
-		].join("\n");
-		case "failing-checks": {
-			const failed = blocker.ci.kind === "ci-failing" ? blocker.ci.failed : [];
-			const details = failed.map((check) => `${check.name} ${check.reportedState} ${check.description} ${check.link}`);
-			if (blocker.ci.kind === "ci-github-rejected") details.push(`mergeStateStatus=${blocker.ci.github.mergeStateStatus}`, `headRollupState=${blocker.ci.github.headRollupState}`);
-			return [
-				"BLOCKER: failing-checks",
-				`pr=${blocker.pr.number}`,
-				`failed=${failed.length}`,
-				...details
-			].join("\n");
-		}
-		case "merge-gate": {
-			const action = blocker.reason === "closed-without-merge" ? "restore or remove the closed PR from the queued stack" : blocker.reason === "draft-pr" ? "mark the PR ready for review before waiting for the merge queue" : "resolve the changes-requested review before waiting for the merge queue";
-			return [
-				`BLOCKER: ${blocker.reason}`,
-				`pr=${blocker.pr.number}`,
-				`action=${action}`
-			].join("\n");
-		}
-		case "status-query": return [
-			"BLOCKER: status-query",
-			`failures=${blocker.failures}`,
-			`detail=${blocker.failure.detail}`,
-			"action=verify current PR context, GitHub authentication, and API availability, then rearm"
-		].join("\n");
-		default: return blocker;
-	}
-}
-function renderPretty(verdict) {
-	switch (verdict.kind) {
-		case "QUEUE": return `QUEUE: captured ${verdict.queue.length} PR${verdict.queue.length === 1 ? "" : "s"} bottom-to-top: ${verdict.queue.map((pr) => `#${pr.number}`).join(",")}\n`;
-		case "STATUS": return renderStatusTable(verdict.rows);
-		case "WAITING": return verdict.reason.kind === "pending-checks" ? `WAITING: frontier=#${verdict.frontier.number}; ${verdict.reason.pending.length} check${verdict.reason.pending.length === 1 ? "" : "s"} pending\n` : `WAITING: frontier=#${verdict.frontier.number} is blocker-free; waiting for merge queue (${verdict.reason.unmergedCount} PR${verdict.reason.unmergedCount === 1 ? "" : "s"} unmerged)\n`;
-		case "ADVANCE": return `ADVANCE: merged #${verdict.merged.number}; next=#${verdict.frontier.number}; remaining=${verdict.remaining}\n`;
-		case "RETRY": return `RETRY: GitHub status query failed; retrying in ${verdict.retryInSeconds}s\ndetail=${verdict.failure.detail}\n`;
-		case "BLOCKER": return `${renderBlocker(verdict.blocker)}\n`;
-		case "READY": return `READY: no merge conflicts, no unresolved review threads, no failing or pending checks${verdict.scope.kind === "single" && verdict.scope.pr.kind === "ready-pr" ? `\nmergeStateStatus=${verdict.scope.pr.proof.ci.github.mergeStateStatus}\nreviewDecision=${verdict.scope.pr.proof.gate.reviewDecision}\nisDraft=${verdict.scope.pr.proof.gate.draft === "draft-allowed"}${verdict.scope.pr.proof.gate.draft === "draft-allowed" ? "\nnote=draft allowed (--allow-draft); leave draft — do not mark ready" : ""}` : ""}\n`;
-		case "COMPLETE": return `COMPLETE: queued stack merged (${verdict.queue.length} PR${verdict.queue.length === 1 ? "" : "s"})\n`;
-		case "TIMEOUT":
-			if (verdict.reason.kind === "pending-checks") return "TIMEOUT: checks still pending\n";
-			if (verdict.reason.kind === "status-unavailable") return "TIMEOUT: GitHub status remained unavailable\n";
-			return `TIMEOUT: queued stack still has ${verdict.reason.unmergedCount} PR${verdict.reason.unmergedCount === 1 ? "" : "s"} unmerged; frontier=#${verdict.reason.frontier.number}\n`;
-		default: return verdict;
-	}
-}
-export { renderJson, renderPretty, renderStatusTable };

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

@@ -1,9 +0,0 @@
-// runtime/skills/poteto-mode/scripts/watch-pr/types.ts
-function nonEmpty(items) {
-	return items.length === 0 ? null : [items[0], ...items.slice(1)];
-}
-function parsePrNumber(value, label = "PR number") {
-	if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) throw new Error(`${label} must be a positive integer`);
-	return value;
-}
-export { nonEmpty, parsePrNumber };

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

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-// runtime/skills/poteto-mode/scripts/watch-pr/watch-pr
-const { main } = await import("./cli.mjs");
-process.exitCode = await main(process.argv.slice(2));
-export {};