@sourcepress/github 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { GitHubClient } from "./client.js";
+export { listContentFiles, getContentFile, listKnowledgeFiles } from "./content.js";
+export { GitHubPRApprovalProvider } from "./approval.js";
+export type { GitHubClientConfig, GitHubFile, GitHubTreeEntry, GitHubPR } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACpF,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AACzD,YAAY,EAAE,kBAAkB,EAAE,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { GitHubClient } from "./client.js";
+export { listContentFiles, getContentFile, listKnowledgeFiles } from "./content.js";
+export { GitHubPRApprovalProvider } from "./approval.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACpF,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+export interface GitHubClientConfig {
+    owner: string;
+    repo: string;
+    branch: string;
+    token: string;
+}
+export interface GitHubFile {
+    path: string;
+    sha: string;
+    content: string;
+    encoding: "utf-8" | "base64";
+}
+export interface GitHubTreeEntry {
+    path: string;
+    sha: string;
+    type: "blob" | "tree";
+    size?: number;
+}
+export interface GitHubPR {
+    number: number;
+    title: string;
+    body: string;
+    state: "open" | "closed" | "merged";
+    html_url: string;
+    head: {
+        ref: string;
+        sha: string;
+    };
+    base: {
+        ref: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,GAAG,QAAQ,CAAC;CAC7B;AAED,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,QAAQ;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC;CACtB"}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@sourcepress/github",
+	"version": "0.1.0",
+	"publishConfig": { "access": "public" },
+	"type": "module",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"scripts": {
+		"build": "tsc",
+		"test": "vitest run",
+		"typecheck": "tsc --noEmit",
+		"clean": "rm -rf dist"
+	},
+	"dependencies": {
+		"@sourcepress/core": "workspace:*",
+		"yaml": "^2.8.3"
+	},
+	"devDependencies": {
+		"typescript": "^5.7.0",
+		"vitest": "^3.0.0"
+	}
+}

package/src/__tests__/approval.test.ts

@@ -0,0 +1,207 @@
+import type { ContentChange } from "@sourcepress/core";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { GitHubPRApprovalProvider } from "../approval.js";
+import type { GitHubClient } from "../client.js";
+
+function makeMockClient(): GitHubClient {
+	return {
+		createBranch: vi.fn().mockResolvedValue("abc123"),
+		createOrUpdateFile: vi.fn().mockResolvedValue({ sha: "def456", commit_sha: "ghi789" }),
+		createPR: vi.fn().mockResolvedValue({
+			number: 42,
+			title: "[SourcePress] create: posts/hello",
+			body: "",
+			state: "open",
+			html_url: "https://github.com/owner/repo/pull/42",
+			head: { ref: "sourcepress/approve/posts/hello-123", sha: "abc" },
+			base: { ref: "main" },
+		}),
+		mergePR: vi.fn().mockResolvedValue(undefined),
+		closePR: vi.fn().mockResolvedValue(undefined),
+		getPR: vi.fn().mockResolvedValue({
+			number: 42,
+			title: "",
+			body: "",
+			state: "open",
+			html_url: "https://github.com/owner/repo/pull/42",
+			head: { ref: "branch", sha: "abc" },
+			base: { ref: "main" },
+		}),
+		getFile: vi.fn(),
+		getTree: vi.fn(),
+		getHeadSha: vi.fn(),
+		owner: "owner",
+		repo: "repo",
+		branch: "main",
+	} as unknown as GitHubClient;
+}
+
+const sampleChange: ContentChange = {
+	collection: "posts",
+	slug: "hello",
+	path: "content/posts/hello.md",
+	action: "create",
+	content: "# Hello\n\nThis is a test post.",
+	frontmatter: { title: "Hello", draft: false },
+	provenance: {
+		generated_by: "claude-3-5-sonnet",
+		generated_at: "2026-04-04T10:00:00Z",
+		source_files: ["knowledge/brand.md", "knowledge/tone.md"],
+		eval_score: 92,
+		prompt_version: "v1.2",
+	},
+};
+
+describe("GitHubPRApprovalProvider", () => {
+	let client: GitHubClient;
+	let provider: GitHubPRApprovalProvider;
+
+	beforeEach(() => {
+		client = makeMockClient();
+		provider = new GitHubPRApprovalProvider(client);
+	});
+
+	it("submit() creates branch, commits file, opens PR", async () => {
+		const request = await provider.submit(sampleChange);
+
+		expect(client.createBranch).toHaveBeenCalledOnce();
+		const branchArg = (client.createBranch as ReturnType<typeof vi.fn>).mock.calls[0][0] as string;
+		expect(branchArg).toMatch(/^sourcepress\/approve\/posts\/hello-\d+$/);
+
+		expect(client.createOrUpdateFile).toHaveBeenCalledWith(
+			"content/posts/hello.md",
+			"# Hello\n\nThis is a test post.",
+			expect.stringContaining("hello"),
+			branchArg,
+		);
+
+		expect(client.createPR).toHaveBeenCalledOnce();
+
+		expect(request.status).toBe("pending");
+		expect(request.id).toBe("42");
+		expect(request.pr_number).toBe(42);
+		expect(request.pr_url).toBe("https://github.com/owner/repo/pull/42");
+	});
+
+	it("status() returns correct status from PR state", async () => {
+		const mockGetPR = client.getPR as ReturnType<typeof vi.fn>;
+
+		mockGetPR.mockResolvedValueOnce({
+			number: 1,
+			state: "open",
+			html_url: "",
+			head: { ref: "", sha: "" },
+			base: { ref: "" },
+			title: "",
+			body: "",
+		});
+		expect(await provider.status("1")).toBe("pending");
+
+		mockGetPR.mockResolvedValueOnce({
+			number: 2,
+			state: "merged",
+			html_url: "",
+			head: { ref: "", sha: "" },
+			base: { ref: "" },
+			title: "",
+			body: "",
+		});
+		expect(await provider.status("2")).toBe("approved");
+
+		mockGetPR.mockResolvedValueOnce({
+			number: 3,
+			state: "closed",
+			html_url: "",
+			head: { ref: "", sha: "" },
+			base: { ref: "" },
+			title: "",
+			body: "",
+		});
+		expect(await provider.status("3")).toBe("rejected");
+	});
+
+	it("approve() merges the PR and fires status change callback", async () => {
+		await provider.submit(sampleChange);
+
+		const callback = vi.fn();
+		provider.onStatusChange(callback);
+
+		await provider.approve("42", "editor@example.com", "Looks good");
+
+		expect(client.mergePR).toHaveBeenCalledWith(42);
+		expect(callback).toHaveBeenCalledWith("42", "approved", "editor@example.com");
+
+		const requests = await provider.pending();
+		expect(requests).toHaveLength(0);
+	});
+
+	it("reject() closes the PR and fires status change callback", async () => {
+		await provider.submit(sampleChange);
+
+		const callback = vi.fn();
+		provider.onStatusChange(callback);
+
+		await provider.reject("42", "editor@example.com", "Needs revision");
+
+		expect(client.closePR).toHaveBeenCalledWith(42);
+		expect(callback).toHaveBeenCalledWith("42", "rejected", "editor@example.com");
+
+		const requests = await provider.pending();
+		expect(requests).toHaveLength(0);
+	});
+
+	it("pending() returns only pending requests", async () => {
+		const mockCreatePR = client.createPR as ReturnType<typeof vi.fn>;
+		mockCreatePR
+			.mockResolvedValueOnce({
+				number: 1,
+				state: "open",
+				html_url: "https://github.com/owner/repo/pull/1",
+				head: { ref: "b1", sha: "s1" },
+				base: { ref: "main" },
+				title: "",
+				body: "",
+			})
+			.mockResolvedValueOnce({
+				number: 2,
+				state: "open",
+				html_url: "https://github.com/owner/repo/pull/2",
+				head: { ref: "b2", sha: "s2" },
+				base: { ref: "main" },
+				title: "",
+				body: "",
+			})
+			.mockResolvedValueOnce({
+				number: 3,
+				state: "open",
+				html_url: "https://github.com/owner/repo/pull/3",
+				head: { ref: "b3", sha: "s3" },
+				base: { ref: "main" },
+				title: "",
+				body: "",
+			});
+
+		await provider.submit({ ...sampleChange, slug: "post-1", path: "content/posts/post-1.md" });
+		await provider.submit({ ...sampleChange, slug: "post-2", path: "content/posts/post-2.md" });
+		await provider.submit({ ...sampleChange, slug: "post-3", path: "content/posts/post-3.md" });
+
+		await provider.approve("1", "editor@example.com");
+		await provider.reject("2", "editor@example.com", "Not ready");
+
+		const pending = await provider.pending();
+		expect(pending).toHaveLength(1);
+		expect(pending[0].id).toBe("3");
+	});
+
+	it("submit() includes EU AI Act provenance in PR body", async () => {
+		await provider.submit(sampleChange);
+
+		const mockCreatePR = client.createPR as ReturnType<typeof vi.fn>;
+		const prBody = mockCreatePR.mock.calls[0][1] as string;
+
+		expect(prBody).toContain("claude-3-5-sonnet");
+		expect(prBody).toContain("knowledge/brand.md");
+		expect(prBody).toContain("2026-04-04T10:00:00Z");
+		expect(prBody).toContain("92");
+	});
+});

package/src/__tests__/content.test.ts

@@ -0,0 +1,68 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { GitHubClient } from "../client.js";
+import { getContentFile, listContentFiles } from "../content.js";
+
+const mockFetch = vi.fn();
+vi.stubGlobal("fetch", mockFetch);
+
+function mockResponse(data: unknown, status = 200) {
+	return {
+		ok: status >= 200 && status < 300,
+		status,
+		json: () => Promise.resolve(data),
+		text: () => Promise.resolve(JSON.stringify(data)),
+	};
+}
+
+describe("content operations", () => {
+	let client: GitHubClient;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		client = new GitHubClient({ owner: "test", repo: "site", branch: "main", token: "test-token" });
+	});
+
+	describe("listContentFiles", () => {
+		it("returns only files under the content path", async () => {
+			mockFetch.mockResolvedValueOnce(
+				mockResponse({
+					tree: [
+						{ path: "content/posts/hello.mdx", sha: "abc", type: "blob" },
+						{ path: "content/posts/world.mdx", sha: "def", type: "blob" },
+						{ path: "knowledge/client.md", sha: "ghi", type: "blob" },
+						{ path: "content/posts", sha: "jkl", type: "tree" },
+					],
+				}),
+			);
+			const files = await listContentFiles(client, "content/");
+			expect(files).toEqual(["content/posts/hello.mdx", "content/posts/world.mdx"]);
+		});
+	});
+
+	describe("getContentFile", () => {
+		it("parses frontmatter and body from MDX file", async () => {
+			const rawContent = "---\ntitle: Hello World\ndraft: true\n---\n\nThis is the body.";
+			mockFetch.mockResolvedValueOnce(
+				mockResponse({
+					path: "content/posts/hello.mdx",
+					sha: "abc123",
+					content: btoa(rawContent),
+					encoding: "base64",
+				}),
+			);
+			const file = await getContentFile(client, "content/posts/hello.mdx", "posts");
+			expect(file).not.toBeNull();
+			expect(file?.slug).toBe("hello");
+			expect(file?.collection).toBe("posts");
+			expect(file?.frontmatter.title).toBe("Hello World");
+			expect(file?.frontmatter.draft).toBe(true);
+			expect(file?.body).toBe("This is the body.");
+		});
+
+		it("returns null for non-existent file", async () => {
+			mockFetch.mockResolvedValueOnce(mockResponse(null, 404));
+			const file = await getContentFile(client, "content/posts/nope.mdx", "posts");
+			expect(file).toBeNull();
+		});
+	});
+});

