diffing 0.6.2 → 0.7.0

package/dist/cli-gh-6qiblgj7.mjs

@@ -0,0 +1,150 @@
+import { t as formatComments } from "./comment-format-CKTt0fzi.mjs";
+import { i as readServerLock, r as isLockAlive } from "./server-lock-uqSdDYeR.mjs";
+import { parseArgs } from "node:util";
+//#region src/cli-gh.ts
+/**
+* `diffing gh …` — the headless / port-agnostic surface for the PR review
+* mode. Mirrors the shape of the local review CLI: each subcommand resolves
+* the running server from the per-repo lockfile and talks to it via
+* localhost HTTP. No port ever leaves the lockfile.
+*
+*   diffing gh pr-fetch <ref>           → GET  /api/gh/pr/init then dump
+*   diffing gh pr-review                → POST /api/gh/submit (current session)
+*   diffing gh pr-list-comments         → GET  /api/gh/pr-session/comments (XML)
+*   diffing gh status                   → GET  /api/gh/session (one-line summary)
+*/
+const EXIT_OK = 0;
+const EXIT_NO_SERVER = 3;
+const EXIT_NOT_FOUND = 4;
+const EXIT_USAGE = 5;
+function baseUrl() {
+	const lock = readServerLock();
+	if (!lock || !isLockAlive(lock)) {
+		console.error("No diffing server running for this repo. Start one with `diffing \"gh pr <ref>\"`.");
+		process.exit(EXIT_NO_SERVER);
+	}
+	return `http://${lock.host === "0.0.0.0" || lock.host === "::" ? "127.0.0.1" : lock.host}:${lock.port}`;
+}
+async function ghStatus() {
+	const base = baseUrl();
+	const res = await fetch(`${base}/api/gh/session`);
+	if (res.status === 404) {
+		console.error("No active PR session. Start one with `diffing \"gh pr <ref>\"`.");
+		return EXIT_NOT_FOUND;
+	}
+	const s = await res.json();
+	const submittedLine = s.submittedAt ? `submitted at ${new Date(s.submittedAt).toISOString()} → ${s.submittedReviewUrl ?? "(no url)"}` : "not submitted yet";
+	console.log(`${s.owner}/${s.repo}#${s.pullNumber}  ${s.title}`);
+	console.log(`  url:        ${s.url}`);
+	console.log(`  author:     ${s.author?.login ?? "(unknown)"}`);
+	console.log(`  +${s.additions} -${s.deletions}  (${s.changedFiles} files)`);
+	console.log(`  head:       ${s.headSha.slice(0, 7)}`);
+	console.log(`  base:       ${s.baseSha.slice(0, 7)}`);
+	console.log(`  existing:   ${s.existingComments?.length ?? 0} review comments (read-only context)`);
+	console.log(`  new:        ${s.comments?.length ?? 0} comments in this session`);
+	console.log(`  status:     ${submittedLine}`);
+	return EXIT_OK;
+}
+async function ghPrFetch(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		options: { json: { type: "boolean" } },
+		allowPositionals: true
+	});
+	const ref = positionals[0];
+	if (!ref) {
+		console.error("Usage: diffing gh pr-fetch <ref> [--json]");
+		return EXIT_USAGE;
+	}
+	const base = baseUrl();
+	let res = await fetch(`${base}/api/gh/pr/refresh`, { method: "POST" });
+	if (res.status === 404) res = await fetch(`${base}/api/gh/pr/init`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ ref })
+	});
+	if (!res.ok) {
+		const err = await res.json().catch(() => ({}));
+		console.error(`Failed to fetch PR: ${err.error ?? res.statusText}`);
+		return 1;
+	}
+	const sessionRes = await fetch(`${base}/api/gh/session`);
+	const result = sessionRes.ok ? await sessionRes.json() : await res.json();
+	if (values.json) process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+	else console.log(`${result.owner}/${result.repo}#${result.pullNumber}  ${result.url}`);
+	return EXIT_OK;
+}
+async function ghPrListComments() {
+	const base = baseUrl();
+	const res = await fetch(`${base}/api/gh/pr-session/comments`);
+	if (res.status === 404) {
+		console.error("No active PR session.");
+		return EXIT_NOT_FOUND;
+	}
+	const comments = await res.json();
+	process.stdout.write(formatComments(comments) + "\n");
+	return EXIT_OK;
+}
+async function ghPrReview(args) {
+	const { values } = parseArgs({
+		args,
+		options: {
+			decision: {
+				type: "string",
+				short: "d"
+			},
+			body: {
+				type: "string",
+				short: "b"
+			},
+			"dry-run": { type: "boolean" },
+			json: { type: "boolean" }
+		},
+		allowPositionals: false
+	});
+	const decision = values.decision;
+	if (decision !== "approve" && decision !== "comment" && decision !== "request-changes" && decision !== "draft") {
+		console.error("Usage: diffing gh pr-review --decision <approve|comment|request-changes|draft> [--body <text>] [--dry-run]");
+		return EXIT_USAGE;
+	}
+	const base = baseUrl();
+	const payload = {
+		decision,
+		body: values.body ?? "",
+		dryRun: values["dry-run"] === true
+	};
+	const res = await fetch(`${base}/api/gh/submit`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(payload)
+	});
+	if (!res.ok) {
+		const err = await res.json().catch(() => ({}));
+		console.error(`Failed to submit review: ${err.error ?? res.statusText}`);
+		return 1;
+	}
+	const result = await res.json();
+	if (values.json) process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+	else if (result.ok) if (result.dryRun) console.log("Dry run OK — payload would have been accepted by GitHub.");
+	else console.log(`Review submitted via ${result.authSource}: ${result.reviewUrl ?? `#${result.reviewId}`}`);
+	else {
+		console.error(`Submit failed (auth=${result.authSource}): ${result.error ?? "unknown error"}`);
+		return 1;
+	}
+	return EXIT_OK;
+}
+async function runGhSubcommand(args) {
+	const action = args[0];
+	const rest = args.slice(1);
+	switch (action) {
+		case "status": return ghStatus();
+		case "pr-fetch": return ghPrFetch(rest);
+		case "pr-review": return ghPrReview(rest);
+		case "pr-list-comments": return ghPrListComments();
+		default:
+			console.error("Usage: diffing gh <status|pr-fetch|pr-review|pr-list-comments> [...]");
+			return EXIT_USAGE;
+	}
+}
+//#endregion
+export { runGhSubcommand };

