kanbot 0.0.0-stage → 0.1.0

package/src/github/api.ts

@@ -0,0 +1,332 @@
+import type { Checks, Comment, Issue, PR } from "../daemon/types.ts";
+import type { Gh } from "./gh.ts";
+
+const COMMENT = "id databaseId author { login } body createdAt";
+
+const PR_FIELDS = `
+	id number url title body state headRefName headRefOid mergeable createdAt
+	labels(first: 30) { nodes { name } }
+	comments(last: 100) { nodes { ${COMMENT} } }
+	reviews(last: 50) { nodes { ${COMMENT} } }
+	reviewThreads(last: 100) {
+		nodes {
+			id isResolved path line
+			comments(last: 30) { nodes { ${COMMENT} } }
+		}
+	}
+	commits(last: 1) { nodes { commit { statusCheckRollup { state } } } }`;
+
+const ISSUE_QUERY = `
+query($owner: String!, $name: String!, $number: Int!) {
+	repository(owner: $owner, name: $name) {
+		issue(number: $number) {
+			id number url title body state
+			labels(first: 50) { nodes { name } }
+			comments(last: 100) { nodes { ${COMMENT} } }
+			closedByPullRequestsReferences(first: 10, includeClosedPrs: true) {
+				nodes { ${PR_FIELDS} }
+			}
+		}
+	}
+}`;
+
+const LABELED_PRS_QUERY = `
+query($owner: String!, $name: String!, $label: String!) {
+	repository(owner: $owner, name: $name) {
+		pullRequests(labels: [$label], states: OPEN, first: 50) {
+			nodes { isCrossRepository ${PR_FIELDS} }
+		}
+	}
+}`;
+
+type RawComment = Omit<Comment, "author"> & {
+	author: { login: string } | null;
+};
+type Nodes<T> = { nodes: T[] };
+
+const comment = (c: RawComment): Comment => ({
+	...c,
+	author: c.author?.login ?? "ghost",
+});
+const names = (l: Nodes<{ name: string }>) => l.nodes.map((n) => n.name);
+
+export async function fetchIssue(gh: Gh, number: number): Promise<Issue> {
+	// biome-ignore lint/suspicious/noExplicitAny: raw GraphQL shape, mapped below
+	const data = await gh.query<any>(ISSUE_QUERY, {
+		owner: gh.owner,
+		name: gh.name,
+		number,
+	});
+	const i = data.repository.issue;
+	return {
+		id: i.id,
+		number: i.number,
+		url: i.url,
+		title: i.title,
+		body: i.body,
+		state: i.state,
+		labels: names(i.labels),
+		comments: i.comments.nodes.map(comment),
+		prs: i.closedByPullRequestsReferences.nodes.map(mapPR),
+	};
+}
+
+/**
+ * Open PRs with `label`, for review without a board card. Fork PRs are left
+ * out: their branch isn't on origin, so fixes couldn't be pushed.
+ */
+export async function fetchLabeledPRs(gh: Gh, label: string): Promise<PR[]> {
+	// biome-ignore lint/suspicious/noExplicitAny: raw GraphQL shape, mapped below
+	const data = await gh.query<any>(LABELED_PRS_QUERY, {
+		owner: gh.owner,
+		name: gh.name,
+		label,
+	});
+	return data.repository.pullRequests.nodes
+		.filter((p: { isCrossRepository: boolean }) => !p.isCrossRepository)
+		.map(mapPR);
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: raw GraphQL shape
+function mapPR(p: any): PR {
+	return {
+		id: p.id,
+		number: p.number,
+		url: p.url,
+		title: p.title,
+		body: p.body,
+		state: p.state,
+		headRefName: p.headRefName,
+		headSha: p.headRefOid,
+		createdAt: p.createdAt,
+		labels: names(p.labels),
+		comments: p.comments.nodes.map(comment),
+		reviews: p.reviews.nodes.map(comment).filter((r: Comment) => r.body.trim()),
+		// biome-ignore lint/suspicious/noExplicitAny: raw GraphQL shape
+		threads: p.reviewThreads.nodes.map((t: any) => ({
+			id: t.id,
+			isResolved: t.isResolved,
+			path: t.path,
+			line: t.line,
+			comments: t.comments.nodes.map(comment),
+		})),
+		checks: (p.commits.nodes[0]?.commit.statusCheckRollup?.state ??
+			null) as Checks,
+		mergeable: p.mergeable,
+	};
+}
+
+// ---- writes ---------------------------------------------------------------
+
+export function postComment(gh: Gh, number: number, body: string) {
+	return gh.restWrite(
+		`comment on #${number}`,
+		"POST",
+		gh.r(`/issues/${number}/comments`),
+		{ body },
+	);
+}
+
+export function updateIssueBody(gh: Gh, number: number, body: string) {
+	return gh.restWrite(
+		`update body of #${number}`,
+		"PATCH",
+		gh.r(`/issues/${number}`),
+		{ body },
+	);
+}
+
+export function addLabels(gh: Gh, number: number, labels: string[]) {
+	if (!labels.length) return Promise.resolve(null);
+	return gh.restWrite(
+		`label #${number} ${labels.join(",")}`,
+		"POST",
+		gh.r(`/issues/${number}/labels`),
+		{
+			labels,
+		},
+	);
+}
+
+export async function removeLabel(gh: Gh, number: number, label: string) {
+	try {
+		await gh.restWrite(
+			`unlabel #${number} ${label}`,
+			"DELETE",
+			gh.r(`/issues/${number}/labels/${encodeURIComponent(label)}`),
+		);
+	} catch (e) {
+		if (!String(e).includes("404")) throw e;
+	}
+}
+
+export function react(
+	gh: Gh,
+	subjectId: string,
+	content: "EYES" | "THUMBS_UP" | "ROCKET",
+) {
+	return gh.mutate(
+		`react ${content}`,
+		`mutation($s: ID!, $c: ReactionContent!) { addReaction(input: { subjectId: $s, content: $c }) { reaction { content } } }`,
+		{ s: subjectId, c: content },
+	);
+}
+
+export async function createIssue(gh: Gh, title: string, body: string) {
+	return gh.restWrite<{ number: number; node_id: string }>(
+		`create issue "${title}"`,
+		"POST",
+		gh.r("/issues"),
+		{ title, body },
+	);
+}
+
+export function addSubIssue(gh: Gh, parentId: string, childId: string) {
+	return gh.mutate(
+		"add sub-issue",
+		`mutation($p: ID!, $c: ID!) { addSubIssue(input: { issueId: $p, subIssueId: $c }) { issue { id } } }`,
+		{ p: parentId, c: childId },
+	);
+}
+
+export function createPR(
+	gh: Gh,
+	pr: {
+		title: string;
+		body: string;
+		head: string;
+		base: string;
+		draft?: boolean;
+	},
+) {
+	return gh.restWrite<{ number: number; html_url: string }>(
+		`open PR ${pr.head} → ${pr.base}`,
+		"POST",
+		gh.r("/pulls"),
+		pr,
+	);
+}
+
+export function updatePRBody(gh: Gh, number: number, body: string) {
+	return gh.restWrite(
+		`update body of PR #${number}`,
+		"PATCH",
+		gh.r(`/pulls/${number}`),
+		{ body },
+	);
+}
+
+export function closePR(gh: Gh, number: number) {
+	return gh.restWrite(
+		`close PR #${number}`,
+		"PATCH",
+		gh.r(`/pulls/${number}`),
+		{ state: "closed" },
+	);
+}
+
+export function replyToThread(gh: Gh, threadId: string, body: string) {
+	return gh.mutate(
+		"reply to review thread",
+		`mutation($t: ID!, $b: String!) {
+			addPullRequestReviewThreadReply(input: { pullRequestReviewThreadId: $t, body: $b }) { comment { id } }
+		}`,
+		{ t: threadId, b: body },
+	);
+}
+
+export function resolveThread(gh: Gh, threadId: string) {
+	return gh.mutate(
+		"resolve review thread",
+		`mutation($t: ID!) { resolveReviewThread(input: { threadId: $t }) { thread { id } } }`,
+		{ t: threadId },
+	);
+}
+
+export async function ensureLabel(
+	gh: Gh,
+	name: string,
+	color: string,
+	description: string,
+) {
+	try {
+		await gh.restWrite(`create label ${name}`, "POST", gh.r("/labels"), {
+			name,
+			color,
+			description,
+		});
+	} catch (e) {
+		if (!String(e).includes("already_exists")) throw e;
+	}
+}
+
+export async function failedCheckLogs(gh: Gh, sha: string): Promise<string> {
+	type Runs = {
+		check_runs: {
+			name: string;
+			conclusion: string | null;
+			output: {
+				title: string | null;
+				summary: string | null;
+				text: string | null;
+			};
+		}[];
+	};
+	const runs = await gh.rest<Runs>(
+		gh.r(`/commits/${sha}/check-runs?per_page=50`),
+	);
+	return runs.check_runs
+		.filter((r) => r.conclusion === "failure" || r.conclusion === "timed_out")
+		.map(
+			(r) =>
+				`### ${r.name} (${r.conclusion})\n${[r.output.title, r.output.summary, r.output.text].filter(Boolean).join("\n").slice(0, 6000)}`,
+		)
+		.join("\n\n");
+}
+
+// ---- Copilot code review ------------------------------------------------------
+
+const COPILOT_RULESET = "kanbot: Copilot review";
+
+/** Create or update the branch ruleset that requests Copilot review on PRs. */
+export async function ensureCopilotRuleset(gh: Gh, onPush: boolean) {
+	const body = {
+		name: COPILOT_RULESET,
+		target: "branch",
+		enforcement: "active",
+		conditions: { ref_name: { include: ["~DEFAULT_BRANCH"], exclude: [] } },
+		rules: [
+			{
+				type: "copilot_code_review",
+				parameters: {
+					review_on_push: onPush,
+					review_draft_pull_requests: false,
+				},
+			},
+		],
+	};
+	const sets = await gh.rest<{ id: number; name: string }[]>(gh.r("/rulesets"));
+	const existing = sets.find((s) => s.name === COPILOT_RULESET);
+	return existing
+		? gh.restWrite(
+				"update Copilot review ruleset",
+				"PUT",
+				gh.r(`/rulesets/${existing.id}`),
+				body,
+			)
+		: gh.restWrite(
+				"create Copilot review ruleset",
+				"POST",
+				gh.r("/rulesets"),
+				body,
+			);
+}
+
+/** The active Copilot review rule on `branch`, if any. */
+export async function copilotReviewRule(gh: Gh, branch: string) {
+	type Rule = { type: string; parameters?: { review_on_push?: boolean } };
+	const rules = await gh.rest<Rule[]>(
+		gh.r(`/rules/branches/${encodeURIComponent(branch)}`),
+	);
+	return rules.find((r) => r.type === "copilot_code_review") ?? null;
+}

package/src/github/gh.ts

@@ -0,0 +1,110 @@
+import { log } from "../log.ts";
+
+/**
+ * Thin wrapper over the `gh` CLI so kanbot reuses the user's existing auth.
+ * Reads always run; writes are skipped (and logged) in dry-run mode.
+ */
+export class Gh {
+	constructor(
+		readonly repo: string,
+		readonly dryRun = false,
+	) {}
+
+	get owner() {
+		return this.repo.split("/")[0] as string;
+	}
+	get name() {
+		return this.repo.split("/")[1] as string;
+	}
+
+	async query<T>(
+		query: string,
+		variables: Record<string, unknown> = {},
+	): Promise<T> {
+		const input = JSON.stringify({ query, variables });
+		// Projects mutations sometimes fail with "temporary conflict … try again"
+		// when a board workflow (e.g. Auto-add) touches the same item.
+		for (let attempt = 1; ; attempt++) {
+			try {
+				return await this.queryOnce<T>(input);
+			} catch (e) {
+				if (attempt >= 3 || !/try again/i.test(String(e))) throw e;
+				await Bun.sleep(1000 * attempt);
+			}
+		}
+	}
+
+	private async queryOnce<T>(input: string): Promise<T> {
+		const out = await run(["api", "graphql", "--input", "-"], input);
+		const json = JSON.parse(out) as { data: T; errors?: { message: string }[] };
+		if (json.errors?.length) {
+			throw new Error(
+				`GraphQL: ${json.errors.map((e) => e.message).join("; ")}`,
+			);
+		}
+		return json.data;
+	}
+
+	async mutate<T>(
+		what: string,
+		query: string,
+		variables: Record<string, unknown> = {},
+	): Promise<T | null> {
+		if (this.dryRun) {
+			log.info(`[dry-run] ${what}`);
+			return null;
+		}
+		return this.query<T>(query, variables);
+	}
+
+	async rest<T = unknown>(path: string): Promise<T> {
+		return JSON.parse(await run(["api", path])) as T;
+	}
+
+	async restWrite<T = unknown>(
+		what: string,
+		method: "POST" | "PATCH" | "PUT" | "DELETE",
+		path: string,
+		body?: unknown,
+	): Promise<T | null> {
+		if (this.dryRun) {
+			log.info(`[dry-run] ${what}`);
+			return null;
+		}
+		const out = await run(
+			[
+				"api",
+				"-X",
+				method,
+				path,
+				...(body === undefined ? [] : ["--input", "-"]),
+			],
+			body === undefined ? undefined : JSON.stringify(body),
+		);
+		return (out.trim() ? JSON.parse(out) : null) as T;
+	}
+
+	/** `repos/{owner}/{name}` + suffix */
+	r(suffix: string) {
+		return `repos/${this.repo}${suffix}`;
+	}
+}
+
+export async function run(args: string[], input?: string): Promise<string> {
+	const proc = Bun.spawn(["gh", ...args], {
+		stdin: input === undefined ? "ignore" : new Blob([input]),
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const [out, err, code] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+		proc.exited,
+	]);
+	if (code !== 0) {
+		throw new Error(
+			`gh ${args.slice(0, 3).join(" ")} failed (${code}): ${err.trim() || out.trim()}`,
+		);
+	}
+	return out;
+}

package/src/github/markers.ts

@@ -0,0 +1,82 @@
+/**
+ * Hidden HTML-comment markers. Agents post as the human's own account, so the
+ * marker is the only way to tell kanbot output apart from human input, and it
+ * doubles as the idempotency key for every side effect.
+ */
+
+const ANY = /<!--\s*kanbot(?::[^>]*)?-->/;
+const PLAN_START = "<!-- kanbot:plan:start -->";
+const PLAN_END = "<!-- kanbot:plan:end -->";
+
+export function marker(...parts: (string | number)[]) {
+	return parts.length
+		? `<!-- kanbot:${parts.join(":")} -->`
+		: "<!-- kanbot -->";
+}
+
+export function isKanbot(body: string) {
+	return ANY.test(body);
+}
+
+export function hasMarker(body: string, ...parts: (string | number)[]) {
+	return body.includes(marker(...parts));
+}
+
+/** All values `x` from markers shaped `<!-- kanbot:<kind>:x -->`. */
+export function markerValues(body: string, kind: string): string[] {
+	const re = new RegExp(`<!-- kanbot:${kind}:([^ ]+) -->`, "g");
+	return [...body.matchAll(re)].map((m) => m[1] as string);
+}
+
+export function extractPlan(body: string): string | null {
+	const start = body.indexOf(PLAN_START);
+	const end = body.indexOf(PLAN_END);
+	if (start === -1 || end === -1 || end < start) return null;
+	return body.slice(start + PLAN_START.length, end).trim();
+}
+
+/** The human-written part of an issue body (everything outside the plan block). */
+export function stripPlan(body: string): string {
+	const start = body.indexOf(PLAN_START);
+	const end = body.indexOf(PLAN_END);
+	if (start === -1 || end === -1) return body.trim();
+	return (body.slice(0, start) + body.slice(end + PLAN_END.length)).trim();
+}
+
+export function withPlan(body: string, plan: string): string {
+	const block = `${PLAN_START}\n\n${plan.trim()}\n\n${PLAN_END}`;
+	const human = stripPlan(body);
+	return human ? `${human}\n\n---\n\n${block}` : block;
+}
+
+const DESC_START = "<!-- kanbot:desc:start -->";
+const DESC_END = "<!-- kanbot:desc:end -->";
+/** Where the daemon's own PR body sections begin, for bodies without a desc block. */
+const PR_TAIL = /^(### Risks|### Checks|> Exploratory|Closes #)/m;
+
+/**
+ * Put the agent-written PR description in a marked block, replacing the
+ * previous one and keeping the daemon's sections (risks, checks, Closes #n).
+ */
+export function withDescription(body: string, description: string): string {
+	const block = `${DESC_START}\n\n${description.trim()}\n\n${DESC_END}`;
+	const start = body.indexOf(DESC_START);
+	const end = body.indexOf(DESC_END);
+	if (start !== -1 && end > start)
+		return body.slice(0, start) + block + body.slice(end + DESC_END.length);
+	const tail = body.search(PR_TAIL);
+	return tail === -1 ? block : `${block}\n\n${body.slice(tail)}`;
+}
+
+/** Embed machine-readable data in a comment. */
+export function embedJson(kind: string, data: unknown) {
+	return `<!-- kanbot-data:${kind} ${Buffer.from(JSON.stringify(data)).toString("base64")} -->`;
+}
+
+export function readJson<T>(body: string, kind: string): T | null {
+	const m = body.match(
+		new RegExp(`<!-- kanbot-data:${kind} ([A-Za-z0-9+/=]+) -->`),
+	);
+	if (!m?.[1]) return null;
+	return JSON.parse(Buffer.from(m[1], "base64").toString("utf8")) as T;
+}