package/src/approval.ts

@@ -0,0 +1,117 @@
+import type {
+	ApprovalProvider,
+	ApprovalRequest,
+	ApprovalStatus,
+	ContentChange,
+	StatusChangeHandler,
+} from "@sourcepress/core";
+import type { GitHubClient } from "./client.js";
+
+export class GitHubPRApprovalProvider implements ApprovalProvider {
+	private client: GitHubClient;
+	private requests: Map<string, ApprovalRequest> = new Map();
+	private callbacks: StatusChangeHandler[] = [];
+
+	constructor(client: GitHubClient) {
+		this.client = client;
+	}
+
+	async submit(change: ContentChange): Promise<ApprovalRequest> {
+		const timestamp = Date.now();
+		const branchName = `sourcepress/approve/${change.collection}/${change.slug}-${timestamp}`;
+
+		await this.client.createBranch(branchName);
+		await this.client.createOrUpdateFile(
+			change.path,
+			change.content,
+			`chore: submit ${change.action} ${change.slug} for approval`,
+			branchName,
+		);
+
+		const prBody = [
+			"## SourcePress Approval Request",
+			"",
+			`**Collection:** ${change.collection}`,
+			`**Slug:** ${change.slug}`,
+			`**Action:** ${change.action}`,
+			"",
+			"## EU AI Act Provenance",
+			"",
+			"| Field | Value |",
+			"|-------|-------|",
+			`| generated_by | ${change.provenance.generated_by} |`,
+			`| generated_at | ${change.provenance.generated_at} |`,
+			`| source_files | ${change.provenance.source_files.join(", ")} |`,
+			`| eval_score | ${change.provenance.eval_score ?? "N/A"} |`,
+			`| prompt_version | ${change.provenance.prompt_version ?? "N/A"} |`,
+		].join("\n");
+
+		const pr = await this.client.createPR(
+			`[SourcePress] ${change.action}: ${change.collection}/${change.slug}`,
+			prBody,
+			branchName,
+		);
+
+		const request: ApprovalRequest = {
+			id: String(pr.number),
+			change,
+			status: "pending",
+			submitted_at: new Date().toISOString(),
+			submitted_by: change.provenance.generated_by,
+			pr_url: pr.html_url,
+			pr_number: pr.number,
+		};
+
+		this.requests.set(request.id, request);
+		return request;
+	}
+
+	async status(id: string): Promise<ApprovalStatus> {
+		const pr = await this.client.getPR(Number(id));
+		if (pr.state === "open") return "pending";
+		// GitHub API returns "closed" for both closed and merged; check merged field
+		// The GitHubPR type uses "merged" as a state value per our types.ts
+		if (pr.state === "merged") return "approved";
+		return "rejected";
+	}
+
+	async approve(id: string, by: string, comment?: string): Promise<void> {
+		await this.client.mergePR(Number(id));
+
+		const existing = this.requests.get(id);
+		if (existing) {
+			existing.status = "approved";
+			existing.reviewed_by = by;
+			existing.reviewed_at = new Date().toISOString();
+			if (comment) existing.review_comment = comment;
+		}
+
+		for (const cb of this.callbacks) {
+			cb(id, "approved", by);
+		}
+	}
+
+	async reject(id: string, by: string, reason: string): Promise<void> {
+		await this.client.closePR(Number(id));
+
+		const existing = this.requests.get(id);
+		if (existing) {
+			existing.status = "rejected";
+			existing.reviewed_by = by;
+			existing.reviewed_at = new Date().toISOString();
+			existing.review_comment = reason;
+		}
+
+		for (const cb of this.callbacks) {
+			cb(id, "rejected", by);
+		}
+	}
+
+	async pending(): Promise<ApprovalRequest[]> {
+		return Array.from(this.requests.values()).filter((r) => r.status === "pending");
+	}
+
+	onStatusChange(callback: StatusChangeHandler): void {
+		this.callbacks.push(callback);
+	}
+}

