diffing 0.6.2 → 0.7.0

package/dist/git-DaP_1rVy.mjs

@@ -0,0 +1,2 @@
+import { d as getProjectStorageDir } from "./git-Czo96ymM.mjs";
+export { getProjectStorageDir };

package/dist/github-C9GLNak7.mjs

@@ -0,0 +1,2 @@
+import { n as buildReviewPayload, p as replyToPrComment, s as fetchPrChecks } from "./github-HfIlIS-J.mjs";
+export { buildReviewPayload, fetchPrChecks, replyToPrComment };

package/dist/github-HfIlIS-J.mjs

@@ -0,0 +1,525 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/lib/github.ts
+const execFileAsync = promisify(execFile);
+/**
+* Probe the `gh` CLI: is it on `$PATH`, and is the user authenticated?
+* Never throws — returns a permissive `available: false` on any failure.
+*/
+async function detectGhCli() {
+	try {
+		const { stdout } = await execFileAsync("gh", ["--version"], { encoding: "utf-8" });
+		const version = stdout.split("\n")[0]?.trim() || void 0;
+		try {
+			const result = await execFileAsync("gh", ["auth", "status"], { encoding: "utf-8" });
+			return {
+				available: true,
+				authenticated: true,
+				version,
+				user: parseGhAuthStatusUser(`${result.stdout ?? ""}\n${result.stderr ?? ""}`)
+			};
+		} catch {
+			return {
+				available: true,
+				authenticated: false,
+				version
+			};
+		}
+	} catch {
+		return {
+			available: false,
+			authenticated: false
+		};
+	}
+}
+/**
+* Extract the GitHub username from `gh auth status` output. Exported for
+* unit tests — see `__tests__/github-auth.test.ts`.
+*
+* Real-world samples:
+*   `✓ Logged in to github.com account octocat (keyring)`        (gh 2.40+)
+*   `Logged in to github.com as octocat (oauth_token)`            (older gh)
+*   `  ✓ Logged in to github.com as octocat (~/.config/gh/hosts.yml)`
+*/
+function parseGhAuthStatusUser(output) {
+	const account = /Logged in to [^\s]+ account\s+([^\s(]+)/.exec(output);
+	if (account) return account[1];
+	return /Logged in to [^\s]+ as\s+([^\s(]+)/.exec(output)?.[1];
+}
+/** Read the most-preferred GitHub token from the env. */
+function readGithubToken() {
+	const env = process.env;
+	return env.GH_TOKEN || env.GITHUB_TOKEN || env.GITHUB_API_TOKEN || null;
+}
+function parsePrRef(input, cwdRepo) {
+	const trimmed = input.trim();
+	const urlMatch = /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/i.exec(trimmed);
+	if (urlMatch) return {
+		owner: urlMatch[1],
+		repo: urlMatch[2],
+		pullNumber: Number(urlMatch[3]),
+		ref: trimmed
+	};
+	const shorthand = /^([^/\s]+)\/([^#\s]+)#(\d+)$/.exec(trimmed);
+	if (shorthand) return {
+		owner: shorthand[1],
+		repo: shorthand[2],
+		pullNumber: Number(shorthand[3]),
+		ref: trimmed
+	};
+	const bare = /^#?(\d+)$/.exec(trimmed);
+	if (bare && cwdRepo) return {
+		owner: cwdRepo.owner,
+		repo: cwdRepo.repo,
+		pullNumber: Number(bare[1]),
+		ref: trimmed
+	};
+	if (bare) throw new Error(`Cannot resolve bare PR number "${trimmed}" — run from inside the target repo, or pass a full URL or \`owner/repo#1234\`.`);
+	throw new Error(`Unrecognised PR ref: ${trimmed}`);
+}
+/**
+* Best-effort: derive `{ owner, repo }` for the current working directory
+* from `git remote get-url origin`. Falls back to throwing.
+*/
+async function detectCwdRepo() {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"remote",
+			"get-url",
+			"origin"
+		], { encoding: "utf-8" });
+		const url = stdout.trim();
+		const m = /github\.com[:/]([^/\s]+)\/([^/\s]+?)(?:\.git)?\s*$/.exec(url);
+		if (m) return {
+			owner: m[1],
+			repo: m[2]
+		};
+	} catch {}
+	return null;
+}
+/**
+* Fetch PR metadata + diff + existing review comments using `gh`.
+* Throws with a user-readable message on failure.
+*/
+async function fetchPrMetadataViaGh(resolved) {
+	const args = ["-R", `${resolved.owner}/${resolved.repo}`];
+	let metaJson;
+	try {
+		const { stdout } = await execFileAsync("gh", [
+			"pr",
+			"view",
+			String(resolved.pullNumber),
+			...args,
+			"--json",
+			"number,title,url,author,baseRefOid,headRefOid,additions,deletions,changedFiles,headRepositoryOwner,headRepository"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 20 * 1024 * 1024
+		});
+		metaJson = JSON.parse(stdout);
+	} catch (err) {
+		const stderr = err?.stderr || err?.message || "unknown error";
+		throw new Error(`gh pr view failed: ${stderr.trim()}`);
+	}
+	let diff = "";
+	try {
+		const { stdout } = await execFileAsync("gh", [
+			"pr",
+			"diff",
+			String(resolved.pullNumber),
+			...args
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		diff = stdout;
+	} catch (err) {
+		const stderr = err?.stderr || err?.message || "unknown error";
+		throw new Error(`gh pr diff failed: ${stderr.trim()}`);
+	}
+	const author = metaJson.author ? {
+		login: metaJson.author.login,
+		avatarUrl: metaJson.author.avatarUrl
+	} : null;
+	const existingComments = await fetchExistingCommentsViaGh(resolved);
+	return {
+		number: metaJson.number,
+		title: metaJson.title,
+		url: metaJson.url,
+		author,
+		baseSha: metaJson.baseRefOid,
+		headSha: metaJson.headRefOid,
+		additions: metaJson.additions,
+		deletions: metaJson.deletions,
+		changedFiles: metaJson.changedFiles,
+		owner: resolved.owner,
+		repo: resolved.repo,
+		diff,
+		existingComments
+	};
+}
+async function fetchExistingCommentsViaGh(resolved) {
+	`${resolved.owner}${resolved.repo}`;
+	const endpoint = `repos/${resolved.owner}/${resolved.repo}/pulls/${resolved.pullNumber}/comments`;
+	const reviewsEndpoint = `repos/${resolved.owner}/${resolved.repo}/pulls/${resolved.pullNumber}/reviews`;
+	let reviews = [];
+	try {
+		const { stdout } = await execFileAsync("gh", [
+			"api",
+			reviewsEndpoint,
+			"--paginate"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 20 * 1024 * 1024
+		});
+		const all = JSON.parse(stdout);
+		if (Array.isArray(all)) reviews = all;
+	} catch {}
+	reviews.sort((a, b) => a.submitted_at < b.submitted_at ? 1 : -1);
+	const recentReviews = reviews.slice(0, 50);
+	const reviewStateById = /* @__PURE__ */ new Map();
+	for (const r of recentReviews) reviewStateById.set(r.id, r.state);
+	let commentsRaw = [];
+	try {
+		const { stdout } = await execFileAsync("gh", [
+			"api",
+			`${endpoint}?per_page=100`,
+			"--paginate"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 20 * 1024 * 1024
+		});
+		const parsed = JSON.parse(stdout);
+		if (Array.isArray(parsed)) commentsRaw = parsed;
+	} catch {
+		return [];
+	}
+	const byId = /* @__PURE__ */ new Map();
+	for (const c of commentsRaw) byId.set(c.id, c);
+	const replyByParent = /* @__PURE__ */ new Map();
+	for (const c of commentsRaw) if (c.in_reply_to_id && byId.has(c.in_reply_to_id)) {
+		const list = replyByParent.get(c.in_reply_to_id) ?? [];
+		list.push(c);
+		replyByParent.set(c.in_reply_to_id, list);
+	}
+	const tops = [];
+	for (const c of commentsRaw) {
+		if (c.in_reply_to_id) continue;
+		const state = c.pull_request_review_id ? reviewStateById.get(c.pull_request_review_id) ?? null : null;
+		tops.push({
+			id: c.id,
+			author: c.user ? {
+				login: c.user.login,
+				avatarUrl: c.user.avatar_url
+			} : null,
+			body: c.body ?? "",
+			path: c.path,
+			line: typeof c.line === "number" ? c.line : null,
+			side: c.side === "LEFT" || c.side === "RIGHT" ? c.side : null,
+			createdAt: c.created_at,
+			updatedAt: c.updated_at,
+			state,
+			replies: (replyByParent.get(c.id) ?? []).map((r) => ({
+				id: r.id,
+				author: r.user ? {
+					login: r.user.login,
+					avatarUrl: r.user.avatar_url
+				} : null,
+				body: r.body ?? "",
+				createdAt: r.created_at,
+				updatedAt: r.updated_at
+			})),
+			isOutdated: Boolean(c.line == null && c.original_line != null || c.position === null && c.original_position != null)
+		});
+	}
+	tops.sort((a, b) => {
+		if (a.path !== b.path) return a.path.localeCompare(b.path);
+		return (a.line ?? 0) - (b.line ?? 0);
+	});
+	return tops;
+}
+/**
+* POST the review to GitHub. Prefers `gh api` (uses the user's existing
+* `gh auth`); falls back to a direct HTTP call with `$GITHUB_TOKEN` when
+* `gh` is unavailable.
+*/
+async function submitReview(input) {
+	const gh = await detectGhCli();
+	if (gh.available && gh.authenticated) return submitViaGh(input);
+	const token = readGithubToken();
+	if (token) return submitViaToken(input, token);
+	return {
+		ok: false,
+		authSource: "none",
+		error: "Cannot submit: no `gh` CLI on $PATH (or not authenticated) and no $GITHUB_TOKEN env var. Run `gh auth login` or set $GITHUB_TOKEN."
+	};
+}
+/**
+* Map our `PrDecision` to the GitHub REST event string. Exported so the
+* test suite can pin the mapping (including the `rejected → REQUEST_CHANGES`
+* quirk, which exists because GitHub has no REJECT event).
+*
+* Returns `null` for `draft` — GitHub creates a PENDING review when `event`
+* is omitted from the payload.
+*/
+function decisionToEvent(decision) {
+	if (decision === "draft") return null;
+	if (decision === "approve") return "APPROVE";
+	if (decision === "request-changes") return "REQUEST_CHANGES";
+	return "COMMENT";
+}
+/**
+* Map open line-anchored `ReviewComment`s to GitHub multi-line review comments.
+* - `deletions` → LEFT, `additions` → RIGHT
+* - Ranges use `start_line`/`line` (no N-part explosion)
+* - File-level comments (`lineNumber === 0`) are excluded; callers fold them
+*   into the review body via {@link buildReviewPayload}.
+*/
+function expandMultiLineComments(comments) {
+	const flat = [];
+	for (const c of comments) {
+		if (c.status !== "open") continue;
+		if (c.lineNumber === 0) continue;
+		const path = stripBPrefix(c.filePath);
+		const side = c.side === "deletions" ? "LEFT" : "RIGHT";
+		const start = c.startLineNumber && c.startLineNumber < c.lineNumber ? c.startLineNumber : void 0;
+		const entry = {
+			path,
+			line: c.lineNumber,
+			side,
+			body: c.body
+		};
+		if (start !== void 0) {
+			entry.start_line = start;
+			entry.start_side = side;
+		}
+		flat.push(entry);
+	}
+	return flat;
+}
+function buildReviewPayload(input) {
+	const comments = input.comments ?? [];
+	const inline = expandMultiLineComments(comments);
+	const fileLevel = comments.filter((c) => c.status === "open" && c.lineNumber === 0);
+	let body = typeof input.body === "string" ? input.body.trim() : "";
+	if (fileLevel.length > 0) {
+		const block = ["### File comments", ...fileLevel.map((c) => {
+			return `**\`${stripBPrefix(c.filePath)}\`:** ${c.body}`;
+		})].join("\n\n");
+		body = body ? `${body}\n\n${block}` : block;
+	}
+	const event = decisionToEvent(input.decision ?? "comment");
+	if (event === null) return {
+		body: body || void 0,
+		comments: inline
+	};
+	return {
+		body: body || void 0,
+		event,
+		comments: inline
+	};
+}
+function stripBPrefix(path) {
+	if (path.startsWith("b/")) return path.slice(2);
+	if (path.startsWith("a/")) return path.slice(2);
+	return path;
+}
+async function submitViaGh(input) {
+	const payload = buildReviewPayload(input);
+	`${input.resolved.owner}${input.resolved.repo}`;
+	const args = [
+		"api",
+		"--method",
+		"POST",
+		`repos/${input.resolved.owner}/${input.resolved.repo}/pulls/${input.resolved.pullNumber}/reviews`,
+		"-H",
+		"Accept: application/vnd.github+json",
+		"--input",
+		"-"
+	];
+	try {
+		const { stdout } = await execFileAsync("gh", args, {
+			encoding: "utf-8",
+			maxBuffer: 20 * 1024 * 1024,
+			input: JSON.stringify(payload)
+		});
+		const result = JSON.parse(stdout);
+		return {
+			ok: true,
+			authSource: "gh",
+			reviewId: result.id,
+			reviewUrl: result.html_url
+		};
+	} catch (err) {
+		const stdout = err?.stdout || "";
+		const stderr = err?.stderr || err?.message || "unknown error";
+		let parsed = null;
+		try {
+			parsed = JSON.parse(stdout);
+		} catch {}
+		return {
+			ok: false,
+			authSource: "gh",
+			error: parsed?.message || stderr.trim()
+		};
+	}
+}
+async function submitViaToken(input, token) {
+	const payload = buildReviewPayload(input);
+	const url = `https://api.github.com/repos/${input.resolved.owner}/${input.resolved.repo}/pulls/${input.resolved.pullNumber}/reviews`;
+	try {
+		const res = await fetch(url, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${token}`,
+				Accept: "application/vnd.github+json",
+				"X-GitHub-Api-Version": "2022-11-28",
+				"Content-Type": "application/json",
+				"User-Agent": "diffing-cli"
+			},
+			body: JSON.stringify(payload)
+		});
+		if (!res.ok) {
+			const errBody = await res.text().catch(() => "");
+			return {
+				ok: false,
+				authSource: "token",
+				error: `HTTP ${res.status}: ${errBody.slice(0, 500)}`
+			};
+		}
+		const result = await res.json();
+		return {
+			ok: true,
+			authSource: "token",
+			reviewId: result.id,
+			reviewUrl: result.html_url
+		};
+	} catch (err) {
+		return {
+			ok: false,
+			authSource: "token",
+			error: err?.message || "Network error"
+		};
+	}
+}
+/**
+* Fetch check runs + combined status for a PR head via `gh api`.
+* Best-effort: returns [] on any failure so the UI can degrade gracefully.
+*/
+async function fetchPrChecks(resolved, headSha) {
+	const checks = [];
+	try {
+		const { stdout } = await execFileAsync("gh", [
+			"api",
+			`repos/${resolved.owner}/${resolved.repo}/commits/${headSha}/check-runs?per_page=50`,
+			"-H",
+			"Accept: application/vnd.github+json"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 10 * 1024 * 1024
+		});
+		const parsed = JSON.parse(stdout);
+		for (const run of parsed.check_runs ?? []) {
+			let state = "unknown";
+			if (run.status === "completed") {
+				const c = (run.conclusion ?? "").toLowerCase();
+				if (c === "success") state = "success";
+				else if (c === "failure" || c === "startup_failure") state = "failure";
+				else if (c === "neutral") state = "neutral";
+				else if (c === "cancelled") state = "cancelled";
+				else if (c === "timed_out") state = "timed_out";
+				else if (c === "skipped") state = "skipped";
+				else if (c === "action_required") state = "action_required";
+				else state = "error";
+			} else state = "pending";
+			checks.push({
+				name: run.name,
+				state,
+				conclusion: run.conclusion,
+				detailsUrl: run.html_url ?? null
+			});
+		}
+	} catch {}
+	return checks;
+}
+/**
+* Reply to an existing GitHub review comment (thread).
+* POST /repos/{owner}/{repo}/pulls/{pull_number}/comments with in_reply_to.
+*/
+async function replyToPrComment(input) {
+	const endpoint = `repos/${input.resolved.owner}/${input.resolved.repo}/pulls/${input.resolved.pullNumber}/comments`;
+	const payload = JSON.stringify({
+		body: input.body,
+		in_reply_to: input.inReplyTo
+	});
+	try {
+		const { stdout } = await execFileAsync("gh", [
+			"api",
+			"--method",
+			"POST",
+			endpoint,
+			"-H",
+			"Accept: application/vnd.github+json",
+			"--input",
+			"-"
+		], {
+			encoding: "utf-8",
+			input: payload,
+			maxBuffer: 5 * 1024 * 1024
+		});
+		return {
+			ok: true,
+			id: JSON.parse(stdout).id
+		};
+	} catch (err) {
+		const msg = err?.stderr || err?.stdout || err?.message || "reply failed";
+		return {
+			ok: false,
+			error: String(msg).slice(0, 500)
+		};
+	}
+}
+async function buildPrSession(ref) {
+	const meta = await fetchPrMetadataViaGh(parsePrRef(ref, await detectCwdRepo() ?? void 0));
+	return {
+		ref,
+		owner: meta.owner,
+		repo: meta.repo,
+		pullNumber: meta.number,
+		baseSha: meta.baseSha,
+		headSha: meta.headSha,
+		title: meta.title,
+		url: meta.url,
+		author: meta.author,
+		additions: meta.additions,
+		deletions: meta.deletions,
+		changedFiles: meta.changedFiles,
+		diff: meta.diff,
+		comments: [],
+		existingComments: meta.existingComments
+	};
+}
+/** Refresh `diff` + `existingComments` + head SHA in an existing session. */
+async function refreshPrSession(session) {
+	const meta = await fetchPrMetadataViaGh({
+		owner: session.owner,
+		repo: session.repo,
+		pullNumber: session.pullNumber,
+		ref: session.ref
+	});
+	return {
+		...session,
+		baseSha: meta.baseSha,
+		headSha: meta.headSha,
+		title: meta.title,
+		url: meta.url,
+		author: meta.author,
+		additions: meta.additions,
+		deletions: meta.deletions,
+		changedFiles: meta.changedFiles,
+		diff: meta.diff,
+		existingComments: meta.existingComments
+	};
+}
+//#endregion
+export { detectGhCli as a, fetchPrMetadataViaGh as c, readGithubToken as d, refreshPrSession as f, detectCwdRepo as i, parseGhAuthStatusUser as l, submitReview as m, buildReviewPayload as n, expandMultiLineComments as o, replyToPrComment as p, decisionToEvent as r, fetchPrChecks as s, buildPrSession as t, parsePrRef as u };