diffing 0.6.0 → 0.7.0

package/dist/git-Czo96ymM.mjs

@@ -0,0 +1,789 @@
+import { execFile, execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { basename, join, relative, resolve, sep } from "node:path";
+import { readFileSync } from "node:fs";
+import { promisify } from "node:util";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { parseSync } from "editorconfig";
+//#region src/lib/path.ts
+function decodeAndNormalize(p) {
+	let decoded = p;
+	try {
+		decoded = decodeURIComponent(p);
+	} catch {}
+	return decoded.replace(/\\/g, "/");
+}
+function toSafeRelativePath(filePath, baseDir) {
+	const normalized = decodeAndNormalize(filePath);
+	if (normalized.includes("..") || normalized.includes("\0")) return null;
+	const resolved = resolve(baseDir, normalized);
+	const resolvedBase = resolve(baseDir);
+	if (!(resolved === resolvedBase || resolved.startsWith(resolvedBase + sep))) return null;
+	return relative(resolvedBase, resolved);
+}
+function isSafePath(relativePath, baseDir) {
+	return toSafeRelativePath(relativePath, baseDir) !== null;
+}
+//#endregion
+//#region src/lib/git.ts
+const execFileAsync = promisify(execFile);
+function splitLines(content) {
+	return content.split(/\r\n|\n|\r/);
+}
+function isBinaryFile(absolutePath) {
+	try {
+		const buffer = readFileSync(absolutePath);
+		const bytesToCheck = Math.min(buffer.length, 8192);
+		for (let i = 0; i < bytesToCheck; i++) if (buffer[i] === 0) return true;
+		return false;
+	} catch {
+		return true;
+	}
+}
+function getFileContent(filePath, version) {
+	const root = getRepoRoot();
+	const relPath = toSafeRelativePath(filePath, root);
+	if (!relPath) return null;
+	const resolved = resolve(root, relPath);
+	if (version === "new") try {
+		return readFileSync(resolved);
+	} catch {
+		return null;
+	}
+	try {
+		return execFileSync("git", ["show", `HEAD:${relPath}`], {
+			stdio: "pipe",
+			maxBuffer: 50 * 1024 * 1024
+		});
+	} catch {
+		return null;
+	}
+}
+let cachedRepoRoot = null;
+const editorConfigCache = /* @__PURE__ */ new Map();
+function isGitRepo() {
+	try {
+		execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { stdio: "pipe" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getRepoRoot() {
+	if (cachedRepoRoot !== null) return cachedRepoRoot;
+	cachedRepoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf-8" }).trim();
+	return cachedRepoRoot;
+}
+function getRepoName() {
+	return basename(getRepoRoot());
+}
+function getBranchName() {
+	try {
+		return execFileSync("git", [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		], {
+			stdio: "pipe",
+			encoding: "utf-8"
+		}).trim();
+	} catch {
+		return "";
+	}
+}
+const DIFF_FLAGS = [
+	"--no-ext-diff",
+	"--no-textconv",
+	"--no-color"
+];
+function getTabSizeForFiles(filePaths) {
+	const root = getRepoRoot();
+	const result = {};
+	for (const filePath of filePaths) try {
+		const config = parseSync(join(root, filePath), { cache: editorConfigCache });
+		const size = config.tab_width ?? (config.indent_size === "tab" ? void 0 : config.indent_size);
+		if (typeof size === "number") result[filePath] = size;
+	} catch {}
+	return result;
+}
+async function getRepoRootAsync() {
+	if (cachedRepoRoot !== null) return cachedRepoRoot;
+	try {
+		const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf-8" });
+		cachedRepoRoot = stdout.trim();
+		return cachedRepoRoot;
+	} catch {
+		return "";
+	}
+}
+async function getUntrackedFilePathsAsync() {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"ls-files",
+			"--others",
+			"--exclude-standard"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		const trimmed = stdout.trim();
+		return trimmed ? trimmed.split("\n") : [];
+	} catch {
+		return [];
+	}
+}
+async function getUntrackedFilesDiffAsync() {
+	const root = await getRepoRootAsync();
+	const filePaths = await getUntrackedFilePathsAsync();
+	if (filePaths.length === 0) return "";
+	const patches = [];
+	const fileDiffPromises = filePaths.map(async (file) => {
+		const absolutePath = join(root, file);
+		if (isBinaryFile(absolutePath)) return [
+			`diff --git a/${file} b/${file}`,
+			"new file mode 100644",
+			"index 0000000..0000001",
+			`Binary files /dev/null and b/${file} differ`
+		].join("\n");
+		else try {
+			const lines = splitLines(await readFile(absolutePath, "utf-8"));
+			const diffLines = lines.map((l) => `+${l}`);
+			return [
+				`diff --git a/${file} b/${file}`,
+				"new file mode 100644",
+				"index 0000000..0000001",
+				"--- /dev/null",
+				`+++ b/${file}`,
+				`@@ -0,0 +1,${lines.length} @@`,
+				...diffLines
+			].join("\n");
+		} catch {
+			return "";
+		}
+	});
+	const results = await Promise.all(fileDiffPromises);
+	for (const r of results) if (r) patches.push(r);
+	return patches.length > 0 ? "\n" + patches.join("\n") : "";
+}
+async function getCustomGitDiffAsync(args) {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"diff",
+			...DIFF_FLAGS,
+			...args
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		return stdout;
+	} catch {
+		return "";
+	}
+}
+async function getGitDiffAsync(options = {}) {
+	const unstagedPromise = execFileAsync("git", ["diff", ...DIFF_FLAGS], {
+		encoding: "utf-8",
+		maxBuffer: 50 * 1024 * 1024
+	}).then(({ stdout }) => stdout).catch(() => "");
+	const stagedPromise = options.staged ? execFileAsync("git", [
+		"diff",
+		...DIFF_FLAGS,
+		"--staged"
+	], {
+		encoding: "utf-8",
+		maxBuffer: 50 * 1024 * 1024
+	}).then(({ stdout }) => stdout).catch(() => "") : Promise.resolve("");
+	const untrackedPromise = options.untracked ? getUntrackedFilesDiffAsync() : Promise.resolve("");
+	const [unstaged, staged, untrackedPatch] = await Promise.all([
+		unstagedPromise,
+		stagedPromise,
+		untrackedPromise
+	]);
+	const parts = [];
+	if (unstaged) parts.push(unstaged);
+	if (staged) parts.push(staged);
+	if (untrackedPatch) parts.push(untrackedPatch);
+	return parts.join("\n");
+}
+/**
+* Lists every file the working tree knows about (tracked + untracked,
+* excluding standard-ignored paths). Used by the Phase D file viewer to
+* power a path picker.
+*/
+function listRepoFiles() {
+	try {
+		const tracked = execFileSync("git", ["ls-files"], {
+			encoding: "utf-8",
+			maxBuffer: 100 * 1024 * 1024
+		}).trim();
+		const untracked = execFileSync("git", [
+			"ls-files",
+			"--others",
+			"--exclude-standard"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 100 * 1024 * 1024
+		}).trim();
+		const set = /* @__PURE__ */ new Set();
+		for (const list of [tracked, untracked]) {
+			if (!list) continue;
+			for (const line of list.split("\n")) if (line) set.add(line);
+		}
+		return [...set].sort();
+	} catch {
+		return [];
+	}
+}
+/**
+* Reports whether the repo is currently in the middle of a merge and which
+* files have unresolved conflicts. Used by the Phase C merge-conflict UI to
+* decide when to render the @pierre/diffs UnresolvedFile component.
+*/
+function getMergeStatus() {
+	let root;
+	try {
+		root = getRepoRoot();
+	} catch {
+		return {
+			inMerge: false,
+			conflicts: []
+		};
+	}
+	const mergeHead = join(root, ".git", "MERGE_HEAD");
+	let inMerge = false;
+	try {
+		readFileSync(mergeHead);
+		inMerge = true;
+	} catch {
+		inMerge = false;
+	}
+	let conflicts = [];
+	try {
+		const out = execFileSync("git", [
+			"diff",
+			"--name-only",
+			"--diff-filter=U"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		}).trim();
+		conflicts = out ? out.split("\n") : [];
+	} catch {
+		conflicts = [];
+	}
+	return {
+		inMerge: inMerge || conflicts.length > 0,
+		conflicts
+	};
+}
+function gitAddFile(filePath) {
+	execFileSync("git", [
+		"add",
+		"--",
+		filePath
+	], { stdio: "pipe" });
+}
+/**
+* Returns a unified diff for a single working-tree file (covers unstaged
+* and untracked changes). Used by the Phase E hunk-revert flow to derive
+* the exact patch text we need to `git apply --reverse`.
+*/
+function getFilePatch(filePath) {
+	try {
+		const unstaged = execFileSync("git", [
+			"diff",
+			...DIFF_FLAGS,
+			"--",
+			filePath
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		if (unstaged) return unstaged;
+	} catch {}
+	try {
+		const absolutePath = join(getRepoRoot(), filePath);
+		if (isBinaryFile(absolutePath)) return "";
+		const lines = splitLines(readFileSync(absolutePath, "utf-8"));
+		return [
+			`diff --git a/${filePath} b/${filePath}`,
+			"new file mode 100644",
+			"index 0000000..0000001",
+			"--- /dev/null",
+			`+++ b/${filePath}`,
+			`@@ -0,0 +1,${lines.length} @@`,
+			...lines.map((l) => `+${l}`)
+		].join("\n");
+	} catch {
+		return "";
+	}
+}
+/**
+* Extracts the Nth hunk text from a single-file patch. Returns the lines
+* from `@@ ... @@` through the line before the next `@@` (or EOF).
+*/
+function extractHunk(patch, hunkIndex) {
+	const lines = patch.split("\n");
+	const hunkStarts = [];
+	for (let i = 0; i < lines.length; i++) if (lines[i].startsWith("@@ ")) hunkStarts.push(i);
+	if (hunkIndex < 0 || hunkIndex >= hunkStarts.length) return null;
+	const start = hunkStarts[hunkIndex];
+	const end = hunkIndex + 1 < hunkStarts.length ? hunkStarts[hunkIndex + 1] : lines.length;
+	return lines.slice(start, end).join("\n");
+}
+/** Header lines that the per-file patch needs in order for `git apply` to
+* recognize the target. Stops just before the first `@@` hunk header. */
+function extractPatchHeader(patch) {
+	const lines = patch.split("\n");
+	const out = [];
+	for (const line of lines) {
+		if (line.startsWith("@@ ")) break;
+		out.push(line);
+	}
+	return out.join("\n");
+}
+/**
+* Reverts a single hunk from the working tree by piping a minimal patch to
+* `git apply --reverse`. Throws if git rejects the apply (typically because
+* the file has shifted since the diff was rendered).
+*/
+function revertHunk(filePath, hunkIndex) {
+	const patch = getFilePatch(filePath);
+	if (!patch) throw new Error("No diff available for this file");
+	const header = extractPatchHeader(patch);
+	const hunk = extractHunk(patch, hunkIndex);
+	if (!hunk) throw new Error(`Hunk ${hunkIndex} not found`);
+	execFileSync("git", [
+		"apply",
+		"--reverse",
+		"-"
+	], {
+		input: `${header}\n${hunk}\n`,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		]
+	});
+}
+function getProjectStorageDir(customRepoRoot) {
+	const root = customRepoRoot || getRepoRoot();
+	const hash = createHash("sha256").update(root).digest("hex").slice(0, 8);
+	const repoName = basename(root);
+	return join(homedir(), ".diffing", `${repoName}-${hash}`);
+}
+/**
+* Retrieves git blame for deleted lines and recent log history for the file,
+* providing context on what commit introduced the deleted code.
+*/
+function getHunkHistory(filePath, deletionStart, deletionCount, revision = "HEAD") {
+	if (!isSafePath(filePath, getRepoRoot())) throw new Error("Forbidden file path");
+	const blame = [];
+	if (deletionCount > 0) try {
+		const lines = execFileSync("git", [
+			"blame",
+			"--date=format:%Y-%m-%d",
+			"-L",
+			`${deletionStart},+${deletionCount}`,
+			revision,
+			"--",
+			filePath
+		], {
+			encoding: "utf-8",
+			maxBuffer: 10 * 1024 * 1024
+		}).split("\n");
+		const commitHashes = /* @__PURE__ */ new Set();
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			const match = line.match(/^(\^?[0-9a-fA-F]+) \((.*?) (\d{4}-\d{2}-\d{2}) (\d+)\)(?: (.*))?$/);
+			if (match) {
+				const [_, commit, author, date, lineNum, content] = match;
+				const cleanCommit = commit.startsWith("^") ? commit.slice(1) : commit;
+				blame.push({
+					commit: cleanCommit,
+					author: author.trim(),
+					date,
+					line: parseInt(lineNum, 10),
+					content: content || "",
+					summary: ""
+				});
+				commitHashes.add(cleanCommit);
+			}
+		}
+		const commitSummaries = {};
+		for (const hash of commitHashes) try {
+			commitSummaries[hash] = execFileSync("git", [
+				"show",
+				"-s",
+				"--format=%s",
+				hash
+			], { encoding: "utf-8" }).trim();
+		} catch {
+			commitSummaries[hash] = "Unknown commit";
+		}
+		for (const entry of blame) entry.summary = commitSummaries[entry.commit] || "Unknown commit";
+	} catch (err) {
+		console.warn("Failed to get git blame for hunk history:", err.message);
+	}
+	const recentCommits = [];
+	try {
+		const logOut = execFileSync("git", [
+			"log",
+			"-n",
+			"5",
+			"--date=format:%Y-%m-%d",
+			"--format=%h|%an|%ad|%s",
+			"--",
+			filePath
+		], { encoding: "utf-8" });
+		for (const line of logOut.split("\n")) {
+			if (!line.trim()) continue;
+			const [hash, author, date, summary] = line.split("|");
+			if (hash && author && date && summary) recentCommits.push({
+				hash,
+				author: author.trim(),
+				date,
+				summary: summary.trim()
+			});
+		}
+	} catch (err) {
+		console.warn("Failed to get git log for hunk history:", err.message);
+	}
+	return {
+		blame,
+		recentCommits
+	};
+}
+/**
+* Parse the output of `git log --pretty=raw -p` into `CommitInfo[]`.
+*
+* The `raw` format emits one record per commit:
+*
+*   commit <sha>
+*   tree <sha>
+*   parent <sha>            (zero or more; merges have ≥ 2)
+*   author <name> <email> <unix-time> <tz>
+*   committer <name> <email> <unix-time> <tz>
+*   gpgsig -----BEGIN ...   (optional; continuation lines start with a single space)
+*    <indented body>
+*
+*       <indented commit message — 4 spaces of indent>
+*
+*   diff --git a/... b/...  (the per-commit patch; may be empty)
+*   ...
+*
+* Records are separated by blank lines but the unambiguous boundary is the
+* next line beginning with `commit <40-hex>` at column 0.
+*/
+function parseGitShowRaw(raw) {
+	if (!raw) return [];
+	const out = [];
+	const lines = raw.split("\n");
+	const starts = [];
+	for (let i = 0; i < lines.length; i++) if (/^commit [0-9a-f]{40}\b/.test(lines[i])) starts.push(i);
+	if (starts.length === 0) return [];
+	for (let s = 0; s < starts.length; s++) {
+		const begin = starts[s];
+		const end = s + 1 < starts.length ? starts[s + 1] : lines.length;
+		const info = parseSingleCommitRaw(lines.slice(begin, end));
+		if (info) out.push(info);
+	}
+	return out;
+}
+function parseSingleCommitRaw(lines) {
+	const shaMatch = (lines[0] ?? "").match(/^commit ([0-9a-f]{40})/);
+	if (!shaMatch) return null;
+	const sha = shaMatch[1];
+	let i = 1;
+	const parents = [];
+	let authorName = "";
+	let authorEmail = "";
+	let authorDate = "";
+	let committerName = "";
+	let committerEmail = "";
+	let committerDate = "";
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line === "") break;
+		if (line.startsWith(" ")) {
+			i++;
+			continue;
+		}
+		const idx = line.indexOf(" ");
+		const key = idx === -1 ? line : line.slice(0, idx);
+		const value = idx === -1 ? "" : line.slice(idx + 1);
+		switch (key) {
+			case "tree": break;
+			case "parent":
+				if (value) parents.push(value);
+				break;
+			case "author": {
+				const ident = parseIdent(value);
+				authorName = ident.name;
+				authorEmail = ident.email;
+				authorDate = ident.date;
+				break;
+			}
+			case "committer": {
+				const ident = parseIdent(value);
+				committerName = ident.name;
+				committerEmail = ident.email;
+				committerDate = ident.date;
+				break;
+			}
+			default: break;
+		}
+		i++;
+	}
+	if (i < lines.length && lines[i] === "") i++;
+	const msgLines = [];
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line.startsWith("    ")) {
+			msgLines.push(line.slice(4));
+			i++;
+			continue;
+		}
+		if (line === "") {
+			msgLines.push("");
+			i++;
+			continue;
+		}
+		break;
+	}
+	const { subject, body } = splitMessage(msgLines);
+	let patchStart = -1;
+	for (let j = i; j < lines.length; j++) {
+		const line = lines[j];
+		if (line.startsWith("diff --git ") || line.startsWith("Binary files ")) {
+			patchStart = j;
+			break;
+		}
+		if (line === "") continue;
+		break;
+	}
+	const patch = patchStart === -1 ? "" : lines.slice(patchStart).join("\n").replace(/\n+$/, "\n");
+	return {
+		sha,
+		shortSha: sha.slice(0, 7),
+		parents,
+		subject,
+		body,
+		authorName,
+		authorEmail,
+		authorDate,
+		committerName,
+		committerEmail,
+		committerDate,
+		patch
+	};
+}
+/**
+* Parse a `Name <email> <unix-seconds> <±HHMM>` ident line into structured
+* fields. The email is bracketed; the timestamp is split out and converted to
+* ISO 8601 for consumers.
+*/
+function parseIdent(value) {
+	const match = value.match(/^(.*?)\s+<([^>]*)>\s+(\d+)\s+([+-]\d{4})$/);
+	if (!match) return {
+		name: value,
+		email: "",
+		date: ""
+	};
+	const [, name, email, secs, tz] = match;
+	return {
+		name,
+		email,
+		date: unixToIso(Number(secs), tz)
+	};
+}
+function unixToIso(secs, tz) {
+	if (!Number.isFinite(secs)) return "";
+	const sign = tz.startsWith("-") ? -1 : 1;
+	const tzHours = Number(tz.slice(1, 3));
+	const tzMins = Number(tz.slice(3, 5));
+	const offsetMs = sign * (tzHours * 60 + tzMins) * 6e4;
+	const d = new Date(secs * 1e3 + offsetMs);
+	const pad = (n, w = 2) => String(n).padStart(w, "0");
+	return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}T${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}${tz.slice(0, 3)}:${tz.slice(3)}`;
+}
+function splitMessage(msgLines) {
+	if (msgLines.length === 0) return {
+		subject: "",
+		body: ""
+	};
+	let start = 0;
+	while (start < msgLines.length && msgLines[start] === "") start++;
+	let stop = msgLines.length;
+	while (stop > start && msgLines[stop - 1] === "") stop--;
+	if (start >= stop) return {
+		subject: "",
+		body: ""
+	};
+	const subject = msgLines[start];
+	let bodyStart = start + 1;
+	if (bodyStart < stop && msgLines[bodyStart] === "") bodyStart++;
+	return {
+		subject,
+		body: msgLines.slice(bodyStart, stop).join("\n")
+	};
+}
+async function getShowDiff(revspecs, pathspecs = []) {
+	if (revspecs.length === 0) return {
+		commits: [],
+		patch: "",
+		truncated: 0
+	};
+	let shaList;
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"rev-list",
+			"--no-walk",
+			"--reverse",
+			...revspecs,
+			...pathspecs.length ? ["--", ...pathspecs] : []
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		shaList = stdout.split("\n").filter(Boolean);
+	} catch {
+		return {
+			commits: [],
+			patch: "",
+			truncated: 0
+		};
+	}
+	if (shaList.length === 0) return {
+		commits: [],
+		patch: "",
+		truncated: 0
+	};
+	const truncated = Math.max(0, shaList.length - 100);
+	const trimmed = truncated === 0 ? shaList : shaList.slice(0, 100);
+	let raw;
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"log",
+			"--no-walk",
+			"--reverse",
+			"-p",
+			"--pretty=raw",
+			...DIFF_FLAGS,
+			...trimmed,
+			...pathspecs.length ? ["--", ...pathspecs] : []
+		], {
+			encoding: "utf-8",
+			maxBuffer: 200 * 1024 * 1024
+		});
+		raw = stdout;
+	} catch {
+		return {
+			commits: [],
+			patch: "",
+			truncated: 0
+		};
+	}
+	const commits = parseGitShowRaw(raw);
+	return {
+		commits,
+		patch: commits.map((c) => c.patch).filter(Boolean).join("\n"),
+		truncated
+	};
+}
+/**
+* Cheap summary of a revspec series: just subject + author + date. Used by
+* the diff overview banner to render "what am I looking at?" for custom
+* non-show revisions (e.g. `diffing main..feature`).
+*
+* Uses `git log --no-walk --reverse --pretty=%s%x00%an%x00%aI`. The NUL
+* separators avoid the `|` ambiguity the older `getHunkHistory` parser
+* suffers from; we keep that call alone rather than refactoring it.
+*
+* `--no-walk` keeps single-SHA revspecs cheap (just that commit's metadata)
+* while ranges still expand normally. Reuses the same `MAX_SHOW_COMMITS`
+* cap as `getShowDiff` so the banner and the per-commit view agree.
+*/
+async function getCommitSeriesSummary(revspecs, pathspecs = []) {
+	const empty = {
+		commitCount: 0,
+		truncated: 0,
+		subjects: [],
+		authors: []
+	};
+	if (revspecs.length === 0) return empty;
+	let shaList;
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"rev-list",
+			"--no-walk",
+			"--reverse",
+			...revspecs,
+			...pathspecs.length ? ["--", ...pathspecs] : []
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		shaList = stdout.split("\n").filter(Boolean);
+	} catch {
+		return empty;
+	}
+	const totalCommits = shaList.length;
+	if (totalCommits === 0) return empty;
+	const truncated = Math.max(0, totalCommits - 100);
+	const trimmed = truncated === 0 ? shaList : shaList.slice(0, 100);
+	let raw;
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"log",
+			"--no-walk",
+			"--reverse",
+			"--pretty=%s%x00%an%x00%aI",
+			...DIFF_FLAGS,
+			...trimmed,
+			...pathspecs.length ? ["--", ...pathspecs] : []
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		raw = stdout;
+	} catch {
+		return {
+			...empty,
+			commitCount: totalCommits,
+			truncated
+		};
+	}
+	const subjects = [];
+	const authors = [];
+	const seenAuthors = /* @__PURE__ */ new Set();
+	let fromDate;
+	let toDate;
+	for (const line of raw.split("\n")) {
+		if (!line) continue;
+		const parts = line.split("\0");
+		const subject = parts[0] ?? "";
+		const author = parts[1] ?? "";
+		const date = parts[2] ?? "";
+		if (subject) subjects.push(subject);
+		if (author && !seenAuthors.has(author)) {
+			seenAuthors.add(author);
+			authors.push(author);
+		}
+		if (date) {
+			if (!fromDate || date < fromDate) fromDate = date;
+			if (!toDate || date > toDate) toDate = date;
+		}
+	}
+	return {
+		commitCount: totalCommits,
+		truncated,
+		subjects,
+		authors,
+		fromDate,
+		toDate
+	};
+}
+//#endregion
+export { isSafePath as C, revertHunk as S, getUntrackedFilePathsAsync as _, getCustomGitDiffAsync as a, listRepoFiles as b, getGitDiffAsync as c, getProjectStorageDir as d, getRepoName as f, getTabSizeForFiles as g, getShowDiff as h, getCommitSeriesSummary as i, getHunkHistory as l, getRepoRootAsync as m, extractPatchHeader as n, getFileContent as o, getRepoRoot as p, getBranchName as r, getFilePatch as s, extractHunk as t, getMergeStatus as u, gitAddFile as v, toSafeRelativePath as w, parseGitShowRaw as x, isGitRepo as y };