package/dist/cli-gh-D5OCnjNe.mjs

@@ -0,0 +1,150 @@
+import { t as formatComments } from "./comment-format-B5AcGcR-.mjs";
+import { i as readServerLock, r as isLockAlive } from "./server-lock-uqSdDYeR.mjs";
+import { parseArgs } from "node:util";
+//#region src/cli-gh.ts
+/**
+* `diffing gh …` — the headless / port-agnostic surface for the PR review
+* mode. Mirrors the shape of the local review CLI: each subcommand resolves
+* the running server from the per-repo lockfile and talks to it via
+* localhost HTTP. No port ever leaves the lockfile.
+*
+*   diffing gh pr-fetch <ref>           → GET  /api/gh/pr/init then dump
+*   diffing gh pr-review                → POST /api/gh/submit (current session)
+*   diffing gh pr-list-comments         → GET  /api/gh/pr-session/comments (XML)
+*   diffing gh status                   → GET  /api/gh/session (one-line summary)
+*/
+const EXIT_OK = 0;
+const EXIT_NO_SERVER = 3;
+const EXIT_NOT_FOUND = 4;
+const EXIT_USAGE = 5;
+function baseUrl() {
+	const lock = readServerLock();
+	if (!lock || !isLockAlive(lock)) {
+		console.error("No diffing server running for this repo. Start one with `diffing \"gh pr <ref>\"`.");
+		process.exit(EXIT_NO_SERVER);
+	}
+	return `http://${lock.host === "0.0.0.0" || lock.host === "::" ? "127.0.0.1" : lock.host}:${lock.port}`;
+}
+async function ghStatus() {
+	const base = baseUrl();
+	const res = await fetch(`${base}/api/gh/session`);
+	if (res.status === 404) {
+		console.error("No active PR session. Start one with `diffing \"gh pr <ref>\"`.");
+		return EXIT_NOT_FOUND;
+	}
+	const s = await res.json();
+	const submittedLine = s.submittedAt ? `submitted at ${new Date(s.submittedAt).toISOString()} → ${s.submittedReviewUrl ?? "(no url)"}` : "not submitted yet";
+	console.log(`${s.owner}/${s.repo}#${s.pullNumber}  ${s.title}`);
+	console.log(`  url:        ${s.url}`);
+	console.log(`  author:     ${s.author?.login ?? "(unknown)"}`);
+	console.log(`  +${s.additions} -${s.deletions}  (${s.changedFiles} files)`);
+	console.log(`  head:       ${s.headSha.slice(0, 7)}`);
+	console.log(`  base:       ${s.baseSha.slice(0, 7)}`);
+	console.log(`  existing:   ${s.existingComments?.length ?? 0} review comments (read-only context)`);
+	console.log(`  new:        ${s.comments?.length ?? 0} comments in this session`);
+	console.log(`  status:     ${submittedLine}`);
+	return EXIT_OK;
+}
+async function ghPrFetch(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		options: { json: { type: "boolean" } },
+		allowPositionals: true
+	});
+	const ref = positionals[0];
+	if (!ref) {
+		console.error("Usage: diffing gh pr-fetch <ref> [--json]");
+		return EXIT_USAGE;
+	}
+	const base = baseUrl();
+	let res = await fetch(`${base}/api/gh/pr/refresh`, { method: "POST" });
+	if (res.status === 404) res = await fetch(`${base}/api/gh/pr/init`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ ref })
+	});
+	if (!res.ok) {
+		const err = await res.json().catch(() => ({}));
+		console.error(`Failed to fetch PR: ${err.error ?? res.statusText}`);
+		return 1;
+	}
+	const sessionRes = await fetch(`${base}/api/gh/session`);
+	const result = sessionRes.ok ? await sessionRes.json() : await res.json();
+	if (values.json) process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+	else console.log(`${result.owner}/${result.repo}#${result.pullNumber}  ${result.url}`);
+	return EXIT_OK;
+}
+async function ghPrListComments() {
+	const base = baseUrl();
+	const res = await fetch(`${base}/api/gh/pr-session/comments`);
+	if (res.status === 404) {
+		console.error("No active PR session.");
+		return EXIT_NOT_FOUND;
+	}
+	const comments = await res.json();
+	process.stdout.write(formatComments(comments) + "\n");
+	return EXIT_OK;
+}
+async function ghPrReview(args) {
+	const { values } = parseArgs({
+		args,
+		options: {
+			decision: {
+				type: "string",
+				short: "d"
+			},
+			body: {
+				type: "string",
+				short: "b"
+			},
+			"dry-run": { type: "boolean" },
+			json: { type: "boolean" }
+		},
+		allowPositionals: false
+	});
+	const decision = values.decision;
+	if (decision !== "approve" && decision !== "comment" && decision !== "request-changes" && decision !== "draft") {
+		console.error("Usage: diffing gh pr-review --decision <approve|comment|request-changes|draft> [--body <text>] [--dry-run]");
+		return EXIT_USAGE;
+	}
+	const base = baseUrl();
+	const payload = {
+		decision,
+		body: values.body ?? "",
+		dryRun: values["dry-run"] === true
+	};
+	const res = await fetch(`${base}/api/gh/submit`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(payload)
+	});
+	if (!res.ok) {
+		const err = await res.json().catch(() => ({}));
+		console.error(`Failed to submit review: ${err.error ?? res.statusText}`);
+		return 1;
+	}
+	const result = await res.json();
+	if (values.json) process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+	else if (result.ok) if (result.dryRun) console.log("Dry run OK — payload would have been accepted by GitHub.");
+	else console.log(`Review submitted via ${result.authSource}: ${result.reviewUrl ?? `#${result.reviewId}`}`);
+	else {
+		console.error(`Submit failed (auth=${result.authSource}): ${result.error ?? "unknown error"}`);
+		return 1;
+	}
+	return EXIT_OK;
+}
+async function runGhSubcommand(args) {
+	const action = args[0];
+	const rest = args.slice(1);
+	switch (action) {
+		case "status": return ghStatus();
+		case "pr-fetch": return ghPrFetch(rest);
+		case "pr-review": return ghPrReview(rest);
+		case "pr-list-comments": return ghPrListComments();
+		default:
+			console.error("Usage: diffing gh <status|pr-fetch|pr-review|pr-list-comments> [...]");
+			return EXIT_USAGE;
+	}
+}
+//#endregion
+export { runGhSubcommand };

