diffing 0.2.1 → 0.3.0

package/dist/cli.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { C as revertHunk, S as listRepoFiles, T as toSafeRelativePath, _ as getRepoRoot, a as extractPlanLines, b as gitAddFile, c as formatComments, d as getFileContent, f as getGitDiffAsync, g as getRepoName, h as getProjectStorageDir, i as writeServerLock, l as getBranchName, m as getMergeStatus, o as formatPlanReview, p as getHunkHistory, r as removeServerLock, s as sectionTitleForLine, u as getCustomGitDiffAsync, v as getTabSizeForFiles, w as isSafePath, x as isGitRepo, y as getUntrackedFilePathsAsync } from "./server-lock-DpCrvL-Z.mjs";
+import { C as toSafeRelativePath, S as isSafePath, _ as getUntrackedFilePathsAsync, a as formatComments, b as listRepoFiles, c as getFileContent, d as getMergeStatus, f as getProjectStorageDir, g as getTabSizeForFiles, h as getShowDiff, i as writeServerLock, l as getGitDiffAsync, m as getRepoRoot, o as getBranchName, p as getRepoName, r as removeServerLock, s as getCustomGitDiffAsync, u as getHunkHistory, v as gitAddFile, x as revertHunk, y as isGitRepo } from "./server-lock-Dj9fG9md.mjs";
+import { n as formatPlanReview, r as sectionTitleForLine, t as extractPlanLines } from "./plan-format-f62JWFI-.mjs";
+import { execFile, execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { dirname, extname, join, resolve } from "node:path";
+import { dirname, extname, isAbsolute, join, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync, watch, writeFileSync } from "node:fs";
 import getPort from "get-port";
-import { parseArgs } from "node:util";
-import { execFileSync } from "node:child_process";
+import { parseArgs, promisify } from "node:util";
 import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { Hono } from "hono";
@@ -48,7 +49,11 @@ const DEFAULTS$1 = {
 	help: false,
 	version: false,
 	includeUnstaged: true,
-	includeUntracked: true
+	includeUntracked: true,
+	tui: false,
+	gpu: false,
+	showMode: false,
+	showRevspecs: []
 };
 /**
 * All git-diff option definitions for `node:util.parseArgs`.
@@ -173,6 +178,15 @@ const DIFFING_OPTIONS = {
 		type: "boolean",
 		default: false
 	},
+	tui: {
+		type: "boolean",
+		default: false
+	},
+	gpu: {
+		type: "boolean",
+		default: false
+	},
+	"gh-pr": { type: "string" },
 	help: {
 		type: "boolean",
 		short: "h"
@@ -209,18 +223,37 @@ Output Modes:
   - Terminal mode: when output is a pipe, redirect, or non-TTY
   - Web mode:     when output is a TTY (interactive terminal)
 
-  Force a mode with --web or --terminal flags.
+  Force a mode with --web, --terminal, or --tui flags.
+  --tui is experimental and opt-in. It opens a native-Rust terminal
+  interface that mirrors the web dashboard. Falls back to git diff
+  output if the environment cannot support a TUI (piped stdin, CI,
+  missing binary).
+
+Subcommands:
+  show <revspec>...    Drop-in for 'git show'. Renders commit metadata
+                       (subject, author, date, message body) above the
+                       diff in the web UI. Accepts single commits,
+                       ranges (a..b, a...b), tags, and multiple SHAs.
+                       Use '--' to separate revspecs from pathspecs.
 
 Examples:
   diffing                        Review uncommitted changes (web UI)
   diffing --staged               Review staged changes
   diffing HEAD~3                 Review last 3 commits
   diffing main..feature          Compare branches
+  diffing show HEAD              Review a single commit's metadata + diff
+  diffing show HEAD~3..HEAD      Review the last 3 commits as a series
+  diffing show HEAD -- src/      Limit a commit review to a directory
   diffing --diff-algorithm=patience src/  Diff with patience algorithm
   diffing -U10                   Diff with 10 context lines
   diffing --word-diff=color      Word-level diff in color
   diffing -b -w                  Ignore whitespace changes
-  diffing --host 0.0.0.0         Allow other machines on the LAN to review`);
+  diffing --host 0.0.0.0         Allow other machines on the LAN to review
+  diffing --tui                  Open the experimental TUI (native Rust)
+
+Note: 'diffing <sha>' runs 'git diff <sha>' (working tree vs <sha>); it
+is not the same as 'diffing show <sha>'. Use 'show' when you want to
+review a commit's changes.`);
 }
 function printGitDiffHelp() {
 	console.log(`
@@ -464,7 +497,8 @@ function parseDiffOptions(rawArgs) {
 		}
 		for (let i = dashDashIdx + 1; i < rawArgs.length; i++) opts.pathspecs.push(rawArgs[i]);
 	} else for (const p of positionals) opts.revisions.push(p);
-	if (values.web) opts.outputMode = "web";
+	if (values.tui) opts.outputMode = "tui";
+	else if (values.web) opts.outputMode = "web";
 	else if (values.terminal) opts.outputMode = "terminal";
 	if (process.stdout.isTTY && opts.outputMode === "auto") opts.outputMode = "web";
 	else if (!process.stdout.isTTY && opts.outputMode === "auto") opts.outputMode = "terminal";
@@ -545,6 +579,21 @@ function buildGitDiffArgs(opts) {
 	}
 	return args;
 }
+/**
+* Transform a `parseDiffOptions(...)` result into a "show mode" variant:
+* moves any parsed revisions into `showRevspecs`, clears `revisions` (so the
+* existing diff-engine path does not try to `git diff` them), and sets the
+* `showMode` flag. Pathspecs and every other flag survive unchanged.
+*
+* Returns the same object for callsite ergonomics — the mutation is in-place
+* because `parseDiffOptions` always returns a fresh object.
+*/
+function intoShowMode(opts) {
+	opts.showRevspecs = opts.revisions;
+	opts.revisions = [];
+	opts.showMode = true;
+	return opts;
+}
 //#endregion
 //#region src/lib/diff-engine.ts
 const MAX_BUFFER = 50 * 1024 * 1024;
@@ -553,10 +602,11 @@ const MAX_BUFFER = 50 * 1024 * 1024;
 * or a "custom" mode (specific revisions / pathspecs).
 *
 * Custom mode is used when the user provides explicit revisions or pathspecs
-* beyond just toggling staged/untracked.
+* beyond just toggling staged/untracked. `showMode` is *also* a custom mode
+* — the "Show staged / Show untracked" toggles don't apply to a commit view.
 */
 function isCustomMode$1(opts) {
-	return opts.revisions.length > 0 || opts.pathspecs.length > 0;
+	return opts.revisions.length > 0 || opts.pathspecs.length > 0 || opts.showMode;
 }
 function parseFilePaths(patch) {
 	const paths = /* @__PURE__ */ new Set();
@@ -603,8 +653,24 @@ function parseBinaryFiles(patch, untrackedFiles) {
 }
 /**
 * Execute a diff asynchronously — used by the server.
+*
+* Show mode bypasses the normal `git diff` path entirely: it resolves
+* revspecs to a commit list and fetches per-commit metadata + patches in
+* one `git log` call. The concatenated patch is returned in the same shape
+* the existing UI pipeline expects (so file tree, binary detection, and
+* tab-size detection all keep working unchanged); the per-commit data
+* rides along on `commits` for the metadata banners.
 */
 async function executeDiffAsync(opts) {
+	if (opts.showMode) {
+		const { commits, patch, truncated } = await getShowDiff(opts.showRevspecs, opts.pathspecs);
+		return {
+			patch,
+			args: [],
+			commits,
+			truncated
+		};
+	}
 	if (isCustomMode$1(opts)) {
 		const args = buildGitDiffArgs(opts);
 		return {
@@ -624,10 +690,10 @@ async function executeDiffAsync(opts) {
 * Execute a diff and produce the full enriched result used by the web API.
 */
 async function executeDiffWithMeta(opts) {
-	const { patch } = await executeDiffAsync(opts);
+	const { patch, commits, truncated } = await executeDiffAsync(opts);
 	const repoName = getRepoName();
 	const branch = getBranchName();
-	const untrackedFiles = opts.includeUntracked ? await getUntrackedFilePathsAsync() : [];
+	const untrackedFiles = opts.includeUntracked && !opts.showMode ? await getUntrackedFilePathsAsync() : [];
 	const binaryFiles = parseBinaryFiles(patch, new Set(untrackedFiles));
 	const filePaths = parseFilePaths(patch);
 	return {
@@ -637,14 +703,19 @@ async function executeDiffWithMeta(opts) {
 		tabSizeMap: getTabSizeForFiles(filePaths),
 		untrackedFiles,
 		repoName,
-		branch
+		branch,
+		...commits ? { commits } : {},
+		...truncated ? { truncated } : {}
 	};
 }
 /**
 * Run the diff in terminal mode: forward to git diff with full flags,
-* output to stdout. Behaves identically to `git diff`.
+* output to stdout. Behaves identically to `git diff`. In show mode this
+* delegates to `git show` instead so `diffing show <rev>... --terminal`
+* is a drop-in for `git show <rev>...`.
 */
 function runTerminalDiff(opts) {
+	if (opts.showMode) return runTerminalShow(opts);
 	const args = buildGitDiffArgs(opts);
 	const enforceDefaults = !opts.outputFormat && !opts.quiet;
 	const finalArgs = [];
@@ -665,6 +736,30 @@ function runTerminalDiff(opts) {
 	}
 }
 /**
+* Terminal mode for `diffing show`: spawn `git show` with the user's revspecs
+* and pathspecs, inherit stdio, propagate exit code. We pass `--no-ext-diff`
+* so the output is a clean unified diff regardless of the user's git config
+* (matches the web-mode pipeline), but otherwise hand everything to git.
+*/
+function runTerminalShow(opts) {
+	const args = [
+		"show",
+		"--no-ext-diff",
+		...opts.showRevspecs
+	];
+	if (opts.pathspecs.length > 0) args.push("--", ...opts.pathspecs);
+	try {
+		execFileSync("git", args, {
+			encoding: "utf-8",
+			maxBuffer: MAX_BUFFER,
+			stdio: "inherit"
+		});
+		return 0;
+	} catch (err) {
+		return err.status ?? 1;
+	}
+}
+/**
 * Validate the environment: check that we're in a git repo.
 * Returns an error message or null.
 */
@@ -1438,6 +1533,62 @@ var FileUiStateStore = class {
 	}
 };
 //#endregion
+//#region src/lib/editor-launcher.ts
+function resolveEditorCommand(editor, absolutePath, platform = process.platform, env = process.env) {
+	switch (editor) {
+		case "vscode": return guiEditorCommand("code", absolutePath, platform);
+		case "zed": return guiEditorCommand("zed", absolutePath, platform);
+		case "vim": return terminalEditorCommand("vim", absolutePath, platform, env);
+		case "neovim": return terminalEditorCommand("nvim", absolutePath, platform, env);
+		default: return null;
+	}
+}
+function guiEditorCommand(bin, absolutePath, platform) {
+	if (platform === "win32") return {
+		cmd: `${bin}.cmd`,
+		args: [absolutePath]
+	};
+	return {
+		cmd: bin,
+		args: [absolutePath]
+	};
+}
+function terminalEditorCommand(bin, absolutePath, platform, env) {
+	if (platform === "darwin") return {
+		cmd: "osascript",
+		args: ["-e", `tell application "Terminal" to do script "${bin} \\"${absolutePath.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}\\""`]
+	};
+	if (platform === "win32") return {
+		cmd: "cmd.exe",
+		args: [
+			"/c",
+			"start",
+			"\"\"",
+			"cmd.exe",
+			"/k",
+			bin,
+			absolutePath
+		]
+	};
+	const term = env.TERMINAL?.trim();
+	if (term) return {
+		cmd: term,
+		args: [
+			"-e",
+			bin,
+			absolutePath
+		]
+	};
+	return {
+		cmd: "x-terminal-emulator",
+		args: [
+			"-e",
+			bin,
+			absolutePath
+		]
+	};
+}
+//#endregion
 //#region src/lib/review-session.ts
 var ReviewSession = class {
 	round = 0;
@@ -1630,6 +1781,483 @@ var PlanReviewSession = class {
 	}
 };
 //#endregion
+//#region src/lib/pr-session.ts
+var FilePrSessionStore = class {
+	dirPath;
+	filePath;
+	constructor(storageDir) {
+		this.dirPath = storageDir ?? getProjectStorageDir();
+		this.filePath = join(this.dirPath, "pr-session.json");
+	}
+	async get() {
+		try {
+			const data = await readFile(this.filePath, "utf-8");
+			return JSON.parse(data);
+		} catch {
+			return null;
+		}
+	}
+	async save(session) {
+		try {
+			await mkdir(this.dirPath, { recursive: true });
+			await writeFile(this.filePath, JSON.stringify(session, null, 2), "utf-8");
+		} catch (err) {
+			console.error("Failed to save pr-session to file:", err);
+		}
+	}
+	async set(session) {
+		await this.save(session);
+	}
+	async update(fields) {
+		const current = await this.get();
+		if (!current) return null;
+		const next = {
+			...current,
+			...fields
+		};
+		await this.save(next);
+		return next;
+	}
+	async clear() {
+		try {
+			const { unlink } = await import("node:fs/promises");
+			await unlink(this.filePath);
+		} catch {}
+	}
+};
+//#endregion
+//#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 headOwner = metaJson.headRepositoryOwner?.login || metaJson.headRepository?.owner?.login || resolved.owner;
+	const repoName = metaJson.headRepository?.name || resolved.repo;
+	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: headOwner,
+		repo: repoName,
+		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: typeof c.position === "number" && c.position === null ? false : false
+		});
+	}
+	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).
+*/
+function decisionToEvent(decision) {
+	if (decision === "approve") return "APPROVE";
+	if (decision === "request-changes") return "REQUEST_CHANGES";
+	return "COMMENT";
+}
+/**
+* Expand multi-line `ReviewComment`s into N single-line `gh`-shaped entries
+* with `[part N/M]` prefixes. Exported for the test suite — the body of the
+* caller (`buildReviewPayload`) is otherwise private.
+*
+* Skips: non-`open` comments, file-level comments (`lineNumber === 0`).
+* Strips the `a/` / `b/` prefix from the file path (GitHub expects PR-relative
+* paths in the `path` field).
+*/
+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 start = c.startLineNumber && c.startLineNumber < c.lineNumber ? c.startLineNumber : c.lineNumber;
+		const end = c.lineNumber;
+		const span = end - start + 1;
+		if (span > 1) for (let i = 0; i < span; i++) flat.push({
+			path,
+			line: start + i,
+			side: "RIGHT",
+			body: `[part ${i + 1}/${span}]\n${c.body}`
+		});
+		else flat.push({
+			path,
+			line: end,
+			side: "RIGHT",
+			body: c.body
+		});
+	}
+	return flat;
+}
+function buildReviewPayload(input) {
+	return {
+		body: input.body,
+		event: decisionToEvent(input.decision ?? "comment"),
+		comments: expandMultiLineComments(input.comments ?? [])
+	};
+}
+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"
+		};
+	}
+}
+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
 //#region src/server.ts
 const MIME_TYPES = {
 	".html": "text/html",
@@ -1647,13 +2275,14 @@ const MIME_TYPES = {
 	".avif": "image/avif"
 };
 function isCustomMode(opts) {
-	return opts.revisions.length > 0 || opts.pathspecs.length > 0;
+	return opts.revisions.length > 0 || opts.pathspecs.length > 0 || opts.showMode;
 }
-function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
+function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore, prSessionStore) {
 	const app = new Hono();
 	const customMode = isCustomMode(diffOpts);
 	const store = commentStore ?? new FileCommentStore();
 	const plans = planStore ?? new FilePlanStore();
+	const prStore = prSessionStore ?? new FilePrSessionStore();
 	const uiStateStore = new FileUiStateStore();
 	const viewedFiles = /* @__PURE__ */ new Set();
 	const activeClients = /* @__PURE__ */ new Set();
@@ -1675,6 +2304,7 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 		mkdirSync(storageDir, { recursive: true });
 		let commentsDebounce = null;
 		let plansDebounce = null;
+		let prSessionDebounce = null;
 		watch(storageDir, (_eventType, filename) => {
 			if (!filename) return;
 			if (filename.startsWith("comments.json")) {
@@ -1683,6 +2313,9 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 			} else if (filename.startsWith("plans.json")) {
 				if (plansDebounce) clearTimeout(plansDebounce);
 				plansDebounce = setTimeout(() => broadcast("plans", Date.now().toString()), 120);
+			} else if (filename.startsWith("pr-session.json")) {
+				if (prSessionDebounce) clearTimeout(prSessionDebounce);
+				prSessionDebounce = setTimeout(() => broadcast("pr-session", Date.now().toString()), 120);
 			}
 		}).unref();
 	} catch (err) {
@@ -1743,11 +2376,40 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 	app.get("/api/diff", async (c) => {
 		const staged = c.req.query("staged") === "true";
 		const untracked = c.req.query("untracked") === "true";
-		const result = await executeDiffWithMeta(customMode ? diffOpts : {
+		const prSession = await prStore.get();
+		if (prSession) {
+			const binaryFiles = [];
+			const filePaths = [];
+			for (const line of prSession.diff.split("\n")) {
+				const m = /^diff --git a\/.+ b\/(.+)$/.exec(line);
+				if (m) filePaths.push(m[1]);
+			}
+			return c.json({
+				patch: prSession.diff,
+				repoName: prSession.repo,
+				branch: `#${prSession.pullNumber}`,
+				customMode: true,
+				binaryFiles,
+				tabSizeMap: {},
+				untrackedFiles: [],
+				prMode: true,
+				prRef: prSession.ref,
+				prOwner: prSession.owner,
+				prRepo: prSession.repo,
+				prPullNumber: prSession.pullNumber,
+				prUrl: prSession.url,
+				prTitle: prSession.title,
+				prAuthor: prSession.author,
+				prHeadSha: prSession.headSha,
+				prBaseSha: prSession.baseSha
+			});
+		}
+		const optsForDiff = customMode ? diffOpts : {
 			...diffOpts,
 			staged,
 			includeUntracked: untracked
-		});
+		};
+		const result = await executeDiffWithMeta(optsForDiff);
 		return c.json({
 			patch: result.patch,
 			repoName: result.repoName,
@@ -1755,7 +2417,10 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 			customMode,
 			binaryFiles: result.binaryFiles,
 			tabSizeMap: result.tabSizeMap,
-			untrackedFiles: result.untrackedFiles
+			untrackedFiles: result.untrackedFiles,
+			showMode: optsForDiff.showMode || void 0,
+			commits: result.commits,
+			truncated: result.truncated
 		});
 	});
 	app.get("/api/file-content", (c) => {
@@ -1791,12 +2456,17 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 			const relPath = toSafeRelativePath(filePath, root);
 			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
 			const absolutePath = resolve(root, relPath);
-			const { exec } = await import("node:child_process");
-			if (editor === "vscode") exec(`code "${absolutePath}"`);
-			else if (editor === "zed") exec(`zed "${absolutePath}"`);
-			else if (editor === "vim") exec(`osascript -e 'tell application "Terminal" to do script "vim \\"${absolutePath}\\""'`);
-			else if (editor === "neovim") exec(`osascript -e 'tell application "Terminal" to do script "nvim \\"${absolutePath}\\""'`);
-			else await (await import("open")).default(absolutePath);
+			if (editor && editor !== "default") {
+				const command = resolveEditorCommand(editor, absolutePath);
+				if (command) {
+					const { execFile } = await import("node:child_process");
+					execFile(command.cmd, command.args, (err) => {
+						if (err) console.error(`Failed to launch ${editor} for ${absolutePath}: ${err.message}`);
+					});
+					return c.json({ ok: true });
+				}
+			}
+			await (await import("open")).default(absolutePath);
 			return c.json({ ok: true });
 		} catch (err) {
 			return c.json({ error: `Failed to open file: ${err.message}` }, 500);
@@ -1881,7 +2551,7 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 		try {
 			const relPath = toSafeRelativePath(filePath, getRepoRoot());
 			if (!relPath) return c.json({ error: "Forbidden file path" }, 403);
-			const history = getHunkHistory(relPath, deletionStart, deletionCount, diffOpts.revisions[0] || "HEAD");
+			const history = getHunkHistory(relPath, deletionStart, deletionCount, diffOpts.showMode ? diffOpts.showRevspecs[diffOpts.showRevspecs.length - 1] || "HEAD" : diffOpts.revisions[0] || "HEAD");
 			return c.json(history);
 		} catch (err) {
 			return c.json({ error: err.message || "Failed to fetch hunk history" }, 500);
@@ -2027,6 +2697,193 @@ function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore, planStore) {
 		if (!await store.remove(id)) return c.json({ error: "Comment not found" }, 404);
 		return c.json({ ok: true });
 	});
+	/** Shared helper: 404 with a stable shape so the client knows "not in PR mode". */
+	const notInPrMode = (c) => c.json({
+		error: "Not in PR review mode",
+		prMode: false
+	}, 404);
+	app.get("/api/gh/session", async (c) => {
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		return c.json({
+			prMode: true,
+			ref: session.ref,
+			owner: session.owner,
+			repo: session.repo,
+			pullNumber: session.pullNumber,
+			baseSha: session.baseSha,
+			headSha: session.headSha,
+			title: session.title,
+			url: session.url,
+			author: session.author,
+			additions: session.additions,
+			deletions: session.deletions,
+			changedFiles: session.changedFiles,
+			existingComments: session.existingComments,
+			submittedAt: session.submittedAt,
+			submittedReviewId: session.submittedReviewId,
+			submittedReviewUrl: session.submittedReviewUrl,
+			authSource: session.authSource
+		});
+	});
+	/** Re-fetch PR metadata (head SHA, diff, existing comments) and persist. */
+	app.post("/api/gh/pr/refresh", async (c) => {
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		try {
+			const refreshed = await refreshPrSession(session);
+			await prStore.set(refreshed);
+			return c.json({
+				ok: true,
+				headSha: refreshed.headSha
+			});
+		} catch (err) {
+			return c.json({ error: err?.message ?? "Refresh failed" }, 500);
+		}
+	});
+	/** Initialize a PR session from a ref like `1234`, `o/r#42`, or a GitHub URL. */
+	app.post("/api/gh/pr/init", async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const ref = typeof body?.ref === "string" ? body.ref : "";
+		if (!ref.trim()) return c.json({ error: "ref is required" }, 400);
+		try {
+			parsePrRef(ref, await detectCwdRepo() ?? void 0);
+			const session = await buildPrSession(ref);
+			await prStore.set(session);
+			return c.json({
+				ok: true,
+				ref: session.ref,
+				owner: session.owner,
+				repo: session.repo,
+				pullNumber: session.pullNumber,
+				url: session.url
+			});
+		} catch (err) {
+			return c.json({ error: err?.message ?? "Failed to initialise PR session" }, 500);
+		}
+	});
+	app.get("/api/gh/pr-session/comments", async (c) => {
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		return c.json(session.comments ?? []);
+	});
+	app.post("/api/gh/pr-session/comments", async (c) => {
+		const body = await c.req.json();
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const comment = {
+			id: crypto.randomUUID(),
+			filePath: body.filePath,
+			side: body.side,
+			lineNumber: body.lineNumber,
+			startLineNumber: body.startLineNumber,
+			lineContent: body.lineContent,
+			body: body.body,
+			status: "open",
+			createdAt: Date.now(),
+			replies: []
+		};
+		const next = {
+			...session,
+			comments: [...session.comments ?? [], comment]
+		};
+		await prStore.set(next);
+		return c.json(comment, 201);
+	});
+	app.put("/api/gh/pr-session/comments/:id", async (c) => {
+		const id = c.req.param("id");
+		const { body, status } = await c.req.json();
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const comments = (session.comments ?? []).map((cm) => cm.id === id ? {
+			...cm,
+			body: body ?? cm.body,
+			status: status ?? cm.status
+		} : cm);
+		await prStore.set({
+			...session,
+			comments
+		});
+		const updated = comments.find((cm) => cm.id === id) ?? null;
+		if (!updated) return c.json({ error: "Comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.delete("/api/gh/pr-session/comments/:id", async (c) => {
+		const id = c.req.param("id");
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const comments = (session.comments ?? []).filter((cm) => cm.id !== id);
+		await prStore.set({
+			...session,
+			comments
+		});
+		return c.json({ ok: true });
+	});
+	app.post("/api/gh/pr-session/comments/:id/replies", async (c) => {
+		const id = c.req.param("id");
+		const { body, role, model } = await c.req.json();
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const comments = (session.comments ?? []).map((cm) => {
+			if (cm.id !== id) return cm;
+			const reply = {
+				id: crypto.randomUUID(),
+				body,
+				createdAt: Date.now(),
+				role: role || (model ? "agent" : "user"),
+				model: model || void 0
+			};
+			return {
+				...cm,
+				replies: [...cm.replies ?? [], reply]
+			};
+		});
+		await prStore.set({
+			...session,
+			comments
+		});
+		return c.json(comments.find((cm) => cm.id === id));
+	});
+	/** Submit the current PR session's review (new comments + verdict + body) to GitHub. */
+	app.post("/api/gh/submit", async (c) => {
+		const session = await prStore.get();
+		if (!session) return notInPrMode(c);
+		const body = await c.req.json().catch(() => ({}));
+		const decision = body.decision;
+		if (decision !== "approve" && decision !== "comment" && decision !== "request-changes") return c.json({ error: "decision must be one of: approve, comment, request-changes" }, 400);
+		const generalBody = typeof body.body === "string" ? body.body : "";
+		const dryRun = body.dryRun === true;
+		const result = await submitReview({
+			resolved: {
+				owner: session.owner,
+				repo: session.repo,
+				pullNumber: session.pullNumber,
+				ref: session.ref
+			},
+			decision,
+			body: generalBody,
+			comments: session.comments ?? []
+		});
+		if (result.ok && !dryRun) {
+			const next = {
+				...session,
+				submittedAt: Date.now(),
+				submittedReviewId: result.reviewId,
+				submittedReviewUrl: result.reviewUrl,
+				authSource: result.authSource
+			};
+			await prStore.set(next);
+		}
+		return c.json({
+			ok: result.ok,
+			reviewId: result.reviewId,
+			reviewUrl: result.reviewUrl,
+			failedComments: result.failedComments ?? 0,
+			authSource: result.authSource,
+			error: result.error,
+			dryRun
+		});
+	});
 	app.post("/api/review/send", async (c) => {
 		const body = await c.req.json().catch(() => ({}));
 		const generalComment = typeof body?.generalComment === "string" ? body.generalComment : void 0;
@@ -2269,7 +3126,11 @@ async function newestActivityMs(projectDir) {
 			return null;
 		}
 	};
-	for (const name of ["comments.json", "plans.json"]) {
+	for (const name of [
+		"comments.json",
+		"plans.json",
+		"pr-session.json"
+	]) {
 		const file = join(projectDir, name);
 		if (!existsSync(file)) continue;
 		const m = await safeStat(file);
@@ -2320,14 +3181,35 @@ function startServer(options) {
 	cleanupStaleProjects().catch((err) => {
 		console.error("Failed to clean up stale projects:", err);
 	});
+	let prMode = false;
+	const prReady = (async () => {
+		if (!options.prRef) return;
+		console.error(`Building PR session for ${options.prRef}...`);
+		try {
+			const store = new FilePrSessionStore();
+			const existing = await store.get();
+			if (!existing || existing.ref !== options.prRef) {
+				const session = await buildPrSession(options.prRef);
+				await store.set(session);
+			}
+			prMode = true;
+		} catch (err) {
+			console.error(`[pr-session] failed to build session for ${options.prRef}: ${err?.message ?? err}`);
+		}
+	})();
 	const app = createApp(options.clientDir, options.diffOpts);
 	return new Promise((resolve) => {
-		serve({
-			fetch: app.fetch,
-			port: options.port,
-			hostname: options.host
-		}, (info) => {
-			resolve({ port: info.port });
+		prReady.then(() => {
+			serve({
+				fetch: app.fetch,
+				port: options.port,
+				hostname: options.host
+			}, (info) => {
+				resolve({
+					port: info.port,
+					prMode
+				});
+			});
 		});
 	});
 }
@@ -2715,8 +3597,68 @@ 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;
+let ghPrConsumed = 0;
+if (args[0]?.startsWith("gh pr ") === true) {
+	const rest = args[0].slice(6).trim();
+	if (rest) {
+		prRef = rest;
+		ghPrConsumed = 1;
+	}
+} else if (args[0] === "gh" && args[1] === "pr" && args[2] !== void 0) {
+	prRef = args[2];
+	ghPrConsumed = 3;
+}
+if (ghPrConsumed > 0) args.splice(0, ghPrConsumed);
 if (new Set([
 	"await-review",
 	"reply",
@@ -2725,17 +3667,30 @@ if (new Set([
 	"url",
 	"mcp",
 	"plan",
-	"update"
+	"update",
+	"gh"
 ]).has(args[0])) {
 	if (args[0] === "mcp") {
-		const { startMcpServer } = await import("./mcp-CFeE13n-.mjs");
+		const { startMcpServer } = await import("./mcp-BWeWR4yd.mjs");
 		await startMcpServer();
 		await new Promise(() => {});
 	}
-	const { runSubcommand } = await import("./cli-agent-BNwY5lZE.mjs");
+	const { runSubcommand } = await import("./cli-agent-KxNAFIPf.mjs");
 	process.exit(await runSubcommand(args[0], args.slice(1)));
 }
+let showSubcommand = false;
+if (args[0] === "show") {
+	showSubcommand = true;
+	args.shift();
+}
 const opts = parseDiffOptions(args);
+if (showSubcommand) {
+	if (opts.revisions.length === 0 && !opts.help && !opts.version) {
+		console.error("Usage: diffing show <revspec>... [-- <pathspec>...]");
+		process.exit(5);
+	}
+	intoShowMode(opts);
+}
 if (opts.help) {
 	printHelp();
 	process.exit(0);
@@ -2751,6 +3706,10 @@ if (envErr) {
 	console.error(envErr);
 	process.exit(1);
 }
+if (opts.outputMode === "tui") {
+	const tuiResult = await launchTui(args);
+	process.exit(tuiResult);
+}
 if (opts.outputMode === "terminal") {
 	const exitCode = runTerminalDiff(opts);
 	process.exit(exitCode);
@@ -2759,7 +3718,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-KL-2sGxE.mjs");
+		const { checkForUpdates } = await import("./update-check-DAPFCqpF.mjs");
 		return await checkForUpdates(currentVersion);
 	} catch {
 		return null;
@@ -2768,12 +3727,12 @@ const updateCheckPromise = (async () => {
 const port = await getPort(opts.port ? { port: opts.port } : void 0);
 const host = opts.host;
 const clientDir = resolve(__pkgDir, "client");
-const { existsSync: existsSync$1 } = await import("node:fs");
-const { port: actualPort } = await startServer({
+const { port: actualPort, prMode } = await startServer({
 	port,
 	host,
-	clientDir: existsSync$1(clientDir) ? clientDir : resolve(process.cwd(), "dist/client"),
-	diffOpts: opts
+	clientDir: existsSync(clientDir) ? clientDir : resolve(process.cwd(), "dist/client"),
+	diffOpts: opts,
+	prRef: prRef ?? void 0
 });
 const localUrl = `http://${host}:${actualPort}`;
 try {
@@ -2789,7 +3748,9 @@ try {
 		pid: process.pid,
 		repoRoot,
 		startedAt: Date.now(),
-		version: currentVersion
+		version: currentVersion,
+		mode: prMode ? "gh-pr" : "web",
+		prRef: prMode ? prRef ?? void 0 : void 0
 	});
 } catch {}
 console.log(`diffing server running at ${localUrl}`);
@@ -2797,7 +3758,7 @@ await playStartupDisplay();
 try {
 	const updateInfo = await updateCheckPromise;
 	if (updateInfo?.hasUpdate) {
-		const { printUpdateDisclaimer } = await import("./update-check-KL-2sGxE.mjs");
+		const { printUpdateDisclaimer } = await import("./update-check-DAPFCqpF.mjs");
 		printUpdateDisclaimer(currentVersion, updateInfo.latestVersion);
 	}
 } catch {}
@@ -2817,5 +3778,64 @@ const shutdown = () => {
 };
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
+/**
+* Wrapper around `findTuiBinary` that passes this script's `import.meta.url`
+* so the search paths anchor to the bundled CLI's directory. The real
+* implementation lives in `lib/find-tui-binary.ts` and is unit-tested there.
+*/
+function findTuiBinary() {
+	return findTuiBinary$1(import.meta.url);
+}
+/**
+* Fall back to default `git diff` output when the TUI cannot run.
+* Re-parses `args` so the terminal output exactly matches `diffing` (no flag)
+* in a non-TTY context.
+*/
+function runTerminalFallback(args) {
+	const terminalOpts = parseDiffOptions(args.filter((a) => a !== "--tui"));
+	terminalOpts.outputMode = "terminal";
+	terminalOpts.tui = false;
+	return runTerminalDiff(terminalOpts);
+}
+/**
+* Launch the native-Rust TUI binary as a child process. Returns the process
+* exit code. If the TUI cannot start (no TTY, missing binary), prints a
+* single stderr line and falls back to the default `git diff` output.
+*/
+async function launchTui(args) {
+	if (!process.stdout.isTTY || !process.stdin.isTTY) {
+		console.error("diffing --tui requires a TTY; falling back to git diff");
+		return runTerminalFallback(args);
+	}
+	const bin = findTuiBinary();
+	if (!bin) {
+		console.error("diffing-tui binary not found; build it with `pnpm build:tui`; falling back to git diff");
+		return runTerminalFallback(args);
+	}
+	const forwarded = args.filter((a) => a !== "--tui");
+	let repoRoot;
+	try {
+		repoRoot = getRepoRoot();
+	} catch {
+		repoRoot = process.cwd();
+	}
+	console.log(`diffing TUI starting (binary: ${bin})`);
+	await playStartupDisplay();
+	return new Promise((resolveP) => {
+		const child = spawn(bin, [
+			"--repo",
+			repoRoot,
+			...forwarded
+		], {
+			stdio: "inherit",
+			env: process.env
+		});
+		child.on("exit", (code) => resolveP(code ?? 0));
+		child.on("error", (err) => {
+			console.error(`diffing-tui failed to start: ${err.message}; falling back to git diff`);
+			resolveP(runTerminalFallback(args));
+		});
+	});
+}
 //#endregion
-export {};
+export { findTuiBinary };