Commit 83a161b49f68

@@ -0,0 +1,317 @@
+/**
+ * CI/Checks action handlers for GitHub extension
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { GhDetails } from "../types";
+import { parseChecks, parseRunList, getErrorMessage, getCheckIcon, getRunStatusIcon } from "../utils";
+
+/**
+ * Show check status for a PR
+ */
+export async function handleChecks(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for checks action" }],
+			details: { action: "checks", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Fetching checks for PR #${params.number}...` }] });
+
+	const result = await pi.exec(
+		"gh",
+		["pr", "view", String(params.number), "--json", "statusCheckRollup"],
+		{ signal, timeout: 30000 },
+	);
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Get checks") }],
+			details: { action: "checks", error: result.stderr, prNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	const checks = parseChecks(result.stdout);
+
+	if (checks.length === 0) {
+		return {
+			content: [{ type: "text", text: `No checks found for PR #${params.number}` }],
+			details: { action: "checks", output: "No checks found", prNumber: params.number } as GhDetails,
+		};
+	}
+
+	const passed = checks.filter((c) => c.conclusion === "SUCCESS").length;
+	const failed = checks.filter((c) => c.conclusion === "FAILURE").length;
+	const pending = checks.filter(
+		(c) => !c.conclusion || c.status === "IN_PROGRESS" || c.status === "QUEUED",
+	).length;
+	const skipped = checks.filter(
+		(c) => c.conclusion === "SKIPPED" || c.conclusion === "CANCELLED",
+	).length;
+
+	let output = `PR #${params.number} checks: ${passed} passed, ${failed} failed, ${pending} pending`;
+	if (skipped > 0) output += `, ${skipped} skipped`;
+	output += "\n\n";
+
+	for (const check of checks) {
+		const icon = getCheckIcon(check);
+		output += `${icon} ${check.name} (${check.conclusion || check.status || "pending"})`;
+		if (check.detailsUrl) output += ` ${check.detailsUrl}`;
+		output += "\n";
+	}
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "checks", output, prNumber: params.number } as GhDetails,
+	};
+}
+
+/**
+ * Get failed check logs
+ */
+export async function handleChecksLog(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.runId) {
+		return {
+			content: [{ type: "text", text: "Error: 'runId' parameter is required for checks-log action" }],
+			details: { action: "checks-log", error: "missing_run_id" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Fetching logs for run ${params.runId}...` }] });
+
+	const result = await pi.exec("gh", ["run", "view", String(params.runId), "--log-failed"], {
+		signal,
+		timeout: 60000,
+	});
+
+	if (result.code !== 0) {
+		// If --log-failed has no output, try regular log
+		if (result.stderr.includes("no failed jobs")) {
+			return {
+				content: [{ type: "text", text: `No failed jobs in run ${params.runId}` }],
+				details: { action: "checks-log", output: "No failed jobs", runId: params.runId } as GhDetails,
+			};
+		}
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Get run logs") }],
+			details: { action: "checks-log", error: result.stderr, runId: params.runId } as GhDetails,
+			isError: true,
+		};
+	}
+
+	const logs = result.stdout;
+	const maxLen = 50000;
+	const output =
+		logs.length > maxLen
+			? logs.slice(logs.length - maxLen) + "\n\n[... logs truncated, showing last 50KB]"
+			: logs;
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "checks-log", output: `Run ${params.runId} logs (${logs.length} chars)`, runId: params.runId } as GhDetails,
+	};
+}
+
+/**
+ * Restart failed checks (requires approval)
+ */
+export async function handleChecksRestart(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.runId) {
+		return {
+			content: [{ type: "text", text: "Error: 'runId' parameter is required for checks-restart action" }],
+			details: { action: "checks-restart", error: "missing_run_id" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmed = await ctx.ui.confirm(
+			`Restart run ${params.runId}?`,
+			`This will rerun${params.failedOnly !== false ? " failed jobs in" : ""} workflow run ${params.runId}.`,
+		);
+		if (!confirmed) {
+			ctx.ui.notify("Restart cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Restart cancelled by user" }],
+				details: { action: "checks-restart", cancelled: true, runId: params.runId } as GhDetails,
+			};
+		}
+	}
+
+	const args = ["run", "rerun", String(params.runId)];
+	if (params.failedOnly !== false) args.push("--failed");
+
+	onUpdate?.({ content: [{ type: "text", text: `Restarting run ${params.runId}...` }] });
+
+	const result = await pi.exec("gh", args, { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Restart run") }],
+			details: { action: "checks-restart", error: result.stderr, runId: params.runId } as GhDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Restarted run ${params.runId}${params.failedOnly !== false ? " (failed jobs only)" : ""}` }],
+		details: { action: "checks-restart", output: result.stdout.trim(), runId: params.runId } as GhDetails,
+	};
+}
+
+/**
+ * List workflow runs
+ */
+export async function handleRunList(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	const args = [
+		"run",
+		"list",
+		"--json",
+		"databaseId,name,displayTitle,status,conclusion,headBranch,event,url,createdAt,updatedAt",
+	];
+
+	if (params.branch) args.push("--branch", params.branch);
+	if (params.status) args.push("--status", params.status);
+	if (params.workflow) args.push("--workflow", params.workflow);
+	if (params.limit) args.push("--limit", String(params.limit));
+	else args.push("--limit", "20");
+
+	onUpdate?.({ content: [{ type: "text", text: "Fetching workflow runs..." }] });
+
+	const result = await pi.exec("gh", args, { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "List runs") }],
+			details: { action: "run-list", error: result.stderr } as GhDetails,
+			isError: true,
+		};
+	}
+
+	const runs = parseRunList(result.stdout);
+
+	if (runs.length === 0) {
+		return {
+			content: [{ type: "text", text: "No workflow runs found." }],
+			details: { action: "run-list", output: "No runs found" } as GhDetails,
+		};
+	}
+
+	let output = `Workflow runs (${runs.length}):\n\n`;
+	for (const run of runs) {
+		const icon = getRunStatusIcon(run);
+		output += `${icon} ${run.databaseId} ${run.name}: ${run.displayTitle}`;
+		output += ` (${run.conclusion || run.status})`;
+		output += ` [${run.headBranch}]`;
+		output += ` ${run.url}`;
+		output += "\n";
+	}
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "run-list", output } as GhDetails,
+	};
+}
+
+/**
+ * View specific run details
+ */
+export async function handleRunView(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.runId) {
+		return {
+			content: [{ type: "text", text: "Error: 'runId' parameter is required for run-view action" }],
+			details: { action: "run-view", error: "missing_run_id" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Fetching run ${params.runId}...` }] });
+
+	const result = await pi.exec(
+		"gh",
+		[
+			"run",
+			"view",
+			String(params.runId),
+			"--json",
+			"databaseId,name,displayTitle,status,conclusion,headBranch,event,url,createdAt,updatedAt,jobs",
+		],
+		{ signal, timeout: 30000 },
+	);
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "View run") }],
+			details: { action: "run-view", error: result.stderr, runId: params.runId } as GhDetails,
+			isError: true,
+		};
+	}
+
+	let data: any;
+	try {
+		data = JSON.parse(result.stdout);
+	} catch {
+		return {
+			content: [{ type: "text", text: result.stdout }],
+			details: { action: "run-view", output: result.stdout, runId: params.runId } as GhDetails,
+		};
+	}
+
+	let output = `# Run ${data.databaseId}: ${data.name}\n\n`;
+	output += `Title: ${data.displayTitle}\n`;
+	output += `Status: ${data.conclusion || data.status}\n`;
+	output += `Branch: ${data.headBranch}\n`;
+	output += `Event: ${data.event}\n`;
+	output += `URL: ${data.url}\n`;
+
+	const jobs = data.jobs ?? [];
+	if (jobs.length > 0) {
+		output += `\n## Jobs (${jobs.length})\n\n`;
+		for (const job of jobs) {
+			const icon = job.conclusion === "success" ? "✓" : job.conclusion === "failure" ? "✗" : "⏳";
+			output += `${icon} ${job.name} (${job.conclusion || job.status})`;
+			if (job.url) output += ` ${job.url}`;
+			output += "\n";
+		}
+	}
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "run-view", output, runId: params.runId } as GhDetails,
+	};
+}