package/dist/cli-gh-KjPnyST6.mjs

@@ -0,0 +1,150 @@
+import { t as formatComments } from "./comment-format-DG_PAehC.mjs";
+import { i as readServerLock, r as isLockAlive } from "./server-lock-uqSdDYeR.mjs";
+import { parseArgs } from "node:util";
+//#region src/cli-gh.ts
+/**
+* `diffing gh …` — the headless / port-agnostic surface for the PR review
+* mode. Mirrors the shape of the local review CLI: each subcommand resolves
+* the running server from the per-repo lockfile and talks to it via
+* localhost HTTP. No port ever leaves the lockfile.
+*
+*   diffing gh pr-fetch <ref>           → GET  /api/gh/pr/init then dump
+*   diffing gh pr-review                → POST /api/gh/submit (current session)
+*   diffing gh pr-list-comments         → GET  /api/gh/pr-session/comments (XML)
+*   diffing gh status                   → GET  /api/gh/session (one-line summary)
+*/
+const EXIT_OK = 0;
+const EXIT_NO_SERVER = 3;
+const EXIT_NOT_FOUND = 4;
+const EXIT_USAGE = 5;
+function baseUrl() {
+	const lock = readServerLock();
+	if (!lock || !isLockAlive(lock)) {
+		console.error("No diffing server running for this repo. Start one with `diffing \"gh pr <ref>\"`.");
+		process.exit(EXIT_NO_SERVER);
+	}
+	return `http://${lock.host === "0.0.0.0" || lock.host === "::" ? "127.0.0.1" : lock.host}:${lock.port}`;
+}
+async function ghStatus() {
+	const base = baseUrl();
+	const res = await fetch(`${base}/api/gh/session`);
+	if (res.status === 404) {
+		console.error("No active PR session. Start one with `diffing \"gh pr <ref>\"`.");
+		return EXIT_NOT_FOUND;
+	}
+	const s = await res.json();
+	const submittedLine = s.submittedAt ? `submitted at ${new Date(s.submittedAt).toISOString()} → ${s.submittedReviewUrl ?? "(no url)"}` : "not submitted yet";
+	console.log(`${s.owner}/${s.repo}#${s.pullNumber}  ${s.title}`);
+	console.log(`  url:        ${s.url}`);
+	console.log(`  author:     ${s.author?.login ?? "(unknown)"}`);
+	console.log(`  +${s.additions} -${s.deletions}  (${s.changedFiles} files)`);
+	console.log(`  head:       ${s.headSha.slice(0, 7)}`);
+	console.log(`  base:       ${s.baseSha.slice(0, 7)}`);
+	console.log(`  existing:   ${s.existingComments?.length ?? 0} review comments (read-only context)`);
+	console.log(`  new:        ${s.comments?.length ?? 0} comments in this session`);
+	console.log(`  status:     ${submittedLine}`);
+	return EXIT_OK;
+}
+async function ghPrFetch(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		options: { json: { type: "boolean" } },
+		allowPositionals: true
+	});
+	const ref = positionals[0];
+	if (!ref) {
+		console.error("Usage: diffing gh pr-fetch <ref> [--json]");
+		return EXIT_USAGE;
+	}
+	const base = baseUrl();
+	let res = await fetch(`${base}/api/gh/pr/refresh`, { method: "POST" });
+	if (res.status === 404) res = await fetch(`${base}/api/gh/pr/init`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ ref })
+	});
+	if (!res.ok) {
+		const err = await res.json().catch(() => ({}));
+		console.error(`Failed to fetch PR: ${err.error ?? res.statusText}`);
+		return 1;
+	}
+	const sessionRes = await fetch(`${base}/api/gh/session`);
+	const result = sessionRes.ok ? await sessionRes.json() : await res.json();
+	if (values.json) process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+	else console.log(`${result.owner}/${result.repo}#${result.pullNumber}  ${result.url}`);
+	return EXIT_OK;
+}
+async function ghPrListComments() {
+	const base = baseUrl();
+	const res = await fetch(`${base}/api/gh/pr-session/comments`);
+	if (res.status === 404) {
+		console.error("No active PR session.");
+		return EXIT_NOT_FOUND;
+	}
+	const comments = await res.json();
+	process.stdout.write(formatComments(comments) + "\n");
+	return EXIT_OK;
+}
+async function ghPrReview(args) {
+	const { values } = parseArgs({
+		args,
+		options: {
+			decision: {
+				type: "string",
+				short: "d"
+			},
+			body: {
+				type: "string",
+				short: "b"
+			},
+			"dry-run": { type: "boolean" },
+			json: { type: "boolean" }
+		},
+		allowPositionals: false
+	});
+	const decision = values.decision;
+	if (decision !== "approve" && decision !== "comment" && decision !== "request-changes" && decision !== "draft") {
+		console.error("Usage: diffing gh pr-review --decision <approve|comment|request-changes|draft> [--body <text>] [--dry-run]");
+		return EXIT_USAGE;
+	}
+	const base = baseUrl();
+	const payload = {
+		decision,
+		body: values.body ?? "",
+		dryRun: values["dry-run"] === true
+	};
+	const res = await fetch(`${base}/api/gh/submit`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(payload)
+	});
+	if (!res.ok) {
+		const err = await res.json().catch(() => ({}));
+		console.error(`Failed to submit review: ${err.error ?? res.statusText}`);
+		return 1;
+	}
+	const result = await res.json();
+	if (values.json) process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+	else if (result.ok) if (result.dryRun) console.log("Dry run OK — payload would have been accepted by GitHub.");
+	else console.log(`Review submitted via ${result.authSource}: ${result.reviewUrl ?? `#${result.reviewId}`}`);
+	else {
+		console.error(`Submit failed (auth=${result.authSource}): ${result.error ?? "unknown error"}`);
+		return 1;
+	}
+	return EXIT_OK;
+}
+async function runGhSubcommand(args) {
+	const action = args[0];
+	const rest = args.slice(1);
+	switch (action) {
+		case "status": return ghStatus();
+		case "pr-fetch": return ghPrFetch(rest);
+		case "pr-review": return ghPrReview(rest);
+		case "pr-list-comments": return ghPrListComments();
+		default:
+			console.error("Usage: diffing gh <status|pr-fetch|pr-review|pr-list-comments> [...]");
+			return EXIT_USAGE;
+	}
+}
+//#endregion
+export { runGhSubcommand };

