diffing 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,1903 @@
+#!/usr/bin/env node
+import { _ as gitAddFile, a as formatComments, b as revertHunk, c as getFileContent, d as getMergeStatus, f as getProjectStorageDir, g as getUntrackedFilePathsAsync, h as getTabSizeForFiles, i as writeServerLock, l as getGitDiffAsync, m as getRepoRoot, o as getBranchName, p as getRepoName, r as removeServerLock, s as getCustomGitDiffAsync, u as getHunkHistory, v as isGitRepo, x as isSafePath, y as listRepoFiles } from "./server-lock-Bx9ixiF6.mjs";
+import { fileURLToPath } from "node:url";
+import { dirname, extname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, watch, writeFileSync } from "node:fs";
+import getPort from "get-port";
+import { parseArgs } from "node:util";
+import { execFileSync } from "node:child_process";
+import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { serve } from "@hono/node-server";
+//#region src/lib/diff-options.ts
+const DEFAULTS$1 = {
+	revisions: [],
+	staged: false,
+	merge: false,
+	pathspecs: [],
+	indentHeuristic: true,
+	noIndentHeuristic: false,
+	ignoreSpaceChange: false,
+	ignoreAllSpace: false,
+	ignoreBlankLines: false,
+	ignoreCrAtEol: false,
+	functionContext: false,
+	patchWithRaw: false,
+	patchWithStat: false,
+	compactSummary: false,
+	cumulative: false,
+	pickaxeAll: false,
+	exitCode: false,
+	quiet: false,
+	noPrefix: false,
+	binary: false,
+	fullIndex: false,
+	text: false,
+	textconv: false,
+	noExtDiff: false,
+	itaVisible: false,
+	noRelative: false,
+	findCopiesHarder: false,
+	check: false,
+	outputMode: "auto",
+	host: "127.0.0.1",
+	noOpen: false,
+	help: false,
+	version: false,
+	includeUnstaged: true,
+	includeUntracked: true
+};
+/**
+* All git-diff option definitions for `node:util.parseArgs`.
+* Categorised to match `git diff --help`.
+*/
+const GIT_DIFF_OPTIONS = {
+	staged: { type: "boolean" },
+	cached: { type: "boolean" },
+	merge: { type: "boolean" },
+	"diff-algorithm": { type: "string" },
+	"indent-heuristic": {
+		type: "boolean",
+		default: true
+	},
+	"no-indent-heuristic": { type: "boolean" },
+	anchored: { type: "string" },
+	"ignore-space-change": {
+		type: "boolean",
+		short: "b"
+	},
+	"ignore-all-space": {
+		type: "boolean",
+		short: "w"
+	},
+	"ignore-blank-lines": { type: "boolean" },
+	"ignore-cr-at-eol": { type: "boolean" },
+	"ws-error-highlight": { type: "string" },
+	"unified": {
+		type: "string",
+		short: "U"
+	},
+	"inter-hunk-context": { type: "string" },
+	"function-context": {
+		type: "boolean",
+		short: "W"
+	},
+	"word-diff": { type: "string" },
+	"word-diff-regex": { type: "string" },
+	"color-words": { type: "string" },
+	"color-moved": { type: "string" },
+	"color-moved-ws": { type: "string" },
+	"find-copies": {
+		type: "string",
+		short: "C"
+	},
+	"find-copies-harder": { type: "boolean" },
+	"find-renames": {
+		type: "string",
+		short: "M"
+	},
+	"break-rewrites": {
+		type: "string",
+		short: "B"
+	},
+	patch: {
+		type: "boolean",
+		short: "p"
+	},
+	"no-patch": {
+		type: "boolean",
+		short: "s"
+	},
+	raw: { type: "boolean" },
+	"patch-with-raw": { type: "boolean" },
+	"patch-with-stat": { type: "boolean" },
+	numstat: { type: "boolean" },
+	shortstat: { type: "boolean" },
+	stat: { type: "string" },
+	summary: { type: "boolean" },
+	"name-only": { type: "boolean" },
+	"name-status": { type: "boolean" },
+	check: { type: "boolean" },
+	"compact-summary": { type: "boolean" },
+	dirstat: { type: "string" },
+	"dirstat-by-file": { type: "string" },
+	cumulative: { type: "boolean" },
+	"diff-filter": { type: "string" },
+	S: { type: "string" },
+	G: { type: "string" },
+	"pickaxe-all": { type: "boolean" },
+	output: {
+		type: "string",
+		short: "o"
+	},
+	"exit-code": { type: "boolean" },
+	quiet: { type: "boolean" },
+	"src-prefix": { type: "string" },
+	"dst-prefix": { type: "string" },
+	"no-prefix": { type: "boolean" },
+	"line-prefix": { type: "string" },
+	submodule: { type: "string" },
+	binary: { type: "boolean" },
+	"no-binary": { type: "boolean" },
+	"full-index": { type: "boolean" },
+	text: {
+		type: "boolean",
+		short: "a"
+	},
+	textconv: { type: "boolean" },
+	"no-textconv": { type: "boolean" },
+	"no-ext-diff": { type: "boolean" },
+	"ext-diff": { type: "string" },
+	"ita-visible": { type: "boolean" },
+	"ita-invisible-in-index": { type: "boolean" },
+	relative: { type: "string" },
+	"no-relative": { type: "boolean" },
+	"ignore-submodules": { type: "string" }
+};
+/** Options that are diffit-specific, not git-diff options. */
+const DIFFIT_OPTIONS = {
+	port: { type: "string" },
+	host: { type: "string" },
+	"no-open": {
+		type: "boolean",
+		default: false
+	},
+	web: {
+		type: "boolean",
+		default: false
+	},
+	terminal: {
+		type: "boolean",
+		default: false
+	},
+	help: {
+		type: "boolean",
+		short: "h"
+	},
+	version: { type: "boolean" }
+};
+function getVersion() {
+	try {
+		const __dirname = dirname(fileURLToPath(import.meta.url));
+		return JSON.parse(readFileSync(resolve(__dirname, "..", "..", "package.json"), "utf-8")).version;
+	} catch {
+		return "unknown";
+	}
+}
+function printHelp() {
+	const version = getVersion();
+	console.log(`diffit v${version} – Local code review tool for git diffs
+
+Usage: diffit [<git diff options>] [<revision>...] [-- <path>...]
+       diffit --web [<git diff options>] [<revision>...] [-- <path>...]
+       diffit [server options]
+
+Git Diff Options (drop-in replacement for git diff):`);
+	printGitDiffHelp();
+	console.log(`
+Diffit Server Options:
+  --port <port>        Port to run the server on (default: random available port)
+  --host <host>        Host address to bind to (default: 127.0.0.1). Pass
+                       0.0.0.0 to expose the server to the local network.
+  --no-open            Don't open the browser automatically
+
+Output Modes:
+  By default diffit auto-selects the best output mode:
+  - Terminal mode: when output is a pipe, redirect, or non-TTY
+  - Web mode:     when output is a TTY (interactive terminal)
+
+  Force a mode with --web or --terminal flags.
+
+Examples:
+  diffit                        Review uncommitted changes (web UI)
+  diffit --staged               Review staged changes
+  diffit HEAD~3                 Review last 3 commits
+  diffit main..feature          Compare branches
+  diffit --diff-algorithm=patience src/  Diff with patience algorithm
+  diffit -U10                   Diff with 10 context lines
+  diffit --word-diff=color      Word-level diff in color
+  diffit -b -w                  Ignore whitespace changes
+  diffit --host 0.0.0.0         Allow other machines on the LAN to review`);
+}
+function printGitDiffHelp() {
+	console.log(`
+  Revision / Range:
+    --staged, --cached      Show staged changes
+    --merge                 Show merge conflicts
+
+  Diff Algorithm:
+    --diff-algorithm=<A>    Choose diff algorithm (minimal, patience, histogram, myers)
+    --indent-heuristic      Enable indent heuristic (default: on)
+    --no-indent-heuristic   Disable indent heuristic
+    --anchored=<TEXT>       Anchor diff algorithm to <TEXT>
+
+  Whitespace:
+    -b, --ignore-space-change       Ignore changes in amount of whitespace
+    -w, --ignore-all-space          Ignore whitespace when comparing lines
+    --ignore-blank-lines            Ignore blank lines
+    --ignore-cr-at-eol              Ignore carriage-return at EOL
+    --ws-error-highlight=<KIND>     Highlight whitespace errors (none, default, all)
+
+  Context:
+    -U<n>, --unified=<n>           Generate diffs with <n> lines of context
+    --inter-hunk-context=<n>        Show <n> lines between diff hunks
+    -W, --function-context          Show whole function as context
+
+  Word Diff:
+    --word-diff=<MODE>              Word diff (color, plain, porcelain, none)
+    --word-diff-regex=<REGEX>       Regex to determine a word
+    --color-words[=<REGEX>]         Word diff with color
+
+  Moved / Copied Detection:
+    --color-moved=<MODE>            Color moved lines (no, default, plain, blocks, zebra, dimmed-zebra)
+    --color-moved-ws=<MODE>         How whitespace is treated in --color-moved
+    -C[<n>], --find-copies[=<n>]    Detect copies
+    --find-copies-harder            Spend extra cycles to find copies
+    -M[<n>], --find-renames[=<n>]   Detect renames
+    -B[<n>], --break-rewrites[=<n>] Break complete rewrite changes into delete/add pairs
+
+  Output Format:
+    -p, --patch                     Generate patch (default)
+    -s, --no-patch                  Suppress diff output
+    --raw                           Generate raw diff
+    --patch-with-raw                Both patch and raw output
+    --patch-with-stat               Both patch and stat
+    --numstat                       Machine-friendly stat: additions/deletions per file
+    --shortstat                     Summary of additions/deletions
+    --stat[=<width>]                Diffstat with graph
+    --summary                       Extended header summary
+    --name-only                     Show only names of changed files
+    --name-status                   Show only names and status of changed files
+    --check                         Check if diff introduces whitespace errors
+    --compact-summary               Compact summary for submodule changes
+    --dirstat[=<param>]             Directory-level change stats
+    --dirstat-by-file[=<param>]     Per-file directory stats
+    --cumulative                    Cumulative directory stats
+
+  Filtering:
+    --diff-filter=[(A|C|D|M|R|T|U|X|B)...[*]]
+    -S<string>                      Look for differences that change number of occurrences of <string>
+    -G<regex>                       Look for differences whose patch text contains <regex>
+    --pickaxe-all                   Show all changes with -S or -G
+
+  Output Control:
+    -o, --output=<file>             Write diff to <file>
+    --exit-code                     Exit with 1 if differences, 0 if not
+    --quiet                         Disable all output, imply --exit-code
+
+  Prefixes:
+    --src-prefix=<PREFIX>           Source prefix (default: "a/")
+    --dst-prefix=<PREFIX>           Destination prefix (default: "b/")
+    --no-prefix                     Do not show source/destination prefixes
+    --line-prefix=<PREFIX>          Prepend <PREFIX> to every line
+
+  Submodule:
+    --submodule=<FORMAT>            Submodule diff format (diff, log, short)
+
+  Miscellaneous:
+    --binary                        Output binary diff (apply patch to binary files)
+    --no-binary                     Don't output binary diff
+    --full-index                    Show full blob object names
+    -a, --text                      Treat all files as text
+    --textconv                      Allow external text conversion filters
+    --no-textconv                   Disallow external text conversion filters
+    --no-ext-diff                   Disallow external diff drivers
+    --ext-diff=<CMD>                Allow external diff driver
+    --ita-visible                   Include intent-to-add files
+    --ignore-submodules=<WHEN>      Ignore submodule changes
+    --relative[=<path>]             Show changes relative to <path>
+    --no-relative                   Don't show relative paths`);
+}
+/**
+* Parse raw `process.argv` slice into typed DiffOptions.
+*
+* Strategy:
+* 1. Split argv into: [diffit options] [git revisions] [-- pathspecs]
+* 2. Parse known flags via node:util.parseArgs
+* 3. Anything unknown / positional becomes a revision or pathspec
+*/
+function parseDiffOptions(rawArgs) {
+	const { values, positionals } = parseArgs({
+		options: {
+			...GIT_DIFF_OPTIONS,
+			...DIFFIT_OPTIONS
+		},
+		allowPositionals: true,
+		strict: false,
+		args: rawArgs
+	});
+	const opts = { ...DEFAULTS$1 };
+	if (values.help) opts.help = true;
+	if (values.version) opts.version = true;
+	if (values.port) opts.port = parseInt(values.port, 10);
+	if (values.host) opts.host = values.host;
+	if (values["no-open"]) opts.noOpen = true;
+	if (values.staged || values.cached) opts.staged = true;
+	if (values.merge) opts.merge = true;
+	const algo = values["diff-algorithm"];
+	if (algo && [
+		"minimal",
+		"patience",
+		"histogram",
+		"myers"
+	].includes(algo)) opts.algorithm = algo;
+	if (values["no-indent-heuristic"]) {
+		opts.noIndentHeuristic = true;
+		opts.indentHeuristic = false;
+	}
+	if (values.anchored) opts.anchored = values.anchored;
+	if (values["ignore-space-change"]) opts.ignoreSpaceChange = true;
+	if (values["ignore-all-space"]) opts.ignoreAllSpace = true;
+	if (values["ignore-blank-lines"]) opts.ignoreBlankLines = true;
+	if (values["ignore-cr-at-eol"]) opts.ignoreCrAtEol = true;
+	const wsh = values["ws-error-highlight"];
+	if (wsh && [
+		"none",
+		"default",
+		"all"
+	].includes(wsh)) opts.wsErrorHighlight = wsh;
+	if (values.unified) opts.unifiedContext = parseInt(values.unified, 10);
+	if (values["inter-hunk-context"]) opts.interHunkContext = parseInt(values["inter-hunk-context"], 10);
+	if (values["function-context"]) opts.functionContext = true;
+	const wd = values["word-diff"];
+	if (wd && [
+		"color",
+		"plain",
+		"porcelain",
+		"none"
+	].includes(wd)) opts.wordDiff = wd;
+	if (values["word-diff-regex"]) opts.wordDiffRegex = values["word-diff-regex"];
+	if (values["color-words"]) {
+		opts.wordDiff = "color";
+		opts.wordDiffRegex = values["color-words"] || void 0;
+	}
+	const cm = values["color-moved"];
+	if (cm && [
+		"default",
+		"plain",
+		"blocks",
+		"zebra",
+		"dimmed-zebra",
+		"no"
+	].includes(cm)) opts.colorMoved = cm;
+	const cmw = values["color-moved-ws"];
+	if (cmw && [
+		"no",
+		"ignore-space-at-eol",
+		"ignore-space-change",
+		"ignore-all-space",
+		"allow-indentation-change"
+	].includes(cmw)) opts.colorMovedWs = cmw;
+	if (values["find-copies"] !== void 0) {
+		const v = values["find-copies"];
+		opts.findCopies = v ? parseInt(v, 10) : 40;
+	}
+	if (values["find-copies-harder"]) opts.findCopiesHarder = true;
+	if (values["find-renames"] !== void 0) {
+		const v = values["find-renames"];
+		opts.findRenames = v ? parseInt(v, 10) : 50;
+	}
+	if (values["break-rewrites"] !== void 0) opts.breakRewrites = values["break-rewrites"];
+	if (values.raw) opts.outputFormat = "raw";
+	if (values.numstat) opts.outputFormat = "numstat";
+	if (values.shortstat) opts.outputFormat = "shortstat";
+	if (values.stat !== void 0) opts.outputFormat = "stat";
+	if (values.summary) opts.outputFormat = "summary";
+	if (values["name-only"]) opts.outputFormat = "name-only";
+	if (values["name-status"]) opts.outputFormat = "name-status";
+	if (values["patch-with-raw"]) opts.patchWithRaw = true;
+	if (values["patch-with-stat"]) opts.patchWithStat = true;
+	if (values["compact-summary"]) opts.compactSummary = true;
+	if (values.dirstat) opts.dirstat = values.dirstat;
+	if (values["dirstat-by-file"]) opts.dirstatByFile = values["dirstat-by-file"];
+	if (values.cumulative) opts.cumulative = true;
+	if (values["no-patch"]) opts.outputFormat = void 0;
+	if (values.check) opts.outputFormat = void 0;
+	if (values["diff-filter"]) opts.diffFilter = values["diff-filter"];
+	if (values.S) opts.pickaxeString = values.S;
+	if (values.G) opts.pickaxeRegex = values.G;
+	if (values["pickaxe-all"]) opts.pickaxeAll = true;
+	if (values.output) opts.outputFile = values.output;
+	if (values["exit-code"]) opts.exitCode = true;
+	if (values.quiet) {
+		opts.quiet = true;
+		opts.exitCode = true;
+	}
+	if (values["src-prefix"]) opts.srcPrefix = values["src-prefix"];
+	if (values["dst-prefix"]) opts.dstPrefix = values["dst-prefix"];
+	if (values["no-prefix"]) opts.noPrefix = true;
+	if (values["line-prefix"]) opts.linePrefix = values["line-prefix"];
+	const sm = values.submodule;
+	if (sm && [
+		"diff",
+		"log",
+		"short"
+	].includes(sm)) opts.submodule = sm;
+	if (values.binary) opts.binary = true;
+	if (values["no-binary"]) opts.binary = false;
+	if (values["full-index"]) opts.fullIndex = true;
+	if (values.text) opts.text = true;
+	if (values.textconv) opts.textconv = true;
+	if (values["no-textconv"]) opts.textconv = false;
+	if (values["no-ext-diff"]) opts.noExtDiff = true;
+	if (values["ext-diff"]) opts.extDiff = values["ext-diff"];
+	if (values["ita-visible"] || values["ita-invisible-in-index"]) opts.itaVisible = true;
+	if (values.relative !== void 0) opts.relative = values.relative || void 0;
+	if (values["no-relative"]) opts.noRelative = true;
+	if (values["ignore-submodules"]) {
+		const ig = values["ignore-submodules"];
+		if ([
+			"none",
+			"untracked",
+			"dirty",
+			"all"
+		].includes(ig)) opts.ignoreSubmodules = ig;
+	}
+	const dashDashIdx = rawArgs.indexOf("--");
+	if (dashDashIdx >= 0) {
+		for (let i = 0; i < dashDashIdx; i++) {
+			const arg = rawArgs[i];
+			if (!arg.startsWith("-")) opts.revisions.push(arg);
+		}
+		for (let i = dashDashIdx + 1; i < rawArgs.length; i++) opts.pathspecs.push(rawArgs[i]);
+	} else for (const p of positionals) opts.revisions.push(p);
+	if (values.web) opts.outputMode = "web";
+	else if (values.terminal) opts.outputMode = "terminal";
+	if (process.stdout.isTTY && opts.outputMode === "auto") opts.outputMode = "web";
+	else if (!process.stdout.isTTY && opts.outputMode === "auto") opts.outputMode = "terminal";
+	if (opts.outputFormat || opts.patchWithRaw || opts.patchWithStat || opts.exitCode || opts.quiet || opts.outputFile) opts.outputMode = "terminal";
+	return opts;
+}
+/**
+* Build the `git diff` argument array from parsed options.
+* Returns args that can be spread into `git diff <args>`.
+*/
+function buildGitDiffArgs(opts) {
+	const args = [];
+	if (opts.algorithm) args.push(`--diff-algorithm=${opts.algorithm}`);
+	if (opts.noIndentHeuristic) args.push("--no-indent-heuristic");
+	if (opts.anchored) args.push(`--anchored=${opts.anchored}`);
+	if (opts.staged) args.push("--staged");
+	if (opts.merge) args.push("--merge");
+	if (opts.ignoreSpaceChange) args.push("--ignore-space-change");
+	if (opts.ignoreAllSpace) args.push("--ignore-all-space");
+	if (opts.ignoreBlankLines) args.push("--ignore-blank-lines");
+	if (opts.ignoreCrAtEol) args.push("--ignore-cr-at-eol");
+	if (opts.wsErrorHighlight) args.push(`--ws-error-highlight=${opts.wsErrorHighlight}`);
+	if (opts.unifiedContext !== void 0) args.push(`--unified=${opts.unifiedContext}`);
+	if (opts.interHunkContext !== void 0) args.push(`--inter-hunk-context=${opts.interHunkContext}`);
+	if (opts.functionContext) args.push("--function-context");
+	if (opts.wordDiff) if (opts.wordDiff === "color" && opts.wordDiffRegex && !opts.colorWords) {
+		args.push(`--word-diff=color`);
+		args.push(`--word-diff-regex=${opts.wordDiffRegex}`);
+	} else if (opts.wordDiff === "color" && opts.colorWords) args.push(`--color-words=${opts.wordDiffRegex || "."}`);
+	else args.push(`--word-diff=${opts.wordDiff}`);
+	if (opts.wordDiffRegex && opts.wordDiff !== "color") args.push(`--word-diff-regex=${opts.wordDiffRegex}`);
+	if (opts.colorMoved) args.push(`--color-moved=${opts.colorMoved}`);
+	if (opts.colorMovedWs) args.push(`--color-moved-ws=${opts.colorMovedWs}`);
+	if (opts.findCopies !== void 0) args.push(opts.findCopies === 40 ? "-C" : `-C${opts.findCopies}`);
+	if (opts.findCopiesHarder) args.push("--find-copies-harder");
+	if (opts.findRenames !== void 0) args.push(opts.findRenames === 50 ? "-M" : `-M${opts.findRenames}`);
+	if (opts.breakRewrites !== void 0) args.push(`-B${opts.breakRewrites}`);
+	if (opts.outputFormat === "raw") args.push("--raw");
+	if (opts.outputFormat === "numstat") args.push("--numstat");
+	if (opts.outputFormat === "shortstat") args.push("--shortstat");
+	if (opts.outputFormat === "stat") args.push("--stat");
+	if (opts.outputFormat === "summary") args.push("--summary");
+	if (opts.outputFormat === "name-only") args.push("--name-only");
+	if (opts.outputFormat === "name-status") args.push("--name-status");
+	if (opts.patchWithRaw) args.push("--patch-with-raw");
+	if (opts.patchWithStat) args.push("--patch-with-stat");
+	if (opts.compactSummary) args.push("--compact-summary");
+	if (opts.dirstat) args.push(`--dirstat=${opts.dirstat}`);
+	if (opts.dirstatByFile) args.push(`--dirstat-by-file=${opts.dirstatByFile}`);
+	if (opts.cumulative) args.push("--cumulative");
+	if (opts.check) args.push("--check");
+	if (opts.diffFilter) args.push(`--diff-filter=${opts.diffFilter}`);
+	if (opts.pickaxeString) args.push(`-S${opts.pickaxeString}`);
+	if (opts.pickaxeRegex) args.push(`-G${opts.pickaxeRegex}`);
+	if (opts.pickaxeAll) args.push("--pickaxe-all");
+	if (opts.outputFile) args.push(`--output=${opts.outputFile}`);
+	if (opts.exitCode) args.push("--exit-code");
+	if (opts.quiet) args.push("--quiet");
+	if (opts.srcPrefix) args.push(`--src-prefix=${opts.srcPrefix}`);
+	if (opts.dstPrefix) args.push(`--dst-prefix=${opts.dstPrefix}`);
+	if (opts.noPrefix) args.push("--no-prefix");
+	if (opts.linePrefix) args.push(`--line-prefix=${opts.linePrefix}`);
+	if (opts.submodule) args.push(`--submodule=${opts.submodule}`);
+	if (opts.binary) args.push("--binary");
+	if (opts.fullIndex) args.push("--full-index");
+	if (opts.text) args.push("--text");
+	if (opts.textconv) args.push("--textconv");
+	if (opts.noExtDiff) args.push("--no-ext-diff");
+	if (opts.extDiff) args.push(`--ext-diff=${opts.extDiff}`);
+	if (opts.itaVisible) args.push("--ita-visible");
+	if (opts.relative !== void 0) args.push(opts.relative ? `--relative=${opts.relative}` : "--relative");
+	if (opts.noRelative) args.push("--no-relative");
+	if (opts.ignoreSubmodules) args.push(`--ignore-submodules=${opts.ignoreSubmodules}`);
+	for (const rev of opts.revisions) args.push(rev);
+	if (opts.pathspecs.length > 0) {
+		args.push("--");
+		args.push(...opts.pathspecs);
+	}
+	return args;
+}
+//#endregion
+//#region src/lib/diff-engine.ts
+const MAX_BUFFER = 50 * 1024 * 1024;
+/**
+* Determine whether to use the "standard" web mode (unstaged+staged+untracked)
+* or a "custom" mode (specific revisions / pathspecs).
+*
+* Custom mode is used when the user provides explicit revisions or pathspecs
+* beyond just toggling staged/untracked.
+*/
+function isCustomMode$1(opts) {
+	return opts.revisions.length > 0 || opts.pathspecs.length > 0;
+}
+function parseFilePaths(patch) {
+	const paths = /* @__PURE__ */ new Set();
+	for (const line of patch.split("\n")) {
+		const match = line.match(/^diff --git a\/.+ b\/(.+)$/);
+		if (match) paths.add(match[1]);
+	}
+	return [...paths];
+}
+function parseBinaryFiles(patch, untrackedFiles) {
+	const binaryFiles = [];
+	const lines = patch.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (!line.startsWith("Binary files ") || !line.includes(" differ")) continue;
+		let filePath = "";
+		for (let j = i - 1; j >= 0; j--) {
+			const match = lines[j].match(/^diff --git a\/.+ b\/(.+)$/);
+			if (match) {
+				filePath = match[1];
+				break;
+			}
+		}
+		if (!filePath) continue;
+		let changeType = "changed";
+		for (let j = i - 1; j >= 0; j--) {
+			if (lines[j].startsWith("diff --git")) break;
+			if (lines[j].startsWith("new file mode")) {
+				changeType = "added";
+				break;
+			}
+			if (lines[j].startsWith("deleted file mode")) {
+				changeType = "deleted";
+				break;
+			}
+		}
+		if (changeType === "added" && untrackedFiles?.has(filePath)) changeType = "untracked";
+		binaryFiles.push({
+			path: filePath,
+			type: changeType
+		});
+	}
+	return binaryFiles;
+}
+/**
+* Execute a diff asynchronously — used by the server.
+*/
+async function executeDiffAsync(opts) {
+	if (isCustomMode$1(opts)) {
+		const args = buildGitDiffArgs(opts);
+		return {
+			patch: await getCustomGitDiffAsync(args),
+			args
+		};
+	}
+	return {
+		patch: await getGitDiffAsync({
+			staged: opts.staged,
+			untracked: opts.includeUntracked
+		}),
+		args: []
+	};
+}
+/**
+* Execute a diff and produce the full enriched result used by the web API.
+*/
+async function executeDiffWithMeta(opts) {
+	const { patch } = await executeDiffAsync(opts);
+	const repoName = getRepoName();
+	const branch = getBranchName();
+	const untrackedFiles = opts.includeUntracked ? await getUntrackedFilePathsAsync() : [];
+	const binaryFiles = parseBinaryFiles(patch, new Set(untrackedFiles));
+	const filePaths = parseFilePaths(patch);
+	return {
+		patch,
+		binaryFiles,
+		filePaths,
+		tabSizeMap: getTabSizeForFiles(filePaths),
+		untrackedFiles,
+		repoName,
+		branch
+	};
+}
+/**
+* Run the diff in terminal mode: forward to git diff with full flags,
+* output to stdout. Behaves identically to `git diff`.
+*/
+function runTerminalDiff(opts) {
+	const args = buildGitDiffArgs(opts);
+	const enforceDefaults = !opts.outputFormat && !opts.quiet;
+	const finalArgs = [];
+	if (enforceDefaults) {
+		if (!args.includes("--no-ext-diff") && !opts.extDiff) finalArgs.push("--no-ext-diff");
+	}
+	finalArgs.push(...args);
+	try {
+		execFileSync("git", ["diff", ...finalArgs], {
+			encoding: "utf-8",
+			maxBuffer: MAX_BUFFER,
+			stdio: "inherit"
+		});
+		return 0;
+	} catch (err) {
+		if (err.status === 1 && opts.exitCode) return 1;
+		return err.status ?? 1;
+	}
+}
+/**
+* Validate the environment: check that we're in a git repo.
+* Returns an error message or null.
+*/
+function validateEnvironment() {
+	if (!isGitRepo()) return "Error: not inside a git repository";
+	return null;
+}
+//#endregion
+//#region src/lib/symbols.ts
+const SYMBOL_PATTERNS = [
+	{
+		pattern: /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w[\w$]*)\s*[<(]/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?(?:const|let|var)\s+(\w[\w$]*)\s*=\s*(?:async\s*)?\(/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?(?:const|let|var)\s+(\w[\w$]*)\s*=\s*(?:async\s+)?function/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?class\s+(\w[\w$]*)/i,
+		kind: "class",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?interface\s+(\w[\w$]*)/i,
+		kind: "interface",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?type\s+(\w[\w$]*)\s*=/i,
+		kind: "type",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?enum\s+(\w[\w$]*)/i,
+		kind: "enum",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:export\s+)?(?:const|let|var)\s+(\w[\w$]*)\s*=/i,
+		kind: "variable",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*def\s+(\w[\w$]*)\s*\(/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:pub(?:\s*\(\w+\))?\s+)?fn\s+(\w[\w$]*)\s*[<(]/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:pub(?:\s*\(\w+\))?\s+)?struct\s+(\w[\w$]*)/i,
+		kind: "struct",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:pub(?:\s*\(\w+\))?\s+)?enum\s+(\w[\w$]*)/i,
+		kind: "enum",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:pub(?:\s*\(\w+\))?\s+)?impl\s+(\w[\w$]*)/i,
+		kind: "impl",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:pub(?:\s*\(\w+\))?\s+)?trait\s+(\w[\w$]*)/i,
+		kind: "trait",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*func\s+(\w[\w$]*)\s*\(/i,
+		kind: "function",
+		nameGroup: 1
+	},
+	{
+		pattern: /^\s*(?:func\s+)?\((\w[\w$]*)\s+\*?\w+\)\s+(\w[\w$]*)\s*\(/i,
+		kind: "method",
+		nameGroup: 2
+	}
+];
+/**
+* Returns the symbol defined on this line (name + kind), or null if the line
+* is not a recognizable definition. The first matching pattern wins.
+*/
+function classifySymbolLine(line) {
+	for (const { pattern, kind, nameGroup } of SYMBOL_PATTERNS) {
+		const match = pattern.exec(line);
+		if (match) {
+			const name = match[nameGroup];
+			if (name) return {
+				name,
+				kind
+			};
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/lib/search.ts
+/**
+* Server-side code search powered by `@ff-labs/fff-node` — a native (Rust)
+* fuzzy file finder + live grep. Because it is a native Node addon it cannot
+* run in the browser, so the React client calls the `/api/search` endpoint and
+* this module owns the single long-lived `FileFinder` instance for the repo.
+*
+* Design notes:
+*  - The native binary is loaded lazily via dynamic import inside `init()` so a
+*    missing/incompatible platform binary degrades gracefully (search returns
+*    an error) instead of crashing the whole server at module load.
+*  - One finder per process, keyed implicitly to the repo root. Its frecency /
+*    history databases live under the project's `~/.diffit/<repo>` storage dir
+*    so we never write stray files into the user's repository.
+*  - fff runs its own file-system watcher, so the index stays fresh as the
+*    working tree changes during a review.
+*  - "Symbols" search is plain grep for the identifier, then each hit line is
+*    classified with the shared {@link classifySymbolLine} patterns — fff 0.8.x
+*    does not populate `isDefinition`, so we do the classification ourselves.
+*/
+const DEFAULT_LIMIT = 60;
+const MAX_LIMIT = 200;
+/** Internal page size when no path filter — generous so diff-first client
+*  ranking has enough to work with. */
+const SCAN_PAGE = 200;
+/** Larger page size when filtering to a path set, so the post-filter is
+*  effectively complete for normal-sized diffs/repos. */
+const SCAN_PAGE_FILTERED = 1e3;
+let finder = null;
+let initPromise = null;
+let initError = null;
+let shutdownHooked = false;
+function clampLimit(limit) {
+	if (!limit || limit < 1) return DEFAULT_LIMIT;
+	return Math.min(limit, MAX_LIMIT);
+}
+async function init() {
+	try {
+		const { FileFinder } = await import("@ff-labs/fff-node");
+		const root = getRepoRoot();
+		const dbDir = join(getProjectStorageDir(root), "fff");
+		mkdirSync(dbDir, { recursive: true });
+		const created = FileFinder.create({
+			basePath: root,
+			frecencyDbPath: join(dbDir, "frecency.db"),
+			historyDbPath: join(dbDir, "history.db"),
+			logLevel: "error"
+		});
+		if (!created.ok) {
+			initError = created.error;
+			return null;
+		}
+		const f = created.value;
+		if (!shutdownHooked) {
+			shutdownHooked = true;
+			process.once("exit", () => {
+				try {
+					f.destroy();
+				} catch {}
+			});
+		}
+		await f.waitForScan(8e3);
+		finder = f;
+		return f;
+	} catch (err) {
+		initError = err?.message ?? String(err);
+		return null;
+	}
+}
+async function getFinder() {
+	if (finder) return finder;
+	if (initError) return null;
+	if (!initPromise) initPromise = init();
+	return initPromise;
+}
+function isIndexing(f) {
+	try {
+		return f.isScanning();
+	} catch {
+		return false;
+	}
+}
+async function searchFiles(query, opts = {}) {
+	const f = await getFinder();
+	if (!f) return {
+		scope: "files",
+		items: [],
+		total: 0,
+		indexing: false,
+		error: initError ?? "Search unavailable"
+	};
+	const limit = clampLimit(opts.limit);
+	const pathSet = opts.paths ? new Set(opts.paths) : null;
+	const pageSize = pathSet ? SCAN_PAGE_FILTERED : Math.max(SCAN_PAGE, limit);
+	const res = f.fileSearch(query, { pageSize });
+	if (!res.ok) return {
+		scope: "files",
+		items: [],
+		total: 0,
+		indexing: isIndexing(f),
+		error: res.error
+	};
+	const items = [];
+	const { items: raw, scores } = res.value;
+	for (let i = 0; i < raw.length && items.length < limit; i++) {
+		const it = raw[i];
+		if (pathSet && !pathSet.has(it.relativePath)) continue;
+		const score = scores[i];
+		items.push({
+			path: it.relativePath,
+			fileName: it.fileName,
+			gitStatus: it.gitStatus,
+			matchType: score?.matchType ?? "",
+			exact: !!score?.exactMatch
+		});
+	}
+	return {
+		scope: "files",
+		items,
+		total: res.value.totalMatched,
+		indexing: isIndexing(f)
+	};
+}
+async function searchContent(query, opts = {}) {
+	const f = await getFinder();
+	if (!f) return {
+		scope: "text",
+		items: [],
+		total: 0,
+		indexing: false,
+		error: initError ?? "Search unavailable"
+	};
+	if (!query) return {
+		scope: "text",
+		items: [],
+		total: 0,
+		indexing: isIndexing(f)
+	};
+	const limit = clampLimit(opts.limit);
+	const pathSet = opts.paths ? new Set(opts.paths) : null;
+	const pageSize = pathSet ? SCAN_PAGE_FILTERED : Math.max(SCAN_PAGE, limit);
+	const res = f.grep(query, {
+		mode: opts.regex ? "regex" : "plain",
+		smartCase: true,
+		beforeContext: 0,
+		afterContext: 0,
+		pageSize
+	});
+	if (!res.ok) return {
+		scope: "text",
+		items: [],
+		total: 0,
+		indexing: isIndexing(f),
+		error: res.error
+	};
+	const items = [];
+	for (const m of res.value.items) {
+		if (items.length >= limit) break;
+		if (pathSet && !pathSet.has(m.relativePath)) continue;
+		items.push(toContentHit(m));
+	}
+	return {
+		scope: "text",
+		items,
+		total: res.value.totalMatched,
+		indexing: isIndexing(f),
+		regexError: res.value.regexFallbackError || void 0
+	};
+}
+function toContentHit(m) {
+	return {
+		path: m.relativePath,
+		fileName: m.fileName,
+		line: m.lineNumber,
+		col: m.col,
+		content: m.lineContent,
+		matchRanges: m.matchRanges ?? [],
+		gitStatus: m.gitStatus
+	};
+}
+async function searchSymbols(query, opts = {}) {
+	const f = await getFinder();
+	if (!f) return {
+		scope: "symbols",
+		items: [],
+		total: 0,
+		indexing: false,
+		error: initError ?? "Search unavailable"
+	};
+	if (!query) return {
+		scope: "symbols",
+		items: [],
+		total: 0,
+		indexing: isIndexing(f)
+	};
+	const limit = clampLimit(opts.limit);
+	const pathSet = opts.paths ? new Set(opts.paths) : null;
+	const pageSize = pathSet ? SCAN_PAGE_FILTERED : Math.max(SCAN_PAGE_FILTERED, limit * 8);
+	const res = f.grep(query, {
+		mode: "plain",
+		smartCase: true,
+		beforeContext: 0,
+		afterContext: 0,
+		pageSize
+	});
+	if (!res.ok) return {
+		scope: "symbols",
+		items: [],
+		total: 0,
+		indexing: isIndexing(f),
+		error: res.error
+	};
+	const items = [];
+	const ql = query.toLowerCase();
+	const seen = /* @__PURE__ */ new Set();
+	for (const m of res.value.items) {
+		if (items.length >= limit) break;
+		if (pathSet && !pathSet.has(m.relativePath)) continue;
+		const sym = classifySymbolLine(m.lineContent);
+		if (!sym) continue;
+		if (!sym.name.toLowerCase().includes(ql)) continue;
+		const key = `${m.relativePath}:${m.lineNumber}:${sym.name}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const nameIdx = m.lineContent.indexOf(sym.name);
+		const matchRanges = nameIdx >= 0 ? [[nameIdx, nameIdx + sym.name.length]] : m.matchRanges ?? [];
+		items.push({
+			name: sym.name,
+			kind: sym.kind,
+			path: m.relativePath,
+			fileName: m.fileName,
+			line: m.lineNumber,
+			content: m.lineContent,
+			matchRanges,
+			gitStatus: m.gitStatus
+		});
+	}
+	return {
+		scope: "symbols",
+		items,
+		total: items.length,
+		indexing: isIndexing(f)
+	};
+}
+async function searchAll(query, opts = {}) {
+	const limit = clampLimit(opts.limit);
+	const [filesRes, contentRes, symbolsRes] = await Promise.all([
+		searchFiles(query, {
+			...opts,
+			limit
+		}),
+		searchContent(query, {
+			...opts,
+			limit
+		}),
+		searchSymbols(query, {
+			...opts,
+			limit
+		})
+	]);
+	const items = [];
+	for (const hit of filesRes.items) items.push({
+		kind: "file",
+		hit
+	});
+	for (const hit of symbolsRes.items) items.push({
+		kind: "symbol",
+		hit
+	});
+	for (const hit of contentRes.items) items.push({
+		kind: "text",
+		hit
+	});
+	const total = (filesRes.total || 0) + (contentRes.total || 0) + (symbolsRes.total || 0);
+	const indexing = filesRes.indexing || contentRes.indexing || symbolsRes.indexing;
+	const error = filesRes.error || contentRes.error || symbolsRes.error;
+	const regexError = contentRes.regexError;
+	return {
+		scope: "all",
+		items: items.slice(0, limit),
+		total,
+		indexing,
+		error,
+		regexError
+	};
+}
+async function getSearchStatus() {
+	const f = await getFinder();
+	if (!f) return {
+		available: false,
+		indexing: false,
+		indexedFiles: 0,
+		error: initError ?? "Search unavailable"
+	};
+	let indexedFiles = 0;
+	let indexing = false;
+	try {
+		const prog = f.getScanProgress();
+		if (prog.ok) {
+			indexedFiles = prog.value.scannedFilesCount;
+			indexing = prog.value.isScanning;
+		}
+	} catch {}
+	return {
+		available: true,
+		indexing,
+		indexedFiles
+	};
+}
+/** Record that the user opened `path` from a query, improving fff's frecency
+*  ranking for future searches. Best-effort, never throws. */
+async function trackSelection(query, path) {
+	const f = await getFinder();
+	if (!f) return;
+	try {
+		f.trackQuery(query, path);
+	} catch {}
+}
+//#endregion
+//#region src/lib/settings.ts
+const CONFIG_DIR = join(homedir(), ".config", "diffit");
+const SETTINGS_FILE = join(CONFIG_DIR, "settings.json");
+const DEFAULTS = {
+	staged: true,
+	untracked: true,
+	diffStyle: "split",
+	defaultTabSize: 4,
+	theme: "nord",
+	editorIDE: "default",
+	lineDiffType: "word",
+	lineWrap: false,
+	diffIndicators: "classic",
+	showLineNumbers: true,
+	hunkSeparators: "line-info",
+	lineHoverHighlight: "both",
+	fontSize: 13,
+	expandContextByDefault: false,
+	collapsedContextThreshold: 10,
+	expansionLineCount: 20,
+	haptics: true
+};
+function loadSettings() {
+	try {
+		const data = readFileSync(SETTINGS_FILE, "utf-8");
+		return {
+			...DEFAULTS,
+			...JSON.parse(data)
+		};
+	} catch {
+		return { ...DEFAULTS };
+	}
+}
+function saveSettings(settings) {
+	const merged = {
+		...loadSettings(),
+		...settings
+	};
+	mkdirSync(CONFIG_DIR, { recursive: true });
+	writeFileSync(SETTINGS_FILE, JSON.stringify(merged, null, 2));
+	return merged;
+}
+//#endregion
+//#region src/lib/comments.ts
+var FileCommentStore = class {
+	dirPath;
+	filePath;
+	constructor(customRepoRoot) {
+		if (customRepoRoot) this.dirPath = join(customRepoRoot, ".diffit");
+		else this.dirPath = getProjectStorageDir();
+		this.filePath = join(this.dirPath, "comments.json");
+	}
+	async getAll() {
+		try {
+			const data = await readFile(this.filePath, "utf-8");
+			return JSON.parse(data);
+		} catch {
+			return [];
+		}
+	}
+	async save(comments) {
+		try {
+			await mkdir(this.dirPath, { recursive: true });
+			try {
+				const repoRoot = getRepoRoot();
+				await writeFile(join(this.dirPath, "repo_path.txt"), repoRoot, "utf-8");
+			} catch {}
+			await writeFile(this.filePath, JSON.stringify(comments, null, 2), "utf-8");
+		} catch (err) {
+			console.error("Failed to save comments to file:", err);
+		}
+	}
+	async add(comment) {
+		const comments = await this.getAll();
+		comments.push(comment);
+		await this.save(comments);
+		return comment;
+	}
+	async update(id, fields) {
+		const comments = await this.getAll();
+		const index = comments.findIndex((c) => c.id === id);
+		if (index === -1) return null;
+		const comment = comments[index];
+		if (fields.body !== void 0) comment.body = fields.body;
+		if (fields.status !== void 0) comment.status = fields.status;
+		await this.save(comments);
+		return comment;
+	}
+	async remove(id) {
+		const comments = await this.getAll();
+		const index = comments.findIndex((c) => c.id === id);
+		if (index === -1) return false;
+		comments.splice(index, 1);
+		await this.save(comments);
+		return true;
+	}
+	async addReply(commentId, reply) {
+		const comments = await this.getAll();
+		const index = comments.findIndex((c) => c.id === commentId);
+		if (index === -1) return null;
+		const comment = comments[index];
+		if (!comment.replies) comment.replies = [];
+		comment.replies.push(reply);
+		await this.save(comments);
+		return comment;
+	}
+	async removeReply(commentId, replyId) {
+		const comments = await this.getAll();
+		const index = comments.findIndex((c) => c.id === commentId);
+		if (index === -1) return null;
+		const comment = comments[index];
+		const replyIndex = comment.replies.findIndex((r) => r.id === replyId);
+		if (replyIndex === -1) return null;
+		comment.replies.splice(replyIndex, 1);
+		await this.save(comments);
+		return comment;
+	}
+	async updateReply(commentId, replyId, body) {
+		const comments = await this.getAll();
+		const index = comments.findIndex((c) => c.id === commentId);
+		if (index === -1) return null;
+		const comment = comments[index];
+		const reply = comment.replies.find((r) => r.id === replyId);
+		if (!reply) return null;
+		reply.body = body;
+		await this.save(comments);
+		return comment;
+	}
+};
+//#endregion
+//#region src/lib/review-session.ts
+var ReviewSession = class {
+	round = 0;
+	lastSentAt = null;
+	lastPayload = null;
+	waiters = /* @__PURE__ */ new Set();
+	onStatusChange;
+	constructor(onStatusChange) {
+		this.onStatusChange = onStatusChange;
+	}
+	/**
+	* Block until the next `send()` or until `timeoutMs` elapses.
+	*
+	* If `sinceRound` is provided and is behind the current round, a send already
+	* happened since the client last checked → resolve immediately with the
+	* cached payload (the race guard). Otherwise register a waiter.
+	*/
+	await(opts) {
+		const { sinceRound, timeoutMs, signal } = opts;
+		if (sinceRound !== void 0 && sinceRound < this.round && this.lastPayload) return Promise.resolve({
+			status: "released",
+			payload: this.lastPayload
+		});
+		if (signal?.aborted) return Promise.resolve({
+			status: "keep-waiting",
+			round: this.round
+		});
+		return new Promise((resolve) => {
+			const waiter = {
+				resolve,
+				timer: setTimeout(() => {
+					this.removeWaiter(waiter);
+					resolve({
+						status: "keep-waiting",
+						round: this.round
+					});
+				}, timeoutMs),
+				cleanup: () => {}
+			};
+			if (signal) {
+				const onAbort = () => {
+					this.removeWaiter(waiter);
+					resolve({
+						status: "keep-waiting",
+						round: this.round
+					});
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				waiter.cleanup = () => signal.removeEventListener("abort", onAbort);
+			}
+			this.waiters.add(waiter);
+			this.emitStatus();
+		});
+	}
+	/** Capture a review batch and release every blocked waiter. */
+	send(input) {
+		this.round += 1;
+		this.lastSentAt = input.sentAt;
+		const payload = {
+			round: this.round,
+			sentAt: input.sentAt,
+			commentXml: input.commentXml,
+			openCount: input.openCount,
+			comments: input.comments
+		};
+		this.lastPayload = payload;
+		const waiters = [...this.waiters];
+		this.waiters.clear();
+		for (const waiter of waiters) {
+			clearTimeout(waiter.timer);
+			waiter.cleanup();
+			waiter.resolve({
+				status: "released",
+				payload
+			});
+		}
+		this.emitStatus();
+		return payload;
+	}
+	snapshot() {
+		return {
+			round: this.round,
+			waiters: this.waiters.size,
+			lastSentAt: this.lastSentAt
+		};
+	}
+	removeWaiter(waiter) {
+		if (!this.waiters.delete(waiter)) return;
+		clearTimeout(waiter.timer);
+		waiter.cleanup();
+		this.emitStatus();
+	}
+	emitStatus() {
+		this.onStatusChange?.(this.snapshot());
+	}
+};
+//#endregion
+//#region src/server.ts
+const MIME_TYPES = {
+	".html": "text/html",
+	".js": "application/javascript",
+	".css": "text/css",
+	".json": "application/json",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".ico": "image/x-icon",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".bmp": "image/bmp",
+	".avif": "image/avif"
+};
+function isCustomMode(opts) {
+	return opts.revisions.length > 0 || opts.pathspecs.length > 0;
+}
+function createApp(clientDir, diffOpts = DEFAULTS$1, commentStore) {
+	const app = new Hono();
+	const customMode = isCustomMode(diffOpts);
+	const store = commentStore ?? new FileCommentStore();
+	const viewedFiles = /* @__PURE__ */ new Set();
+	const activeClients = /* @__PURE__ */ new Set();
+	const broadcast = (event, data) => {
+		for (const send of activeClients) try {
+			send(event, data);
+		} catch {}
+	};
+	const reviewSession = new ReviewSession((snapshot) => broadcast("agent-status", JSON.stringify(snapshot)));
+	let repoRoot;
+	try {
+		repoRoot = getRepoRoot();
+	} catch {
+		repoRoot = process.cwd();
+	}
+	if (!commentStore) try {
+		const storageDir = getProjectStorageDir();
+		mkdirSync(storageDir, { recursive: true });
+		let commentsDebounce = null;
+		watch(storageDir, (_eventType, filename) => {
+			if (filename && !filename.startsWith("comments.json")) return;
+			if (commentsDebounce) clearTimeout(commentsDebounce);
+			commentsDebounce = setTimeout(() => broadcast("comments", Date.now().toString()), 120);
+		}).unref();
+	} catch (err) {
+		console.warn("Failed to initialize comment store watcher:", err);
+	}
+	let debounceTimeout = null;
+	try {
+		watch(repoRoot, { recursive: true }, (eventType, filename) => {
+			if (!filename) return;
+			const parts = filename.split(/[/\\]/);
+			const isGit = parts.includes(".git");
+			const isNodeModules = parts.includes("node_modules");
+			const isDist = parts.includes("dist");
+			const isChangeset = parts.includes(".changeset");
+			let shouldTrigger = false;
+			if (isGit) {
+				const isIndex = filename.endsWith("index");
+				const isHead = filename.endsWith("HEAD");
+				const isRefs = filename.includes("refs/") || filename.includes("refs\\");
+				if (isIndex || isHead || isRefs) shouldTrigger = true;
+			} else if (!isNodeModules && !isDist && !isChangeset) shouldTrigger = true;
+			if (shouldTrigger) {
+				if (debounceTimeout) clearTimeout(debounceTimeout);
+				debounceTimeout = setTimeout(() => broadcast("change", Date.now().toString()), 200);
+			}
+		}).unref();
+	} catch (err) {
+		console.warn("Failed to initialize repository watcher:", err);
+	}
+	app.get("/api/live", async (c) => {
+		return streamSSE(c, async (stream) => {
+			const sendUpdate = (event, data) => {
+				stream.writeSSE({
+					event,
+					data
+				});
+			};
+			activeClients.add(sendUpdate);
+			await stream.writeSSE({
+				event: "heartbeat",
+				data: Date.now().toString()
+			});
+			const heartbeatInterval = setInterval(() => {
+				stream.writeSSE({
+					event: "heartbeat",
+					data: Date.now().toString()
+				}).catch(() => {});
+			}, 15e3);
+			await new Promise((resolve) => {
+				stream.onAbort(() => {
+					clearInterval(heartbeatInterval);
+					activeClients.delete(sendUpdate);
+					resolve();
+				});
+			});
+		});
+	});
+	app.get("/api/diff", async (c) => {
+		const staged = c.req.query("staged") === "true";
+		const untracked = c.req.query("untracked") === "true";
+		const result = await executeDiffWithMeta(customMode ? diffOpts : {
+			...diffOpts,
+			staged,
+			includeUntracked: untracked
+		});
+		return c.json({
+			patch: result.patch,
+			repoName: result.repoName,
+			branch: result.branch,
+			customMode,
+			binaryFiles: result.binaryFiles,
+			tabSizeMap: result.tabSizeMap,
+			untrackedFiles: result.untrackedFiles
+		});
+	});
+	app.get("/api/file-content", (c) => {
+		const path = c.req.query("path");
+		const version = c.req.query("version");
+		if (!path || !version) return c.json({ error: "Missing path or version" }, 400);
+		const content = getFileContent(path, version);
+		if (!content) return c.json({ error: "File not found" }, 404);
+		const contentType = MIME_TYPES[extname(path)] || "application/octet-stream";
+		return new Response(new Uint8Array(content), { headers: { "Content-Type": contentType } });
+	});
+	app.get("/api/file-text", (c) => {
+		const path = c.req.query("path");
+		const version = c.req.query("version");
+		if (!path || !version) return c.json({ error: "Missing path or version" }, 400);
+		const buffer = getFileContent(path, version);
+		if (!buffer) return c.json({
+			content: "",
+			missing: true
+		});
+		const sample = buffer.subarray(0, Math.min(buffer.length, 8192));
+		for (let i = 0; i < sample.length; i++) if (sample[i] === 0) return c.json({ error: "Binary file" }, 415);
+		return c.json({
+			content: buffer.toString("utf-8"),
+			missing: false
+		});
+	});
+	app.post("/api/open-file", async (c) => {
+		const { filePath, editor } = await c.req.json();
+		if (!filePath) return c.json({ error: "filePath is required" }, 400);
+		try {
+			const root = getRepoRoot();
+			if (!isSafePath(filePath, root)) return c.json({ error: "Forbidden file path" }, 403);
+			const absolutePath = resolve(root, filePath);
+			const { exec } = await import("node:child_process");
+			if (editor === "vscode") exec(`code "${absolutePath}"`);
+			else if (editor === "zed") exec(`zed "${absolutePath}"`);
+			else if (editor === "vim") exec(`osascript -e 'tell application "Terminal" to do script "vim \\"${absolutePath}\\""'`);
+			else if (editor === "neovim") exec(`osascript -e 'tell application "Terminal" to do script "nvim \\"${absolutePath}\\""'`);
+			else await (await import("open")).default(absolutePath);
+			return c.json({ ok: true });
+		} catch (err) {
+			return c.json({ error: `Failed to open file: ${err.message}` }, 500);
+		}
+	});
+	app.get("/api/repo-files", (c) => {
+		try {
+			return c.json({ files: listRepoFiles() });
+		} catch (err) {
+			return c.json({ error: err.message }, 500);
+		}
+	});
+	app.post("/api/search", async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const scope = body.scope ?? "files";
+		const query = typeof body.query === "string" ? body.query : "";
+		const limit = typeof body.limit === "number" ? body.limit : void 0;
+		const paths = Array.isArray(body.changedPaths) ? body.changedPaths : void 0;
+		try {
+			if (scope === "all") return c.json(await searchAll(query, {
+				limit,
+				regex: !!body.regex,
+				paths
+			}));
+			if (scope === "text") return c.json(await searchContent(query, {
+				limit,
+				regex: !!body.regex,
+				paths
+			}));
+			if (scope === "symbols") return c.json(await searchSymbols(query, {
+				limit,
+				paths
+			}));
+			return c.json(await searchFiles(query, {
+				limit,
+				paths
+			}));
+		} catch (err) {
+			return c.json({
+				scope,
+				items: [],
+				total: 0,
+				indexing: false,
+				error: err?.message ?? "Search failed"
+			}, 500);
+		}
+	});
+	app.get("/api/search/status", async (c) => {
+		return c.json(await getSearchStatus());
+	});
+	app.post("/api/search/track", async (c) => {
+		const { query, path } = await c.req.json().catch(() => ({}));
+		if (path) await trackSelection(query ?? "", path);
+		return c.json({ ok: true });
+	});
+	app.get("/api/merge-status", (c) => {
+		try {
+			const status = getMergeStatus();
+			return c.json(status);
+		} catch (err) {
+			return c.json({ error: err.message }, 500);
+		}
+	});
+	app.post("/api/revert-hunk", async (c) => {
+		const { filePath, hunkIndex } = await c.req.json();
+		if (!filePath || typeof hunkIndex !== "number") return c.json({ error: "Missing filePath or hunkIndex" }, 400);
+		try {
+			if (!isSafePath(filePath, getRepoRoot())) return c.json({ error: "Forbidden file path" }, 403);
+			revertHunk(filePath, hunkIndex);
+			return c.json({ ok: true });
+		} catch (err) {
+			const stderr = typeof err?.stderr === "string" ? err.stderr : err?.stderr instanceof Buffer ? err.stderr.toString("utf-8") : "";
+			return c.json({ error: stderr || err?.message || "Failed to revert hunk" }, 500);
+		}
+	});
+	app.get("/api/hunk-history", async (c) => {
+		const filePath = c.req.query("filePath");
+		const deletionStart = Number(c.req.query("deletionStart"));
+		const deletionCount = Number(c.req.query("deletionCount"));
+		if (!filePath || Number.isNaN(deletionStart) || Number.isNaN(deletionCount)) return c.json({ error: "Missing or invalid parameters" }, 400);
+		try {
+			if (!isSafePath(filePath, getRepoRoot())) return c.json({ error: "Forbidden file path" }, 403);
+			const history = getHunkHistory(filePath, deletionStart, deletionCount, diffOpts.revisions[0] || "HEAD");
+			return c.json(history);
+		} catch (err) {
+			return c.json({ error: err.message || "Failed to fetch hunk history" }, 500);
+		}
+	});
+	app.post("/api/save-file", async (c) => {
+		const { filePath, content, gitAdd } = await c.req.json();
+		if (!filePath || typeof content !== "string") return c.json({ error: "Missing filePath or content" }, 400);
+		try {
+			const root = getRepoRoot();
+			if (!isSafePath(filePath, root)) return c.json({ error: "Forbidden file path" }, 403);
+			await writeFile(resolve(root, filePath), content, "utf-8");
+			if (gitAdd) try {
+				gitAddFile(filePath);
+			} catch (err) {
+				return c.json({
+					ok: true,
+					gitAddError: err.message
+				});
+			}
+			return c.json({ ok: true });
+		} catch (err) {
+			return c.json({ error: `Failed to save file: ${err.message}` }, 500);
+		}
+	});
+	app.get("/api/settings", (c) => {
+		return c.json(loadSettings());
+	});
+	app.put("/api/settings", async (c) => {
+		const settings = saveSettings(await c.req.json());
+		return c.json(settings);
+	});
+	app.get("/api/viewed", (c) => {
+		return c.json([...viewedFiles]);
+	});
+	app.put("/api/viewed", async (c) => {
+		const { filePath, viewed } = await c.req.json();
+		if (viewed) viewedFiles.add(filePath);
+		else viewedFiles.delete(filePath);
+		return c.json({ ok: true });
+	});
+	app.get("/api/comments", async (c) => {
+		const comments = await store.getAll();
+		return c.json(comments);
+	});
+	app.post("/api/comments", async (c) => {
+		const body = await c.req.json();
+		const comment = {
+			id: crypto.randomUUID(),
+			filePath: body.filePath,
+			side: body.side,
+			lineNumber: body.lineNumber,
+			startLineNumber: body.startLineNumber,
+			lineContent: body.lineContent,
+			body: body.body,
+			status: "open",
+			createdAt: Date.now(),
+			replies: []
+		};
+		const created = await store.add(comment);
+		return c.json(created, 201);
+	});
+	app.put("/api/comments/:id", async (c) => {
+		const id = c.req.param("id");
+		const { body, status } = await c.req.json();
+		const updated = await store.update(id, {
+			body,
+			status
+		});
+		if (!updated) return c.json({ error: "Comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.post("/api/comments/:id/replies", async (c) => {
+		const commentId = c.req.param("id");
+		const { body, role, model } = await c.req.json();
+		const reply = {
+			id: crypto.randomUUID(),
+			body,
+			createdAt: Date.now(),
+			role: role || (model ? "agent" : "user"),
+			model: model || void 0
+		};
+		const updated = await store.addReply(commentId, reply);
+		if (!updated) return c.json({ error: "Comment not found" }, 404);
+		return c.json(updated);
+	});
+	app.delete("/api/comments/:id/replies/:replyId", async (c) => {
+		const commentId = c.req.param("id");
+		const replyId = c.req.param("replyId");
+		const updated = await store.removeReply(commentId, replyId);
+		if (!updated) return c.json({ error: "Comment or reply not found" }, 404);
+		return c.json(updated);
+	});
+	app.put("/api/comments/:id/replies/:replyId", async (c) => {
+		const commentId = c.req.param("id");
+		const replyId = c.req.param("replyId");
+		const { body } = await c.req.json();
+		if (!body) return c.json({ error: "Body is required" }, 400);
+		const updated = await store.updateReply(commentId, replyId, body);
+		if (!updated) return c.json({ error: "Comment or reply not found" }, 404);
+		return c.json(updated);
+	});
+	app.post("/api/comments/:id/apply-suggestion", async (c) => {
+		const id = c.req.param("id");
+		const comment = (await store.getAll()).find((c) => c.id === id);
+		if (!comment) return c.json({ error: "Comment not found" }, 404);
+		if (comment.side !== "additions") return c.json({ error: "Suggestions can only be applied to added or modified lines" }, 400);
+		const match = comment.body.match(/```suggestion\n([\s\S]*?)```/);
+		if (!match) return c.json({ error: "No suggestion block found in comment body" }, 400);
+		const suggestion = match[1];
+		try {
+			const root = getRepoRoot();
+			if (!isSafePath(comment.filePath, root)) return c.json({ error: "Forbidden file path" }, 403);
+			const absolutePath = resolve(root, comment.filePath);
+			const lines = (await readFile(absolutePath, "utf-8")).split(/\r?\n/);
+			const lineIdx = comment.lineNumber - 1;
+			if (lineIdx < 0 || lineIdx >= lines.length) return c.json({ error: "Comment line number out of range" }, 400);
+			lines[lineIdx] = suggestion.trimEnd();
+			await writeFile(absolutePath, lines.join("\n"), "utf-8");
+			await store.update(id, { status: "resolved" });
+			return c.json({ ok: true });
+		} catch (err) {
+			return c.json({ error: `Failed to apply suggestion: ${err.message}` }, 500);
+		}
+	});
+	app.delete("/api/comments/:id", async (c) => {
+		const id = c.req.param("id");
+		if (!await store.remove(id)) return c.json({ error: "Comment not found" }, 404);
+		return c.json({ ok: true });
+	});
+	app.post("/api/review/send", async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const generalComment = typeof body?.generalComment === "string" ? body.generalComment : void 0;
+		const all = await store.getAll();
+		const openCount = all.filter((x) => x.status === "open").length;
+		const payload = reviewSession.send({
+			sentAt: Date.now(),
+			commentXml: formatComments(all, generalComment),
+			openCount,
+			comments: all
+		});
+		return c.json({
+			ok: true,
+			round: payload.round,
+			openCount: payload.openCount,
+			waiters: reviewSession.snapshot().waiters
+		});
+	});
+	app.get("/api/review/await", async (c) => {
+		const sinceRaw = c.req.query("sinceRound");
+		const sinceRound = sinceRaw !== void 0 && sinceRaw !== "" ? Number(sinceRaw) : void 0;
+		const requested = Number(c.req.query("timeoutMs")) || 25e3;
+		const timeoutMs = Math.min(Math.max(requested, 1e3), 5e4);
+		const result = await reviewSession.await({
+			sinceRound: Number.isNaN(sinceRound) ? void 0 : sinceRound,
+			timeoutMs,
+			signal: c.req.raw.signal
+		});
+		return c.json(result);
+	});
+	app.get("/api/review/status", (c) => {
+		return c.json(reviewSession.snapshot());
+	});
+	app.post("/api/attachments", async (c) => {
+		const file = (await c.req.parseBody())["file"];
+		if (!file || !(file instanceof File)) return c.json({ error: "No file uploaded" }, 400);
+		try {
+			const storageDir = getProjectStorageDir();
+			const attachmentsDir = join(storageDir, "attachments");
+			await mkdir(attachmentsDir, { recursive: true });
+			const repoRoot = getRepoRoot();
+			await writeFile(join(storageDir, "repo_path.txt"), repoRoot, "utf-8");
+			const ext = extname(file.name) || ".png";
+			const filename = `pasted_image_${crypto.randomUUID()}${ext}`;
+			const absolutePath = join(attachmentsDir, filename);
+			const arrayBuffer = await file.arrayBuffer();
+			await writeFile(absolutePath, new Uint8Array(arrayBuffer));
+			return c.json({ url: `/api/attachments/${filename}` });
+		} catch (err) {
+			return c.json({ error: `Failed to save attachment: ${err.message}` }, 500);
+		}
+	});
+	app.get("/api/attachments/:filename", async (c) => {
+		const filename = c.req.param("filename");
+		const attachmentsDir = join(getProjectStorageDir(), "attachments");
+		const absolutePath = resolve(attachmentsDir, filename);
+		if (!absolutePath.startsWith(attachmentsDir)) return c.text("Forbidden", 403);
+		try {
+			const content = await readFile(absolutePath);
+			const contentType = MIME_TYPES[extname(absolutePath)] || "application/octet-stream";
+			return new Response(content, { headers: { "Content-Type": contentType } });
+		} catch {
+			return c.text("Attachment not found", 404);
+		}
+	});
+	app.get("/*", async (c) => {
+		let filePath = c.req.path;
+		if (filePath === "/") filePath = "/index.html";
+		const relativePath = filePath.slice(1);
+		if (!isSafePath(relativePath, clientDir)) return c.text("Forbidden", 403);
+		const fullPath = resolve(clientDir, relativePath);
+		try {
+			const content = await readFile(fullPath);
+			const contentType = MIME_TYPES[extname(fullPath)] || "application/octet-stream";
+			return new Response(content, { headers: { "Content-Type": contentType } });
+		} catch {
+			const indexContent = await readFile(join(clientDir, "index.html"));
+			return new Response(indexContent, { headers: { "Content-Type": "text/html" } });
+		}
+	});
+	return app;
+}
+async function cleanupStaleProjects() {
+	const baseDir = join(homedir(), ".diffit");
+	if (!existsSync(baseDir)) return;
+	try {
+		const entries = await readdir(baseDir, { withFileTypes: true });
+		const now = Date.now();
+		const STALE_TIME = 336 * 60 * 60 * 1e3;
+		for (const entry of entries) if (entry.isDirectory()) {
+			const projectDir = join(baseDir, entry.name);
+			const repoPathFile = join(projectDir, "repo_path.txt");
+			const commentsFile = join(projectDir, "comments.json");
+			let shouldDelete = false;
+			if (existsSync(repoPathFile)) try {
+				const repoPath = (await readFile(repoPathFile, "utf-8")).trim();
+				if (!repoPath || !existsSync(repoPath)) shouldDelete = true;
+			} catch {}
+			if (!shouldDelete && existsSync(commentsFile)) try {
+				if (now - (await stat(commentsFile)).mtimeMs > STALE_TIME) shouldDelete = true;
+			} catch {}
+			if (shouldDelete) await rm(projectDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	} catch (err) {
+		console.error("Failed to cleanup stale projects:", err);
+	}
+}
+function startServer(options) {
+	cleanupStaleProjects().catch((err) => {
+		console.error("Failed to clean up stale projects:", err);
+	});
+	const app = createApp(options.clientDir, options.diffOpts);
+	return new Promise((resolve) => {
+		serve({
+			fetch: app.fetch,
+			port: options.port,
+			hostname: options.host
+		}, (info) => {
+			resolve({ port: info.port });
+		});
+	});
+}
+//#endregion
+//#region src/cli.ts
+const args = process.argv.slice(2);
+if (new Set([
+	"await-review",
+	"reply",
+	"resolve",
+	"comments",
+	"url",
+	"mcp"
+]).has(args[0])) {
+	if (args[0] === "mcp") {
+		const { startMcpServer } = await import("./mcp-nMwTAut3.mjs");
+		await startMcpServer();
+		await new Promise(() => {});
+	}
+	const { runSubcommand } = await import("./cli-agent-CtNivjQW.mjs");
+	process.exit(await runSubcommand(args[0], args.slice(1)));
+}
+const opts = parseDiffOptions(args);
+if (opts.help) {
+	printHelp();
+	process.exit(0);
+}
+if (opts.version) {
+	const __dirname = dirname(fileURLToPath(import.meta.url));
+	const pkg = JSON.parse(readFileSync(resolve(__dirname, "..", "package.json"), "utf-8"));
+	console.log(pkg.version);
+	process.exit(0);
+}
+const envErr = validateEnvironment();
+if (envErr) {
+	console.error(envErr);
+	process.exit(1);
+}
+if (opts.outputMode === "terminal") {
+	const exitCode = runTerminalDiff(opts);
+	process.exit(exitCode);
+}
+const port = await getPort(opts.port ? { port: opts.port } : void 0);
+const host = opts.host;
+const clientDir = resolve(dirname(fileURLToPath(import.meta.url)), "client");
+const { existsSync: existsSync$1 } = await import("node:fs");
+const { port: actualPort } = await startServer({
+	port,
+	host,
+	clientDir: existsSync$1(clientDir) ? clientDir : resolve(process.cwd(), "dist/client"),
+	diffOpts: opts
+});
+const localUrl = `http://${host}:${actualPort}`;
+try {
+	let repoRoot;
+	try {
+		repoRoot = getRepoRoot();
+	} catch {
+		repoRoot = process.cwd();
+	}
+	const __pkgDir = dirname(fileURLToPath(import.meta.url));
+	const version = JSON.parse(readFileSync(resolve(__pkgDir, "..", "package.json"), "utf-8")).version;
+	writeServerLock({
+		port: actualPort,
+		host,
+		pid: process.pid,
+		repoRoot,
+		startedAt: Date.now(),
+		version
+	});
+} catch {}
+console.log(`diffit server running at ${localUrl}`);
+if (!opts.noOpen) {
+	const settings = loadSettings();
+	const openUrl = `http://${host === "0.0.0.0" ? "127.0.0.1" : host}:${actualPort}`;
+	const openModule = await import("open");
+	let appName;
+	if (settings.browser) appName = openModule.apps[settings.browser] || settings.browser;
+	const options = appName ? { app: { name: appName } } : {};
+	openModule.default(openUrl, options);
+}
+const shutdown = () => {
+	console.log("\nShutting down...");
+	removeServerLock();
+	process.exit(0);
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+//#endregion
+export {};