@jaydenfyi/diffx 0.0.1

package/dist/command-5FPIcmTx.mjs

@@ -0,0 +1,2434 @@
+import { define } from "gunshi";
+import git from "simple-git";
+import crypto from "node:crypto";
+import { spawn } from "node:child_process";
+import { minimatch } from "minimatch";
+
+//#region src/types.ts
+/** Error types with exit codes */
+const ExitCode = {
+	SUCCESS: 0,
+	NO_FILES_MATCHED: 1,
+	INVALID_INPUT: 2,
+	GIT_ERROR: 3
+};
+/** Custom error with exit code */
+var DiffxError = class extends Error {
+	_tag = "DiffxError";
+	constructor(message, exitCode) {
+		super(message);
+		this.exitCode = exitCode;
+		this.name = "DiffxError";
+	}
+};
+
+//#endregion
+//#region src/parsers/range/github-parser.ts
+function parseGitHubPRUrl(input) {
+	const match = input.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)(\/.*)?$/i);
+	if (!match) return null;
+	return {
+		owner: match[1],
+		repo: match[2],
+		prNumber: parseInt(match[3], 10)
+	};
+}
+function parseGitHubCommitUrl(input) {
+	const match = input.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/commit\/([a-f0-9]+)$/i);
+	if (!match) return null;
+	return {
+		owner: match[1],
+		repo: match[2],
+		commitSha: match[3]
+	};
+}
+function parseGitHubPRChangesUrl(input) {
+	const match = input.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)\/changes\/([a-f0-9]+)\.\.([a-f0-9]+)$/i);
+	if (!match) return null;
+	return {
+		owner: match[1],
+		repo: match[2],
+		prNumber: parseInt(match[3], 10),
+		leftCommitSha: match[4],
+		rightCommitSha: match[5]
+	};
+}
+function parseGitHubCompareUrl(input) {
+	const match = input.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/compare\/(.+)\.\.\.(.+)$/i);
+	if (!match) return null;
+	const owner = match[1];
+	const repo = match[2];
+	const leftRef = match[3];
+	const rightRef = match[4];
+	const crossForkMatch = rightRef.match(/^([^:]+):([^:]+):(.+)$/);
+	if (crossForkMatch) return {
+		owner,
+		repo,
+		leftRef,
+		rightRef: crossForkMatch[3],
+		rightOwner: crossForkMatch[1],
+		rightRepo: crossForkMatch[2]
+	};
+	const crossForkSlashMatch = rightRef.match(/^([^:]+):([^/]+)\/(.+)$/);
+	if (crossForkSlashMatch) return {
+		owner,
+		repo,
+		leftRef,
+		rightRef: crossForkSlashMatch[3],
+		rightOwner: crossForkSlashMatch[1],
+		rightRepo: crossForkSlashMatch[2]
+	};
+	return {
+		owner,
+		repo,
+		leftRef,
+		rightRef
+	};
+}
+function parsePRRef(input) {
+	const result = input.match(/^github:([^/]+)\/([^/]+)#(\d+)$/i);
+	if (!result) return null;
+	return {
+		owner: result[1],
+		repo: result[2],
+		prNumber: parseInt(result[3], 10)
+	};
+}
+function parseGithubRefRange(input) {
+	const result = input.match(/^github:([^/]+)\/([^@]+)@(.+)\.\.(.+)$/i);
+	if (!result) return null;
+	const owner = result[1];
+	const repo = result[2];
+	const left = result[3].trim();
+	const right = result[4].trim();
+	if (!owner || !repo || !left || !right) return null;
+	return {
+		ownerRepo: `${owner}/${repo}`,
+		left,
+		right
+	};
+}
+function parsePRRange(input) {
+	if (!input.includes("..")) return null;
+	const parts = input.split("..");
+	if (parts.length !== 2) return null;
+	const left = parseGitHubPRUrl(parts[0].trim()) ?? parsePRRef(parts[0].trim());
+	const right = parseGitHubPRUrl(parts[1].trim()) ?? parsePRRef(parts[1].trim());
+	if (!left || !right) return null;
+	return {
+		left,
+		right
+	};
+}
+
+//#endregion
+//#region src/parsers/range/git-url-parser.ts
+function parseGitUrlRange(input) {
+	const isGitUrl = (s) => s.includes("://") || s.includes("@") && s.includes(":");
+	const doubleDotIndex = input.indexOf("..");
+	if (doubleDotIndex !== -1) {
+		const leftPart = input.slice(0, doubleDotIndex);
+		const rightPart = input.slice(doubleDotIndex + 2);
+		const lastAtLeft = leftPart.lastIndexOf("@");
+		const lastAtRight = rightPart.lastIndexOf("@");
+		if (lastAtLeft !== -1 && lastAtRight !== -1) {
+			const leftUrl = leftPart.slice(0, lastAtLeft);
+			const leftRef = leftPart.slice(lastAtLeft + 1);
+			const rightUrl = rightPart.slice(0, lastAtRight);
+			const rightRef = rightPart.slice(lastAtRight + 1);
+			if (isGitUrl(leftUrl) && isGitUrl(rightUrl)) return {
+				leftUrl,
+				leftRef,
+				rightUrl,
+				rightRef
+			};
+		}
+	}
+	const atBeforeDoubleDot = input.lastIndexOf("@", input.indexOf(".."));
+	if (atBeforeDoubleDot !== -1 && input.includes("..")) {
+		const url = input.slice(0, atBeforeDoubleDot);
+		const parts = input.slice(atBeforeDoubleDot + 1).split("..");
+		if (parts.length === 2 && isGitUrl(url)) return {
+			leftUrl: url,
+			leftRef: parts[0],
+			rightUrl: url,
+			rightRef: parts[1]
+		};
+	}
+	return null;
+}
+
+//#endregion
+//#region src/parsers/range/gitlab-parser.ts
+function parseMRRef(input) {
+	const result = input.match(/^gitlab:([^/]+)\/([^/]+)!(\d+)$/i);
+	if (!result) return null;
+	return {
+		owner: result[1],
+		repo: result[2],
+		mrNumber: parseInt(result[3], 10)
+	};
+}
+function parseGitlabRefRange(input) {
+	const result = input.match(/^gitlab:([^/]+)\/([^@]+)@(.+)\.\.(.+)$/i);
+	if (!result) return null;
+	const owner = result[1];
+	const repo = result[2];
+	const left = result[3].trim();
+	const right = result[4].trim();
+	if (!owner || !repo || !left || !right) return null;
+	return {
+		ownerRepo: `${owner}/${repo}`,
+		left,
+		right
+	};
+}
+
+//#endregion
+//#region src/parsers/range/ref-range-parser.ts
+function parseRemoteRefRange(input) {
+	const separatorIndex = input.indexOf("..");
+	if (separatorIndex === -1) return null;
+	const leftPart = input.slice(0, separatorIndex).trim();
+	const rightPart = input.slice(separatorIndex + 2).trim();
+	if (!leftPart || !rightPart) return null;
+	const parseRemoteSide = (value) => {
+		const match = value.match(/^([^/]+)\/([^@]+)@(.+)$/);
+		if (!match) return null;
+		const owner = match[1].trim();
+		const repo = match[2].trim();
+		const ref = match[3].trim();
+		if (!owner || !repo || !ref) return null;
+		return {
+			owner,
+			repo,
+			ref
+		};
+	};
+	const left = parseRemoteSide(leftPart);
+	if (!left) return null;
+	const rightFull = parseRemoteSide(rightPart);
+	if (rightFull) {
+		if (rightFull.owner !== left.owner || rightFull.repo !== left.repo) return null;
+		return {
+			left: `${left.owner}/${left.repo}@${left.ref}`,
+			right: `${rightFull.owner}/${rightFull.repo}@${rightFull.ref}`,
+			ownerRepo: `${left.owner}/${left.repo}`
+		};
+	}
+	return {
+		left: `${left.owner}/${left.repo}@${left.ref}`,
+		right: `${left.owner}/${left.repo}@${rightPart}`,
+		ownerRepo: `${left.owner}/${left.repo}`
+	};
+}
+function parseLocalRefRange(input) {
+	const parts = input.split("..");
+	if (parts.length !== 2 || !parts[0] || !parts[1]) return null;
+	return {
+		left: parts[0].trim(),
+		right: parts[1].trim()
+	};
+}
+
+//#endregion
+//#region src/parsers/range-parser.ts
+/**
+* Parse a range input string into a RefRange
+*/
+function parseRangeInput(input) {
+	const prRange = parsePRRange(input);
+	if (prRange) return {
+		type: "pr-range",
+		left: "",
+		right: "",
+		leftPr: prRange.left,
+		rightPr: prRange.right
+	};
+	const gitUrlRange = parseGitUrlRange(input);
+	if (gitUrlRange) return {
+		type: "git-url-range",
+		left: gitUrlRange.leftRef,
+		right: gitUrlRange.rightRef,
+		leftGitUrl: gitUrlRange.leftUrl,
+		rightGitUrl: gitUrlRange.rightUrl
+	};
+	const githubCompare = parseGitHubCompareUrl(input);
+	if (githubCompare) return {
+		type: "github-compare-url",
+		left: "",
+		right: "",
+		ownerRepo: `${githubCompare.owner}/${githubCompare.repo}`,
+		leftRef: githubCompare.leftRef,
+		rightRef: githubCompare.rightRef,
+		rightOwner: githubCompare.rightOwner,
+		rightRepo: githubCompare.rightRepo
+	};
+	const githubPrChanges = parseGitHubPRChangesUrl(input);
+	if (githubPrChanges) return {
+		type: "github-pr-changes-url",
+		left: "",
+		right: "",
+		ownerRepo: `${githubPrChanges.owner}/${githubPrChanges.repo}`,
+		prNumber: githubPrChanges.prNumber,
+		leftCommitSha: githubPrChanges.leftCommitSha,
+		rightCommitSha: githubPrChanges.rightCommitSha
+	};
+	const githubPr = parseGitHubPRUrl(input);
+	if (githubPr) return {
+		type: "github-url",
+		left: "",
+		right: "",
+		ownerRepo: `${githubPr.owner}/${githubPr.repo}`,
+		prNumber: githubPr.prNumber
+	};
+	const githubCommit = parseGitHubCommitUrl(input);
+	if (githubCommit) return {
+		type: "github-commit-url",
+		left: "",
+		right: "",
+		ownerRepo: `${githubCommit.owner}/${githubCommit.repo}`,
+		commitSha: githubCommit.commitSha
+	};
+	const githubRefRange = parseGithubRefRange(input);
+	if (githubRefRange) {
+		const gitUrl = `git@github.com:${githubRefRange.ownerRepo}.git`;
+		return {
+			type: "git-url-range",
+			left: githubRefRange.left,
+			right: githubRefRange.right,
+			leftGitUrl: gitUrl,
+			rightGitUrl: gitUrl
+		};
+	}
+	const gitlabRefRange = parseGitlabRefRange(input);
+	if (gitlabRefRange) {
+		const gitUrl = `git@gitlab.com:${gitlabRefRange.ownerRepo}.git`;
+		return {
+			type: "git-url-range",
+			left: gitlabRefRange.left,
+			right: gitlabRefRange.right,
+			leftGitUrl: gitUrl,
+			rightGitUrl: gitUrl
+		};
+	}
+	const prRef = parsePRRef(input);
+	if (prRef) return {
+		type: "pr-ref",
+		left: "",
+		right: "",
+		ownerRepo: `${prRef.owner}/${prRef.repo}`,
+		prNumber: prRef.prNumber
+	};
+	const mrRef = parseMRRef(input);
+	if (mrRef) return {
+		type: "gitlab-mr-ref",
+		left: "",
+		right: "",
+		ownerRepo: `${mrRef.owner}/${mrRef.repo}`,
+		prNumber: mrRef.mrNumber
+	};
+	const remoteRange = parseRemoteRefRange(input);
+	if (remoteRange) return {
+		type: "remote-range",
+		left: remoteRange.left,
+		right: remoteRange.right,
+		ownerRepo: remoteRange.ownerRepo
+	};
+	const localRange = parseLocalRefRange(input);
+	if (localRange) return {
+		type: "local-range",
+		left: localRange.left,
+		right: localRange.right
+	};
+	throw new DiffxError(`Invalid range or URL: ${input}\n\nSupported formats:\n  - Local refs: main..feature, abc123..def456\n  - Remote refs: owner/repo@main..owner/repo@feature\n  - Git URL: git@github.com:owner/repo.git@main..feature\n  - Git URL (HTTPS): https://github.com/owner/repo.git@main..feature\n  - GitHub refs: github:owner/repo@main..feature\n  - GitHub PR ref: github:owner/repo#123\n  - GitHub PR range: github:owner/repo#123..github:owner/repo#456\n  - GitHub PR URL: https://github.com/owner/repo/pull/123\n  - PR URL range: https://github.com/owner/repo/pull/123..https://github.com/owner/repo/pull/456\n  - GitHub commit URL: https://github.com/owner/repo/commit/abc123\n  - GitHub PR changes URL: https://github.com/owner/repo/pull/123/changes/abc123..def456\n  - GitHub compare URL: https://github.com/owner/repo/compare/main...feature\n  - Cross-fork compare: https://github.com/owner/repo/compare/main...other:repo:feature\n  - GitLab refs: gitlab:owner/repo@main..feature\n  - GitLab MR ref: gitlab:owner/repo!123`, ExitCode.INVALID_INPUT);
+}
+
+//#endregion
+//#region src/git/git-client.ts
+/**
+* Git client wrapper using simple-git
+*/
+/**
+* Git client wrapper for diffx operations
+*/
+var GitClient = class {
+	git = git();
+	buildColorFlag(color) {
+		return color ? [`--color=${color}`] : [];
+	}
+	buildColorArgs(options) {
+		return options?.color ? [`--color=${options.color}`] : [];
+	}
+	buildExtraArgs(options) {
+		return options?.extraArgs ?? [];
+	}
+	/**
+	* Generate a unified diff between two refs
+	*/
+	async diff(left, right, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			left,
+			`${right}`
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		else args.push("--");
+		return this.git.diff(args);
+	}
+	/**
+	* Generate a unified diff between a ref and the working tree (includes staged + unstaged)
+	*/
+	async diffAgainstWorktree(ref, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			ref
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		else args.push("--");
+		return this.git.diff(args);
+	}
+	/**
+	* Generate a patch between two refs
+	*/
+	async formatPatch(left, right, options) {
+		const args = [
+			"format-patch",
+			"--stdout",
+			`${left}..${right}`
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.raw(args);
+	}
+	/**
+	* Generate diff statistics between two refs
+	*/
+	async diffStat(left, right, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--stat",
+			`${left}..${right}`
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Generate diff statistics between a ref and the working tree
+	*/
+	async diffStatAgainstWorktree(ref, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--stat",
+			ref
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Generate per-file additions/deletions between two refs
+	*/
+	async diffNumStat(left, right, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--numstat",
+			`${left}..${right}`
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Generate per-file additions/deletions between a ref and the working tree
+	*/
+	async diffNumStatAgainstWorktree(ref, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--numstat",
+			ref
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Generate summary statistics between two refs
+	*/
+	async diffShortStat(left, right, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--shortstat",
+			`${left}..${right}`
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Generate name-only output between two refs
+	*/
+	async diffNameOnly(left, right, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--name-only",
+			`${left}..${right}`
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Generate summary statistics between a ref and the working tree
+	*/
+	async diffShortStatAgainstWorktree(ref, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--shortstat",
+			ref
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Generate name-only output between a ref and the working tree
+	*/
+	async diffNameOnlyAgainstWorktree(ref, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--name-only",
+			ref
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Generate name-status output between a ref and the working tree
+	*/
+	async diffNameStatusAgainstWorktree(ref, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--name-status",
+			ref
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Check if a ref exists locally
+	*/
+	async refExists(ref) {
+		try {
+			await this.git.revparse(["--verify", `refs/heads/${ref}`]);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Check if a ref exists (local or remote)
+	*/
+	async refExistsAny(ref) {
+		try {
+			await this.git.revparse(["--verify", ref]);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Add a remote repository
+	*/
+	async addRemote(name, url) {
+		await this.git.remote([
+			"add",
+			name,
+			url
+		]);
+	}
+	/**
+	* Get all remotes
+	*/
+	async getRemotes() {
+		return (await this.git.getRemotes(true)).map((r) => ({
+			name: r.name,
+			fetchUrl: r.refs.fetch,
+			pushUrl: r.refs.push
+		}));
+	}
+	/**
+	* Fetch refs from a remote (shallow fetch)
+	*/
+	async fetch(remote, refs) {
+		const args = [
+			"fetch",
+			"--no-tags",
+			"--depth",
+			"1",
+			remote
+		];
+		if (refs && refs.length > 0) args.push(...refs);
+		await this.git.raw(args);
+	}
+	/**
+	* Fetch refs from a URL into explicit refspecs (shallow fetch)
+	*/
+	async fetchFromUrl(url, refspecs, depth) {
+		const args = [
+			"fetch",
+			"--no-tags",
+			"--depth",
+			String(depth),
+			url,
+			...refspecs
+		];
+		await this.git.raw(args);
+	}
+	/**
+	* Fetch a specific PR reference (without depth limit to get merge history)
+	*/
+	async fetchPR(remote, prNumber) {
+		const headRef = `refs/pull/${prNumber}/head:refs/remotes/${remote}/pull/${prNumber}/head`;
+		const mergeRef = `refs/pull/${prNumber}/merge:refs/remotes/${remote}/pull/${prNumber}/merge`;
+		await this.git.raw([
+			"fetch",
+			"--no-tags",
+			"--depth",
+			"2",
+			remote,
+			headRef,
+			mergeRef
+		]);
+	}
+	/**
+	* Delete refs if they exist
+	*/
+	async deleteRefs(refs) {
+		await Promise.all(refs.map(async (ref) => {
+			try {
+				await this.git.raw([
+					"update-ref",
+					"-d",
+					ref
+				]);
+			} catch {}
+		}));
+	}
+	/**
+	* Get the current branch name
+	*/
+	async getCurrentBranch() {
+		return (await this.git.revparse(["--abbrev-ref", "HEAD"])).trim();
+	}
+	/**
+	* Get the HEAD commit hash
+	*/
+	async getHeadHash() {
+		return this.git.revparse(["HEAD"]);
+	}
+	/**
+	* Check if the working tree has staged or unstaged changes
+	*/
+	async hasWorktreeChanges() {
+		const status = await this.git.status();
+		return status.files.length > 0 || status.not_added.length > 0;
+	}
+	/**
+	* Get working tree status
+	*/
+	async getStatus() {
+		return this.git.status();
+	}
+	/**
+	* Get untracked files
+	*/
+	async getUntrackedFiles() {
+		return (await this.git.status()).not_added;
+	}
+	/**
+	* Generate a unified diff for an untracked file (vs /dev/null)
+	*/
+	async diffNoIndex(filePath, color) {
+		const colorArgs = this.buildColorFlag(color);
+		return this.git.raw([
+			"diff",
+			...colorArgs,
+			"--no-index",
+			"--",
+			"/dev/null",
+			filePath
+		]);
+	}
+	/**
+	* Generate diff statistics for an untracked file (vs /dev/null)
+	*/
+	async diffStatNoIndex(filePath, color) {
+		const colorArgs = this.buildColorFlag(color);
+		return this.git.raw([
+			"diff",
+			...colorArgs,
+			"--no-index",
+			"--stat",
+			"--",
+			"/dev/null",
+			filePath
+		]);
+	}
+	/**
+	* Generate per-file additions/deletions for an untracked file (vs /dev/null)
+	*/
+	async diffNumStatNoIndex(filePath, color) {
+		const colorArgs = this.buildColorFlag(color);
+		return this.git.raw([
+			"diff",
+			...colorArgs,
+			"--no-index",
+			"--numstat",
+			"--",
+			"/dev/null",
+			filePath
+		]);
+	}
+	/**
+	* Generate name-status diff between two refs
+	*/
+	async diffNameStatus(left, right, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--name-status",
+			`${left}..${right}`
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Generate summary output between two refs
+	*/
+	async diffSummary(left, right, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--summary",
+			`${left}..${right}`
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Generate summary output between a ref and the working tree
+	*/
+	async diffSummaryAgainstWorktree(ref, options) {
+		const args = [
+			...this.buildExtraArgs(options),
+			...this.buildColorArgs(options),
+			"--summary",
+			ref
+		];
+		if (options?.files && options.files.length > 0) args.push("--", ...options.files);
+		return this.git.diff(args);
+	}
+	/**
+	* Get the default branch ref for a remote (e.g., origin/main)
+	*/
+	async getRemoteHeadRef(remote) {
+		try {
+			const trimmed = (await this.git.raw([
+				"symbolic-ref",
+				"--quiet",
+				"--short",
+				`refs/remotes/${remote}/HEAD`
+			])).trim();
+			return trimmed.length > 0 ? trimmed : null;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Get a best-effort default branch ref (remote or local)
+	*/
+	async getDefaultBranchRef() {
+		const remoteNames = (await this.getRemotes()).map((r) => r.name);
+		const preferredRemotes = remoteNames.includes("origin") ? ["origin", ...remoteNames.filter((name) => name !== "origin")] : remoteNames;
+		for (const remote of preferredRemotes) {
+			const headRef = await this.getRemoteHeadRef(remote);
+			if (headRef) return headRef;
+		}
+		const fallbackBranchNames = [
+			"main",
+			"master",
+			"develop",
+			"trunk"
+		];
+		for (const remote of preferredRemotes) for (const branch of fallbackBranchNames) {
+			const ref = `${remote}/${branch}`;
+			if (await this.refExistsAny(ref)) return ref;
+		}
+		for (const branch of fallbackBranchNames) if (await this.refExistsAny(branch)) return branch;
+		return null;
+	}
+	/**
+	* Get the merge-base between two refs
+	*/
+	async mergeBase(left, right) {
+		return this.git.raw([
+			"merge-base",
+			left,
+			right
+		]);
+	}
+	/**
+	* Get a git config value
+	*/
+	async getConfigValue(key, scope = "all") {
+		try {
+			const scopeArgs = scope === "all" ? [] : [`--${scope}`];
+			const trimmed = (await this.git.raw([
+				"config",
+				...scopeArgs,
+				"--get",
+				key
+			])).trim();
+			return trimmed.length > 0 ? trimmed : null;
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Validate that two refs can be diffed
+	*/
+	async validateRefs(left, right) {
+		try {
+			await this.git.diff([`${left}..${right}`]);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Run native git diff with raw arguments
+	* This is the primary method for git diff pass-through compatibility
+	*
+	* @param args - Raw git diff arguments (e.g., ["--stat", "HEAD", "--", "src/"])
+	* @param options - Execution options
+	* @returns Git diff output and exit information
+	*/
+	async runGitDiffRaw(args, options = {}) {
+		const { capture = true } = options;
+		const colorArgs = process.stdout.isTTY ? ["--color=always"] : ["--color=never"];
+		try {
+			const fullArgs = [
+				"diff",
+				...colorArgs,
+				...args
+			];
+			if (capture) return {
+				stdout: await this.git.raw(fullArgs),
+				stderr: "",
+				exitCode: 0
+			};
+			else return {
+				stdout: await this.git.raw(fullArgs),
+				stderr: "",
+				exitCode: 0
+			};
+		} catch (error) {
+			if (error instanceof Error) return {
+				stdout: "",
+				stderr: error.message,
+				exitCode: 1
+			};
+			return {
+				stdout: "",
+				stderr: String(error),
+				exitCode: 1
+			};
+		}
+	}
+};
+/**
+* Singleton Git client instance
+*/
+const gitClient = new GitClient();
+
+//#endregion
+//#region src/git/utils.ts
+/**
+* Git utility functions
+*/
+/**
+* Build a GitHub HTTPS URL from owner/repo
+*/
+function buildGitHubUrl(owner, repo) {
+	return `https://github.com/${owner}/${repo}.git`;
+}
+/**
+* Normalize a ref for use with git commands
+*/
+function normalizeRef(ref) {
+	return ref.replace(/^refs\/(heads|tags)\//, "");
+}
+/**
+* Create a temporary ref prefix for one-off fetches
+*/
+function createTempRefPrefix() {
+	const token = crypto.randomBytes(8).toString("hex");
+	return `refs/diffx/tmp/${Date.now().toString(36)}-${token}`;
+}
+
+//#endregion
+//#region src/resolvers/local-ref-resolver.ts
+/**
+* Resolve a local ref range to actual refs
+*/
+async function resolveLocalRefs(range) {
+	if (range.type !== "local-range") throw new DiffxError("Invalid ref type for local resolver", ExitCode.INVALID_INPUT);
+	const left = normalizeRef(range.left);
+	const right = normalizeRef(range.right);
+	const leftExists = await gitClient.refExistsAny(left);
+	const rightExists = await gitClient.refExistsAny(right);
+	if (!leftExists) throw new DiffxError(`Left ref does not exist: ${range.left}`, ExitCode.INVALID_INPUT);
+	if (!rightExists) throw new DiffxError(`Right ref does not exist: ${range.right}`, ExitCode.INVALID_INPUT);
+	return {
+		left,
+		right
+	};
+}
+
+//#endregion
+//#region src/resolvers/remote-ref-resolver.ts
+/**
+* Resolve a remote ref range to local refs
+*/
+async function resolveRemoteRefs(range) {
+	if (range.type !== "remote-range" || !range.ownerRepo) throw new DiffxError("Invalid ref type for remote resolver", ExitCode.INVALID_INPUT);
+	const [owner, repo] = range.ownerRepo.split("/");
+	if (!owner || !repo) throw new DiffxError(`Invalid owner/repo: ${range.ownerRepo}`, ExitCode.INVALID_INPUT);
+	const leftMatch = range.left.match(/^[^/]+\/[^@]+@(.+)$/);
+	const rightMatch = range.right.match(/^[^/]+\/[^@]+@(.+)$/);
+	if (!leftMatch || !rightMatch) throw new DiffxError("Invalid remote ref format", ExitCode.INVALID_INPUT);
+	const leftRemoteRef = leftMatch[1];
+	const rightRemoteRef = rightMatch[1];
+	const remoteUrl = buildGitHubUrl(owner, repo);
+	const tempPrefix = createTempRefPrefix();
+	const leftDestRef = `${tempPrefix}/left`;
+	const rightDestRef = `${tempPrefix}/right`;
+	try {
+		await gitClient.fetchFromUrl(remoteUrl, [`${leftRemoteRef}:${leftDestRef}`, `${rightRemoteRef}:${rightDestRef}`], 1);
+		return {
+			left: leftDestRef,
+			right: rightDestRef,
+			cleanup: async () => {
+				await gitClient.deleteRefs([leftDestRef, rightDestRef]);
+			}
+		};
+	} catch (error) {
+		throw new DiffxError(`Failed to fetch remote refs: ${error.message}`, ExitCode.GIT_ERROR);
+	}
+}
+
+//#endregion
+//#region src/resolvers/pr-url-resolver.ts
+async function fetchPRRefs(pr, tempPrefix) {
+	const { owner, repo, prNumber } = pr;
+	const remoteUrl = buildGitHubUrl(owner, repo);
+	const headRef = `${tempPrefix}/pull/${prNumber}/head`;
+	const mergeRef = `${tempPrefix}/pull/${prNumber}/merge`;
+	await gitClient.fetchFromUrl(remoteUrl, [`refs/pull/${prNumber}/head:${headRef}`, `refs/pull/${prNumber}/merge:${mergeRef}`], 2);
+	return {
+		headRef,
+		mergeRef,
+		cleanupRefs: [headRef, mergeRef]
+	};
+}
+/**
+* Resolve a GitHub PR to local refs
+*/
+async function resolvePRRefs(range) {
+	if (!range.ownerRepo || range.prNumber === void 0) throw new DiffxError("Invalid PR ref", ExitCode.INVALID_INPUT);
+	try {
+		const [owner, repo] = range.ownerRepo.split("/");
+		if (!owner || !repo) throw new DiffxError(`Invalid owner/repo: ${range.ownerRepo}`, ExitCode.INVALID_INPUT);
+		const tempPrefix = createTempRefPrefix();
+		const refs = await fetchPRRefs({
+			owner,
+			repo,
+			prNumber: range.prNumber
+		}, tempPrefix);
+		return {
+			left: `${refs.mergeRef}^1`,
+			right: refs.mergeRef,
+			cleanup: async () => {
+				await gitClient.deleteRefs(refs.cleanupRefs);
+			}
+		};
+	} catch (error) {
+		throw new DiffxError(`Failed to fetch PR refs: ${error.message}`, ExitCode.GIT_ERROR);
+	}
+}
+/**
+* Resolve a PR-to-PR range (compare PR heads)
+*/
+async function resolvePRRangeRefs(range) {
+	if (!range.leftPr || !range.rightPr) throw new DiffxError("Invalid PR range", ExitCode.INVALID_INPUT);
+	try {
+		const tempPrefix = createTempRefPrefix();
+		const leftRefs = await fetchPRRefs(range.leftPr, `${tempPrefix}/left`);
+		const rightRefs = await fetchPRRefs(range.rightPr, `${tempPrefix}/right`);
+		return {
+			left: leftRefs.headRef,
+			right: rightRefs.headRef,
+			cleanup: async () => {
+				await gitClient.deleteRefs([...leftRefs.cleanupRefs, ...rightRefs.cleanupRefs]);
+			}
+		};
+	} catch (error) {
+		throw new DiffxError(`Failed to fetch PR range refs: ${error.message}`, ExitCode.GIT_ERROR);
+	}
+}
+/**
+* Resolve a GitHub commit URL to local refs
+* Shows the changes in that commit (commit^..commit)
+*/
+async function resolveGitHubCommitRefs(range) {
+	if (!range.ownerRepo || !range.commitSha) throw new DiffxError("Invalid GitHub commit URL", ExitCode.INVALID_INPUT);
+	try {
+		const [owner, repo] = range.ownerRepo.split("/");
+		if (!owner || !repo) throw new DiffxError(`Invalid owner/repo: ${range.ownerRepo}`, ExitCode.INVALID_INPUT);
+		const remoteUrl = buildGitHubUrl(owner, repo);
+		const commitRef = `${createTempRefPrefix()}/commit/${range.commitSha}`;
+		await gitClient.fetchFromUrl(remoteUrl, [`${range.commitSha}:${commitRef}`], 2);
+		return {
+			left: `${commitRef}^`,
+			right: commitRef,
+			cleanup: async () => {
+				await gitClient.deleteRefs([commitRef]);
+			}
+		};
+	} catch (error) {
+		throw new DiffxError(`Failed to fetch commit refs: ${error.message}`, ExitCode.GIT_ERROR);
+	}
+}
+/**
+* Resolve a GitHub PR changes URL (compare two commits in a PR)
+*/
+async function resolveGitHubPRChangesRefs(range) {
+	if (!range.ownerRepo || !range.prNumber || !range.leftCommitSha || !range.rightCommitSha) throw new DiffxError("Invalid GitHub PR changes URL", ExitCode.INVALID_INPUT);
+	try {
+		const [owner, repo] = range.ownerRepo.split("/");
+		if (!owner || !repo) throw new DiffxError(`Invalid owner/repo: ${range.ownerRepo}`, ExitCode.INVALID_INPUT);
+		const remoteUrl = buildGitHubUrl(owner, repo);
+		const tempPrefix = createTempRefPrefix();
+		const leftCommitRef = `${tempPrefix}/left-commit/${range.leftCommitSha}`;
+		const rightCommitRef = `${tempPrefix}/right-commit/${range.rightCommitSha}`;
+		await gitClient.fetchFromUrl(remoteUrl, [`${range.leftCommitSha}:${leftCommitRef}`, `${range.rightCommitSha}:${rightCommitRef}`], 2);
+		return {
+			left: leftCommitRef,
+			right: rightCommitRef,
+			cleanup: async () => {
+				await gitClient.deleteRefs([leftCommitRef, rightCommitRef]);
+			}
+		};
+	} catch (error) {
+		throw new DiffxError(`Failed to fetch PR changes refs: ${error.message}`, ExitCode.GIT_ERROR);
+	}
+}
+/**
+* Resolve a GitHub compare URL (compare two refs, possibly across forks)
+*/
+async function resolveGitHubCompareRefs(range) {
+	if (!range.ownerRepo || !range.leftRef || !range.rightRef) throw new DiffxError("Invalid GitHub compare URL", ExitCode.INVALID_INPUT);
+	try {
+		const [owner, repo] = range.ownerRepo.split("/");
+		if (!owner || !repo) throw new DiffxError(`Invalid owner/repo: ${range.ownerRepo}`, ExitCode.INVALID_INPUT);
+		const tempPrefix = createTempRefPrefix();
+		const leftRef = `${tempPrefix}/left/${range.leftRef}`;
+		const rightRef = `${tempPrefix}/right/${range.rightRef}`;
+		const cleanupRefs$1 = [leftRef, rightRef];
+		const leftUrl = buildGitHubUrl(owner, repo);
+		const rightUrl = buildGitHubUrl(range.rightOwner || owner, range.rightRepo || repo);
+		const isCommitSha = (ref) => /^[a-f0-9]{7,40}$/i.test(ref);
+		const buildRefspec = (ref, targetRef) => {
+			if (isCommitSha(ref)) return [`${ref}:${targetRef}`];
+			return [`refs/heads/${ref}:${targetRef}`, `refs/tags/${ref}:${targetRef}`];
+		};
+		const fetchRef = async (url, ref, targetRef) => {
+			let fetchError = null;
+			for (const refspec of buildRefspec(ref, targetRef)) try {
+				await gitClient.fetchFromUrl(url, [refspec], 1);
+				return refspec;
+			} catch (e) {
+				fetchError = e;
+			}
+			throw fetchError ?? /* @__PURE__ */ new Error(`Failed to fetch ref: ${ref}`);
+		};
+		const leftRefspec = await fetchRef(leftUrl, range.leftRef, leftRef);
+		const rightRefspec = await fetchRef(rightUrl, range.rightRef, rightRef);
+		const getMergeBase = async () => {
+			try {
+				const mergeBase$1 = (await gitClient.mergeBase(leftRef, rightRef)).trim();
+				return mergeBase$1.length > 0 ? mergeBase$1 : null;
+			} catch {
+				return null;
+			}
+		};
+		let mergeBase = await getMergeBase();
+		if (!mergeBase) {
+			await gitClient.fetchFromUrl(leftUrl, [leftRefspec], 200);
+			await gitClient.fetchFromUrl(rightUrl, [rightRefspec], 200);
+			mergeBase = await getMergeBase();
+		}
+		if (!mergeBase) throw new Error("Failed to determine merge base for compare refs");
+		return {
+			left: mergeBase,
+			right: rightRef,
+			cleanup: async () => {
+				await gitClient.deleteRefs(cleanupRefs$1);
+			}
+		};
+	} catch (error) {
+		throw new DiffxError(`Failed to fetch compare refs: ${error.message}`, ExitCode.GIT_ERROR);
+	}
+}
+
+//#endregion
+//#region src/resolvers/git-url-resolver.ts
+/**
+* Resolve a git URL range to local refs
+*/
+async function resolveGitUrlRefs(range) {
+	if (range.type !== "git-url-range" || !range.leftGitUrl || !range.rightGitUrl) throw new DiffxError("Invalid ref type for git URL resolver", ExitCode.INVALID_INPUT);
+	const leftUrl = range.leftGitUrl;
+	const rightUrl = range.rightGitUrl;
+	const leftRef = range.left;
+	const rightRef = range.right;
+	const tempPrefix = createTempRefPrefix();
+	const leftDestRef = `${tempPrefix}/left`;
+	const rightDestRef = `${tempPrefix}/right`;
+	try {
+		if (leftUrl === rightUrl) await gitClient.fetchFromUrl(leftUrl, [`${leftRef}:${leftDestRef}`, `${rightRef}:${rightDestRef}`], 1);
+		else {
+			await gitClient.fetchFromUrl(leftUrl, [`${leftRef}:${leftDestRef}`], 1);
+			await gitClient.fetchFromUrl(rightUrl, [`${rightRef}:${rightDestRef}`], 1);
+		}
+		return {
+			left: leftDestRef,
+			right: rightDestRef,
+			cleanup: async () => {
+				await gitClient.deleteRefs([leftDestRef, rightDestRef]);
+			}
+		};
+	} catch (error) {
+		throw new DiffxError(`Failed to fetch refs from git URL: ${error.message}`, ExitCode.GIT_ERROR);
+	}
+}
+
+//#endregion
+//#region src/resolvers/gitlab-mr-resolver.ts
+async function fetchMRRefs(range, tempPrefix) {
+	if (!range.ownerRepo || range.prNumber === void 0) throw new DiffxError("Invalid GitLab MR ref", ExitCode.INVALID_INPUT);
+	const [owner, repo] = range.ownerRepo.split("/");
+	if (!owner || !repo) throw new DiffxError(`Invalid owner/repo: ${range.ownerRepo}`, ExitCode.INVALID_INPUT);
+	const remoteUrl = `git@gitlab.com:${owner}/${repo}.git`;
+	const mrNumber = range.prNumber;
+	const headRef = `${tempPrefix}/merge-requests/${mrNumber}/head`;
+	const mergeRef = `${tempPrefix}/merge-requests/${mrNumber}/merge`;
+	await gitClient.fetchFromUrl(remoteUrl, [`refs/merge-requests/${mrNumber}/head:${headRef}`, `refs/merge-requests/${mrNumber}/merge:${mergeRef}`], 2);
+	return {
+		headRef,
+		mergeRef,
+		cleanupRefs: [headRef, mergeRef]
+	};
+}
+/**
+* Resolve a GitLab MR to local refs
+*/
+async function resolveGitLabMRRefs(range) {
+	try {
+		const refs = await fetchMRRefs(range, createTempRefPrefix());
+		return {
+			left: `${refs.mergeRef}^1`,
+			right: refs.mergeRef,
+			cleanup: async () => {
+				await gitClient.deleteRefs(refs.cleanupRefs);
+			}
+		};
+	} catch (error) {
+		throw new DiffxError(`Failed to fetch GitLab MR refs: ${error.message}`, ExitCode.GIT_ERROR);
+	}
+}
+
+//#endregion
+//#region src/resolvers/ref-resolver.ts
+const resolversByRefRangeType = {
+	"local-range": resolveLocalRefs,
+	"remote-range": resolveRemoteRefs,
+	"pr-ref": resolvePRRefs,
+	"github-url": resolvePRRefs,
+	"pr-range": resolvePRRangeRefs,
+	"git-url-range": resolveGitUrlRefs,
+	"github-commit-url": resolveGitHubCommitRefs,
+	"github-pr-changes-url": resolveGitHubPRChangesRefs,
+	"github-compare-url": resolveGitHubCompareRefs,
+	"gitlab-mr-ref": resolveGitLabMRRefs
+};
+/**
+* Resolve any ref range to concrete left/right refs
+*/
+async function resolveRefs(range) {
+	const resolver = resolversByRefRangeType[range.type];
+	return resolver(range);
+}
+
+//#endregion
+//#region src/resolvers/auto-base-resolver.ts
+/**
+* Auto base resolver
+* Resolves current branch diff against its inferred base branch
+*/
+/**
+* Resolve refs for auto base diff (merge-base..HEAD)
+*/
+async function resolveAutoBaseRefs() {
+	const baseRef = await gitClient.getDefaultBranchRef();
+	if (!baseRef) throw new DiffxError("Could not determine a base branch automatically. Provide an explicit range (e.g., main..HEAD).", ExitCode.INVALID_INPUT);
+	let mergeBase;
+	try {
+		mergeBase = (await gitClient.mergeBase(baseRef, "HEAD")).trim();
+	} catch {
+		throw new DiffxError(`Could not find a merge base with ${baseRef}. Provide an explicit range (e.g., ${baseRef}..HEAD).`, ExitCode.INVALID_INPUT);
+	}
+	if (!mergeBase) throw new DiffxError(`Could not find a merge base with ${baseRef}. Provide an explicit range (e.g., ${baseRef}..HEAD).`, ExitCode.INVALID_INPUT);
+	return {
+		left: mergeBase,
+		right: "HEAD",
+		baseRef,
+		mergeBase
+	};
+}
+
+//#endregion
+//#region src/output/patch-generator.ts
+/**
+* Generate patch between two refs
+*/
+async function generatePatch(left, right, options, patchStyle = "diff") {
+	if (patchStyle === "diff") return gitClient.diff(left, right, options);
+	return gitClient.formatPatch(left, right, options);
+}
+
+//#endregion
+//#region src/output/output-factory.ts
+const outputGeneratorsByMode = {
+	diff: (left, right, options) => gitClient.diff(left, right, options),
+	patch: generatePatch,
+	stat: (left, right, options) => gitClient.diffStat(left, right, options),
+	numstat: (left, right, options) => gitClient.diffNumStat(left, right, options),
+	shortstat: (left, right, options) => gitClient.diffShortStat(left, right, options),
+	"name-only": (left, right, options) => gitClient.diffNameOnly(left, right, options),
+	"name-status": (left, right, options) => gitClient.diffNameStatus(left, right, options),
+	summary: (left, right, options) => gitClient.diffSummary(left, right, options)
+};
+const outputGeneratorsAgainstWorktreeByMode = {
+	diff: (ref, options) => gitClient.diffAgainstWorktree(ref, options),
+	patch: (ref, options) => gitClient.diffAgainstWorktree(ref, options),
+	stat: (ref, options) => gitClient.diffStatAgainstWorktree(ref, options),
+	numstat: (ref, options) => gitClient.diffNumStatAgainstWorktree(ref, options),
+	shortstat: (ref, options) => gitClient.diffShortStatAgainstWorktree(ref, options),
+	"name-only": (ref, options) => gitClient.diffNameOnlyAgainstWorktree(ref, options),
+	"name-status": (ref, options) => gitClient.diffNameStatusAgainstWorktree(ref, options),
+	summary: (ref, options) => gitClient.diffSummaryAgainstWorktree(ref, options)
+};
+/**
+* Generate output based on the specified mode
+*/
+async function generateOutput(mode, left, right, options, patchStyle) {
+	const generator = outputGeneratorsByMode[mode];
+	return generator(left, right, options, patchStyle);
+}
+/**
+* Generate output between a ref and the working tree
+*/
+async function generateOutputAgainstWorktree(mode, ref, options) {
+	const generator = outputGeneratorsAgainstWorktreeByMode[mode];
+	return generator(ref, options);
+}
+
+//#endregion
+//#region src/errors/error-handler.ts
+/**
+* Error handler
+* Normalizes unknown errors into DiffxError instances
+*/
+/**
+* Normalize an unknown error into a typed DiffxError
+*/
+function handleError(error) {
+	if (error instanceof DiffxError) return error;
+	if (error instanceof Error) return new DiffxError(error.message, ExitCode.GIT_ERROR);
+	return new DiffxError(String(error), ExitCode.GIT_ERROR);
+}
+/**
+* Check whether output is empty and whether that emptiness came from file filters
+*/
+function checkEmptyOutput(output, { hasActiveFilters: hasActiveFilters$1, hasUnfilteredChanges: hasUnfilteredChanges$1 }) {
+	if (!(!output || output.trim().length === 0)) return {
+		isEmpty: false,
+		isFilterMismatch: false
+	};
+	return {
+		isEmpty: true,
+		isFilterMismatch: hasActiveFilters$1 && hasUnfilteredChanges$1
+	};
+}
+/**
+* Create a typed no-files-matched error
+*/
+function createNoFilesMatchedError() {
+	return new DiffxError("No files matched the specified filters", ExitCode.NO_FILES_MATCHED);
+}
+
+//#endregion
+//#region src/cli/pager.ts
+/**
+* Pager utilities
+*/
+function shouldUsePager(control) {
+	if (control.disable) return false;
+	if (control.force) return true;
+	if (!process.stdout.isTTY) return false;
+	if (control.pager === "false") return false;
+	if (control.pager) return true;
+	return resolvePagerCommand().then((cmd) => cmd !== null && cmd !== "" && cmd !== "false");
+}
+async function resolvePagerCommand() {
+	const gitPager = process.env.GIT_PAGER;
+	if (gitPager && gitPager.trim().length > 0) return gitPager.trim();
+	const corePager = await gitClient.getConfigValue("core.pager", "global") ?? await gitClient.getConfigValue("core.pager", "system");
+	if (corePager && corePager.trim().length > 0) return corePager.trim();
+	const pager = process.env.PAGER;
+	if (pager && pager.trim().length > 0) return pager.trim();
+	return null;
+}
+function parsePagerCommand(command) {
+	const tokens = [];
+	let current = "";
+	let quote = null;
+	let escaping = false;
+	for (let i = 0; i < command.length; i++) {
+		const char = command[i];
+		if (escaping) {
+			current += char;
+			escaping = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaping = true;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) quote = null;
+			else current += char;
+			continue;
+		}
+		if (char === "'" || char === "\"") {
+			quote = char;
+			continue;
+		}
+		if (/\s/.test(char)) {
+			if (current.length > 0) {
+				tokens.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += char;
+	}
+	if (escaping || quote) return null;
+	if (current.length > 0) tokens.push(current);
+	if (tokens.length === 0) return null;
+	const [file, ...args] = tokens;
+	return {
+		file,
+		args
+	};
+}
+async function runPager(command, output) {
+	const parsed = parsePagerCommand(command);
+	if (!parsed) throw new Error("Invalid pager command");
+	let args = parsed.args;
+	const env = {};
+	if (parsed.file.endsWith("less") || parsed.file === "less") {
+		if (!args.includes("-R")) args = ["-R", ...args];
+		env.LESS = "FRX";
+	} else env.LESS = void 0;
+	await new Promise((resolve, reject) => {
+		let settled = false;
+		const resolveOnce = () => {
+			if (settled) return;
+			settled = true;
+			resolve();
+		};
+		const rejectOnce = (error) => {
+			if (settled) return;
+			settled = true;
+			reject(error);
+		};
+		const child = spawn(parsed.file, args, {
+			stdio: [
+				"pipe",
+				"inherit",
+				"inherit"
+			],
+			env: {
+				...process.env,
+				...env
+			}
+		});
+		child.on("error", (error) => rejectOnce(error instanceof Error ? error : new Error(String(error))));
+		child.on("exit", (code) => {
+			if (code && code !== 0) {
+				rejectOnce(/* @__PURE__ */ new Error(`Pager exited with code ${code}`));
+				return;
+			}
+			resolveOnce();
+		});
+		if (child.stdin) {
+			child.stdin.on("error", (error) => {
+				if (error.code === "EPIPE" || error.code === "ERR_STREAM_DESTROYED") return;
+				rejectOnce(error);
+			});
+			child.stdin.write(output);
+			child.stdin.end();
+		}
+	});
+}
+async function pageOutput(output, control) {
+	if (!await shouldUsePager(control)) return false;
+	let pagerCommand = control.pager;
+	if (!pagerCommand) pagerCommand = await resolvePagerCommand() ?? "less -R";
+	try {
+		await runPager(pagerCommand, output);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/cli/arg-partitioner.ts
+/**
+* Argument partitioning for git diff pass-through
+*
+* This module handles the separation of diffx-owned flags from git pass-through flags.
+* The goal is to allow any git diff flag to work without diffx needing to know about it.
+*/
+/**
+* Flags that are owned and processed by diffx
+* Everything else is passed through to git diff
+*
+* Note: Git output format flags (--stat, --numstat, etc.) are NOT owned by diffx
+* and are passed through to git for native git compatibility.
+* Use --overview to get diffx enhancements (e.g., including untracked files).
+*/
+const DIFFX_OWNED_FLAGS = [
+	"--mode",
+	"--include",
+	"--exclude",
+	"--pager",
+	"--no-pager",
+	"--overview",
+	"--index"
+];
+const DIFFX_SHORT_FLAG_ALIASES = {
+	"-i": "--include",
+	"-e": "--exclude"
+};
+/**
+* Note: --summary is no longer a diffx-owned flag as of Phase 2
+* It now passes through to native git diff --summary (structural summary)
+* The custom diffx table output is now only available via --overview
+*/
+/**
+* Git output format flags that are mutually exclusive with --overview
+*/
+const GIT_OUTPUT_FORMAT_FLAGS = [
+	"--stat",
+	"--numstat",
+	"--name-only",
+	"--name-status",
+	"--raw",
+	"-p",
+	"--patch",
+	"--shortstat"
+];
+/**
+* Git diff flags that consume the next argv token as a value.
+* This prevents value tokens (e.g. regex patterns containing "..")
+* from being misclassified as diff ranges.
+*/
+const GIT_FLAGS_WITH_SEPARATE_VALUE = new Set([
+	"--abbrev",
+	"--anchored",
+	"--color",
+	"--color-moved",
+	"--color-moved-ws",
+	"--diff-algorithm",
+	"--dst-prefix",
+	"--find-object",
+	"--find-renames",
+	"--find-copies",
+	"--inter-hunk-context",
+	"--line-prefix",
+	"--output",
+	"--output-indicator-context",
+	"--output-indicator-new",
+	"--output-indicator-old",
+	"--relative",
+	"--skip-to",
+	"--rotate-to",
+	"--src-prefix",
+	"--stat-count",
+	"--stat-graph-width",
+	"--stat-name-width",
+	"--stat-width",
+	"--submodule",
+	"--word-diff",
+	"--word-diff-regex",
+	"-G",
+	"-O",
+	"-S",
+	"-U"
+]);
+/**
+* Check if a flag is a diffx-owned flag
+*/
+function isDiffxOwnedFlag(flag) {
+	return DIFFX_OWNED_FLAGS.includes(flag);
+}
+function normalizeDiffxFlag(flag) {
+	if (isDiffxOwnedFlag(flag)) return flag;
+	return DIFFX_SHORT_FLAG_ALIASES[flag] ?? null;
+}
+/**
+* Check if a flag is a git output format flag
+*/
+function isGitOutputFormatFlag(flag) {
+	return GIT_OUTPUT_FORMAT_FLAGS.includes(flag);
+}
+/**
+* Check if the flag is a negatable form (no-* version)
+*/
+function isNegatedFlag(flag) {
+	return flag.startsWith("--no-");
+}
+/**
+* Get the base flag name from a negated flag
+* e.g., "--no-pager" => "pager"
+*/
+function getBaseFlagName(flag) {
+	if (isNegatedFlag(flag)) return `--${flag.slice(5)}`;
+	return flag;
+}
+/**
+* Parse a flag token to extract the flag name
+* Handles:
+* - --flag
+* - --flag=value
+* - --flag value
+* - -f
+* - -fvalue (combined short form)
+*/
+function parseFlagName$1(arg) {
+	if (arg.startsWith("--")) {
+		const idx = arg.indexOf("=");
+		return idx >= 0 ? arg.slice(0, idx) : arg;
+	} else if (arg.startsWith("-") && arg.length > 1) return arg.slice(0, 2);
+	return arg;
+}
+function isGitFlagWithSeparateValue(arg) {
+	const flagName = parseFlagName$1(arg);
+	return GIT_FLAGS_WITH_SEPARATE_VALUE.has(flagName);
+}
+function isValueForPreviousGitFlag(argv, index) {
+	if (index <= 0) return false;
+	const previousArg = argv[index - 1];
+	return !previousArg.startsWith("--no-") && !normalizeDiffxFlag(parseFlagName$1(previousArg)) && isGitFlagWithSeparateValue(previousArg);
+}
+/**
+* Check if an argument takes a value
+* For diffx flags, we know which ones take values
+*/
+function diffxFlagTakesValue(flag) {
+	return flag === "--mode" || flag === "--include" || flag === "--exclude";
+}
+function appendDiffxFlagValue(diffxFlags, flag, value) {
+	const existing = diffxFlags.get(flag);
+	if (existing === void 0) {
+		diffxFlags.set(flag, value);
+		return;
+	}
+	if (Array.isArray(existing)) {
+		existing.push(value);
+		diffxFlags.set(flag, existing);
+		return;
+	}
+	if (typeof existing === "string") {
+		diffxFlags.set(flag, [existing, value]);
+		return;
+	}
+	diffxFlags.set(flag, value);
+}
+/**
+* Check if a token looks like a range/URL input
+* This is a heuristic to distinguish positionals from git revs
+*/
+function looksLikeRangeOrUrl(arg) {
+	if (arg.startsWith("github:")) return true;
+	if (arg.startsWith("gitlab:")) return true;
+	if (arg.startsWith("http://") || arg.startsWith("https://")) return true;
+	if (arg.startsWith("git@") || arg.includes("://")) return true;
+	if (arg.includes("..")) return true;
+	return false;
+}
+/**
+* Partition command-line arguments into diffx-owned and git pass-through
+*
+* @param argv - Raw command-line arguments (excluding program name)
+* @param tokens - Parsed tokens from gunshi CLI framework
+* @returns Partitioned arguments
+*/
+function partitionArgs(argv, tokens) {
+	const diffxFlags = /* @__PURE__ */ new Map();
+	const gitArgs = [];
+	const pathspecs = [];
+	let inputRange = void 0;
+	let seenDoubleDash = false;
+	let i = 0;
+	while (i < argv.length) {
+		const arg = argv[i];
+		if (arg === "--" && !seenDoubleDash) {
+			seenDoubleDash = true;
+			i++;
+			while (i < argv.length) {
+				pathspecs.push(argv[i]);
+				i++;
+			}
+			break;
+		}
+		if (seenDoubleDash) {
+			pathspecs.push(arg);
+			i++;
+			continue;
+		}
+		const flagName = parseFlagName$1(arg);
+		const normalizedFlag = normalizeDiffxFlag(flagName);
+		if (normalizedFlag) {
+			if (diffxFlagTakesValue(normalizedFlag)) {
+				const idx = arg.indexOf("=");
+				if (idx >= 0) appendDiffxFlagValue(diffxFlags, normalizedFlag, arg.slice(idx + 1));
+				else if (arg.startsWith(flagName) && arg.length > flagName.length) appendDiffxFlagValue(diffxFlags, normalizedFlag, arg.slice(flagName.length));
+				else if (i + 1 < argv.length && !argv[i + 1].startsWith("-")) {
+					appendDiffxFlagValue(diffxFlags, normalizedFlag, argv[i + 1]);
+					i++;
+				} else diffxFlags.set(normalizedFlag, true);
+			} else {
+				const baseFlag = getBaseFlagName(normalizedFlag);
+				const value = isNegatedFlag(flagName);
+				diffxFlags.set(baseFlag, !value);
+			}
+			i++;
+			continue;
+		}
+		if (!arg.startsWith("-") && !inputRange && !isValueForPreviousGitFlag(argv, i) && looksLikeRangeOrUrl(arg)) {
+			inputRange = arg;
+			i++;
+			continue;
+		}
+		gitArgs.push(arg);
+		i++;
+	}
+	if (!inputRange) {
+		const positionals = tokens.filter((t) => t.kind === "positional").map((t) => t.value).filter((v) => v && v.trim().length > 0).filter((v) => looksLikeRangeOrUrl(v)).filter((v) => {
+			if (argv.findIndex((arg, i$1) => arg === v && !isValueForPreviousGitFlag(argv, i$1)) >= 0) return true;
+			if (argv.indexOf(v) >= 0) return false;
+			return true;
+		});
+		if (positionals.length > 0) inputRange = positionals[0];
+	}
+	return {
+		diffxFlags,
+		inputRange,
+		gitArgs,
+		pathspecs
+	};
+}
+/**
+* Validate that --overview is not used with git output format flags
+*/
+function validateOverviewMutualExclusivity(diffxFlags, gitArgs) {
+	if (!(diffxFlags.get("--overview") === true)) return;
+	const conflictingFlags = [];
+	for (const [flag] of diffxFlags) if (isGitOutputFormatFlag(flag)) conflictingFlags.push(flag);
+	for (const arg of gitArgs) {
+		const flagName = parseFlagName$1(arg);
+		if (isGitOutputFormatFlag(flagName)) conflictingFlags.push(flagName);
+	}
+	if (conflictingFlags.length > 0) {
+		const flags = conflictingFlags.join(", ");
+		throw new Error(`Cannot use --overview with git output format flags: ${flags}\nUse --overview for diffx custom output, or git flags for native output.`);
+	}
+}
+
+//#endregion
+//#region src/filters/file-filter.ts
+/**
+* Build file patterns array for git commands
+* Filters include patterns first, then excludes from those results
+*/
+function buildFilePatterns(options) {
+	const patterns = [];
+	if (!options.include && !options.exclude) return patterns;
+	if (options.include && options.include.length > 0) patterns.push(...options.include);
+	if (options.exclude && options.exclude.length > 0) options.exclude.forEach((pattern) => {
+		patterns.push(`:!${pattern}`);
+	});
+	return patterns;
+}
+/**
+* Check if a file should be included based on filter options
+*/
+function shouldIncludeFile(filePath, options) {
+	if (!options.include && !options.exclude) return true;
+	if (options.exclude && options.exclude.length > 0) {
+		for (const pattern of options.exclude) if (minimatch(filePath, pattern, { dot: true })) return false;
+	}
+	if (options.include && options.include.length > 0) {
+		for (const pattern of options.include) if (minimatch(filePath, pattern, { dot: true })) return true;
+		return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/cli/command-options.ts
+const MODES = new Set([
+	"diff",
+	"patch",
+	"stat",
+	"numstat",
+	"shortstat",
+	"name-only",
+	"name-status",
+	"summary"
+]);
+function parseFlagName(arg) {
+	if (arg.startsWith("--")) {
+		const idx = arg.indexOf("=");
+		return idx >= 0 ? arg.slice(0, idx) : arg;
+	}
+	if (arg.startsWith("-") && arg.length > 1) return arg.slice(0, 2);
+	return arg;
+}
+function parseMode(value) {
+	if (typeof value !== "string") return null;
+	if (!MODES.has(value)) return null;
+	return value;
+}
+function validateNoConflictingFlags(diffxFlags, gitArgs) {
+	const pager = diffxFlags.get("--pager");
+	const noPager = diffxFlags.get("--no-pager");
+	if (pager && noPager) throw new DiffxError("Cannot use both --pager and --no-pager", ExitCode.INVALID_INPUT);
+	validateOverviewMutualExclusivity(diffxFlags, gitArgs);
+}
+function shouldUseGitPassThrough(partitioned, hasRange, useGitCompat, hasActiveFilters$1) {
+	if (hasActiveFilters$1) return false;
+	if (partitioned.diffxFlags.get("--overview") === true) return false;
+	if (partitioned.diffxFlags.get("--mode")) return false;
+	for (const arg of partitioned.gitArgs) if (isGitOutputFormatFlag(parseFlagName(arg))) return true;
+	if (useGitCompat) return true;
+	if (hasRange) return true;
+	if (partitioned.gitArgs.length > 0 || partitioned.pathspecs.length > 0) return true;
+	return false;
+}
+function getOutputMode({ overview, stat, numstat, shortstat, rawMode, hasStatFlag, hasNumstatFlag, hasShortstatFlag, hasNameOnlyFlag, hasNameStatusFlag }) {
+	const mode = parseMode(rawMode);
+	if (mode) return mode;
+	if (rawMode !== void 0) throw new DiffxError(`Invalid mode: ${rawMode}\nSupported modes: diff, patch, stat, numstat, shortstat, name-only, name-status`, ExitCode.INVALID_INPUT);
+	if (overview) return "numstat";
+	if (stat || hasStatFlag) return "stat";
+	if (numstat || hasNumstatFlag) return "numstat";
+	if (shortstat || hasShortstatFlag) return "shortstat";
+	if (hasNameOnlyFlag) return "name-only";
+	if (hasNameStatusFlag) return "name-status";
+	return "diff";
+}
+function getRangeOrUrl(positionals, partitionedInputRange) {
+	if (positionals.length <= 1) return partitionedInputRange;
+	throw new DiffxError(`Unexpected arguments: ${positionals.slice(1).join(" ")}`, ExitCode.INVALID_INPUT);
+}
+function validatePagerOptions(pager, noPager) {
+	if (pager && noPager) throw new DiffxError("Cannot use both --pager and --no-pager", ExitCode.INVALID_INPUT);
+}
+function hasLongOptionFlag(tokens, optionName) {
+	let seenOptionTerminator = false;
+	for (const token of tokens) {
+		if (token.kind === "option-terminator") {
+			seenOptionTerminator = true;
+			continue;
+		}
+		if (seenOptionTerminator || token.kind !== "option") continue;
+		if (token.name === optionName) return true;
+	}
+	return false;
+}
+function getFilterOptions({ include, exclude }) {
+	const normalize = (value) => {
+		if (!value) return void 0;
+		return Array.isArray(value) ? value : [value];
+	};
+	return {
+		include: normalize(include),
+		exclude: normalize(exclude)
+	};
+}
+function buildDiffOptions(filterOptions, pager, mode, extraGitArgs = []) {
+	const patterns = buildFilePatterns(filterOptions);
+	const color = (mode === "diff" || mode === "patch" || mode === "stat") && (Boolean(pager) || Boolean(process.stdout.isTTY)) ? "always" : "never";
+	return {
+		diffOptions: {
+			files: patterns.length > 0 ? patterns : void 0,
+			color,
+			extraArgs: extraGitArgs.length > 0 ? extraGitArgs : void 0
+		},
+		color
+	};
+}
+function hasActiveFilters(filterOptions) {
+	return Boolean(filterOptions.include?.length || filterOptions.exclude?.length);
+}
+
+//#endregion
+//#region src/cli/git-pass-through.ts
+async function runGitPassThrough({ partitioned, rangeOrUrl, useGitCompat, pager, noPager }) {
+	let cleanup;
+	let left = "";
+	let right = "";
+	if (rangeOrUrl) {
+		let parsed;
+		try {
+			parsed = parseRangeInput(rangeOrUrl);
+		} catch (error) {
+			if (error instanceof DiffxError && error.exitCode === ExitCode.INVALID_INPUT) parsed = void 0;
+			else throw error;
+		}
+		if (!parsed) {
+			if (!partitioned.gitArgs.includes(rangeOrUrl)) left = rangeOrUrl;
+		} else if (parsed.type === "local-range") {
+			left = parsed.left;
+			right = parsed.right;
+		} else {
+			const resolved = await resolveRefs(parsed);
+			left = resolved.left;
+			right = resolved.right;
+			cleanup = resolved.cleanup;
+		}
+	} else if (useGitCompat) {
+		left = "";
+		right = "";
+	}
+	const gitDiffArgs = [];
+	if (left) gitDiffArgs.push(left);
+	if (right) gitDiffArgs.push(right);
+	if (partitioned.pathspecs.length > 0) {
+		gitDiffArgs.push("--");
+		gitDiffArgs.push(...partitioned.pathspecs);
+	}
+	const fullGitArgs = [...partitioned.gitArgs, ...gitDiffArgs];
+	try {
+		const result = await gitClient.runGitDiffRaw(fullGitArgs);
+		if (result.exitCode !== 0) throw new DiffxError(result.stderr.trim().length > 0 ? result.stderr : "git diff failed", ExitCode.GIT_ERROR);
+		const output = result.stdout;
+		if (!await pageOutput(output, {
+			force: pager,
+			disable: Boolean(noPager)
+		})) process.stdout.write(output);
+	} finally {
+		if (cleanup) try {
+			await cleanup();
+		} catch {}
+	}
+}
+
+//#endregion
+//#region src/utils/overview-utils.ts
+const StatusCodeByName = {
+	UNTRACKED: "U",
+	UNMERGED: "U",
+	DELETED: "D",
+	ADDED: "A",
+	RENAMED: "R",
+	COPIED: "C",
+	MODIFIED: "M",
+	IGNORED: "!",
+	UNKNOWN: "?"
+};
+function hasStatusCode(file, code) {
+	return file.working_dir === code || file.index === code;
+}
+function resolveStatusCode(file) {
+	if (hasStatusCode(file, "?")) return StatusCodeByName.UNTRACKED;
+	if (hasStatusCode(file, "U")) return StatusCodeByName.UNMERGED;
+	if (file.index === "!" && file.working_dir === "!") return StatusCodeByName.IGNORED;
+	if (hasStatusCode(file, "D")) return StatusCodeByName.DELETED;
+	if (hasStatusCode(file, "A")) return StatusCodeByName.ADDED;
+	if (hasStatusCode(file, "R")) return StatusCodeByName.RENAMED;
+	if (hasStatusCode(file, "C")) return StatusCodeByName.COPIED;
+	if (hasStatusCode(file, "M")) return StatusCodeByName.MODIFIED;
+	return StatusCodeByName.UNKNOWN;
+}
+async function generateUntrackedOutput(mode, files, color, statAlignWidth) {
+	const chunks = [];
+	const statLines = [];
+	let totalInsertions = 0;
+	let totalDeletions = 0;
+	let totalFiles = 0;
+	for (const filePath of files) switch (mode) {
+		case "diff":
+		case "patch":
+			chunks.push(cleanNoIndexPath$1(await gitClient.diffNoIndex(filePath, color)));
+			break;
+		case "stat":
+			{
+				const statLine = extractStatLine(await gitClient.diffStatNoIndex(filePath, color));
+				if (statLine) statLines.push(formatStatLine(statLine, statAlignWidth));
+				const numstat = await gitClient.diffNumStatNoIndex(filePath, color);
+				for (const line of numstat.split("\n")) {
+					const trimmed = line.trim();
+					if (!trimmed) continue;
+					const parts = trimmed.split("	");
+					if (parts.length < 2) continue;
+					const adds = Number(parts[0]);
+					const dels = Number(parts[1]);
+					totalInsertions += Number.isFinite(adds) ? adds : 0;
+					totalDeletions += Number.isFinite(dels) ? dels : 0;
+					totalFiles += 1;
+				}
+			}
+			break;
+		case "numstat":
+			chunks.push(cleanNoIndexPath$1(await gitClient.diffNumStatNoIndex(filePath, color)).trim());
+			break;
+		case "shortstat":
+			{
+				const numstat = await gitClient.diffNumStatNoIndex(filePath, color);
+				for (const line of numstat.split("\n")) {
+					const trimmed = line.trim();
+					if (!trimmed) continue;
+					const parts = trimmed.split("	");
+					if (parts.length < 2) continue;
+					const adds = Number(parts[0]);
+					const dels = Number(parts[1]);
+					totalInsertions += Number.isFinite(adds) ? adds : 0;
+					totalDeletions += Number.isFinite(dels) ? dels : 0;
+					totalFiles += 1;
+				}
+			}
+			break;
+		case "name-only":
+			chunks.push(filePath);
+			break;
+		case "name-status":
+			chunks.push(`U\t${filePath}`);
+			break;
+		case "summary":
+			chunks.push(`create mode 100644 ${filePath}`);
+			break;
+		default: throw new Error(`Unknown output mode: ${mode}`);
+	}
+	if (mode === "stat") {
+		if (statLines.length === 0) return "";
+		const summary = formatSummaryLine(totalFiles, totalInsertions, totalDeletions);
+		return `${statLines.join("\n")}\n ${summary}`;
+	}
+	if (mode === "shortstat") {
+		if (totalFiles === 0) return "";
+		return formatSummaryLine(totalFiles, totalInsertions, totalDeletions);
+	}
+	return chunks.filter((chunk) => chunk.trim().length > 0).join("\n");
+}
+function mergeOutputs(base, extra) {
+	if (!base) return extra;
+	if (!extra) return base;
+	return `${base.trimEnd()}\n${extra.trimStart()}`;
+}
+async function buildStatusMapForWorktree(filterOptions) {
+	const status = await gitClient.getStatus();
+	const map = /* @__PURE__ */ new Map();
+	for (const filePath of status.not_added) if (shouldIncludeFile(filePath, filterOptions)) map.set(filePath, "U");
+	for (const file of status.files) {
+		if (!shouldIncludeFile(file.path, filterOptions)) continue;
+		if (map.get(file.path) === StatusCodeByName.UNTRACKED) continue;
+		map.set(file.path, resolveStatusCode(file));
+	}
+	return map;
+}
+async function buildStatusMapForRange(left, right) {
+	const output = await gitClient.diffNameStatus(left, right, void 0);
+	const map = /* @__PURE__ */ new Map();
+	for (const line of output.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const parts = trimmed.split("	");
+		const status = parts[0];
+		if (status.startsWith("R") || status.startsWith("C")) {
+			const filePath$1 = parts[2] ?? parts[1];
+			if (filePath$1) map.set(filePath$1, status[0]);
+			continue;
+		}
+		const filePath = parts[1];
+		if (filePath) map.set(filePath, status[0]);
+	}
+	return map;
+}
+function formatNumstatOutput(output, statusMap) {
+	const rows = output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
+		const parts = line.split("	");
+		if (parts.length < 3) return {
+			filePath: line,
+			status: "?",
+			adds: "0",
+			dels: "0"
+		};
+		const adds = parts[0];
+		const dels = parts[1];
+		const filePath = parts.slice(2).join("	").trim();
+		return {
+			filePath,
+			status: statusMap.get(filePath) ?? "?",
+			adds,
+			dels
+		};
+	});
+	const fileWidth = Math.max(4, ...rows.map((row) => row.filePath.length));
+	const statusWidth = 1;
+	const addsWidth = Math.max(1, ...rows.map((row) => row.adds.length));
+	const delsWidth = Math.max(1, ...rows.map((row) => row.dels.length));
+	return `${`${"FILE".padEnd(fileWidth)}  ${"S".padEnd(statusWidth)}  ${"+".padStart(addsWidth)}  ${"-".padStart(delsWidth)}`}\n${rows.map((row) => {
+		return `${row.filePath.padEnd(fileWidth)}  ${row.status.padEnd(statusWidth)}  ${row.adds.padStart(addsWidth)}  ${row.dels.padStart(delsWidth)}`;
+	}).join("\n")}`;
+}
+function cleanNoIndexPath$1(output) {
+	return output.replace(/\/dev\/null => /g, "");
+}
+function formatSummaryLine(files, insertions, deletions) {
+	return `${files} ${files === 1 ? "file changed" : "files changed"}, ${insertions} ${insertions === 1 ? "insertion(+)" : "insertions(+)"}, ${deletions} ${deletions === 1 ? "deletion(-)" : "deletions(-)"}`;
+}
+function extractStatLine(output) {
+	for (const line of output.split("\n")) if (line.includes("|")) return line;
+	return null;
+}
+function formatStatLine(line, alignWidth) {
+	const [leftPart, rightPart = ""] = line.split("|");
+	const fileWithLead = ` ${cleanNoIndexPath$1(leftPart).trim()}`;
+	const width = Math.max(alignWidth ?? 0, fileWithLead.length);
+	return `${fileWithLead.padEnd(width)} |${rightPart}`;
+}
+
+//#endregion
+//#region src/cli/worktree-output.ts
+function cleanNoIndexPath(output) {
+	return output.replace(/\/dev\/null => /g, "");
+}
+function parseStatOutput(output) {
+	const rows = [];
+	let summary = {
+		files: 0,
+		insertions: 0,
+		deletions: 0
+	};
+	for (const line of output.split("\n")) {
+		const idx = line.indexOf("|");
+		if (idx >= 0) {
+			const leftPart = line.slice(0, idx);
+			const rightPart = line.slice(idx + 1);
+			const filePath = cleanNoIndexPath(leftPart).trim();
+			if (filePath.length > 0) {
+				const trimmedRight = rightPart.trim();
+				const match = trimmedRight.match(/^(\d+)\s+(.*)$/);
+				rows.push({
+					filePath,
+					changeCount: match ? match[1] : "0",
+					changeBar: match ? match[2] : trimmedRight,
+					additions: 0,
+					deletions: 0
+				});
+			}
+			continue;
+		}
+		const trimmed = line.trim();
+		if (!trimmed.includes("file changed") && !trimmed.includes("files changed")) continue;
+		const filesMatch = trimmed.match(/^(\d+)\s+files?\s+changed/);
+		const insertionsMatch = trimmed.match(/(\d+)\s+insertions?\(\+\)/);
+		const deletionsMatch = trimmed.match(/(\d+)\s+deletions?\(-\)/);
+		if (filesMatch) summary = {
+			files: Number.parseInt(filesMatch[1], 10) || 0,
+			insertions: insertionsMatch ? Number.parseInt(insertionsMatch[1], 10) || 0 : 0,
+			deletions: deletionsMatch ? Number.parseInt(deletionsMatch[1], 10) || 0 : 0
+		};
+	}
+	return {
+		rows,
+		summary
+	};
+}
+function parseNumstatOutput(output) {
+	const map = /* @__PURE__ */ new Map();
+	for (const line of output.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const parts = trimmed.split("	");
+		if (parts.length < 3) continue;
+		const filePath = cleanNoIndexPath(parts.slice(2).join("	")).trim();
+		if (!filePath) continue;
+		const additions = Number(parts[0]);
+		const deletions = Number(parts[1]);
+		map.set(filePath, {
+			additions: Number.isFinite(additions) ? additions : 0,
+			deletions: Number.isFinite(deletions) ? deletions : 0
+		});
+	}
+	return map;
+}
+function buildStatBar(additions, deletions, width, color) {
+	if (width <= 0) return "";
+	const total = additions + deletions;
+	if (total <= 0) return "";
+	const effectiveWidth = additions > 0 && deletions > 0 ? Math.max(2, width) : width;
+	let plusWidth = additions > 0 ? Math.round(additions / total * effectiveWidth) : 0;
+	let minusWidth = effectiveWidth - plusWidth;
+	if (additions > 0 && plusWidth < 1) plusWidth = 1;
+	if (deletions > 0 && minusWidth < 1) minusWidth = 1;
+	if (plusWidth + minusWidth > effectiveWidth) if (plusWidth > minusWidth && additions > 0) plusWidth = Math.max(1, effectiveWidth - minusWidth);
+	else minusWidth = Math.max(1, effectiveWidth - plusWidth);
+	const plus = "+".repeat(plusWidth);
+	const minus = "-".repeat(minusWidth);
+	if (color === "never") return `${plus}${minus}`;
+	return `${plus ? `\u001b[32m${plus}\u001b[m` : ""}${minus ? `\u001b[31m${minus}\u001b[m` : ""}`;
+}
+function formatStatSummary(summary) {
+	const fileLabel = summary.files === 1 ? "file changed" : "files changed";
+	const insertionLabel = summary.insertions === 1 ? "insertion(+)" : "insertions(+)";
+	const deletionLabel = summary.deletions === 1 ? "deletion(-)" : "deletions(-)";
+	return `${summary.files} ${fileLabel}, ${summary.insertions} ${insertionLabel}, ${summary.deletions} ${deletionLabel}`;
+}
+function formatStatRows(rows) {
+	if (rows.length === 0) return "";
+	const pathWidth = Math.max(...rows.map((row) => row.filePath.length));
+	const countWidth = Math.max(...rows.map((row) => row.changeCount.length));
+	return rows.map((row) => {
+		return ` ${row.filePath.padEnd(pathWidth)} | ${row.changeCount.padStart(countWidth)} ${row.changeBar}`;
+	}).join("\n");
+}
+function parseShortStatOutput(output) {
+	const filesMatch = output.match(/(\d+)\s+files?\s+changed/);
+	const insertionsMatch = output.match(/(\d+)\s+insertions?/);
+	const deletionsMatch = output.match(/(\d+)\s+deletions?/);
+	return {
+		files: filesMatch ? Number.parseInt(filesMatch[1], 10) : 0,
+		insertions: insertionsMatch ? Number.parseInt(insertionsMatch[1], 10) : 0,
+		deletions: deletionsMatch ? Number.parseInt(deletionsMatch[1], 10) : 0
+	};
+}
+async function appendUntrackedStatFiles(output, left, right, filterOptions, color) {
+	if (right) return output;
+	const filteredUntracked = (await gitClient.getUntrackedFiles()).filter((filePath) => shouldIncludeFile(filePath, filterOptions));
+	if (filteredUntracked.length === 0) return output;
+	const base = parseStatOutput(output);
+	const patterns = buildFilePatterns(filterOptions);
+	const trackedNumstat = parseNumstatOutput(await gitClient.diffNumStatAgainstWorktree(left, { files: patterns.length > 0 ? patterns : void 0 }));
+	const baseRows = base.rows.map((row) => {
+		const counts = trackedNumstat.get(row.filePath);
+		if (!counts) return row;
+		const total = counts.additions + counts.deletions;
+		return {
+			...row,
+			additions: counts.additions,
+			deletions: counts.deletions,
+			changeCount: String(total)
+		};
+	});
+	const extraRows = [];
+	let extraSummary = {
+		files: 0,
+		insertions: 0,
+		deletions: 0
+	};
+	for (const filePath of filteredUntracked) {
+		const parsedNumstat = parseNumstatOutput(await gitClient.diffNumStatNoIndex(filePath, color));
+		for (const [parsedPath, counts] of parsedNumstat.entries()) {
+			const total = counts.additions + counts.deletions;
+			extraRows.push({
+				filePath: parsedPath,
+				changeCount: String(total),
+				changeBar: "",
+				additions: counts.additions,
+				deletions: counts.deletions
+			});
+			extraSummary.files += 1;
+			extraSummary.insertions += counts.additions;
+			extraSummary.deletions += counts.deletions;
+		}
+	}
+	const rows = [...baseRows, ...extraRows];
+	if (rows.length === 0) return output;
+	const maxTotalChanges = Math.max(1, ...rows.map((row) => row.additions + row.deletions));
+	const maxGraphWidth = 53;
+	const normalizedRows = rows.map((row) => {
+		const total = row.additions + row.deletions;
+		const graphWidth = total > 0 ? Math.max(1, Math.round(total / maxTotalChanges * maxGraphWidth)) : 0;
+		return {
+			...row,
+			changeCount: String(total),
+			changeBar: buildStatBar(row.additions, row.deletions, graphWidth, color)
+		};
+	});
+	const combinedSummary = {
+		files: base.summary.files + extraSummary.files,
+		insertions: base.summary.insertions + extraSummary.insertions,
+		deletions: base.summary.deletions + extraSummary.deletions
+	};
+	return `${formatStatRows(normalizedRows)}\n ${formatStatSummary(combinedSummary)}`;
+}
+async function appendUntrackedShortStatFiles(output, filterOptions, color) {
+	const filteredUntracked = (await gitClient.getUntrackedFiles()).filter((filePath) => shouldIncludeFile(filePath, filterOptions));
+	if (filteredUntracked.length === 0) return output;
+	const base = parseShortStatOutput(output);
+	let untrackedFiles = 0;
+	let untrackedInsertions = 0;
+	let untrackedDeletions = 0;
+	for (const filePath of filteredUntracked) {
+		const numstatOutput = await gitClient.diffNumStatNoIndex(filePath, color);
+		for (const line of numstatOutput.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			const parts = trimmed.split("	");
+			if (parts.length < 2) continue;
+			const adds = Number(parts[0]);
+			const dels = Number(parts[1]);
+			if (Number.isFinite(adds)) untrackedInsertions += adds;
+			if (Number.isFinite(dels)) untrackedDeletions += dels;
+			untrackedFiles += 1;
+		}
+	}
+	const combined = {
+		files: base.files + untrackedFiles,
+		insertions: base.insertions + untrackedInsertions,
+		deletions: base.deletions + untrackedDeletions
+	};
+	return ` ${combined.files} files changed, ${combined.insertions} insertions(+), ${combined.deletions} deletions(-)`;
+}
+async function appendUntrackedFiles(output, mode, left, right, filterOptions, color) {
+	if (right) return output;
+	if (mode === "stat") return appendUntrackedStatFiles(output, left, right, filterOptions, color);
+	if (mode === "shortstat") return appendUntrackedShortStatFiles(output, filterOptions, color);
+	const filteredUntracked = (await gitClient.getUntrackedFiles()).filter((filePath) => shouldIncludeFile(filePath, filterOptions));
+	if (filteredUntracked.length === 0) return output;
+	return mergeOutputs(output, await generateUntrackedOutput(mode, filteredUntracked, color, void 0));
+}
+async function hasUnfilteredChanges(refs) {
+	if (!refs.right) return gitClient.hasWorktreeChanges();
+	return (await gitClient.diffShortStat(refs.left, refs.right, void 0)).trim().length > 0;
+}
+async function processWorktreeOutput(output, mode, refs, filterOptions, color, useSummaryFormat) {
+	let result = await appendUntrackedFiles(output, mode, refs.left, refs.right || void 0, filterOptions, color);
+	if (mode !== "numstat" || !useSummaryFormat) return result;
+	const statusMap = refs.right ? await buildStatusMapForRange(refs.left, refs.right) : await buildStatusMapForWorktree(filterOptions);
+	result = formatNumstatOutput(result, statusMap);
+	return result;
+}
+
+//#endregion
+//#region src/cli/command.ts
+/**
+* Gunshi CLI command definition for diffx
+*/
+const RANGE_TYPES_USING_DIFF_PATCH_STYLE = new Set([
+	"pr-ref",
+	"github-url",
+	"pr-range",
+	"github-commit-url",
+	"github-pr-changes-url",
+	"github-compare-url"
+]);
+async function resolveRefsForRange(rangeOrUrl, mode) {
+	const range = parseRangeInput(rangeOrUrl);
+	const patchStyle = mode === "patch" && RANGE_TYPES_USING_DIFF_PATCH_STYLE.has(range.type) ? "diff" : void 0;
+	return {
+		...await resolveRefs(range),
+		patchStyle
+	};
+}
+async function resolveRefsForDefault(useGitCompat) {
+	if (useGitCompat) return {
+		left: "",
+		right: ""
+	};
+	if (await gitClient.hasWorktreeChanges()) return {
+		left: "HEAD",
+		right: ""
+	};
+	const auto = await resolveAutoBaseRefs();
+	return {
+		left: auto.mergeBase,
+		right: auto.right
+	};
+}
+async function generateDiffOutput(mode, refs, diffOptions) {
+	const { left, right, patchStyle } = refs;
+	if (right) return generateOutput(mode, left, right, diffOptions, patchStyle);
+	return generateOutputAgainstWorktree(mode, left, diffOptions);
+}
+async function cleanupRefs(refs) {
+	if (!refs.cleanup) return;
+	try {
+		await refs.cleanup();
+	} catch {}
+}
+/**
+* Main diffx command
+*/
+const diffxCommand = define({
+	rendering: { header: null },
+	args: {
+		mode: {
+			type: "string",
+			description: "Output mode: diff (default), patch (unified diff, same as git diff -p), stat, numstat, or shortstat"
+		},
+		stat: {
+			type: "boolean",
+			description: "Show diff statistics (same as --mode stat)"
+		},
+		numstat: {
+			type: "boolean",
+			description: "Show per-file adds/removes (same as --mode numstat)"
+		},
+		summary: {
+			type: "boolean",
+			description: "Show structural summary (create/delete/rename mode). Equivalent to git diff --summary"
+		},
+		shortstat: {
+			type: "boolean",
+			description: "Show summary line only (same as --mode shortstat)"
+		},
+		"name-only": {
+			type: "boolean",
+			description: "Show only filenames of changed files"
+		},
+		"name-status": {
+			type: "boolean",
+			description: "Show filenames with status (M/A/D/etc)"
+		},
+		overview: {
+			type: "boolean",
+			description: "Show custom diffx table with status/additions/deletions (not a git flag)"
+		},
+		pager: {
+			type: "boolean",
+			description: "Force output through a pager (overrides TTY detection)"
+		},
+		"no-pager": {
+			type: "boolean",
+			description: "Disable the pager"
+		},
+		include: {
+			type: "string",
+			description: "Only include files matching this glob pattern",
+			short: "i"
+		},
+		exclude: {
+			type: "string",
+			description: "Exclude files matching this glob pattern",
+			short: "e"
+		},
+		index: {
+			type: "boolean",
+			description: "Strict git diff compatibility: show unstaged changes (index vs working tree)"
+		}
+	},
+	run: async (ctx) => {
+		const partitioned = partitionArgs(process.argv.slice(2), ctx.tokens);
+		validateNoConflictingFlags(partitioned.diffxFlags, partitioned.gitArgs);
+		const rangeOrUrl = getRangeOrUrl(ctx.positionals ?? [], partitioned.inputRange);
+		const { include, exclude, mode: rawMode, stat, numstat, shortstat, overview, "name-only": _nameOnly, "name-status": _nameStatus, pager, "no-pager": noPager, index } = ctx.values;
+		const toPatternList = (value) => {
+			if (typeof value === "string") return value;
+			if (Array.isArray(value)) {
+				const patterns = value.filter((item) => typeof item === "string");
+				return patterns.length > 0 ? patterns : void 0;
+			}
+		};
+		validatePagerOptions(pager, noPager);
+		const hasRange = Boolean(rangeOrUrl);
+		const partitionedInclude = partitioned.diffxFlags.get("--include");
+		const partitionedExclude = partitioned.diffxFlags.get("--exclude");
+		const filterOptions = getFilterOptions({
+			include: toPatternList(partitionedInclude) ?? toPatternList(include),
+			exclude: toPatternList(partitionedExclude) ?? toPatternList(exclude)
+		});
+		const filtersAreActive = hasActiveFilters(filterOptions);
+		if (shouldUseGitPassThrough(partitioned, hasRange, Boolean(index), filtersAreActive)) {
+			await runGitPassThrough({
+				partitioned,
+				rangeOrUrl,
+				useGitCompat: Boolean(index),
+				pager,
+				noPager
+			});
+			return;
+		}
+		const mode = getOutputMode({
+			rawMode,
+			stat,
+			numstat,
+			shortstat,
+			overview,
+			hasStatFlag: hasLongOptionFlag(ctx.tokens, "stat"),
+			hasNumstatFlag: hasLongOptionFlag(ctx.tokens, "numstat"),
+			hasShortstatFlag: hasLongOptionFlag(ctx.tokens, "shortstat"),
+			hasNameOnlyFlag: hasLongOptionFlag(ctx.tokens, "name-only"),
+			hasNameStatusFlag: hasLongOptionFlag(ctx.tokens, "name-status")
+		});
+		const useSummaryFormat = Boolean(overview);
+		const { diffOptions, color } = buildDiffOptions(filterOptions, pager, mode, partitioned.gitArgs);
+		const refs = rangeOrUrl ? await resolveRefsForRange(rangeOrUrl, mode) : await resolveRefsForDefault(Boolean(index));
+		try {
+			let output = await generateDiffOutput(mode, refs, diffOptions);
+			if (!rangeOrUrl || useSummaryFormat) output = await processWorktreeOutput(output, mode, refs, filterOptions, color, useSummaryFormat);
+			const emptyOutput = checkEmptyOutput(output, {
+				hasActiveFilters: filtersAreActive,
+				hasUnfilteredChanges: filtersAreActive ? await hasUnfilteredChanges(refs) : false
+			});
+			if (emptyOutput.isEmpty) {
+				if (emptyOutput.isFilterMismatch) throw createNoFilesMatchedError();
+				return;
+			}
+			const autoPagerMode = mode === "diff" || mode === "patch";
+			if (!await pageOutput(output, {
+				force: pager,
+				disable: Boolean(noPager) || !autoPagerMode && !pager
+			})) console.log(output);
+		} finally {
+			await cleanupRefs(refs);
+		}
+	}
+});
+
+//#endregion
+export { DiffxError as a, parseRangeInput as i, handleError as n, ExitCode as o, resolveRefs as r, diffxCommand as t };
+//# sourceMappingURL=command-5FPIcmTx.mjs.map