package/dist/cli.mjs

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
-import { c as printHelp, i as validateEnvironment, n as loadSettings, o as intoShowMode, r as runTerminalDiff, s as parseDiffOptions, t as startServer } from "./server-BZBFquG8.mjs";
-import { i as readServerLock, n as diffScopeKey, o as removeServerLockIfOwned, r as isLockAlive, s as writeServerLock, t as acquireServerStartupLease, v as getRepoRoot } from "./server-lock-DaSx7DjW.mjs";
-import { execFileSync, spawn } from "node:child_process";
+import { a as intoShowMode, n as runTerminalDiff, o as parseDiffOptions, r as validateEnvironment, s as printHelp, t as startServer } from "./server-C105rwQw.mjs";
+import { p as getRepoRoot } from "./git-Czo96ymM.mjs";
+import { t as loadSettings } from "./settings-BVnzGFL7.mjs";
+import { i as readServerLock, n as diffScopeKey, o as removeServerLockIfOwned, r as isLockAlive, s as writeServerLock, t as acquireServerStartupLease } from "./server-lock-uqSdDYeR.mjs";
+import { t as findTuiBinary$1 } from "./find-tui-binary-CRpbYXLC.mjs";
+import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { dirname, isAbsolute, resolve } from "node:path";
@@ -391,53 +394,6 @@ function playStartupDisplay() {
 	})();
 }
 //#endregion
