@herbertgao/pi-extensions 2026.8.10 → 2026.8.12

package/node_modules/pi-web-access/github-issue-pr.ts

@@ -0,0 +1,700 @@
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import type { ExtractedContent, ExtractOptions } from "./extract.ts";
+import { checkGhAvailable, showGhHint } from "./github-api.ts";
+import { fetchRemoteUrl, loadFetchContentDomainPolicy, loadSsrfConfig } from "./ssrf-protection.ts";
+import { getWebSearchConfigPath } from "./utils.ts";
+
+const CONFIG_PATH = getWebSearchConfigPath();
+const GH_TIMEOUT_MS = 10_000;
+const GH_TOTAL_TIMEOUT_MS = 20_000;
+const MAX_DOC_CHARS = 150_000;
+const BODY_INLINE_CHARS = 4_000;
+const COMMENT_INLINE_CHARS = 700;
+const MAX_INLINE_COMMENTS = 15;
+const MAX_INLINE_REVIEWS = 10;
+const MAX_INLINE_CHECKS = 15;
+const MAX_INLINE_FILES = 50;
+const MAX_INLINE_COMMITS = 20;
+const MAX_INLINE_REVIEW_THREADS = 30;
+const REST_HEADERS = { "Accept": "application/vnd.github+json", "User-Agent": "pi-web-access" };
+const PR_SUBPATHS = new Set(["files", "commits", "checks", "conversation"]);
+
+const PR_FIELDS = [
+	"title", "number", "state", "isDraft", "author", "baseRefName", "headRefName", "headRepositoryOwner",
+	"createdAt", "mergedAt", "closedAt", "labels", "milestone", "additions", "deletions", "changedFiles",
+	"files", "commits", "reviews", "statusCheckRollup", "comments", "body", "closingIssuesReferences", "url",
+];
+const PR_CORE_FIELDS = [
+	"title", "number", "state", "isDraft", "author", "baseRefName", "headRefName", "headRepositoryOwner",
+	"createdAt", "mergedAt", "closedAt", "labels", "milestone", "additions", "deletions", "changedFiles",
+	"files", "commits", "reviews", "comments", "body", "url",
+];
+const ISSUE_FIELDS = [
+	"title", "number", "state", "stateReason", "author", "createdAt", "closedAt", "labels", "assignees", "milestone",
+	"comments", "body", "closedByPullRequestsReferences", "url",
+];
+const ISSUE_CORE_FIELDS = ["title", "number", "state", "author", "createdAt", "closedAt", "labels", "assignees", "milestone", "comments", "body", "url"];
+
+type Kind = "pull" | "issue";
+
+export interface GitHubIssuePrUrlInfo {
+	owner: string;
+	repo: string;
+	kind: Kind;
+	number: number;
+	anchor?: string;
+}
+
+interface GitHubPrIssueConfig {
+	enabled: boolean;
+}
+
+interface GhResult {
+	ok: boolean;
+	stdout: string;
+	stderr: string;
+	code: number | null;
+	error?: string;
+}
+
+interface RenderData {
+	url: string;
+	owner: string;
+	repo: string;
+	kind: Kind;
+	number: number;
+	anchor?: string;
+	view: Record<string, unknown>;
+	reviewThreads: Record<string, unknown>[];
+	reviewThreadsBounded?: boolean;
+	reviewThreadsUnavailable?: boolean;
+	fallbackNotes: string[];
+}
+
+let cachedConfig: GitHubPrIssueConfig | null = null;
+
+function loadConfig(): GitHubPrIssueConfig {
+	if (cachedConfig) return cachedConfig;
+	const defaults = { enabled: true };
+	if (!existsSync(CONFIG_PATH)) {
+		cachedConfig = defaults;
+		return cachedConfig;
+	}
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		throw new Error(`Failed to parse ${CONFIG_PATH}: ${message}`);
+	}
+	const root = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+	const value = root.githubPrIssue;
+	if (value !== undefined && (typeof value !== "object" || value === null || Array.isArray(value))) {
+		throw new Error(`githubPrIssue in ${CONFIG_PATH} must be an object`);
+	}
+	const enabled = typeof (value as { enabled?: unknown } | undefined)?.enabled === "boolean"
+		? (value as { enabled: boolean }).enabled
+		: true;
+	cachedConfig = { enabled };
+	return cachedConfig;
+}
+
+function validOwner(owner: string): boolean {
+	return /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/.test(owner) && !owner.includes("--");
+}
+
+function validRepo(repo: string): boolean {
+	return /^[A-Za-z0-9._-]{1,100}$/.test(repo) && repo !== "." && repo !== "..";
+}
+
+function errorMessage(err: unknown): string {
+	return err instanceof Error ? err.message : String(err);
+}
+
+function isAbortError(err: unknown): boolean {
+	return errorMessage(err).toLowerCase().includes("abort");
+}
+
+export function parseGitHubIssuePrUrl(url: string): GitHubIssuePrUrlInfo | null {
+	let parsed: URL;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return null;
+	}
+	const host = parsed.hostname.toLowerCase();
+	if (host !== "github.com" && host !== "www.github.com") return null;
+	const segments: string[] = [];
+	for (const segment of parsed.pathname.split("/").filter(Boolean)) {
+		try {
+			segments.push(decodeURIComponent(segment));
+		} catch {
+			return null;
+		}
+	}
+	if (segments.length < 4) return null;
+	const owner = segments[0];
+	const repo = segments[1].replace(/\.git$/, "");
+	if (!validOwner(owner) || !validRepo(repo)) return null;
+	const route = segments[2].toLowerCase();
+	if (route !== "pull" && route !== "issues") return null;
+	if (!/^\d+$/.test(segments[3])) return null;
+	const subpath = segments[4]?.toLowerCase();
+	if (route === "pull" && subpath && !PR_SUBPATHS.has(subpath)) return null;
+	if (route === "issues" && subpath) return null;
+	const number = Number.parseInt(segments[3], 10);
+	if (!Number.isSafeInteger(number) || number <= 0) return null;
+	const fragment = parsed.hash.slice(1);
+	const anchorPattern = route === "pull" ? /^(?:issuecomment-\d+|discussion_r\d+)$/i : /^issuecomment-\d+$/i;
+	const anchor = anchorPattern.test(fragment) ? fragment : undefined;
+	return { owner, repo, kind: route === "pull" ? "pull" : "issue", number, ...(anchor ? { anchor } : {}) };
+}
+
+function runGh(args: string[], timeoutMs = GH_TIMEOUT_MS, signal?: AbortSignal): Promise<GhResult> {
+	return new Promise((resolve) => {
+		execFile("gh", args, {
+			timeout: timeoutMs,
+			maxBuffer: 10 * 1024 * 1024,
+			...(signal ? { signal } : {}),
+			env: { ...process.env, GH_PROMPT_DISABLED: "1", GIT_TERMINAL_PROMPT: "0" },
+		}, (err, stdout, stderr) => {
+			const nodeErr = err as NodeJS.ErrnoException | null;
+			resolve({
+				ok: !err,
+				stdout,
+				stderr,
+				code: typeof nodeErr?.code === "number" ? nodeErr.code : null,
+				...(err ? { error: nodeErr?.message ?? String(err) } : {}),
+			});
+		});
+	});
+}
+
+function remainingGhTimeout(deadlineMs: number): number {
+	return Math.max(1, Math.min(GH_TIMEOUT_MS, deadlineMs - Date.now()));
+}
+
+function unknownJsonField(result: GhResult): boolean {
+	return /unknown (?:json )?field|UnknownField|Unknown JSON field/i.test(`${result.stderr}\n${result.error ?? ""}`);
+}
+
+async function ghView(info: GitHubIssuePrUrlInfo, deadlineMs: number, signal?: AbortSignal): Promise<{ view: Record<string, unknown>; notes: string[] } | null> {
+	const repoArg = `${info.owner}/${info.repo}`;
+	const command = info.kind === "pull" ? "pr" : "issue";
+	const fields = info.kind === "pull" ? PR_FIELDS : ISSUE_FIELDS;
+	const coreFields = info.kind === "pull" ? PR_CORE_FIELDS : ISSUE_CORE_FIELDS;
+	let result = await runGh([command, "view", String(info.number), "--repo", repoArg, "--json", fields.join(",")], remainingGhTimeout(deadlineMs), signal);
+	const notes: string[] = [];
+	let linkedReferencesUnavailable = false;
+	if (!result.ok && unknownJsonField(result)) {
+		result = await runGh([command, "view", String(info.number), "--repo", repoArg, "--json", coreFields.join(",")], remainingGhTimeout(deadlineMs), signal);
+		notes.push("Some GitHub fields were unavailable from this gh version; retried with the core field set.");
+		linkedReferencesUnavailable = true;
+	}
+	if (!result.ok) return null;
+	try {
+		const parsed = JSON.parse(result.stdout) as unknown;
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+		const view = parsed as Record<string, unknown>;
+		if (linkedReferencesUnavailable) view.linkedReferencesUnavailable = true;
+		return { view, notes };
+	} catch {
+		return null;
+	}
+}
+
+async function ghReviewThreads(info: GitHubIssuePrUrlInfo, deadlineMs: number, signal?: AbortSignal): Promise<{ comments: Record<string, unknown>[]; note?: string; bounded?: boolean; unavailable?: boolean; anchorUnavailable?: boolean }> {
+	if (info.kind !== "pull") return { comments: [] };
+	const comments: Record<string, unknown>[] = [];
+	let bounded = false;
+	let pageFailed = false;
+	for (let page = 1; page <= 3; page++) {
+		const result = await runGh(["api", `repos/${info.owner}/${info.repo}/pulls/${info.number}/comments?per_page=100&page=${page}`], remainingGhTimeout(deadlineMs), signal);
+		if (!result.ok) {
+			pageFailed = true;
+			break;
+		}
+		let pageItems: unknown;
+		try {
+			pageItems = JSON.parse(result.stdout);
+		} catch {
+			pageFailed = true;
+			break;
+		}
+		if (!Array.isArray(pageItems) || pageItems.length === 0) break;
+		comments.push(...pageItems.filter((item): item is Record<string, unknown> => !!item && typeof item === "object" && !Array.isArray(item)));
+		if (pageItems.length < 100) break;
+		if (page === 3) bounded = true;
+	}
+	const discussionId = anchorId(info.anchor, "discussion_r");
+	if (discussionId && !hasCommentId(comments, discussionId)) {
+		const result = await runGh(["api", `repos/${info.owner}/${info.repo}/pulls/comments/${discussionId}`], remainingGhTimeout(deadlineMs), signal);
+		if (result.ok) {
+			try {
+				const comment = JSON.parse(result.stdout) as unknown;
+				if (comment && typeof comment === "object" && !Array.isArray(comment) && belongsToPull(comment as Record<string, unknown>, discussionId, info)) comments.push(comment as Record<string, unknown>);
+				else return { comments, bounded: bounded || (pageFailed && comments.length > 0), unavailable: pageFailed && comments.length === 0, anchorUnavailable: true };
+			} catch {
+				return { comments, bounded: bounded || (pageFailed && comments.length > 0), unavailable: pageFailed && comments.length === 0, note: "Anchored review thread comment unavailable from gh." };
+			}
+		} else {
+			return { comments, bounded: bounded || (pageFailed && comments.length > 0), unavailable: pageFailed && comments.length === 0, anchorUnavailable: true };
+		}
+	}
+	return { comments, bounded: bounded || (pageFailed && comments.length > 0), unavailable: pageFailed && comments.length === 0 };
+}
+
+function isRateLimited(response: Response): boolean {
+	return response.status === 403 && response.headers.get("x-ratelimit-remaining") === "0";
+}
+
+function anchorId(anchor: string | undefined, prefix: "issuecomment" | "discussion_r"): string | null {
+	const match = anchor?.match(prefix === "issuecomment" ? /^issuecomment-(\d+)$/i : /^discussion_r(\d+)$/i);
+	return match?.[1] ?? null;
+}
+
+function hasCommentId(comments: Record<string, unknown>[], id: string): boolean {
+	return comments.some(comment => commentId(comment) === id);
+}
+
+function belongsToIssue(comment: Record<string, unknown>, id: string, info: GitHubIssuePrUrlInfo): boolean {
+	return commentId(comment) === id && associationMatches(comment.issue_url, info, "issues");
+}
+
+function belongsToPull(comment: Record<string, unknown>, id: string, info: GitHubIssuePrUrlInfo): boolean {
+	return commentId(comment) === id && associationMatches(comment.pull_request_url, info, "pulls");
+}
+
+function associationMatches(value: unknown, info: GitHubIssuePrUrlInfo, route: "issues" | "pulls"): boolean {
+	if (typeof value !== "string") return false;
+	try {
+		const parsed = new URL(value);
+		if (parsed.protocol !== "https:" || parsed.hostname.toLowerCase() !== "api.github.com") return false;
+		return parsed.pathname.toLowerCase() === `/repos/${info.owner}/${info.repo}/${route}/${info.number}`.toLowerCase();
+	} catch {
+		return false;
+	}
+}
+
+function rateLimitResult(url: string, info: GitHubIssuePrUrlInfo, response: Response): ExtractedContent {
+	const reset = response.headers.get("x-ratelimit-reset");
+	const resetNote = reset ? ` Rate limit resets at Unix time ${reset}.` : "";
+	return {
+		url,
+		title: `${info.owner}/${info.repo}#${info.number}`,
+		content: `GitHub API rate limit reached for ${info.owner}/${info.repo} ${info.kind} #${info.number}.${resetNote}\n\nAuthenticate the gh CLI and retry:\n\n\`gh auth login\`\n\nThen fetch this URL again.`,
+		error: "GitHub API rate limit reached; authenticate gh to fetch this PR or issue.",
+		status: response.status,
+	};
+}
+
+async function restJson(url: string, options?: ExtractOptions, signal?: AbortSignal): Promise<{ value: unknown; response: Response } | null> {
+	const ssrf = loadSsrfConfig();
+	const domainPolicy = loadFetchContentDomainPolicy();
+	const response = await fetchRemoteUrl(url, { headers: REST_HEADERS, ...(signal ? { signal } : {}) }, {
+		allowRanges: ssrf.allowRanges,
+		trustEnvProxy: ssrf.trustEnvProxy,
+		domainPolicy,
+		...(options?.lookup ? { lookup: options.lookup } : {}),
+	});
+	if (!response.ok) return { value: null, response };
+	return { value: await response.json(), response };
+}
+
+async function restFallback(url: string, info: GitHubIssuePrUrlInfo, options?: ExtractOptions, signal?: AbortSignal): Promise<ExtractedContent | { data: RenderData } | null> {
+	try {
+		const base = `https://api.github.com/repos/${info.owner}/${info.repo}`;
+		const mainPath = info.kind === "pull" ? `${base}/pulls/${info.number}` : `${base}/issues/${info.number}`;
+		const main = await restJson(mainPath, options, signal);
+		if (!main) return null;
+		if (isRateLimited(main.response)) return rateLimitResult(url, info, main.response);
+		if (!main.response.ok) return null;
+		const view = mapRestView(info, main.value);
+		view.linkedReferencesUnavailable = true;
+		const comments = await restJson(`${base}/issues/${info.number}/comments?per_page=50`, options, signal);
+		if (comments && isRateLimited(comments.response)) return rateLimitResult(url, info, comments.response);
+		const conversationComments = comments?.response.ok && Array.isArray(comments.value)
+			? comments.value.filter((item): item is Record<string, unknown> => !!item && typeof item === "object" && !Array.isArray(item))
+			: [];
+		const issueCommentId = anchorId(info.anchor, "issuecomment");
+		if (issueCommentId && !hasCommentId(conversationComments, issueCommentId)) {
+			const anchoredComment = await restJson(`${base}/issues/comments/${issueCommentId}`, options, signal);
+			if (anchoredComment && isRateLimited(anchoredComment.response)) return rateLimitResult(url, info, anchoredComment.response);
+			if (anchoredComment?.response.ok && anchoredComment.value && typeof anchoredComment.value === "object" && !Array.isArray(anchoredComment.value)) {
+				const comment = anchoredComment.value as Record<string, unknown>;
+				if (belongsToIssue(comment, issueCommentId, info)) conversationComments.push(comment);
+				else view.anchorUnavailable = true;
+			} else {
+				view.anchorUnavailable = true;
+			}
+		}
+		view.comments = conversationComments;
+		const reviewThreads: Record<string, unknown>[] = [];
+		const notes = [info.kind === "pull" ? "Checks unavailable in REST fallback; install or authenticate gh for check status." : "REST fallback used; gh fields unavailable."];
+		if (info.kind === "pull") {
+			view.reviewsUnavailable = true;
+			view.commitsUnavailable = true;
+			const files = await restJson(`${base}/pulls/${info.number}/files?per_page=50`, options, signal);
+			if (files && isRateLimited(files.response)) return rateLimitResult(url, info, files.response);
+			if (files?.response.ok && Array.isArray(files.value)) view.files = files.value;
+			const threads = await restJson(`${base}/pulls/${info.number}/comments?per_page=50`, options, signal);
+			if (threads && isRateLimited(threads.response)) return rateLimitResult(url, info, threads.response);
+			if (threads?.response.ok && Array.isArray(threads.value)) {
+				reviewThreads.push(...threads.value.filter((item): item is Record<string, unknown> => !!item && typeof item === "object" && !Array.isArray(item)));
+			}
+			const discussionId = anchorId(info.anchor, "discussion_r");
+			if (discussionId && !hasCommentId(reviewThreads, discussionId)) {
+				const anchoredThread = await restJson(`${base}/pulls/comments/${discussionId}`, options, signal);
+				if (anchoredThread && isRateLimited(anchoredThread.response)) return rateLimitResult(url, info, anchoredThread.response);
+				if (anchoredThread?.response.ok && anchoredThread.value && typeof anchoredThread.value === "object" && !Array.isArray(anchoredThread.value)) {
+					const comment = anchoredThread.value as Record<string, unknown>;
+					if (belongsToPull(comment, discussionId, info)) reviewThreads.push(comment);
+					else view.anchorUnavailable = true;
+				} else {
+					view.anchorUnavailable = true;
+				}
+			}
+		}
+		return { data: { url, owner: info.owner, repo: info.repo, kind: info.kind, number: info.number, anchor: info.anchor, view, reviewThreads, fallbackNotes: notes } };
+	} catch (err) {
+		if (signal?.aborted || isAbortError(err)) return { url, title: "", content: "", error: "Aborted" };
+		const message = errorMessage(err);
+		return { url, title: `${info.owner}/${info.repo}#${info.number}`, content: message, error: `GitHub REST fallback failed: ${message}` };
+	}
+}
+
+function mapRestView(info: GitHubIssuePrUrlInfo, value: unknown): Record<string, unknown> {
+	const source = value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+	const user = source.user && typeof source.user === "object" ? source.user as Record<string, unknown> : undefined;
+	const base = source.base && typeof source.base === "object" ? source.base as Record<string, unknown> : undefined;
+	const head = source.head && typeof source.head === "object" ? source.head as Record<string, unknown> : undefined;
+	return {
+		title: stringValue(source.title),
+		number: numberValue(source.number) ?? info.number,
+		state: stringValue(source.state),
+		stateReason: stringValue(source.state_reason),
+		isDraft: Boolean(source.draft),
+		author: { login: user ? stringValue(user.login) : "" },
+		baseRefName: base ? stringValue(base.ref) : "",
+		headRefName: head ? stringValue(head.ref) : "",
+		headRepositoryOwner: { login: head && typeof head.repo === "object" && head.repo && typeof (head.repo as Record<string, unknown>).owner === "object" ? stringValue(((head.repo as Record<string, unknown>).owner as Record<string, unknown>).login) : "" },
+		createdAt: stringValue(source.created_at),
+		mergedAt: stringValue(source.merged_at),
+		closedAt: stringValue(source.closed_at),
+		labels: source.labels,
+		assignees: source.assignees,
+		milestone: source.milestone,
+		additions: source.additions,
+		deletions: source.deletions,
+		changedFiles: source.changed_files,
+		body: stringValue(source.body),
+		url: stringValue(source.html_url),
+		commentsCount: source.comments,
+		reviewCommentsCount: source.review_comments,
+	};
+}
+
+function stringValue(value: unknown): string {
+	return typeof value === "string" ? value : "";
+}
+
+function numberValue(value: unknown): number | null {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function authorLogin(value: unknown): string {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return "unknown";
+	const login = (value as Record<string, unknown>).login;
+	return typeof login === "string" && login ? login : "unknown";
+}
+
+function listNames(value: unknown): string {
+	if (!Array.isArray(value) || value.length === 0) return "none";
+	const names = value.map((item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return "";
+		const record = item as Record<string, unknown>;
+		return stringValue(record.name) || stringValue(record.login) || stringValue(record.title);
+	}).filter(Boolean);
+	return names.length > 0 ? names.join(", ") : "none";
+}
+
+function milestoneTitle(value: unknown): string {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return "none";
+	return stringValue((value as Record<string, unknown>).title) || "none";
+}
+
+function truncateText(text: string, limit: number, label: string, appendix: string[]): string {
+	if (text.length <= limit) return text;
+	appendix.push(`## Full ${label}\n\n${text}`);
+	return `${text.slice(0, limit)}\n\n[${label} truncated; use get_search_content findText or offset for the full text]`;
+}
+
+function appendLimitedSection(lines: string[], title: string, items: string[], max: number, marker: string): void {
+	lines.push(`## ${title}`);
+	if (items.length === 0) {
+		lines.push("none", "");
+		return;
+	}
+	lines.push(...items.slice(0, max));
+	if (items.length > max) lines.push(`[${max} of ${items.length} ${marker} shown; use get_search_content offset or the gh command below for more]`);
+	lines.push("");
+}
+
+function objectArray(value: unknown): Record<string, unknown>[] {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item): item is Record<string, unknown> => !!item && typeof item === "object" && !Array.isArray(item));
+}
+
+function commentId(comment: Record<string, unknown>): string {
+	return String(comment.id ?? comment.databaseId ?? "");
+}
+
+function anchorMatches(anchor: string | undefined, comment: Record<string, unknown>): boolean {
+	if (!anchor) return false;
+	const id = commentId(comment);
+	return anchor === `issuecomment-${id}` || anchor === `discussion_r${id}`;
+}
+
+function renderComments(comments: Record<string, unknown>[], anchor: string | undefined, appendix: string[]): string[] {
+	const forced = anchor ? comments.find(comment => anchorMatches(anchor, comment)) : undefined;
+	const selected = comments.slice(0, MAX_INLINE_COMMENTS);
+	if (forced && !selected.includes(forced)) selected.push(forced);
+	const lines = selected.map((comment) => {
+		const body = stringValue(comment.body);
+		const label = `comment ${commentId(comment) || selected.indexOf(comment) + 1}`;
+		return `- ${authorLogin(comment.author ?? comment.user)} at ${stringValue(comment.createdAt) || stringValue(comment.created_at)}${forced === comment ? " [anchored]" : ""}:\n  ${truncateText(body, COMMENT_INLINE_CHARS, label, appendix).replace(/\n/g, "\n  ")}`;
+	});
+	return lines;
+}
+
+function renderCommentMarker(comments: Record<string, unknown>[], renderedCount: number, total: unknown): string | null {
+	const knownTotal = numberValue(total);
+	if (knownTotal !== null && knownTotal > comments.length) {
+		return `[${renderedCount} comments shown from at least ${knownTotal}; use get_search_content findText or offset, or gh issue view -c]`;
+	}
+	if (comments.length > renderedCount) return `[${renderedCount} of ${comments.length} comments shown; use get_search_content findText or offset, or gh issue view -c]`;
+	return null;
+}
+
+function commentCountText(view: Record<string, unknown>): string {
+	const comments = objectArray(view.comments).length;
+	const total = numberValue(view.commentsCount);
+	if (total !== null && total > comments) return `at least ${total}`;
+	return String(comments || total || 0);
+}
+
+function reviewThreadCountText(comments: Record<string, unknown>[], total: unknown, bounded?: boolean, unavailable?: boolean): string {
+	if (unavailable) return "unavailable";
+	const knownTotal = numberValue(total);
+	if (bounded) return `at least ${comments.length}`;
+	if (knownTotal !== null && knownTotal > comments.length) return `at least ${knownTotal}`;
+	return String(comments.length || knownTotal || 0);
+}
+
+function renderChecks(value: unknown): string[] {
+	const checks = objectArray(value);
+	if (checks.length === 0) return ["No check rollup data available."];
+	const rows = checks.map((check) => {
+		const name = stringValue(check.name) || stringValue(check.context) || stringValue(check.workflowName) || "check";
+		const state = stringValue(check.conclusion) || stringValue(check.status) || stringValue(check.state) || "unknown";
+		return `- ${name}: ${state}`;
+	});
+	const failing = rows.filter(row => !/(success|neutral|skipped|completed)$/i.test(row));
+	return [`Rollup: ${failing.length === 0 ? "no failing checks in shown data" : `${failing.length} non-passing checks in shown data`}`, ...rows.slice(0, MAX_INLINE_CHECKS), ...(rows.length > MAX_INLINE_CHECKS ? [`[${MAX_INLINE_CHECKS} of ${rows.length} checks shown]`] : [])];
+}
+
+function renderReviewVerdicts(value: unknown, appendix: string[]): string[] {
+	const latest = new Map<string, Record<string, unknown>>();
+	for (const review of objectArray(value)) latest.set(authorLogin(review.author ?? review.user), review);
+	return [...latest.entries()].map(([author, review]) => {
+		const state = stringValue(review.state) || "COMMENTED";
+		const body = truncateText(stringValue(review.body), 300, `review by ${author}`, appendix);
+		return `- ${author}: ${state}${body ? ` — ${body.replace(/\n/g, " ")}` : ""}`;
+	});
+}
+
+function renderReviewVerdictsOrUnavailable(view: Record<string, unknown>, appendix: string[]): string[] {
+	const rendered = renderReviewVerdicts(view.reviews, appendix);
+	if (rendered.length > 0) return rendered;
+	return view.reviewsUnavailable === true ? ["Unavailable in this GitHub fetch path; use gh for review verdicts."] : [];
+}
+
+function renderFiles(value: unknown): string[] {
+	return objectArray(value).map((file) => {
+		const path = stringValue(file.path) || stringValue(file.filename) || "file";
+		const additions = numberValue(file.additions) ?? 0;
+		const deletions = numberValue(file.deletions) ?? 0;
+		return `- ${path} (+${additions}/−${deletions})`;
+	});
+}
+
+function appendFilesSection(lines: string[], view: Record<string, unknown>): void {
+	lines.push("## Files");
+	const files = renderFiles(view.files);
+	if (files.length === 0) {
+		const total = numberValue(view.changedFiles);
+		if (total !== null && total > 0) {
+			lines.push(`[0 files shown from at least ${total}; use get_search_content offset or the gh command below for more]`, "");
+			return;
+		}
+		lines.push("none", "");
+		return;
+	}
+	lines.push(...files.slice(0, MAX_INLINE_FILES));
+	const total = numberValue(view.changedFiles);
+	if (total !== null && total > files.length) {
+		lines.push(`[${Math.min(files.length, MAX_INLINE_FILES)} files shown from at least ${total}; use get_search_content offset or the gh command below for more]`);
+	} else if (files.length > MAX_INLINE_FILES) {
+		lines.push(`[${MAX_INLINE_FILES} of ${files.length} files shown; use get_search_content offset or the gh command below for more]`);
+	}
+	lines.push("");
+}
+
+function renderCommits(value: unknown): string[] {
+	return objectArray(value).map((commit) => {
+		const oid = stringValue(commit.oid) || stringValue(commit.sha);
+		const message = stringValue(commit.messageHeadline) || (commit.commit && typeof commit.commit === "object" ? stringValue((commit.commit as Record<string, unknown>).message).split("\n")[0] : "");
+		return `- ${oid.slice(0, 7)} ${message}`.trim();
+	});
+}
+
+function renderCommitsOrUnavailable(view: Record<string, unknown>): string[] {
+	const rendered = renderCommits(view.commits);
+	if (rendered.length > 0) return rendered;
+	return view.commitsUnavailable === true ? ["Unavailable in this GitHub fetch path; use gh for commits."] : [];
+}
+
+function renderLinked(value: unknown, kind: "closing" | "closedBy"): string[] {
+	return objectArray(value).map((item) => `- #${numberValue(item.number) ?? "?"} ${stringValue(item.title)}${kind === "closedBy" ? ` (${stringValue(item.url)})` : ""}`);
+}
+
+function renderLinkedOrUnavailable(view: Record<string, unknown>, field: "closingIssuesReferences" | "closedByPullRequestsReferences", kind: "closing" | "closedBy"): string[] {
+	const linked = renderLinked(view[field], kind);
+	if (linked.length > 0) return linked;
+	return view.linkedReferencesUnavailable === true ? ["Unavailable in this GitHub fetch path; use gh for linked references."] : [];
+}
+
+function renderReviewThreads(comments: Record<string, unknown>[], anchor: string | undefined, appendix: string[], total?: unknown, bounded?: boolean, unavailable?: boolean): string[] {
+	if (unavailable) return ["Unavailable in this GitHub fetch path; use gh for review thread comments."];
+	const forced = anchor ? comments.find(comment => anchorMatches(anchor, comment)) : undefined;
+	const selected = comments.slice(0, MAX_INLINE_REVIEW_THREADS);
+	if (forced && !selected.includes(forced)) selected.push(forced);
+	const lines = selected.map((comment) => {
+		const path = stringValue(comment.path) || "unknown path";
+		const line = numberValue(comment.line) ?? numberValue(comment.original_line) ?? numberValue(comment.position) ?? "?";
+		const body = truncateText(stringValue(comment.body), COMMENT_INLINE_CHARS, `review thread comment ${commentId(comment) || selected.indexOf(comment) + 1}`, appendix);
+		return `- ${path}:${line} — ${authorLogin(comment.user ?? comment.author)}${forced === comment ? " [anchored]" : ""} (resolution state unknown):\n  ${body.replace(/\n/g, "\n  ")}`;
+	});
+	const knownTotal = numberValue(total);
+	if (bounded) {
+		lines.push(`[${selected.length} review thread comments shown from at least ${comments.length}; use get_search_content offset, or gh api repos/<owner>/<repo>/pulls/<number>/comments]`);
+	} else if (knownTotal !== null && knownTotal > comments.length) {
+		lines.push(`[${selected.length} review thread comments shown from at least ${knownTotal}; use get_search_content offset, or gh api repos/<owner>/<repo>/pulls/<number>/comments]`);
+	} else if (comments.length > selected.length) {
+		lines.push(`[${selected.length} of ${comments.length} review thread comments shown; use get_search_content offset, or gh api repos/<owner>/<repo>/pulls/<number>/comments]`);
+	}
+	return lines;
+}
+
+export function renderGitHubPrIssue(data: RenderData): ExtractedContent {
+	const { view } = data;
+	const appendix: string[] = [];
+	const title = stringValue(view.title) || `${data.owner}/${data.repo}#${data.number}`;
+	const number = numberValue(view.number) ?? data.number;
+	const stateParts = [stringValue(view.state) || "unknown"];
+	if (view.isDraft === true) stateParts.push("draft");
+	const lines: string[] = [`#${number} ${title}`, ""];
+	lines.push(`- type: ${data.kind}`);
+	lines.push(`- state: ${stateParts.join(" ")}${stringValue(view.stateReason) ? ` (${stringValue(view.stateReason)})` : ""}`);
+	lines.push(`- author: ${authorLogin(view.author)}`);
+	if (data.kind === "pull") {
+		const headOwner = authorLogin(view.headRepositoryOwner);
+		const headRef = stringValue(view.headRefName);
+		const head = headOwner !== "unknown" && headOwner !== data.owner ? `${headOwner}:${headRef}` : headRef;
+		lines.push(`- branch: ${stringValue(view.baseRefName)} ← ${head}`);
+		const commitSummary = view.commitsUnavailable === true ? "commits unavailable" : `${objectArray(view.commits).length} commits`;
+		lines.push(`- changes: +${numberValue(view.additions) ?? 0} −${numberValue(view.deletions) ?? 0}, ${numberValue(view.changedFiles) ?? objectArray(view.files).length} files, ${commitSummary}`);
+	} else {
+		lines.push(`- assignees: ${listNames(view.assignees)}`);
+	}
+	lines.push(`- created: ${stringValue(view.createdAt) || "unknown"}`);
+	if (stringValue(view.mergedAt)) lines.push(`- merged: ${stringValue(view.mergedAt)}`);
+	if (stringValue(view.closedAt)) lines.push(`- closed: ${stringValue(view.closedAt)}`);
+	lines.push(`- labels: ${listNames(view.labels)}`);
+	lines.push(`- milestone: ${milestoneTitle(view.milestone)}`);
+	lines.push(`- comments: ${commentCountText(view)}; review threads: ${reviewThreadCountText(data.reviewThreads, view.reviewCommentsCount, data.reviewThreadsBounded, data.reviewThreadsUnavailable)}`);
+	if (data.anchor) lines.push(`- requested anchor: #${data.anchor}`);
+	lines.push("");
+
+	lines.push("## Body");
+	lines.push(truncateText(stringValue(view.body) || "(empty)", BODY_INLINE_CHARS, "body", appendix), "");
+
+	if (data.kind === "pull") {
+		lines.push("## Checks");
+		lines.push(...renderChecks(view.statusCheckRollup), "");
+		appendLimitedSection(lines, "Review verdicts", renderReviewVerdictsOrUnavailable(view, appendix), MAX_INLINE_REVIEWS, "review verdicts");
+		appendLimitedSection(lines, "Linked references", renderLinkedOrUnavailable(view, "closingIssuesReferences", "closing"), 20, "linked references");
+		appendFilesSection(lines, view);
+		appendLimitedSection(lines, "Commits", renderCommitsOrUnavailable(view), MAX_INLINE_COMMITS, "commits");
+	} else {
+		appendLimitedSection(lines, "Closed by pull requests", renderLinkedOrUnavailable(view, "closedByPullRequestsReferences", "closedBy"), 20, "pull requests");
+	}
+	lines.push("## Conversation comments");
+	const commentLines = renderComments(objectArray(view.comments), data.anchor, appendix);
+	const commentMarker = renderCommentMarker(objectArray(view.comments), commentLines.length, view.commentsCount);
+	if (commentMarker) commentLines.push(commentMarker);
+	if (view.anchorUnavailable === true && data.anchor?.startsWith("issuecomment-")) commentLines.push("[anchored comment unavailable for this issue or pull request]");
+	lines.push(...(commentLines.length > 0 ? commentLines : ["none"]), "");
+	if (data.kind === "pull") {
+		lines.push("## Review thread comments");
+		const threadLines = renderReviewThreads(data.reviewThreads, data.anchor, appendix, view.reviewCommentsCount, data.reviewThreadsBounded, data.reviewThreadsUnavailable);
+		if (view.anchorUnavailable === true && data.anchor?.startsWith("discussion_r")) threadLines.push("[anchored review thread comment unavailable for this pull request]");
+		lines.push(...(threadLines.length > 0 ? threadLines : ["none"]), "");
+	}
+	if (data.fallbackNotes.length > 0) {
+		lines.push("## Availability notes", ...data.fallbackNotes.map(note => `- ${note}`), "");
+	}
+	if (appendix.length > 0) lines.push("## Appendix", ...appendix, "");
+	const viewCommand = data.kind === "pull" ? `gh pr view ${data.number} --repo ${data.owner}/${data.repo}` : `gh issue view ${data.number} --repo ${data.owner}/${data.repo} -c`;
+	lines.push("## Escalation commands");
+	lines.push(`- Full view: \`${viewCommand}\``);
+	if (data.kind === "pull") lines.push(`- Complete diff: \`gh pr diff ${data.number} --repo ${data.owner}/${data.repo}\``);
+	lines.push("- Stored full document: use `get_search_content` with `offset` or `findText`.");
+	const content = lines.join("\n");
+	return {
+		url: data.url,
+		title: `${data.owner}/${data.repo} ${data.kind} #${data.number}: ${title}`,
+		content: content.length > MAX_DOC_CHARS ? `${content.slice(0, MAX_DOC_CHARS)}\n\n[GitHub document truncated at ${MAX_DOC_CHARS} chars; use the gh escalation commands for complete data]` : content,
+		error: null,
+	};
+}
+
+export async function extractGitHubIssuePr(url: string, signal?: AbortSignal, options?: ExtractOptions): Promise<ExtractedContent | null> {
+	const info = parseGitHubIssuePrUrl(url);
+	if (!info) return null;
+	if (!loadConfig().enabled) return null;
+	if (signal?.aborted) return { url, title: "", content: "", error: "Aborted" };
+
+	const ghAvailable = await checkGhAvailable(signal);
+	if (signal?.aborted) return { url, title: "", content: "", error: "Aborted" };
+	if (ghAvailable) {
+		const ghDeadlineMs = Date.now() + GH_TOTAL_TIMEOUT_MS;
+		const viewed = await ghView(info, ghDeadlineMs, signal);
+		if (signal?.aborted) return { url, title: "", content: "", error: "Aborted" };
+		if (viewed) {
+			const threads = await ghReviewThreads(info, ghDeadlineMs, signal);
+			if (signal?.aborted) return { url, title: "", content: "", error: "Aborted" };
+			if (threads.anchorUnavailable) viewed.view.anchorUnavailable = true;
+			const notes = [...viewed.notes, ...(threads.note ? [threads.note] : [])];
+			return renderGitHubPrIssue({ url, owner: info.owner, repo: info.repo, kind: info.kind, number: info.number, anchor: info.anchor, view: viewed.view, reviewThreads: threads.comments, reviewThreadsBounded: threads.bounded, reviewThreadsUnavailable: threads.unavailable, fallbackNotes: notes });
+		}
+	} else {
+		showGhHint();
+	}
+
+	const fallback = await restFallback(url, info, options, signal);
+	if (!fallback) return null;
+	if ("data" in fallback) return renderGitHubPrIssue(fallback.data);
+	return fallback;
+}