package/src/client.ts

@@ -0,0 +1,170 @@
+import type { GitHubClientConfig, GitHubFile, GitHubPR, GitHubTreeEntry } from "./types.js";
+
+interface GitHubFileResponse {
+	path: string;
+	sha: string;
+	content: string;
+	encoding: string;
+}
+
+interface GitHubTreeResponse {
+	tree: Array<{ path: string; sha: string; type: "blob" | "tree"; size: number }>;
+}
+
+interface GitHubCreateFileResponse {
+	content: { sha: string };
+	commit: { sha: string };
+}
+
+interface GitHubRefResponse {
+	object: { sha: string };
+}
+
+export class GitHubClient {
+	private baseUrl: string;
+	private headers: Record<string, string>;
+	readonly owner: string;
+	readonly repo: string;
+	readonly branch: string;
+
+	constructor(config: GitHubClientConfig) {
+		this.owner = config.owner;
+		this.repo = config.repo;
+		this.branch = config.branch;
+		this.baseUrl = `https://api.github.com/repos/${config.owner}/${config.repo}`;
+		this.headers = {
+			Authorization: `Bearer ${config.token}`,
+			Accept: "application/vnd.github.v3+json",
+			"X-GitHub-Api-Version": "2022-11-28",
+		};
+	}
+
+	async getFile(path: string, ref?: string): Promise<GitHubFile | null> {
+		const url = `${this.baseUrl}/contents/${path}${ref ? `?ref=${ref}` : ""}`;
+		const response = await fetch(url, { headers: this.headers });
+		if (response.status === 404) return null;
+		if (!response.ok) throw new Error(`GitHub API error: ${response.status}`);
+		const data = (await response.json()) as GitHubFileResponse;
+		let content: string;
+		if (data.encoding === "base64") {
+			const binary = atob(data.content.replace(/\n/g, ""));
+			const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+			content = new TextDecoder("utf-8").decode(bytes);
+		} else {
+			content = data.content;
+		}
+		return { path: data.path, sha: data.sha, content, encoding: "utf-8" };
+	}
+
+	async getTree(sha?: string): Promise<GitHubTreeEntry[]> {
+		const treeSha = sha ?? this.branch;
+		const url = `${this.baseUrl}/git/trees/${treeSha}?recursive=1`;
+		const response = await fetch(url, { headers: this.headers });
+		if (!response.ok) throw new Error(`GitHub API error: ${response.status}`);
+		const data = (await response.json()) as GitHubTreeResponse;
+		return data.tree.map((entry) => ({
+			path: entry.path,
+			sha: entry.sha,
+			type: entry.type,
+			size: entry.size,
+		}));
+	}
+
+	async createOrUpdateFile(
+		path: string,
+		content: string,
+		message: string,
+		branch?: string,
+		existingSha?: string,
+	): Promise<{ sha: string; commit_sha: string }> {
+		const url = `${this.baseUrl}/contents/${path}`;
+		const body: Record<string, unknown> = {
+			message,
+			content:
+				typeof Buffer !== "undefined"
+					? Buffer.from(content, "utf-8").toString("base64")
+					: btoa(String.fromCodePoint(...new TextEncoder().encode(content))),
+			branch: branch ?? this.branch,
+		};
+		if (existingSha) body.sha = existingSha;
+		const response = await fetch(url, {
+			method: "PUT",
+			headers: { ...this.headers, "Content-Type": "application/json" },
+			body: JSON.stringify(body),
+		});
+		if (!response.ok) {
+			throw new Error(`GitHub API error: ${response.status}`);
+		}
+		const data = (await response.json()) as GitHubCreateFileResponse;
+		return { sha: data.content.sha, commit_sha: data.commit.sha };
+	}
+
+	async createBranch(branchName: string, fromSha?: string): Promise<string> {
+		const sha = fromSha ?? (await this.getHeadSha());
+		const url = `${this.baseUrl}/git/refs`;
+		const response = await fetch(url, {
+			method: "POST",
+			headers: { ...this.headers, "Content-Type": "application/json" },
+			body: JSON.stringify({ ref: `refs/heads/${branchName}`, sha }),
+		});
+		if (!response.ok) {
+			throw new Error(`GitHub API error: ${response.status}`);
+		}
+		const data = (await response.json()) as GitHubRefResponse;
+		return data.object.sha;
+	}
+
+	async createPR(title: string, body: string, head: string, base?: string): Promise<GitHubPR> {
+		const url = `${this.baseUrl}/pulls`;
+		const response = await fetch(url, {
+			method: "POST",
+			headers: { ...this.headers, "Content-Type": "application/json" },
+			body: JSON.stringify({ title, body, head, base: base ?? this.branch }),
+		});
+		if (!response.ok) {
+			throw new Error(`GitHub API error: ${response.status}`);
+		}
+		return (await response.json()) as GitHubPR;
+	}
+
+	async mergePR(prNumber: number): Promise<void> {
+		const url = `${this.baseUrl}/pulls/${prNumber}/merge`;
+		const response = await fetch(url, {
+			method: "PUT",
+			headers: { ...this.headers, "Content-Type": "application/json" },
+			body: JSON.stringify({ merge_method: "squash" }),
+		});
+		if (!response.ok) {
+			throw new Error(`GitHub API error: ${response.status}`);
+		}
+	}
+
+	async getPR(prNumber: number): Promise<GitHubPR> {
+		const url = `${this.baseUrl}/pulls/${prNumber}`;
+		const response = await fetch(url, { headers: this.headers });
+		if (!response.ok) {
+			throw new Error(`GitHub API error: ${response.status}`);
+		}
+		return (await response.json()) as GitHubPR;
+	}
+
+	async closePR(prNumber: number): Promise<void> {
+		const url = `${this.baseUrl}/pulls/${prNumber}`;
+		const response = await fetch(url, {
+			method: "PATCH",
+			headers: { ...this.headers, "Content-Type": "application/json" },
+			body: JSON.stringify({ state: "closed" }),
+		});
+		if (!response.ok) {
+			throw new Error(`GitHub API error: ${response.status}`);
+		}
+	}
+
+	async getHeadSha(): Promise<string> {
+		const url = `${this.baseUrl}/git/ref/heads/${this.branch}`;
+		const response = await fetch(url, { headers: this.headers });
+		if (!response.ok) throw new Error(`GitHub API error: ${response.status}`);
+		const data = (await response.json()) as GitHubRefResponse;
+		return data.object.sha;
+	}
+}