-//#region src/lib/find-tui-binary.ts
-/**
-* Locate the `diffing-tui` native binary. Looks, in order:
-*   1. Sibling of the calling module (`dist/diffing-tui[.exe]` after build).
-*   2. `bin/diffing-tui[.exe]` next to the package root.
-*   3. `target/release/diffing-tui[.exe]` next to the package root
-*      (cargo release build).
-*   4. `target/debug/diffing-tui[.exe]` next to the package root
-*      (cargo debug build — the common case during development, especially
-*      on Windows where release builds are slow).
-*   5. `$PATH` lookup via `which` / `where`.
-*
-* Returns the absolute path of the first match, or `null` if none are found.
-*
-* `callerUrl` is the `import.meta.url` of the caller — pass `import.meta.url`
-* from `cli.ts`. Exposed as a parameter so unit tests can pin the search
-* root to a known location instead of depending on the test runner's CWD.
-*/
-function findTuiBinary$1(callerUrl) {
-	const ext = process.platform === "win32" ? ".exe" : "";
-	const here = dirname(fileURLToPath(callerUrl));
-	const candidates = [
-		resolve(here, `diffing-tui${ext}`),
-		resolve(here, "..", "bin", `diffing-tui${ext}`),
-		resolve(here, "..", "target", "release", `diffing-tui${ext}`),
-		resolve(here, "..", "..", "target", "release", `diffing-tui${ext}`),
-		resolve(here, "..", "target", "debug", `diffing-tui${ext}`),
-		resolve(here, "..", "..", "target", "debug", `diffing-tui${ext}`)
-	];
-	for (const c of candidates) if (existsSync(c)) return c;
-	try {
-		const out = execFileSync(process.platform === "win32" ? "where" : "which", ["diffing-tui"], {
-			encoding: "utf-8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			]
-		}).trim();
-		if (out) {
-			const first = out.split(/\r?\n/)[0]?.trim();
-			if (first && isAbsolute(first)) return first;
-		}
-	} catch {}
-	return null;
-}
-//#endregion
 //#region src/cli.ts
 const args = process.argv.slice(2);
 let prRef = null;