@@ -0,0 +1,443 @@
+/**
+ * Issue action handlers for GitHub extension
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { GhDetails } from "../types";
+import {
+	parseIssueList,
+	getErrorMessage,
+	extractIssueNumber,
+	extractIssueUrl,
+	buildIssueCreateConfirmation,
+	buildCommentConfirmation,
+	truncate,
+} from "../utils";
+
+const ISSUE_LIST_FIELDS = "number,title,state,author,url,labels,assignees,createdAt,updatedAt,body,comments";
+
+/**
+ * List issues
+ */
+export async function handleIssueList(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+	currentUser: string,
+): Promise<any> {
+	const args = ["issue", "list", "--json", ISSUE_LIST_FIELDS];
+
+	if (params.state) args.push("--state", params.state);
+	if (params.label) args.push("--label", params.label);
+	if (params.assignee) {
+		args.push("--assignee", params.assignee === "me" ? (currentUser || "@me") : params.assignee);
+	}
+	if (params.milestone) args.push("--milestone", params.milestone);
+	if (params.limit) args.push("--limit", String(params.limit));
+	else args.push("--limit", "20");
+
+	onUpdate?.({ content: [{ type: "text", text: "Fetching issues..." }] });
+
+	const result = await pi.exec("gh", args, { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "List issues") }],
+			details: { action: "issue-list", error: result.stderr } as GhDetails,
+			isError: true,
+		};
+	}
+
+	const issues = parseIssueList(result.stdout);
+
+	let output = "";
+	if (issues.length === 0) {
+		output = "No issues found.";
+	} else {
+		output = issues
+			.map((issue) => {
+				const labels = issue.labels.length > 0 ? ` [${issue.labels.join(", ")}]` : "";
+				const assignees = issue.assignees.length > 0 ? ` @${issue.assignees.join(", @")}` : "";
+				return `#${issue.number} ${issue.title}${labels}${assignees} (${issue.state})`;
+			})
+			.join("\n");
+	}
+
+	const issueNumbers = issues.map((i) => i.number);
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "issue-list", output, issueNumbers } as GhDetails,
+	};
+}
+
+/**
+ * View issue details
+ */
+export async function handleIssueView(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for issue-view action" }],
+			details: { action: "issue-view", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Fetching issue #${params.number}...` }] });
+
+	const result = await pi.exec(
+		"gh",
+		["issue", "view", String(params.number), "--json", `${ISSUE_LIST_FIELDS},milestone`],
+		{ signal, timeout: 20000 },
+	);
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "View issue") }],
+			details: { action: "issue-view", error: result.stderr, issueNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	let data: any;
+	try {
+		data = JSON.parse(result.stdout);
+	} catch {
+		return {
+			content: [{ type: "text", text: result.stdout }],
+			details: { action: "issue-view", output: result.stdout, issueNumber: params.number } as GhDetails,
+		};
+	}
+
+	let output = "";
+	output += `# Issue #${data.number}: ${data.title}\n\n`;
+	output += `State: ${data.state}\n`;
+	output += `Author: @${data.author?.login ?? "?"}\n`;
+	output += `URL: ${data.url}\n`;
+
+	if (data.labels?.length > 0) {
+		output += `Labels: ${data.labels.map((l: any) => l.name ?? l).join(", ")}\n`;
+	}
+	if (data.assignees?.length > 0) {
+		output += `Assignees: ${data.assignees.map((a: any) => `@${a.login ?? a}`).join(", ")}\n`;
+	}
+	if (data.milestone) {
+		output += `Milestone: ${data.milestone.title ?? data.milestone}\n`;
+	}
+
+	if (data.body) {
+		output += `\n## Description\n\n${data.body}\n`;
+	}
+
+	// Get comments if any
+	const commentsCount = data.comments?.totalCount ?? data.comments ?? 0;
+	if (commentsCount > 0) {
+		output += `\n## Comments (${commentsCount})\n`;
+		// Fetch comments separately via gh issue view --comments
+		const commentsResult = await pi.exec(
+			"gh",
+			["issue", "view", String(params.number), "--comments", "--json", "comments"],
+			{ signal, timeout: 20000 },
+		);
+		if (commentsResult.code === 0) {
+			try {
+				const commentsData = JSON.parse(commentsResult.stdout);
+				const comments = commentsData.comments ?? [];
+				for (const comment of comments) {
+					output += `\n@${comment.author?.login ?? "?"} (${comment.createdAt ?? ""}):\n${comment.body}\n`;
+				}
+			} catch {
+				output += "\n(Could not parse comments)\n";
+			}
+		}
+	}
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: {
+			action: "issue-view",
+			output,
+			issueNumber: data.number,
+			issueUrl: data.url,
+		} as GhDetails,
+	};
+}
+
+/**
+ * Create issue (requires approval)
+ */
+export async function handleIssueCreate(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.title) {
+		return {
+			content: [{ type: "text", text: "Error: 'title' parameter is required for issue-create action" }],
+			details: { action: "issue-create", error: "missing_title" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = buildIssueCreateConfirmation(params);
+		const confirmed = await ctx.ui.confirm("Create Issue?", confirmMessage);
+		if (!confirmed) {
+			ctx.ui.notify("Issue creation cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Issue creation cancelled by user" }],
+				details: { action: "issue-create", cancelled: true } as GhDetails,
+			};
+		}
+	}
+
+	const args = ["issue", "create", "--title", params.title];
+
+	if (params.body) args.push("--body", params.body);
+	if (params.labels?.length) {
+		for (const label of params.labels) args.push("--label", label);
+	}
+	if (params.assignees?.length) {
+		for (const assignee of params.assignees) args.push("--assignee", assignee);
+	}
+	if (params.milestone) args.push("--milestone", params.milestone);
+
+	onUpdate?.({ content: [{ type: "text", text: "Creating issue..." }] });
+
+	const result = await pi.exec("gh", args, { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Create issue") }],
+			details: { action: "issue-create", error: result.stderr } as GhDetails,
+			isError: true,
+		};
+	}
+
+	const issueNumber = extractIssueNumber(result.stdout);
+	const issueUrl = extractIssueUrl(result.stdout) || result.stdout.trim();
+
+	return {
+		content: [{ type: "text", text: `Created issue${issueNumber ? ` #${issueNumber}` : ""}: ${issueUrl}` }],
+		details: {
+			action: "issue-create",
+			output: result.stdout.trim(),
+			issueNumber: issueNumber ?? undefined,
+			issueUrl: issueUrl ?? undefined,
+		} as GhDetails,
+	};
+}
+
+/**
+ * Close issue (requires approval)
+ */
+export async function handleIssueClose(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for issue-close action" }],
+			details: { action: "issue-close", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const reason = params.reason || "completed";
+		const confirmed = await ctx.ui.confirm(
+			`Close issue #${params.number}?`,
+			`This will close the issue as "${reason}".`,
+		);
+		if (!confirmed) {
+			ctx.ui.notify("Close cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Close cancelled by user" }],
+				details: { action: "issue-close", cancelled: true, issueNumber: params.number } as GhDetails,
+			};
+		}
+	}
+
+	const args = ["issue", "close", String(params.number)];
+	if (params.reason) args.push("--reason", params.reason);
+
+	const result = await pi.exec("gh", args, { signal, timeout: 20000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Close issue") }],
+			details: { action: "issue-close", error: result.stderr, issueNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Closed issue #${params.number}` }],
+		details: { action: "issue-close", output: result.stdout.trim(), issueNumber: params.number } as GhDetails,
+	};
+}
+
+/**
+ * Comment on issue (requires approval)
+ */
+export async function handleIssueComment(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for issue-comment action" }],
+			details: { action: "issue-comment", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	if (!params.body) {
+		return {
+			content: [{ type: "text", text: "Error: 'body' parameter is required for issue-comment action" }],
+			details: { action: "issue-comment", error: "missing_body" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = buildCommentConfirmation("Issue", params.number, params.body);
+		const confirmed = await ctx.ui.confirm(`Comment on issue #${params.number}?`, confirmMessage);
+		if (!confirmed) {
+			ctx.ui.notify("Comment cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Comment cancelled by user" }],
+				details: { action: "issue-comment", cancelled: true, issueNumber: params.number } as GhDetails,
+			};
+		}
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Adding comment to issue #${params.number}...` }] });
+
+	const result = await pi.exec(
+		"gh",
+		["issue", "comment", String(params.number), "--body", params.body],
+		{ signal, timeout: 20000 },
+	);
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Comment on issue") }],
+			details: { action: "issue-comment", error: result.stderr, issueNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Added comment to issue #${params.number}` }],
+		details: { action: "issue-comment", output: result.stdout.trim(), issueNumber: params.number } as GhDetails,
+	};
+}
+
+/**
+ * Edit issue (requires approval)
+ */
+export async function handleIssueEdit(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for issue-edit action" }],
+			details: { action: "issue-edit", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// Build description of what we're editing
+	const changes: string[] = [];
+	if (params.title) changes.push(`Title: "${params.title}"`);
+	if (params.body) changes.push(`Body: "${truncate(params.body, 100)}"`);
+	if (params.addLabels?.length) changes.push(`Add labels: ${params.addLabels.join(", ")}`);
+	if (params.removeLabels?.length) changes.push(`Remove labels: ${params.removeLabels.join(", ")}`);
+	if (params.addAssignees?.length) changes.push(`Add assignees: ${params.addAssignees.join(", ")}`);
+	if (params.removeAssignees?.length) changes.push(`Remove assignees: ${params.removeAssignees.join(", ")}`);
+	if (params.milestone) changes.push(`Milestone: ${params.milestone}`);
+
+	if (changes.length === 0) {
+		return {
+			content: [{ type: "text", text: "Error: No fields to update specified" }],
+			details: { action: "issue-edit", error: "no_changes" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = `Issue: #${params.number}\n\nChanges:\n${changes.join("\n")}\n\nThis will modify the issue.`;
+		const confirmed = await ctx.ui.confirm(`Edit issue #${params.number}?`, confirmMessage);
+		if (!confirmed) {
+			ctx.ui.notify("Edit cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Edit cancelled by user" }],
+				details: { action: "issue-edit", cancelled: true, issueNumber: params.number } as GhDetails,
+			};
+		}
+	}
+
+	const args = ["issue", "edit", String(params.number)];
+
+	if (params.title) args.push("--title", params.title);
+	if (params.body) args.push("--body", params.body);
+	if (params.addLabels?.length) {
+		for (const label of params.addLabels) args.push("--add-label", label);
+	}
+	if (params.removeLabels?.length) {
+		for (const label of params.removeLabels) args.push("--remove-label", label);
+	}
+	if (params.addAssignees?.length) {
+		for (const assignee of params.addAssignees) args.push("--add-assignee", assignee);
+	}
+	if (params.removeAssignees?.length) {
+		for (const assignee of params.removeAssignees) args.push("--remove-assignee", assignee);
+	}
+	if (params.milestone) args.push("--milestone", params.milestone);
+
+	onUpdate?.({ content: [{ type: "text", text: `Editing issue #${params.number}...` }] });
+
+	const result = await pi.exec("gh", args, { signal, timeout: 20000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Edit issue") }],
+			details: { action: "issue-edit", error: result.stderr, issueNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Updated issue #${params.number}: ${changes.join("; ")}` }],
+		details: {
+			action: "issue-edit",
+			output: result.stdout.trim(),
+			issueNumber: params.number,
+		} as GhDetails,
+	};
+}

@@ -0,0 +1,610 @@
+/**
+ * Pull Request action handlers for GitHub extension
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { GhDetails } from "../types";
+import {
+	parsePRList,
+	parsePRItem,
+	getErrorMessage,
+	extractPRNumber,
+	extractPRUrl,
+	buildPRCreateConfirmation,
+	buildPRMergeConfirmation,
+	buildReviewConfirmation,
+	buildCommentConfirmation,
+	truncate,
+	getReviewDecisionText,
+} from "../utils";
+
+const PR_LIST_FIELDS = "number,title,state,author,headRefName,baseRefName,url,isDraft,labels,reviewDecision,additions,deletions,changedFiles,createdAt,updatedAt";
+
+/**
+ * List pull requests
+ */
+export async function handlePRList(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+	currentUser: string,
+): Promise<any> {
+	const args = ["pr", "list", "--json", PR_LIST_FIELDS];
+
+	if (params.state) args.push("--state", params.state);
+	if (params.author) {
+		args.push("--author", params.author === "me" ? (currentUser || "@me") : params.author);
+	}
+	if (params.label) args.push("--label", params.label);
+	if (params.base) args.push("--base", params.base);
+	if (params.limit) args.push("--limit", String(params.limit));
+	else args.push("--limit", "20");
+
+	onUpdate?.({ content: [{ type: "text", text: "Fetching PRs..." }] });
+
+	const result = await pi.exec("gh", args, { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "List PRs") }],
+			details: { action: "pr-list", error: result.stderr } as GhDetails,
+			isError: true,
+		};
+	}
+
+	const prs = parsePRList(result.stdout);
+
+	let output = "";
+	if (prs.length === 0) {
+		output = "No pull requests found.";
+	} else {
+		output = prs
+			.map((pr) => {
+				const draft = pr.isDraft ? " [draft]" : "";
+				const review = pr.reviewDecision ? ` (${getReviewDecisionText(pr.reviewDecision)})` : "";
+				const changes = `+${pr.additions}/-${pr.deletions}`;
+				return `#${pr.number} ${pr.title}${draft}${review} (${pr.branch} → ${pr.base}) ${changes} @${pr.author}`;
+			})
+			.join("\n");
+	}
+
+	const prNumbers = prs.map((p) => p.number);
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "pr-list", output, prNumbers } as GhDetails,
+	};
+}
+
+/**
+ * View pull request details
+ */
+export async function handlePRView(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for pr-view action" }],
+			details: { action: "pr-view", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Fetching PR #${params.number}...` }] });
+
+	const fields = `${PR_LIST_FIELDS},body,mergeStateStatus,statusCheckRollup,reviews,comments`;
+	const result = await pi.exec("gh", ["pr", "view", String(params.number), "--json", fields], {
+		signal,
+		timeout: 30000,
+	});
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "View PR") }],
+			details: { action: "pr-view", error: result.stderr, prNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	let data: any;
+	try {
+		data = JSON.parse(result.stdout);
+	} catch {
+		return {
+			content: [{ type: "text", text: result.stdout }],
+			details: { action: "pr-view", output: result.stdout, prNumber: params.number } as GhDetails,
+		};
+	}
+
+	const pr = parsePRItem(data);
+
+	// Build readable output
+	let output = "";
+	output += `# PR #${pr.number}: ${pr.title}\n\n`;
+	output += `State: ${pr.state}${pr.isDraft ? " (draft)" : ""}\n`;
+	output += `Author: @${pr.author}\n`;
+	output += `Branch: ${pr.branch} → ${pr.base}\n`;
+	output += `Review: ${getReviewDecisionText(pr.reviewDecision)}\n`;
+	output += `Changes: ${pr.changedFiles} files (+${pr.additions}/-${pr.deletions})\n`;
+	output += `URL: ${pr.url}\n`;
+
+	if (pr.labels.length > 0) {
+		output += `Labels: ${pr.labels.join(", ")}\n`;
+	}
+
+	if (data.body) {
+		output += `\n## Description\n\n${data.body}\n`;
+	}
+
+	// Checks summary
+	const checks = data.statusCheckRollup ?? [];
+	if (checks.length > 0) {
+		const passed = checks.filter((c: any) => c.conclusion === "SUCCESS").length;
+		const failed = checks.filter((c: any) => c.conclusion === "FAILURE").length;
+		const pending = checks.filter((c: any) => !c.conclusion || c.status === "IN_PROGRESS" || c.status === "QUEUED").length;
+		output += `\n## Checks: ${passed} passed, ${failed} failed, ${pending} pending\n\n`;
+		for (const check of checks) {
+			const icon = check.conclusion === "SUCCESS" ? "✓" : check.conclusion === "FAILURE" ? "✗" : "⏳";
+			output += `${icon} ${check.name ?? check.context ?? "?"} (${check.conclusion || check.status || "pending"})\n`;
+		}
+	}
+
+	// Reviews summary
+	const reviews = data.reviews ?? [];
+	if (reviews.length > 0) {
+		output += `\n## Reviews\n\n`;
+		for (const review of reviews) {
+			output += `@${review.author?.login ?? "?"}: ${review.state}`;
+			if (review.body) output += ` - ${truncate(review.body, 100)}`;
+			output += "\n";
+		}
+	}
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "pr-view", output, prNumber: pr.number, prUrl: pr.url } as GhDetails,
+	};
+}
+
+/**
+ * View PR diff
+ */
+export async function handlePRDiff(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for pr-diff action" }],
+			details: { action: "pr-diff", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Fetching diff for PR #${params.number}...` }] });
+
+	const result = await pi.exec("gh", ["pr", "diff", String(params.number)], { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "PR diff") }],
+			details: { action: "pr-diff", error: result.stderr, prNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	const diff = result.stdout;
+	// Truncate if very large
+	const maxLen = 50000;
+	const output = diff.length > maxLen ? diff.slice(0, maxLen) + "\n\n[... diff truncated, use `gh pr diff` for full output]" : diff;
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "pr-diff", output: `Diff for PR #${params.number} (${diff.length} chars)`, prNumber: params.number } as GhDetails,
+	};
+}
+
+/**
+ * Create pull request (requires approval)
+ */
+export async function handlePRCreate(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.title) {
+		return {
+			content: [{ type: "text", text: "Error: 'title' parameter is required for pr-create action" }],
+			details: { action: "pr-create", error: "missing_title" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = buildPRCreateConfirmation(params);
+		const confirmed = await ctx.ui.confirm("Create Pull Request?", confirmMessage);
+		if (!confirmed) {
+			ctx.ui.notify("PR creation cancelled", "info");
+			return {
+				content: [{ type: "text", text: "PR creation cancelled by user" }],
+				details: { action: "pr-create", cancelled: true } as GhDetails,
+			};
+		}
+	}
+
+	const args = ["pr", "create", "--title", params.title];
+
+	if (params.body) args.push("--body", params.body);
+	if (params.base) args.push("--base", params.base);
+	if (params.draft) args.push("--draft");
+	if (params.labels?.length) {
+		for (const label of params.labels) args.push("--label", label);
+	}
+	if (params.reviewers?.length) {
+		for (const reviewer of params.reviewers) args.push("--reviewer", reviewer);
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: "Creating PR..." }] });
+
+	const result = await pi.exec("gh", args, { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Create PR") }],
+			details: { action: "pr-create", error: result.stderr } as GhDetails,
+			isError: true,
+		};
+	}
+
+	const prNumber = extractPRNumber(result.stdout);
+	const prUrl = extractPRUrl(result.stdout) || result.stdout.trim();
+
+	return {
+		content: [{ type: "text", text: `Created PR${prNumber ? ` #${prNumber}` : ""}: ${prUrl}` }],
+		details: { action: "pr-create", output: result.stdout.trim(), prNumber: prNumber ?? undefined, prUrl: prUrl ?? undefined } as GhDetails,
+	};
+}
+
+/**
+ * Checkout PR locally
+ */
+export async function handlePRCheckout(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for pr-checkout action" }],
+			details: { action: "pr-checkout", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Checking out PR #${params.number}...` }] });
+
+	const result = await pi.exec("gh", ["pr", "checkout", String(params.number)], { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Checkout PR") }],
+			details: { action: "pr-checkout", error: result.stderr, prNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Checked out PR #${params.number}\n${result.stdout.trim()}` }],
+		details: { action: "pr-checkout", output: result.stdout.trim(), prNumber: params.number } as GhDetails,
+	};
+}
+
+/**
+ * Merge pull request (requires approval)
+ */
+export async function handlePRMerge(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for pr-merge action" }],
+			details: { action: "pr-merge", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = buildPRMergeConfirmation(params);
+		const confirmed = await ctx.ui.confirm(`Merge PR #${params.number}?`, confirmMessage);
+		if (!confirmed) {
+			ctx.ui.notify("Merge cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Merge cancelled by user" }],
+				details: { action: "pr-merge", cancelled: true, prNumber: params.number } as GhDetails,
+			};
+		}
+	}
+
+	const args = ["pr", "merge", String(params.number)];
+
+	const method = params.method || "merge";
+	if (method === "squash") args.push("--squash");
+	else if (method === "rebase") args.push("--rebase");
+	else args.push("--merge");
+
+	if (params.deleteBranch) args.push("--delete-branch");
+
+	onUpdate?.({ content: [{ type: "text", text: `Merging PR #${params.number}...` }] });
+
+	const result = await pi.exec("gh", args, { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Merge PR") }],
+			details: { action: "pr-merge", error: result.stderr, prNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Merged PR #${params.number} (${method})\n${result.stdout.trim()}` }],
+		details: { action: "pr-merge", output: result.stdout.trim(), prNumber: params.number, mergeMethod: method } as GhDetails,
+	};
+}
+
+/**
+ * Submit PR review (requires approval)
+ */
+export async function handlePRReview(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for pr-review action" }],
+			details: { action: "pr-review", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	if (!params.reviewAction) {
+		return {
+			content: [{ type: "text", text: "Error: 'reviewAction' parameter is required (approve, request-changes, comment)" }],
+			details: { action: "pr-review", error: "missing_review_action" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = buildReviewConfirmation(params);
+		const confirmed = await ctx.ui.confirm(`Submit review on PR #${params.number}?`, confirmMessage);
+		if (!confirmed) {
+			ctx.ui.notify("Review cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Review cancelled by user" }],
+				details: { action: "pr-review", cancelled: true, prNumber: params.number } as GhDetails,
+			};
+		}
+	}
+
+	const args = ["pr", "review", String(params.number)];
+
+	switch (params.reviewAction) {
+		case "approve":
+			args.push("--approve");
+			break;
+		case "request-changes":
+			args.push("--request-changes");
+			break;
+		case "comment":
+			args.push("--comment");
+			break;
+	}
+
+	if (params.body) args.push("--body", params.body);
+
+	onUpdate?.({ content: [{ type: "text", text: `Submitting review on PR #${params.number}...` }] });
+
+	const result = await pi.exec("gh", args, { signal, timeout: 30000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Submit review") }],
+			details: { action: "pr-review", error: result.stderr, prNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Submitted ${params.reviewAction} review on PR #${params.number}` }],
+		details: {
+			action: "pr-review",
+			output: result.stdout.trim(),
+			prNumber: params.number,
+			reviewAction: params.reviewAction,
+		} as GhDetails,
+	};
+}
+
+/**
+ * Comment on a PR (requires approval)
+ */
+export async function handlePRComment(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for pr-comment action" }],
+			details: { action: "pr-comment", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	if (!params.body) {
+		return {
+			content: [{ type: "text", text: "Error: 'body' parameter is required for pr-comment action" }],
+			details: { action: "pr-comment", error: "missing_body" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmMessage = buildCommentConfirmation("PR", params.number, params.body);
+		const confirmed = await ctx.ui.confirm(`Comment on PR #${params.number}?`, confirmMessage);
+		if (!confirmed) {
+			ctx.ui.notify("Comment cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Comment cancelled by user" }],
+				details: { action: "pr-comment", cancelled: true, prNumber: params.number } as GhDetails,
+			};
+		}
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Adding comment to PR #${params.number}...` }] });
+
+	const result = await pi.exec("gh", ["pr", "comment", String(params.number), "--body", params.body], {
+		signal,
+		timeout: 20000,
+	});
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Comment on PR") }],
+			details: { action: "pr-comment", error: result.stderr, prNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Added comment to PR #${params.number}` }],
+		details: { action: "pr-comment", output: result.stdout.trim(), prNumber: params.number } as GhDetails,
+	};
+}
+
+/**
+ * Mark draft PR as ready for review (requires approval)
+ */
+export async function handlePRReady(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for pr-ready action" }],
+			details: { action: "pr-ready", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmed = await ctx.ui.confirm(
+			`Mark PR #${params.number} as ready?`,
+			"This will mark the draft PR as ready for review.",
+		);
+		if (!confirmed) {
+			ctx.ui.notify("Cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Operation cancelled by user" }],
+				details: { action: "pr-ready", cancelled: true, prNumber: params.number } as GhDetails,
+			};
+		}
+	}
+
+	onUpdate?.({ content: [{ type: "text", text: `Marking PR #${params.number} as ready...` }] });
+
+	const result = await pi.exec("gh", ["pr", "ready", String(params.number)], { signal, timeout: 20000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Mark PR ready") }],
+			details: { action: "pr-ready", error: result.stderr, prNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `PR #${params.number} marked as ready for review` }],
+		details: { action: "pr-ready", output: result.stdout.trim(), prNumber: params.number } as GhDetails,
+	};
+}
+
+/**
+ * Close a PR (requires approval)
+ */
+export async function handlePRClose(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	if (!params.number) {
+		return {
+			content: [{ type: "text", text: "Error: 'number' parameter is required for pr-close action" }],
+			details: { action: "pr-close", error: "missing_number" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	// APPROVAL GATE
+	if (ctx.hasUI) {
+		const confirmed = await ctx.ui.confirm(
+			`Close PR #${params.number}?`,
+			"This will close the pull request without merging.",
+		);
+		if (!confirmed) {
+			ctx.ui.notify("Cancelled", "info");
+			return {
+				content: [{ type: "text", text: "Close cancelled by user" }],
+				details: { action: "pr-close", cancelled: true, prNumber: params.number } as GhDetails,
+			};
+		}
+	}
+
+	const result = await pi.exec("gh", ["pr", "close", String(params.number)], { signal, timeout: 20000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "Close PR") }],
+			details: { action: "pr-close", error: result.stderr, prNumber: params.number } as GhDetails,
+			isError: true,
+		};
+	}
+
+	return {
+		content: [{ type: "text", text: `Closed PR #${params.number}` }],
+		details: { action: "pr-close", output: result.stdout.trim(), prNumber: params.number } as GhDetails,
+	};
+}

@@ -0,0 +1,123 @@
+/**
+ * Repository action handlers for GitHub extension
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { GhDetails } from "../types";
+import { parseRepo, parseReleaseList, getErrorMessage, formatRelativeDate } from "../utils";
+
+/**
+ * View repository info
+ */
+export async function handleRepoView(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	onUpdate?.({ content: [{ type: "text", text: "Fetching repo info..." }] });
+
+	const result = await pi.exec(
+		"gh",
+		[
+			"repo",
+			"view",
+			"--json",
+			"nameWithOwner,description,defaultBranchRef,visibility,url,stargazerCount,forkCount,isArchived",
+		],
+		{ signal, timeout: 20000 },
+	);
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "View repo") }],
+			details: { action: "repo-view", error: result.stderr } as GhDetails,
+			isError: true,
+		};
+	}
+
+	const repo = parseRepo(result.stdout);
+	if (!repo) {
+		return {
+			content: [{ type: "text", text: "Could not parse repository information" }],
+			details: { action: "repo-view", error: "parse_error" } as GhDetails,
+			isError: true,
+		};
+	}
+
+	let output = `# ${repo.nameWithOwner}\n\n`;
+	if (repo.description) output += `${repo.description}\n\n`;
+	output += `Visibility: ${repo.visibility}\n`;
+	output += `Default branch: ${repo.defaultBranch}\n`;
+	output += `Stars: ${repo.stargazerCount} | Forks: ${repo.forkCount}\n`;
+	output += `URL: ${repo.url}\n`;
+	if (repo.isArchived) output += `⚠️ This repository is archived\n`;
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "repo-view", output } as GhDetails,
+	};
+}
+
+/**
+ * List releases
+ */
+export async function handleReleaseList(
+	pi: ExtensionAPI,
+	params: any,
+	signal: AbortSignal | undefined,
+	onUpdate: any,
+	ctx: ExtensionContext,
+): Promise<any> {
+	const args = [
+		"release",
+		"list",
+		"--json",
+		"tagName,name,isDraft,isPrerelease,publishedAt",
+	];
+
+	if (params.limit) args.push("--limit", String(params.limit));
+	else args.push("--limit", "10");
+
+	onUpdate?.({ content: [{ type: "text", text: "Fetching releases..." }] });
+
+	const result = await pi.exec("gh", args, { signal, timeout: 20000 });
+
+	if (result.code !== 0) {
+		return {
+			content: [{ type: "text", text: getErrorMessage(result.stderr, "List releases") }],
+			details: { action: "release-list", error: result.stderr } as GhDetails,
+			isError: true,
+		};
+	}
+
+	const releases = parseReleaseList(result.stdout);
+
+	if (releases.length === 0) {
+		return {
+			content: [{ type: "text", text: "No releases found." }],
+			details: { action: "release-list", output: "No releases found" } as GhDetails,
+		};
+	}
+
+	let output = `Releases (${releases.length}):\n\n`;
+	for (const release of releases) {
+		const flags: string[] = [];
+		if (release.isDraft) flags.push("draft");
+		if (release.isPrerelease) flags.push("pre-release");
+		const flagStr = flags.length > 0 ? ` [${flags.join(", ")}]` : "";
+		const date = formatRelativeDate(release.publishedAt);
+
+		output += `${release.tagName}`;
+		if (release.name && release.name !== release.tagName) output += ` - ${release.name}`;
+		output += `${flagStr}`;
+		if (date) output += ` (${date})`;
+		output += "\n";
+	}
+
+	return {
+		content: [{ type: "text", text: output }],
+		details: { action: "release-list", output } as GhDetails,
+	};
+}

