dsh-pstack 0.1.0 → 0.2.0-beta.3

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

@@ -0,0 +1,626 @@
+import { nonEmpty, parsePrNumber } from "./types.mjs";
+import { spawn } from "node:child_process";
+// runtime/skills/poteto-mode/scripts/watch-pr/github.ts
+const REVIEW_THREADS_QUERY = "\nquery ReviewThreads($owner: String!, $repo: String!, $pr: Int!, $after: String) {\n  repository(owner: $owner, name: $repo) {\n    pullRequest(number: $pr) {\n      reviewThreads(first: 100, after: $after) {\n        pageInfo {\n          hasNextPage\n          endCursor\n        }\n        nodes {\n          id\n          isResolved\n          comments(first: 10) {\n            nodes {\n              body\n              createdAt\n              path\n              line\n              author { login }\n            }\n          }\n        }\n      }\n    }\n  }\n}\n";
+const PR_COMMIT_STATUS_QUERY = "\nquery PrCommitStatuses($owner: String!, $repo: String!, $pr: Int!) {\n  repository(owner: $owner, name: $repo) {\n    pullRequest(number: $pr) {\n      commits(last: 50) {\n        nodes {\n          commit {\n            oid\n            statusCheckRollup {\n              state\n            }\n          }\n        }\n      }\n    }\n  }\n}\n";
+const PR_CHECK_ROLLUP_QUERY = "\nquery PrCheckRollup($owner: String!, $repo: String!, $pr: Int!, $after: String) {\n  repository(owner: $owner, name: $repo) {\n    pullRequest(number: $pr) {\n      commits(last: 1) {\n        nodes {\n          commit {\n            statusCheckRollup {\n              contexts(first: 100, after: $after) {\n                pageInfo {\n                  hasNextPage\n                  endCursor\n                }\n                nodes {\n                  __typename\n                  ... on CheckRun {\n                    name\n                    status\n                    conclusion\n                    detailsUrl\n                  }\n                  ... on StatusContext {\n                    context\n                    state\n                    targetUrl\n                  }\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  }\n}\n";
+var WatcherQueryError = class extends Error {
+	failure;
+	constructor(failure) {
+		super(failure.detail);
+		this.name = "WatcherQueryError";
+		this.failure = failure;
+	}
+};
+var ChecksUnavailable = class extends WatcherQueryError {
+	constructor(detail) {
+		super({
+			kind: "checks-unavailable",
+			retryable: true,
+			detail
+		});
+		this.name = "ChecksUnavailable";
+	}
+};
+const firstLine = (value) => value.trim().split(/\r?\n/, 1)[0]?.slice(0, 240) ?? "";
+function run(argv) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(argv[0], argv.slice(1), { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		let stdout = "";
+		let stderr = "";
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			stdout += chunk;
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk;
+		});
+		child.on("error", reject);
+		child.on("close", (code) => resolve({
+			code: code ?? -1,
+			stdout,
+			stderr
+		}));
+	});
+}
+function parseJson(text, label) {
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		throw new WatcherQueryError({
+			kind: "json-parse",
+			retryable: true,
+			detail: `${label}: ${error instanceof Error ? error.message : String(error)}`
+		});
+	}
+}
+async function runJson(argv) {
+	const result = await run(argv);
+	if (result.code !== 0) throw new WatcherQueryError({
+		kind: "command-exit",
+		retryable: true,
+		code: result.code,
+		detail: firstLine(result.stderr) || `${argv.join(" ")} exited ${result.code}`
+	});
+	return parseJson(result.stdout, argv.join(" "));
+}
+function raw(value) {
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+function missing(path, value) {
+	throw new WatcherQueryError({
+		kind: "missing-key",
+		retryable: true,
+		detail: value === void 0 ? `missing ${path}` : `invalid ${path}: ${raw(value)}`,
+		...value === void 0 ? {} : { rawValue: raw(value) }
+	});
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function record(value, path) {
+	if (!isRecord(value)) missing(path, value);
+	return value;
+}
+function list(value, path) {
+	if (!Array.isArray(value)) missing(path, value);
+	return value;
+}
+function at(value, path) {
+	let current = value;
+	for (const key of path) {
+		const object = record(current, path.join("."));
+		if (!(key in object)) missing(path.join("."));
+		current = object[key];
+	}
+	return current;
+}
+function string(value, path) {
+	if (typeof value !== "string") missing(path, value);
+	return value;
+}
+const optionalString = (value, path) => value === null ? null : string(value, path);
+function enumValue(value, values, path) {
+	if (typeof value === "string") {
+		for (const candidate of values) if (candidate === value) return candidate;
+	}
+	return missing(path, value);
+}
+const nullableEnum = (value, values, path) => value === null ? null : enumValue(value, values, path);
+const MERGE_STATES = [
+	"BEHIND",
+	"BLOCKED",
+	"CLEAN",
+	"CONFLICTING",
+	"DIRTY",
+	"DRAFT",
+	"HAS_HOOKS",
+	"UNKNOWN",
+	"UNSTABLE"
+];
+const ROLLUP_STATES = [
+	"ERROR",
+	"EXPECTED",
+	"FAILURE",
+	"PENDING",
+	"SUCCESS"
+];
+const REVIEW_DECISIONS = [
+	"APPROVED",
+	"CHANGES_REQUESTED",
+	"REVIEW_REQUIRED"
+];
+const reviewDecision = (value) => nullableEnum(value === "" ? null : value, REVIEW_DECISIONS, "pull request.reviewDecision");
+function parseRemote(value) {
+	let normalized = value.trim();
+	if (normalized.startsWith("git@github.com:")) normalized = `https://github.com/${normalized.slice(15)}`;
+	if (normalized.startsWith("ssh://git@github.com/")) normalized = `https://github.com/${normalized.slice(21)}`;
+	try {
+		const url = new URL(normalized);
+		const parts = url.pathname.replace(/\.git$/, "").split("/").filter(Boolean);
+		if (url.protocol !== "https:" || url.hostname !== "github.com" || url.port || url.username || url.password || url.search || url.hash || parts.length !== 2) return null;
+		return {
+			owner: parts[0],
+			repo: parts[1]
+		};
+	} catch {
+		return null;
+	}
+}
+function parsePrUrl(value) {
+	try {
+		const url = new URL(value);
+		const parts = url.pathname.split("/").filter(Boolean);
+		if (url.protocol !== "https:" || url.hostname !== "github.com" || url.port || url.username || url.password || url.search || url.hash || parts.length !== 4 || parts[2] !== "pull") throw new Error("not a canonical GitHub pull URL");
+		return {
+			owner: parts[0],
+			repo: parts[1],
+			number: parsePrNumber(Number(parts[3]))
+		};
+	} catch (error) {
+		throw new WatcherQueryError({
+			kind: "invalid-context-url",
+			retryable: false,
+			rawValue: value,
+			detail: `could not infer owner/repo from PR URL: ${value} (${error instanceof Error ? error.message : String(error)})`
+		});
+	}
+}
+function checkDetails(value, nameKey) {
+	return {
+		name: string(value[nameKey], nameKey),
+		description: typeof value.description === "string" ? value.description : "",
+		link: typeof value.link === "string" ? value.link : typeof value.detailsUrl === "string" ? value.detailsUrl : "",
+		workflow: typeof value.workflow === "string" ? value.workflow : ""
+	};
+}
+function parseFastCheck(value) {
+	const object = record(value, "check");
+	const details = checkDetails(object, "name");
+	const state = string(object.state, "check.state").toUpperCase();
+	const bucket = string(object.bucket, "check.bucket");
+	if (state === "ACTION_REQUIRED") return gateOr("failed", details, state);
+	if (bucket === "fail" || ["FAILURE", "ERROR"].includes(state)) return {
+		...details,
+		kind: "failed",
+		reportedState: state
+	};
+	if (bucket === "pending") return gateOr("pending", details, state);
+	if (bucket === "pass") return {
+		...details,
+		kind: "passed",
+		reportedState: state
+	};
+	if (bucket === "skipping") return {
+		...details,
+		kind: "skipped",
+		reportedState: state
+	};
+	return {
+		...details,
+		kind: "failed",
+		reportedState: state
+	};
+}
+function gateOr(kind, details, reportedState) {
+	return details.name === "Code Review Gate" ? {
+		...details,
+		kind: "code-review-gate",
+		name: "Code Review Gate",
+		reportedState
+	} : {
+		...details,
+		kind,
+		reportedState
+	};
+}
+function mapRollupNode(value) {
+	const object = record(value, "rollup node");
+	const typename = object.__typename;
+	if (typename !== "CheckRun" && typename !== "StatusContext") return null;
+	const details = checkDetails(object, typename === "CheckRun" ? "name" : "context");
+	const link = typeof object.targetUrl === "string" ? object.targetUrl : details.link;
+	if (typename === "CheckRun") {
+		const status = typeof object.status === "string" ? object.status.toUpperCase() : "";
+		const conclusion = typeof object.conclusion === "string" ? object.conclusion.toUpperCase() : "";
+		if (status !== "COMPLETED") return gateOr("pending", {
+			...details,
+			link
+		}, "PENDING");
+		if (conclusion === "SUCCESS") return {
+			...details,
+			link,
+			kind: "passed",
+			reportedState: "SUCCESS"
+		};
+		if (conclusion === "NEUTRAL" || conclusion === "SKIPPED") return {
+			...details,
+			link,
+			kind: "skipped",
+			reportedState: conclusion
+		};
+		if (conclusion === "ACTION_REQUIRED") return gateOr("failed", {
+			...details,
+			link
+		}, conclusion);
+		return {
+			...details,
+			link,
+			kind: "failed",
+			reportedState: "FAILURE"
+		};
+	}
+	const state = typeof object.state === "string" ? object.state.toUpperCase() : "";
+	if (state === "PENDING" || state === "EXPECTED") return gateOr("pending", {
+		...details,
+		link
+	}, "PENDING");
+	return state === "SUCCESS" ? {
+		...details,
+		link,
+		kind: "passed",
+		reportedState: state
+	} : {
+		...details,
+		link,
+		kind: "failed",
+		reportedState: state || "FAILURE"
+	};
+}
+function parseComment(value) {
+	const object = record(value, "review comment");
+	const author = object.author === null ? null : record(object.author, "review comment.author");
+	return {
+		authorLogin: author === null ? null : optionalString(author.login, "review comment.author.login"),
+		body: string(object.body, "review comment.body"),
+		path: optionalString(object.path, "review comment.path"),
+		line: object.line === null ? null : Number.isInteger(object.line) ? Number(object.line) : missing("review comment.line", object.line),
+		createdAt: string(object.createdAt, "review comment.createdAt")
+	};
+}
+function isBugbot(comment) {
+	if (comment === null) return false;
+	const author = (comment.authorLogin ?? "").toLowerCase();
+	const body = comment.body.toLowerCase();
+	return author.includes("bugbot") || author === "cursor" && [
+		"bugbot",
+		"cursor_automation_id",
+		"agentic security review",
+		"description start",
+		"severity"
+	].some((token) => body.includes(token));
+}
+function passKey(comment) {
+	if (comment === null) return null;
+	for (const pattern of [/RUN_ID:\s*([a-zA-Z0-9_.:-]+)/, /CURSOR_AUTOMATION_ID:\s*([a-zA-Z0-9_.:-]+)/]) {
+		const match = pattern.exec(comment.body);
+		if (match?.[1]) return match[1];
+	}
+	return null;
+}
+function parseReviewThreadPage(value) {
+	const reviewThreads = record(at(value, [
+		"data",
+		"repository",
+		"pullRequest",
+		"reviewThreads"
+	]), "reviewThreads");
+	const nodes = list(reviewThreads.nodes, "reviewThreads.nodes");
+	const threads = [];
+	for (const node of nodes) {
+		const thread = record(node, "review thread");
+		if (typeof thread.isResolved !== "boolean") missing("review thread.isResolved", thread.isResolved);
+		const comments = list(at(thread, ["comments", "nodes"]), "review thread.comments.nodes");
+		threads.push({
+			id: string(thread.id, "review thread.id"),
+			firstComment: comments.length === 0 ? null : parseComment(comments[0]),
+			resolved: thread.isResolved
+		});
+	}
+	const page = record(reviewThreads.pageInfo, "reviewThreads.pageInfo");
+	if (typeof page.hasNextPage !== "boolean") missing("reviewThreads.pageInfo.hasNextPage", page.hasNextPage);
+	const cursor = optionalString(page.endCursor, "reviewThreads.pageInfo.endCursor");
+	return {
+		threads,
+		endCursor: page.hasNextPage && cursor ? cursor : null
+	};
+}
+function buildReviewThreads(threads) {
+	const keys = /* @__PURE__ */ new Set();
+	let keyless = false;
+	for (const thread of threads) {
+		if (!isBugbot(thread.firstComment)) continue;
+		const key = passKey(thread.firstComment);
+		if (key === null) keyless = true;
+		else keys.add(key);
+	}
+	const passes = keys.size > 0 ? keys.size : keyless ? 1 : 0;
+	return threads.filter((thread) => !thread.resolved).map(({ id, firstComment }) => ({
+		id,
+		firstComment,
+		isBugbot: isBugbot(firstComment),
+		bugbotReviewPasses: passes
+	}));
+}
+function parsePullRequest(value, context) {
+	const object = record(value, "pull request");
+	if (typeof object.isDraft !== "boolean") missing("pull request.isDraft", object.isDraft);
+	return {
+		context,
+		mergeable: enumValue(object.mergeable, [
+			"MERGEABLE",
+			"CONFLICTING",
+			"UNKNOWN"
+		], "pull request.mergeable"),
+		mergeStateStatus: enumValue(object.mergeStateStatus, MERGE_STATES, "pull request.mergeStateStatus"),
+		reviewDecision: reviewDecision(object.reviewDecision),
+		headRefOid: optionalString(object.headRefOid, "pull request.headRefOid"),
+		headRefName: string(object.headRefName, "pull request.headRefName"),
+		baseRefName: string(object.baseRefName, "pull request.baseRefName"),
+		state: enumValue(object.state, [
+			"OPEN",
+			"CLOSED",
+			"MERGED"
+		], "pull request.state"),
+		mergedAt: optionalString(object.mergedAt, "pull request.mergedAt"),
+		isDraft: object.isDraft
+	};
+}
+function graphqlArgs(query, context) {
+	return [
+		"gh",
+		"api",
+		"graphql",
+		"-f",
+		`query=${query}`,
+		"-f",
+		`owner=${context.owner}`,
+		"-f",
+		`repo=${context.repo}`,
+		"-F",
+		`pr=${context.number}`
+	];
+}
+var GhGitHubReader = class {
+	async originRepo() {
+		const result = await run([
+			"git",
+			"remote",
+			"get-url",
+			"origin"
+		]);
+		return result.code === 0 ? parseRemote(result.stdout) : null;
+	}
+	async currentPr(pr) {
+		const argv = [
+			"gh",
+			"pr",
+			"view"
+		];
+		if (pr !== null) argv.push(String(pr));
+		argv.push("--json", "number,url");
+		const object = record(await runJson(argv), "current PR");
+		return {
+			...parsePrUrl(string(object.url, "current PR.url")),
+			number: pr ?? parsePrNumber(object.number, "current PR.number")
+		};
+	}
+	async pullRequest(context) {
+		return parsePullRequest(await runJson([
+			"gh",
+			"pr",
+			"view",
+			String(context.number),
+			"--repo",
+			`${context.owner}/${context.repo}`,
+			"--json",
+			"mergeable,mergeStateStatus,reviewDecision,headRefOid,headRefName,baseRefName,state,mergedAt,isDraft"
+		]), context);
+	}
+	async openPullRequests(repository) {
+		return list(await runJson([
+			"gh",
+			"pr",
+			"list",
+			"--repo",
+			`${repository.owner}/${repository.repo}`,
+			"--state",
+			"open",
+			"--limit",
+			"300",
+			"--json",
+			"number,headRefName,baseRefName,isCrossRepository"
+		]), "open PRs").map((item, index) => {
+			const object = record(item, `open PRs[${index}]`);
+			if (typeof object.isCrossRepository !== "boolean") missing(`open PRs[${index}].isCrossRepository`, object.isCrossRepository);
+			return {
+				isCrossRepository: object.isCrossRepository,
+				number: parsePrNumber(object.number, `open PRs[${index}].number`),
+				headRefName: string(object.headRefName, `open PRs[${index}].headRefName`),
+				baseRefName: string(object.baseRefName, `open PRs[${index}].baseRefName`)
+			};
+		});
+	}
+	async checksFastPath(context) {
+		const result = await run([
+			"gh",
+			"pr",
+			"checks",
+			String(context.number),
+			"--repo",
+			`${context.owner}/${context.repo}`,
+			"--json",
+			"name,state,description,link,workflow,bucket"
+		]);
+		if ([
+			0,
+			1,
+			8
+		].includes(result.code) && result.stdout.trim()) try {
+			const value = parseJson(result.stdout, "gh pr checks");
+			if (Array.isArray(value)) return {
+				kind: "checks",
+				checks: value.map(parseFastCheck)
+			};
+		} catch (error) {
+			if (!(error instanceof WatcherQueryError)) throw error;
+		}
+		return {
+			kind: "unusable",
+			exitCode: result.code,
+			stderr: result.stderr
+		};
+	}
+	async checkRollupPage(context, after) {
+		const argv = graphqlArgs(PR_CHECK_ROLLUP_QUERY, context);
+		if (after !== null) argv.push("-f", `after=${after}`);
+		const commits = list(at(await runJson(argv), [
+			"data",
+			"repository",
+			"pullRequest",
+			"commits",
+			"nodes"
+		]), "commits.nodes");
+		if (commits.length === 0) return {
+			checks: [],
+			endCursor: null
+		};
+		const commit = record(at(commits[commits.length - 1], ["commit"]), "commit");
+		if (commit.statusCheckRollup === null) return {
+			checks: [],
+			endCursor: null
+		};
+		const contexts = record(at(commit, ["statusCheckRollup", "contexts"]), "contexts");
+		const checks = list(contexts.nodes, "contexts.nodes").map(mapRollupNode).filter((check) => check !== null);
+		const page = record(contexts.pageInfo, "contexts.pageInfo");
+		if (typeof page.hasNextPage !== "boolean") missing("contexts.pageInfo.hasNextPage", page.hasNextPage);
+		const cursor = optionalString(page.endCursor, "contexts.pageInfo.endCursor");
+		return {
+			checks,
+			endCursor: page.hasNextPage && cursor ? cursor : null
+		};
+	}
+	async reviewThreadPage(context, after) {
+		const argv = graphqlArgs(REVIEW_THREADS_QUERY, context);
+		if (after !== null) argv.push("-f", `after=${after}`);
+		return parseReviewThreadPage(await runJson(argv));
+	}
+	async commitRollups(context) {
+		return list(at(await runJson(graphqlArgs(PR_COMMIT_STATUS_QUERY, context)), [
+			"data",
+			"repository",
+			"pullRequest",
+			"commits",
+			"nodes"
+		]), "commits.nodes").map((item, index) => {
+			const commit = record(at(item, ["commit"]), `commits[${index}].commit`);
+			const rollup = commit.statusCheckRollup;
+			return {
+				oid: string(commit.oid, `commits[${index}].oid`),
+				state: rollup === null ? null : nullableEnum(at(rollup, ["state"]), ROLLUP_STATES, `commits[${index}].statusCheckRollup.state`)
+			};
+		});
+	}
+};
+async function resolveChecks(reader, context) {
+	const fast = await reader.checksFastPath(context);
+	const direct = fast.kind === "checks" ? nonEmpty(fast.checks) : null;
+	if (direct !== null) return {
+		source: "gh-pr-checks",
+		checks: direct
+	};
+	const checks = [];
+	let after = null;
+	do {
+		const page = await reader.checkRollupPage(context, after);
+		checks.push(...page.checks);
+		after = page.endCursor;
+	} while (after !== null);
+	const fallback = nonEmpty(checks);
+	if (fallback !== null) return {
+		source: "graphql-rollup",
+		checks: fallback
+	};
+	throw new ChecksUnavailable(`could not read PR checks: ${fast.kind === "unusable" ? `fast path exit=${fast.exitCode}; GraphQL rollup was empty${firstLine(fast.stderr) ? `; ${firstLine(fast.stderr)}` : ""}` : "fast path and GraphQL rollup were empty"}`);
+}
+async function resolveReviewThreads(reader, context) {
+	const threads = [];
+	let after = null;
+	do {
+		const page = await reader.reviewThreadPage(context, after);
+		threads.push(...page.threads);
+		after = page.endCursor;
+	} while (after !== null);
+	return buildReviewThreads(threads);
+}
+async function resolveContext(args) {
+	if (args.pr !== null && args.owner !== null && args.repo !== null) return {
+		owner: args.owner,
+		repo: args.repo,
+		number: args.pr
+	};
+	if (args.pr !== null) {
+		const origin = await args.reader.originRepo();
+		if (origin !== null) return {
+			owner: args.owner ?? origin.owner,
+			repo: args.repo ?? origin.repo,
+			number: args.pr
+		};
+	}
+	const inferred = await args.reader.currentPr(args.pr);
+	return {
+		owner: args.owner ?? inferred.owner,
+		repo: args.repo ?? inferred.repo,
+		number: args.pr ?? inferred.number
+	};
+}
+function orderStack(context, open) {
+	const byNumber = new Map(open.map((pr) => [pr.number, pr]));
+	const byHead = new Map(open.filter((pr) => !pr.isCrossRepository).map((pr) => [pr.headRefName, pr]));
+	const children = /* @__PURE__ */ new Map();
+	for (const pr of open) children.set(pr.baseRefName, [...children.get(pr.baseRefName) ?? [], pr]);
+	for (const values of children.values()) values.sort((a, b) => a.number - b.number);
+	const start = byNumber.get(context.number);
+	if (start === void 0) return [context];
+	const down = [];
+	let current = start;
+	while (byHead.has(current.baseRefName)) {
+		const parent = byHead.get(current.baseRefName);
+		if (parent === void 0) break;
+		down.push(parent);
+		current = parent;
+	}
+	const seen = /* @__PURE__ */ new Set([...down.map((pr) => pr.number), start.number]);
+	const up = [];
+	const visit = (parent) => {
+		if (parent.isCrossRepository) return;
+		for (const child of children.get(parent.headRefName) ?? []) {
+			if (seen.has(child.number)) continue;
+			seen.add(child.number);
+			up.push(child);
+			visit(child);
+		}
+	};
+	visit(start);
+	return nonEmpty([
+		...down.reverse(),
+		start,
+		...up
+	].map((pr) => ({
+		...context,
+		number: pr.number
+	}))) ?? [context];
+}
+async function discoverStack(reader, context) {
+	return orderStack(context, await reader.openPullRequests(context));
+}
+export { ChecksUnavailable, GhGitHubReader, PR_CHECK_ROLLUP_QUERY, PR_COMMIT_STATUS_QUERY, REVIEW_THREADS_QUERY, WatcherQueryError, buildReviewThreads, discoverStack, mapRollupNode, orderStack, parseFastCheck, parsePullRequest, parseReviewThreadPage, resolveChecks, resolveContext, resolveReviewThreads };