@@ -457,12 +413,18 @@ if (new Set([
 	"await-review",
 	"reply",
 	"resolve",
+	"unresolve",
+	"comment",
 	"comments",
 	"url",
 	"mcp",
 	"plan",
 	"update",
-	"gh"
+	"gh",
+	"doctor",
+	"completion",
+	"progress",
+	"inspect"
 ]).has(args[0])) {
 	if (args[0] === "mcp") {
 		const mcpArgs = args.slice(1);
@@ -471,10 +433,16 @@ if (new Set([
 
 Run diffing as a local stdio MCP server bound to one Git repository.
 
+The server advertises session, diff inspection, comment lifecycle, plan
+review, progress, and history tools. Prefer MCP when the harness exposes
+it; otherwise use the CLI mirrors (await-review, comments, plan, …).
+
 Options:
   --repo <path>  Bind to this absolute Git repository path.
                  If omitted, the Git repository containing the current directory is used.
-  -h, --help     Show this help.`);
+  -h, --help     Show this help.
+
+See docs/cli.md §5 (MCP) for the full tool table.`);
 			process.exit(0);
 		}
 		let repoPath;
@@ -507,11 +475,11 @@ Options:
 			console.error("diffing mcp: --repo must be an absolute path");
 			process.exit(5);
 		}
-		const { startMcpServer } = await import("./mcp-BgZO-iXI.mjs");
+		const { startMcpServer } = await import("./mcp-eor39qmD.mjs");
 		await startMcpServer({ repoPath });
 		await new Promise(() => {});
 	}
-	const { runSubcommand } = await import("./cli-agent-BkkRbKqq.mjs");
+	const { runSubcommand } = await import("./cli-agent-D71pq2ep.mjs");
 	process.exit(await runSubcommand(args[0], args.slice(1)));
 }
 let showSubcommand = false;