@@ -0,0 +1,655 @@
+/**
+ * Tests for GitHub extension
+ *
+ * Run with: bun test github.test.ts
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+	parsePRList,
+	parsePRItem,
+	parseIssueList,
+	parseIssueItem,
+	parseChecks,
+	parseRunList,
+	parseReviews,
+	parseReleaseList,
+	parseRepo,
+	truncate,
+	formatDate,
+	formatRelativeDate,
+	getPRStateIcon,
+	getCheckIcon,
+	getRunStatusIcon,
+	getReviewDecisionText,
+	buildPRCreateConfirmation,
+	buildPRMergeConfirmation,
+	buildReviewConfirmation,
+	buildIssueCreateConfirmation,
+	buildCommentConfirmation,
+	isAuthError,
+	isNotFoundError,
+	isRepoError,
+	getErrorMessage,
+	extractPRNumber,
+	extractIssueNumber,
+	extractPRUrl,
+	extractIssueUrl,
+} from "./utils";
+
+// ============================================================================
+// Parsing Tests
+// ============================================================================
+
+describe("PR Parsing", () => {
+	test("parsePRList parses JSON array", () => {
+		const json = JSON.stringify([
+			{
+				number: 123,
+				title: "feat: add feature",
+				state: "OPEN",
+				author: { login: "alice" },
+				headRefName: "feat/feature",
+				baseRefName: "main",
+				url: "https://github.com/org/repo/pull/123",
+				isDraft: false,
+				labels: [{ name: "enhancement" }],
+				reviewDecision: "APPROVED",
+				additions: 50,
+				deletions: 10,
+				changedFiles: 3,
+				createdAt: "2025-01-01T00:00:00Z",
+				updatedAt: "2025-01-02T00:00:00Z",
+			},
+		]);
+
+		const prs = parsePRList(json);
+		expect(prs.length).toBe(1);
+		expect(prs[0].number).toBe(123);
+		expect(prs[0].title).toBe("feat: add feature");
+		expect(prs[0].author).toBe("alice");
+		expect(prs[0].branch).toBe("feat/feature");
+		expect(prs[0].base).toBe("main");
+		expect(prs[0].isDraft).toBe(false);
+		expect(prs[0].labels).toEqual(["enhancement"]);
+		expect(prs[0].reviewDecision).toBe("APPROVED");
+		expect(prs[0].additions).toBe(50);
+		expect(prs[0].deletions).toBe(10);
+		expect(prs[0].changedFiles).toBe(3);
+	});
+
+	test("parsePRList handles empty array", () => {
+		expect(parsePRList("[]")).toEqual([]);
+	});
+
+	test("parsePRList handles invalid JSON", () => {
+		expect(parsePRList("not json")).toEqual([]);
+	});
+
+	test("parsePRItem handles missing fields gracefully", () => {
+		const pr = parsePRItem({});
+		expect(pr.number).toBe(0);
+		expect(pr.title).toBe("");
+		expect(pr.author).toBe("");
+		expect(pr.isDraft).toBe(false);
+		expect(pr.labels).toEqual([]);
+		expect(pr.additions).toBe(0);
+	});
+
+	test("parsePRList handles draft PRs", () => {
+		const json = JSON.stringify([
+			{
+				number: 456,
+				title: "WIP: draft PR",
+				state: "OPEN",
+				author: { login: "bob" },
+				isDraft: true,
+				headRefName: "wip",
+				baseRefName: "main",
+			},
+		]);
+
+		const prs = parsePRList(json);
+		expect(prs[0].isDraft).toBe(true);
+	});
+
+	test("parsePRList handles merged PRs", () => {
+		const json = JSON.stringify([
+			{
+				number: 789,
+				title: "Merged PR",
+				state: "MERGED",
+				author: { login: "carol" },
+				headRefName: "merged-branch",
+				baseRefName: "main",
+			},
+		]);
+
+		const prs = parsePRList(json);
+		expect(prs[0].state).toBe("MERGED");
+	});
+});
+
+describe("Issue Parsing", () => {
+	test("parseIssueList parses JSON array", () => {
+		const json = JSON.stringify([
+			{
+				number: 42,
+				title: "Bug: login broken",
+				state: "OPEN",
+				author: { login: "alice" },
+				url: "https://github.com/org/repo/issues/42",
+				labels: [{ name: "bug" }, { name: "priority:high" }],
+				assignees: [{ login: "bob" }],
+				createdAt: "2025-01-01T00:00:00Z",
+				updatedAt: "2025-01-02T00:00:00Z",
+				body: "Login is broken on mobile",
+				comments: { totalCount: 5 },
+			},
+		]);
+
+		const issues = parseIssueList(json);
+		expect(issues.length).toBe(1);
+		expect(issues[0].number).toBe(42);
+		expect(issues[0].title).toBe("Bug: login broken");
+		expect(issues[0].state).toBe("OPEN");
+		expect(issues[0].labels).toEqual(["bug", "priority:high"]);
+		expect(issues[0].assignees).toEqual(["bob"]);
+		expect(issues[0].comments).toBe(5);
+	});
+
+	test("parseIssueList handles empty array", () => {
+		expect(parseIssueList("[]")).toEqual([]);
+	});
+
+	test("parseIssueList handles invalid JSON", () => {
+		expect(parseIssueList("invalid")).toEqual([]);
+	});
+
+	test("parseIssueItem handles missing fields", () => {
+		const issue = parseIssueItem({});
+		expect(issue.number).toBe(0);
+		expect(issue.title).toBe("");
+		expect(issue.labels).toEqual([]);
+		expect(issue.assignees).toEqual([]);
+		expect(issue.comments).toBe(0);
+	});
+
+	test("parseIssueItem handles numeric comments", () => {
+		const issue = parseIssueItem({ comments: 10 });
+		expect(issue.comments).toBe(10);
+	});
+});
+
+describe("Checks Parsing", () => {
+	test("parseChecks parses statusCheckRollup object", () => {
+		const json = JSON.stringify({
+			statusCheckRollup: [
+				{
+					name: "CI Tests",
+					status: "COMPLETED",
+					conclusion: "SUCCESS",
+					startedAt: "2025-01-01T00:00:00Z",
+					completedAt: "2025-01-01T00:05:00Z",
+					detailsUrl: "https://github.com/org/repo/actions/runs/123",
+				},
+				{
+					name: "Lint",
+					status: "COMPLETED",
+					conclusion: "FAILURE",
+					startedAt: "2025-01-01T00:00:00Z",
+					completedAt: "2025-01-01T00:02:00Z",
+				},
+				{
+					name: "E2E",
+					status: "IN_PROGRESS",
+					conclusion: "",
+				},
+			],
+		});
+
+		const checks = parseChecks(json);
+		expect(checks.length).toBe(3);
+		expect(checks[0].name).toBe("CI Tests");
+		expect(checks[0].conclusion).toBe("SUCCESS");
+		expect(checks[1].name).toBe("Lint");
+		expect(checks[1].conclusion).toBe("FAILURE");
+		expect(checks[2].name).toBe("E2E");
+		expect(checks[2].status).toBe("IN_PROGRESS");
+	});
+
+	test("parseChecks handles plain array", () => {
+		const json = JSON.stringify([
+			{ name: "test", status: "COMPLETED", conclusion: "SUCCESS" },
+		]);
+
+		const checks = parseChecks(json);
+		expect(checks.length).toBe(1);
+		expect(checks[0].name).toBe("test");
+	});
+
+	test("parseChecks handles context field (status checks)", () => {
+		const json = JSON.stringify({
+			statusCheckRollup: [
+				{ context: "ci/jenkins", status: "COMPLETED", conclusion: "SUCCESS", targetUrl: "https://ci.example.com" },
+			],
+		});
+
+		const checks = parseChecks(json);
+		expect(checks[0].name).toBe("ci/jenkins");
+		expect(checks[0].detailsUrl).toBe("https://ci.example.com");
+	});
+
+	test("parseChecks handles empty", () => {
+		expect(parseChecks("{}")).toEqual([]);
+		expect(parseChecks("invalid")).toEqual([]);
+	});
+});
+
+describe("Run Parsing", () => {
+	test("parseRunList parses JSON array", () => {
+		const json = JSON.stringify([
+			{
+				databaseId: 12345,
+				name: "CI",
+				displayTitle: "feat: add feature",
+				status: "completed",
+				conclusion: "success",
+				headBranch: "main",
+				event: "push",
+				url: "https://github.com/org/repo/actions/runs/12345",
+				createdAt: "2025-01-01T00:00:00Z",
+				updatedAt: "2025-01-01T00:05:00Z",
+			},
+		]);
+
+		const runs = parseRunList(json);
+		expect(runs.length).toBe(1);
+		expect(runs[0].databaseId).toBe(12345);
+		expect(runs[0].name).toBe("CI");
+		expect(runs[0].conclusion).toBe("success");
+		expect(runs[0].headBranch).toBe("main");
+	});
+
+	test("parseRunList handles empty", () => {
+		expect(parseRunList("[]")).toEqual([]);
+		expect(parseRunList("invalid")).toEqual([]);
+	});
+});
+
+describe("Review Parsing", () => {
+	test("parseReviews parses reviews object", () => {
+		const json = JSON.stringify({
+			reviews: [
+				{
+					author: { login: "alice" },
+					state: "APPROVED",
+					body: "LGTM",
+					submittedAt: "2025-01-01T00:00:00Z",
+				},
+				{
+					author: { login: "bob" },
+					state: "CHANGES_REQUESTED",
+					body: "Please fix the error handling",
+					submittedAt: "2025-01-01T01:00:00Z",
+				},
+			],
+		});
+
+		const reviews = parseReviews(json);
+		expect(reviews.length).toBe(2);
+		expect(reviews[0].author).toBe("alice");
+		expect(reviews[0].state).toBe("APPROVED");
+		expect(reviews[1].author).toBe("bob");
+		expect(reviews[1].state).toBe("CHANGES_REQUESTED");
+	});
+
+	test("parseReviews handles empty", () => {
+		expect(parseReviews("{}")).toEqual([]);
+	});
+});
+
+describe("Release Parsing", () => {
+	test("parseReleaseList parses JSON", () => {
+		const json = JSON.stringify([
+			{
+				tagName: "v1.0.0",
+				name: "Release 1.0.0",
+				isDraft: false,
+				isPrerelease: false,
+				publishedAt: "2025-01-01T00:00:00Z",
+				url: "https://github.com/org/repo/releases/tag/v1.0.0",
+			},
+		]);
+
+		const releases = parseReleaseList(json);
+		expect(releases.length).toBe(1);
+		expect(releases[0].tagName).toBe("v1.0.0");
+		expect(releases[0].name).toBe("Release 1.0.0");
+		expect(releases[0].isDraft).toBe(false);
+	});
+
+	test("parseReleaseList handles empty", () => {
+		expect(parseReleaseList("[]")).toEqual([]);
+		expect(parseReleaseList("invalid")).toEqual([]);
+	});
+});
+
+describe("Repo Parsing", () => {
+	test("parseRepo parses repo JSON", () => {
+		const json = JSON.stringify({
+			nameWithOwner: "org/repo",
+			description: "A test repo",
+			defaultBranchRef: { name: "main" },
+			visibility: "PUBLIC",
+			url: "https://github.com/org/repo",
+			stargazerCount: 100,
+			forkCount: 20,
+			isArchived: false,
+		});
+
+		const repo = parseRepo(json);
+		expect(repo).not.toBeNull();
+		expect(repo!.nameWithOwner).toBe("org/repo");
+		expect(repo!.description).toBe("A test repo");
+		expect(repo!.defaultBranch).toBe("main");
+		expect(repo!.visibility).toBe("PUBLIC");
+		expect(repo!.stargazerCount).toBe(100);
+		expect(repo!.isArchived).toBe(false);
+	});
+
+	test("parseRepo handles defaultBranch string", () => {
+		const json = JSON.stringify({ defaultBranch: "develop" });
+		const repo = parseRepo(json);
+		expect(repo!.defaultBranch).toBe("develop");
+	});
+
+	test("parseRepo handles invalid JSON", () => {
+		expect(parseRepo("invalid")).toBeNull();
+	});
+});
+
+// ============================================================================
+// Formatting Tests
+// ============================================================================
+
+describe("Formatting", () => {
+	test("truncate shortens long text", () => {
+		expect(truncate("This is a very long text", 15)).toBe("This is a ve...");
+		expect(truncate("This is a very long text", 15).length).toBe(15);
+	});
+
+	test("truncate preserves short text", () => {
+		expect(truncate("Short", 20)).toBe("Short");
+	});
+
+	test("truncate handles exact length", () => {
+		expect(truncate("Exactly 10", 10)).toBe("Exactly 10");
+	});
+
+	test("formatDate formats ISO date", () => {
+		const result = formatDate("2025-06-15T10:30:00Z");
+		expect(result).toBeTruthy();
+		expect(result).not.toBe("");
+	});
+
+	test("formatDate handles empty", () => {
+		expect(formatDate("")).toBe("");
+	});
+
+	test("formatRelativeDate returns relative time", () => {
+		const now = new Date();
+		const fiveMinAgo = new Date(now.getTime() - 5 * 60000).toISOString();
+		expect(formatRelativeDate(fiveMinAgo)).toBe("5m ago");
+
+		const twoHoursAgo = new Date(now.getTime() - 2 * 3600000).toISOString();
+		expect(formatRelativeDate(twoHoursAgo)).toBe("2h ago");
+
+		const threeDaysAgo = new Date(now.getTime() - 3 * 86400000).toISOString();
+		expect(formatRelativeDate(threeDaysAgo)).toBe("3d ago");
+	});
+
+	test("formatRelativeDate handles just now", () => {
+		const now = new Date().toISOString();
+		const result = formatRelativeDate(now);
+		expect(result === "just now" || result === "1m ago").toBe(true);
+	});
+
+	test("formatRelativeDate handles empty", () => {
+		expect(formatRelativeDate("")).toBe("");
+	});
+});
+
+// ============================================================================
+// Icon/Status Tests
+// ============================================================================
+
+describe("Status Icons", () => {
+	test("getPRStateIcon returns correct icons", () => {
+		expect(getPRStateIcon({ state: "MERGED" } as any)).toBe("⏣");
+		expect(getPRStateIcon({ state: "CLOSED" } as any)).toBe("✗");
+		expect(getPRStateIcon({ state: "OPEN", isDraft: true } as any)).toBe("◌");
+		expect(getPRStateIcon({ state: "OPEN", isDraft: false } as any)).toBe("●");
+	});
+
+	test("getCheckIcon returns correct icons", () => {
+		expect(getCheckIcon({ conclusion: "SUCCESS" } as any)).toBe("✓");
+		expect(getCheckIcon({ conclusion: "FAILURE" } as any)).toBe("✗");
+		expect(getCheckIcon({ conclusion: "CANCELLED" } as any)).toBe("⊘");
+		expect(getCheckIcon({ conclusion: "SKIPPED" } as any)).toBe("⊘");
+		expect(getCheckIcon({ status: "IN_PROGRESS", conclusion: "" } as any)).toBe("⏳");
+		expect(getCheckIcon({ status: "QUEUED", conclusion: "" } as any)).toBe("⏳");
+	});
+
+	test("getRunStatusIcon returns correct icons", () => {
+		expect(getRunStatusIcon({ conclusion: "success" } as any)).toBe("✓");
+		expect(getRunStatusIcon({ conclusion: "failure" } as any)).toBe("✗");
+		expect(getRunStatusIcon({ conclusion: "cancelled" } as any)).toBe("⊘");
+		expect(getRunStatusIcon({ status: "in_progress", conclusion: "" } as any)).toBe("⏳");
+	});
+
+	test("getReviewDecisionText returns human-readable text", () => {
+		expect(getReviewDecisionText("APPROVED")).toBe("✓ Approved");
+		expect(getReviewDecisionText("CHANGES_REQUESTED")).toBe("✗ Changes requested");
+		expect(getReviewDecisionText("REVIEW_REQUIRED")).toBe("⏳ Review required");
+		expect(getReviewDecisionText("")).toBe("No reviews");
+	});
+});
+
+// ============================================================================
+// Confirmation Builder Tests
+// ============================================================================
+
+describe("Confirmation Builders", () => {
+	test("buildPRCreateConfirmation includes all fields", () => {
+		const msg = buildPRCreateConfirmation({
+			title: "feat: add feature",
+			body: "Description",
+			base: "main",
+			draft: true,
+			labels: ["enhancement"],
+			reviewers: ["alice"],
+		});
+
+		expect(msg).toContain("feat: add feature");
+		expect(msg).toContain("Base: main");
+		expect(msg).toContain("Body: Description");
+		expect(msg).toContain("Draft: yes");
+		expect(msg).toContain("Labels: enhancement");
+		expect(msg).toContain("Reviewers: alice");
+		expect(msg).toContain("create a new pull request");
+	});
+
+	test("buildPRCreateConfirmation handles minimal", () => {
+		const msg = buildPRCreateConfirmation({ title: "fix: bug" });
+		expect(msg).toContain("fix: bug");
+		expect(msg).not.toContain("Base:");
+		expect(msg).not.toContain("Draft:");
+	});
+
+	test("buildPRCreateConfirmation truncates long body", () => {
+		const msg = buildPRCreateConfirmation({
+			title: "test",
+			body: "a".repeat(300),
+		});
+		expect(msg).toContain("...");
+	});
+
+	test("buildPRMergeConfirmation includes method", () => {
+		const msg = buildPRMergeConfirmation({ number: 123, method: "squash", deleteBranch: true });
+		expect(msg).toContain("#123");
+		expect(msg).toContain("squash");
+		expect(msg).toContain("Delete branch: yes");
+	});
+
+	test("buildReviewConfirmation includes action", () => {
+		const msg = buildReviewConfirmation({ number: 456, reviewAction: "approve", body: "LGTM" });
+		expect(msg).toContain("#456");
+		expect(msg).toContain("approve");
+		expect(msg).toContain("LGTM");
+	});
+
+	test("buildIssueCreateConfirmation includes all fields", () => {
+		const msg = buildIssueCreateConfirmation({
+			title: "Bug report",
+			body: "Steps to reproduce",
+			labels: ["bug"],
+			assignees: ["alice"],
+		});
+
+		expect(msg).toContain("Bug report");
+		expect(msg).toContain("Steps to reproduce");
+		expect(msg).toContain("bug");
+		expect(msg).toContain("alice");
+	});
+
+	test("buildCommentConfirmation includes preview", () => {
+		const msg = buildCommentConfirmation("PR", 123, "Great work!");
+		expect(msg).toContain("PR: #123");
+		expect(msg).toContain("Great work!");
+		expect(msg).toContain("public comment");
+	});
+
+	test("buildCommentConfirmation truncates long comment", () => {
+		const msg = buildCommentConfirmation("Issue", 42, "a".repeat(300));
+		expect(msg).toContain("...");
+	});
+});
+
+// ============================================================================
+// Error Handling Tests
+// ============================================================================
+
+describe("Error Handling", () => {
+	test("isAuthError detects auth failures", () => {
+		expect(isAuthError("authentication required")).toBe(true);
+		expect(isAuthError("unauthorized")).toBe(true);
+		expect(isAuthError("not logged in to any github hosts")).toBe(true);
+		expect(isAuthError("try: gh auth login")).toBe(true);
+		expect(isAuthError("network timeout")).toBe(false);
+	});
+
+	test("isNotFoundError detects not found", () => {
+		expect(isNotFoundError("not found")).toBe(true);
+		expect(isNotFoundError("could not resolve to a repository")).toBe(true);
+		expect(isNotFoundError("authentication failed")).toBe(false);
+	});
+
+	test("isRepoError detects repo errors", () => {
+		expect(isRepoError("not a git repository")).toBe(true);
+		expect(isRepoError("no git remotes found")).toBe(true);
+		expect(isRepoError("authentication failed")).toBe(false);
+	});
+
+	test("getErrorMessage returns helpful messages", () => {
+		expect(getErrorMessage("not logged in", "list")).toContain("gh auth login");
+		expect(getErrorMessage("not a git repository", "view")).toContain("Not in a GitHub repository");
+		expect(getErrorMessage("not found", "view")).toContain("not found");
+		expect(getErrorMessage("something else", "create")).toBe("something else");
+	});
+});
+
+// ============================================================================
+// Extraction Tests
+// ============================================================================
+
+describe("URL/Number Extraction", () => {
+	test("extractPRNumber from URL", () => {
+		expect(extractPRNumber("https://github.com/org/repo/pull/123")).toBe(123);
+	});
+
+	test("extractPRNumber from hash format", () => {
+		expect(extractPRNumber("Created PR #456")).toBe(456);
+	});
+
+	test("extractPRNumber returns null for no match", () => {
+		expect(extractPRNumber("no number here")).toBeNull();
+	});
+
+	test("extractIssueNumber from URL", () => {
+		expect(extractIssueNumber("https://github.com/org/repo/issues/42")).toBe(42);
+	});
+
+	test("extractIssueNumber from hash format", () => {
+		expect(extractIssueNumber("Created issue #99")).toBe(99);
+	});
+
+	test("extractIssueNumber returns null for no match", () => {
+		expect(extractIssueNumber("no number here")).toBeNull();
+	});
+
+	test("extractPRUrl extracts GitHub PR URL", () => {
+		const url = extractPRUrl("Created https://github.com/org/repo/pull/123 successfully");
+		expect(url).toBe("https://github.com/org/repo/pull/123");
+	});
+
+	test("extractPRUrl returns null for no match", () => {
+		expect(extractPRUrl("no url here")).toBeNull();
+	});
+
+	test("extractIssueUrl extracts GitHub issue URL", () => {
+		const url = extractIssueUrl("Created https://github.com/org/repo/issues/42 successfully");
+		expect(url).toBe("https://github.com/org/repo/issues/42");
+	});
+
+	test("extractIssueUrl returns null for no match", () => {
+		expect(extractIssueUrl("no url here")).toBeNull();
+	});
+});
+
+// ============================================================================
+// Auto-detection Pattern Tests
+// ============================================================================
+
+describe("Auto-detection Patterns", () => {
+	test("GitHub PR URL pattern matches", () => {
+		const pattern = /^https:\/\/github\.com\/[^\/]+\/[^\/]+\/pull\/(\d+)\/?$/;
+
+		expect("https://github.com/org/repo/pull/123".match(pattern)?.[1]).toBe("123");
+		expect("https://github.com/org/repo/pull/123/".match(pattern)?.[1]).toBe("123");
+		expect("https://github.com/my-org/my-repo/pull/456".match(pattern)?.[1]).toBe("456");
+	});
+
+	test("GitHub PR URL pattern doesn't match non-PRs", () => {
+		const pattern = /^https:\/\/github\.com\/[^\/]+\/[^\/]+\/pull\/(\d+)\/?$/;
+
+		expect("https://github.com/org/repo/issues/123".match(pattern)).toBeNull();
+		expect("https://github.com/org/repo/pull/".match(pattern)).toBeNull();
+		expect("https://github.com/org/repo".match(pattern)).toBeNull();
+		expect("not a url".match(pattern)).toBeNull();
+	});
+
+	test("GitHub issue URL pattern matches", () => {
+		const pattern = /^https:\/\/github\.com\/[^\/]+\/[^\/]+\/issues\/(\d+)\/?$/;
+
+		expect("https://github.com/org/repo/issues/42".match(pattern)?.[1]).toBe("42");
+		expect("https://github.com/org/repo/issues/42/".match(pattern)?.[1]).toBe("42");
+	});
+
+	test("GitHub issue URL pattern doesn't match non-issues", () => {
+		const pattern = /^https:\/\/github\.com\/[^\/]+\/[^\/]+\/issues\/(\d+)\/?$/;
+
+		expect("https://github.com/org/repo/pull/123".match(pattern)).toBeNull();
+		expect("https://github.com/org/repo/issues/".match(pattern)).toBeNull();
+	});
+});