@@ -520,6 +488,7 @@ if (args[0] === "show") {
 	args.shift();
 }
 const opts = parseDiffOptions(args);
+if (!prRef && opts.ghPr) prRef = opts.ghPr;
 if (showSubcommand) {
 	if (opts.revisions.length === 0 && !opts.help && !opts.version) {
 		console.error("Usage: diffing show <revspec>... [-- <pathspec>...]");
@@ -554,7 +523,7 @@ const __pkgDir = dirname(fileURLToPath(import.meta.url));
 const currentVersion = JSON.parse(readFileSync(resolve(__pkgDir, "..", "package.json"), "utf-8")).version;
 const updateCheckPromise = (async () => {
 	try {
-		const { checkForUpdates } = await import("./update-check-CXeSZANo.mjs");
+		const { checkForUpdates } = await import("./update-check-fe0tR8tx.mjs");
 		return await checkForUpdates(currentVersion);
 	} catch {
 		return null;
@@ -564,6 +533,7 @@ const port = await getPort(opts.port ? { port: opts.port } : void 0);
 const host = opts.host;
 const clientDir = resolve(__pkgDir, "client");
 const resolvedClientDir = existsSync(clientDir) ? clientDir : resolve(process.cwd(), "dist/client");
+const openModulePromise = opts.noOpen ? null : import("open");
 let repoRoot;
 try {
 	repoRoot = getRepoRoot();
@@ -616,23 +586,25 @@ try {
 startupLease.release();
 const localUrl = `http://${host}:${actualPort}`;
 console.log(`diffing server running at ${localUrl}`);
-await playStartupDisplay();
-try {
-	const updateInfo = await updateCheckPromise;
-	if (updateInfo?.hasUpdate) {
-		const { printUpdateDisclaimer } = await import("./update-check-CXeSZANo.mjs");
-		printUpdateDisclaimer(currentVersion, updateInfo.latestVersion);
-	}
-} catch {}
-if (!opts.noOpen) {
+if (openModulePromise) try {
 	const settings = loadSettings();
-	const openUrl = `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${actualPort}`;
-	const openModule = await import("open");
+	const openUrl = `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${actualPort}${prMode ? "/gh/pr" : ""}`;
+	const openModule = await openModulePromise;
 	let appName;
 	if (settings.browser) appName = openModule.apps[settings.browser] || settings.browser;
 	const options = appName ? { app: { name: appName } } : {};
 	openModule.default(openUrl, options);
+} catch (err) {
+	console.error("Failed to open browser:", err instanceof Error ? err.message : err);
 }
+playStartupDisplay();
+try {
+	const updateInfo = await updateCheckPromise;
+	if (updateInfo?.hasUpdate) {
+		const { printUpdateDisclaimer } = await import("./update-check-fe0tR8tx.mjs");
+		printUpdateDisclaimer(currentVersion, updateInfo.latestVersion);
+	}
+} catch {}
 const shutdown = () => {
 	console.log("\nShutting down...");
 	removeServerLockIfOwned(repoRoot, process.pid, sessionOwnerId);