diffing 0.10.5 → 0.11.0

package/dist/server-lock-CY0_1mcS.mjs

@@ -0,0 +1,275 @@
+import { d as getProjectStorageDir, p as getRepoRoot } from "./git-Czo96ymM.mjs";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+//#region src/lib/server-lock.ts
+const STARTUP_LEASE_STALE_MS = 3e4;
+/**
+* Produce a stable comparison key for the diff a server displays. Runtime-only
+* web options are excluded so `--port`/`--no-open` do not create false scope
+* mismatches between a user-started session and an MCP request.
+*/
+function diffScopeKey(options) {
+	const { port: _port, host: _host, noOpen: _noOpen, reuseSession: _reuseSession, replaceSession: _replaceSession, help: _help, version: _version, outputMode: _outputMode, tui: _tui, gpu: _gpu, noExtDiff: _noExtDiff, ...scope } = options;
+	return JSON.stringify(scope);
+}
+function lockPath(repoRoot) {
+	return join(getProjectStorageDir(repoRoot), "server.json");
+}
+function sessionsPath(repoRoot) {
+	return join(getProjectStorageDir(repoRoot), "sessions");
+}
+/** Stable identity for both current and pre-registry lock records. */
+function serverSessionId(lock) {
+	return lock.sessionId ?? lock.ownerId ?? `${lock.mode ?? "web"}-${lock.pid}-${lock.startedAt}`;
+}
+function sameServerSession(left, right) {
+	if (left.sessionId && right.sessionId) return left.sessionId === right.sessionId;
+	return left.pid === right.pid && left.startedAt === right.startedAt && left.port === right.port;
+}
+function sessionPath(lock) {
+	return join(sessionsPath(lock.repoRoot), `${encodeURIComponent(serverSessionId(lock))}.json`);
+}
+function writeJsonAtomically(path, value) {
+	mkdirSync(join(path, ".."), { recursive: true });
+	const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	writeFileSync(temporary, JSON.stringify(value, null, 2), "utf-8");
+	renameSync(temporary, path);
+}
+function normalizedLock(lock) {
+	return lock.sessionId ? lock : {
+		...lock,
+		sessionId: serverSessionId(lock)
+	};
+}
+function writeSessionRecord(lock) {
+	const normalized = normalizedLock(lock);
+	writeJsonAtomically(sessionPath(normalized), normalized);
+	return normalized;
+}
+/**
+* Register a session and make it the active target for legacy clients. Before
+* replacing server.json, adopt a live pre-registry lock so an upgrade never
+* makes an already-running review disappear from the session manager.
+*/
+function writeServerLock(lock) {
+	const current = readServerLock(lock.repoRoot);
+	if (current && isLockAlive(current, lock.repoRoot) && !sameServerSession(current, lock)) writeSessionRecord(current);
+	const normalized = writeSessionRecord(lock);
+	try {
+		writeJsonAtomically(lockPath(lock.repoRoot), normalized);
+	} catch (error) {
+		rmSync(sessionPath(normalized), { force: true });
+		throw error;
+	}
+}
+function readServerLock(repoRoot) {
+	try {
+		const raw = readFileSync(lockPath(repoRoot), "utf-8");
+		const lock = JSON.parse(raw);
+		if (typeof lock.port !== "number" || typeof lock.pid !== "number") return null;
+		return lock;
+	} catch {
+		return null;
+	}
+}
+/** Return every live registered session, newest first, and prune stale entries. */
+function listServerLocks(repoRoot) {
+	let expectedRepoRoot;
+	try {
+		expectedRepoRoot = repoRoot ?? getRepoRoot();
+	} catch {
+		return [];
+	}
+	const sessions = /* @__PURE__ */ new Map();
+	const addIfLive = (candidate, stalePath) => {
+		if (candidate.repoRoot !== expectedRepoRoot || !isLockAlive(candidate, expectedRepoRoot)) {
+			if (stalePath) rmSync(stalePath, { force: true });
+			return;
+		}
+		const normalized = normalizedLock(candidate);
+		sessions.set(serverSessionId(normalized), normalized);
+	};
+	const active = readServerLock(expectedRepoRoot);
+	if (active) addIfLive(active);
+	const directory = sessionsPath(expectedRepoRoot);
+	try {
+		for (const entry of readdirSync(directory, { withFileTypes: true })) {
+			if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+			const path = join(directory, entry.name);
+			try {
+				const candidate = JSON.parse(readFileSync(path, "utf-8"));
+				if (typeof candidate.port !== "number" || typeof candidate.pid !== "number") {
+					rmSync(path, { force: true });
+					continue;
+				}
+				addIfLive(candidate, path);
+			} catch {
+				rmSync(path, { force: true });
+			}
+		}
+	} catch {}
+	return [...sessions.values()].sort((left, right) => right.startedAt - left.startedAt);
+}
+/** Resolve the active session, electing the newest live fallback when needed. */
+function resolveActiveServerLock(repoRoot) {
+	let expectedRepoRoot;
+	try {
+		expectedRepoRoot = repoRoot ?? getRepoRoot();
+	} catch {
+		return null;
+	}
+	const active = readServerLock(expectedRepoRoot);
+	if (active && isLockAlive(active, expectedRepoRoot)) {
+		const normalized = normalizedLock(active);
+		if (!existsSync(sessionPath(normalized))) writeSessionRecord(normalized);
+		if (!active.sessionId) writeJsonAtomically(lockPath(expectedRepoRoot), normalized);
+		return normalized;
+	}
+	const fallback = listServerLocks(expectedRepoRoot)[0];
+	if (!fallback) {
+		removeServerLock(expectedRepoRoot);
+		return null;
+	}
+	return activateServerLock(fallback);
+}
+/** Make an existing registered session the default target for CLI/MCP clients. */
+function activateServerLock(lock) {
+	const normalized = writeSessionRecord(lock);
+	writeJsonAtomically(lockPath(lock.repoRoot), normalized);
+	return normalized;
+}
+/**
+* True if the process named by the lock is still alive and the lock belongs to
+* this repo. `process.kill(pid, 0)` sends no signal — it just probes existence.
+*/
+function isLockAlive(lock, expectedRepoRoot) {
+	try {
+		process.kill(lock.pid, 0);
+	} catch {
+		return false;
+	}
+	try {
+		return lock.repoRoot === (expectedRepoRoot ?? getRepoRoot());
+	} catch {
+		return true;
+	}
+}
+function removeServerLock(repoRoot) {
+	try {
+		rmSync(lockPath(repoRoot), { force: true });
+	} catch {}
+}
+/** Remove one registry entry and elect another live session if it was active. */
+function removeServerSession(lock) {
+	const normalized = normalizedLock(lock);
+	const path = sessionPath(normalized);
+	try {
+		if (sameServerSession(JSON.parse(readFileSync(path, "utf-8")), normalized)) rmSync(path, { force: true });
+	} catch {}
+	const active = readServerLock(lock.repoRoot);
+	if (!active || !sameServerSession(active, normalized)) return;
+	const fallback = listServerLocks(lock.repoRoot).find((candidate) => !sameServerSession(candidate, normalized));
+	if (fallback) activateServerLock(fallback);
+	else removeServerLock(lock.repoRoot);
+}
+/** Unregister live sessions owned by one exact CLI/MCP process identity. */
+function removeServerLockIfOwned(repoRoot, pid, ownerId) {
+	const cleanupLease = acquireServerStartupLease(repoRoot, `cleanup-${ownerId}`);
+	if (!cleanupLease) return false;
+	try {
+		const owned = listServerLocks(repoRoot).filter((lock) => lock.pid === pid && lock.ownerId === ownerId);
+		if (owned.length === 0) return false;
+		for (const lock of owned) removeServerSession(lock);
+		return true;
+	} finally {
+		cleanupLease.release();
+	}
+}
+/**
+* Atomically reserve server startup for one repository. The exclusive-create
+* directory is the cross-process serialization point; callers must re-read
+* server.json after acquiring it because another process may have completed
+* startup between their first lock check and this lease acquisition.
+*/
+function acquireServerStartupLease(repoRoot, ownerId, now = Date.now()) {
+	const path = join(getProjectStorageDir(repoRoot), "server-startup.lock");
+	const recordPath = join(path, "lease.json");
+	const ownerMarkerPath = join(path, `owner-${encodeURIComponent(ownerId)}`);
+	mkdirSync(join(path, ".."), { recursive: true });
+	const tryCreate = () => {
+		try {
+			mkdirSync(path, {
+				recursive: false,
+				mode: 448
+			});
+		} catch (error) {
+			if (error?.code === "EEXIST") return false;
+			throw error;
+		}
+		try {
+			writeFileSync(recordPath, JSON.stringify({
+				ownerId,
+				createdAt: now,
+				pid: process.pid
+			}), "utf-8");
+			writeFileSync(ownerMarkerPath, "", "utf-8");
+		} catch (error) {
+			rmSync(path, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
+		return true;
+	};
+	if (!tryCreate()) {
+		let reclaim = false;
+		let acquiredAfterRace = false;
+		try {
+			const record = JSON.parse(readFileSync(recordPath, "utf-8"));
+			if (typeof record.createdAt !== "number" || typeof record.pid !== "number") throw new Error("Malformed startup lease");
+			let ownerIsAlive = true;
+			try {
+				process.kill(record.pid, 0);
+			} catch (error) {
+				ownerIsAlive = error?.code !== "ESRCH";
+			}
+			reclaim = now - record.createdAt > STARTUP_LEASE_STALE_MS && !ownerIsAlive;
+			if (!reclaim) return null;
+		} catch {
+			try {
+				reclaim = now - statSync(path).mtimeMs > STARTUP_LEASE_STALE_MS;
+			} catch (statError) {
+				if (statError?.code !== "ENOENT") return null;
+				if (!tryCreate()) return null;
+				acquiredAfterRace = true;
+			}
+			if (!reclaim && !acquiredAfterRace) return null;
+		}
+		if (reclaim && !acquiredAfterRace) {
+			const stalePath = `${path}.stale-${process.pid}-${now}`;
+			renameSync(path, stalePath);
+			rmSync(stalePath, {
+				recursive: true,
+				force: true
+			});
+		}
+		if (!acquiredAfterRace && !tryCreate()) return null;
+	}
+	let released = false;
+	return {
+		ownerId,
+		release() {
+			if (released) return;
+			released = true;
+			try {
+				unlinkSync(ownerMarkerPath);
+				unlinkSync(recordPath);
+				rmdirSync(path);
+			} catch {}
+		}
+	};
+}
+//#endregion
+export { listServerLocks as a, removeServerLockIfOwned as c, sameServerSession as d, serverSessionId as f, isLockAlive as i, removeServerSession as l, activateServerLock as n, readServerLock as o, writeServerLock as p, diffScopeKey as r, removeServerLock as s, acquireServerStartupLease as t, resolveActiveServerLock as u };

package/dist/session-conflict-C6V9ZKo7.mjs

@@ -0,0 +1,96 @@
+import { t as loadSettings } from "./settings-yK0GYpbn.mjs";
+import { l as removeServerSession } from "./server-lock-CY0_1mcS.mjs";
+//#region src/lib/session-conflict.ts
+function sleepMs(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Loopback-safe review URL for web / gh-pr locks; null for TUI or invalid ports. */
+function existingSessionUrl(lock) {
+	const mode = lock.mode ?? "web";
+	if (mode === "tui" || !(lock.port > 0)) return null;
+	const host = lock.host === "0.0.0.0" ? "127.0.0.1" : lock.host;
+	const path = mode === "gh-pr" ? "/gh/pr" : "";
+	return `http://${host}:${lock.port}${path}`;
+}
+function defaultClearLock(lock) {
+	removeServerSession(lock);
+}
+function pidAlive(pid, kill) {
+	try {
+		kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Gracefully stop the process that owns `lock`, then clear a matching lockfile.
+* SIGTERM → wait → SIGKILL → wait → throw.
+*/
+async function stopLockOwner(lock, options = {}) {
+	const timeoutMs = options.timeoutMs ?? 5e3;
+	const killDeadlineMs = options.killDeadlineMs ?? 2e3;
+	const pollMs = options.pollMs ?? 100;
+	const kill = options.kill ?? ((pid, signal) => process.kill(pid, signal));
+	const sleep = options.sleep ?? sleepMs;
+	const now = options.now ?? Date.now;
+	const isAlive = options.isAlive ?? ((candidate) => pidAlive(candidate.pid, kill));
+	const clearLock = options.clearLock ?? defaultClearLock;
+	if (!isAlive(lock)) {
+		clearLock(lock);
+		return;
+	}
+	try {
+		kill(lock.pid, "SIGTERM");
+	} catch {}
+	const termDeadline = now() + timeoutMs;
+	while (now() < termDeadline) {
+		if (!isAlive(lock)) {
+			clearLock(lock);
+			return;
+		}
+		await sleep(pollMs);
+	}
+	try {
+		kill(lock.pid, "SIGKILL");
+	} catch {}
+	const killDeadline = now() + killDeadlineMs;
+	while (now() < killDeadline) {
+		if (!isAlive(lock)) {
+			clearLock(lock);
+			return;
+		}
+		await sleep(pollMs);
+	}
+	throw new Error(`Timed out waiting for diffing pid ${lock.pid} to exit after SIGTERM/SIGKILL. End that process manually and try again.`);
+}
+/** Print and optionally open the existing web/gh-pr session; message-only for TUI. */
+async function openExistingSession(lock, options) {
+	if ((lock.mode ?? "web") === "tui") {
+		console.log(`A diffing TUI session is already open for this repository (pid ${lock.pid}). Use that terminal, or replace it with --replace-session.`);
+		return;
+	}
+	const url = existingSessionUrl(lock);
+	if (!url) {
+		console.log(`A diffing review is already running for this repository (pid ${lock.pid}).`);
+		return;
+	}
+	console.log(`Opening existing diffing session at ${url}`);
+	if (options.noOpen) return;
+	if (options.openUrl) {
+		await options.openUrl(url);
+		return;
+	}
+	try {
+		const settings = loadSettings();
+		const openModule = await import("open");
+		let appName;
+		if (settings.browser) appName = openModule.apps[settings.browser] || settings.browser;
+		const openOptions = appName ? { app: { name: appName } } : {};
+		await openModule.default(url, openOptions);
+	} catch (err) {
+		console.error("Failed to open browser:", err instanceof Error ? err.message : err);
+	}
+}
+//#endregion
+export { openExistingSession as n, stopLockOwner as r, existingSessionUrl as t };

package/dist/session-manager-CYNchhVA.mjs

@@ -0,0 +1,159 @@
+import { a as listServerLocks, d as sameServerSession, f as serverSessionId, n as activateServerLock, u as resolveActiveServerLock } from "./server-lock-CY0_1mcS.mjs";
+import { n as openExistingSession, r as stopLockOwner, t as existingSessionUrl } from "./session-conflict-C6V9ZKo7.mjs";
+//#region src/lib/session-manager.ts
+const EXIT_OK = 0;
+const EXIT_NOT_FOUND = 4;
+const EXIT_USAGE = 5;
+function scopeLabel(lock) {
+	if (lock.prRef) return `PR ${lock.prRef}`;
+	if (lock.diffArgs?.length) return lock.diffArgs.join(" ");
+	if (!lock.scope) return "working tree";
+	try {
+		const scope = JSON.parse(lock.scope);
+		const parts = [];
+		if (scope.showMode) parts.push("show");
+		if (scope.staged) parts.push("staged");
+		if (scope.revisions?.length) parts.push(scope.revisions.join(" "));
+		if (scope.pathspecs?.length) parts.push(`-- ${scope.pathspecs.join(" ")}`);
+		return parts.join(" ") || "working tree";
+	} catch {
+		return "custom diff";
+	}
+}
+function summarize(lock, active) {
+	return {
+		id: serverSessionId(lock),
+		active: active ? sameServerSession(lock, active) : false,
+		mode: lock.mode ?? "web",
+		pid: lock.pid,
+		startedAt: lock.startedAt,
+		url: existingSessionUrl(lock),
+		scope: scopeLabel(lock)
+	};
+}
+function formatAge(startedAt) {
+	const seconds = Math.max(0, Math.floor((Date.now() - startedAt) / 1e3));
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h`;
+	return `${Math.floor(hours / 24)}d`;
+}
+function printSessions(sessions, active) {
+	if (sessions.length === 0) {
+		console.log("No diffing sessions are running for this repository.");
+		return;
+	}
+	console.log("ACTIVE  ID        MODE   PID      AGE   SCOPE / URL");
+	for (const lock of sessions) {
+		const summary = summarize(lock, active);
+		const activeMark = summary.active ? "*" : "";
+		const target = summary.url ? `${summary.scope}  ${summary.url}` : summary.scope;
+		console.log(`${activeMark.padEnd(7)} ${summary.id.slice(0, 8).padEnd(9)} ${summary.mode.padEnd(6)} ${String(summary.pid).padEnd(8)} ${formatAge(summary.startedAt).padEnd(5)} ${target}`);
+	}
+	console.log("\nUse `diffing sessions use <id>` to retarget agent commands.");
+}
+function findSession(selector, sessions, active) {
+	if (selector === "active") {
+		if (active) return active;
+		throw new Error("No active diffing session is running.");
+	}
+	const matches = sessions.filter((lock) => serverSessionId(lock).startsWith(selector));
+	if (matches.length === 0) throw new Error(`No live diffing session matches ${JSON.stringify(selector)}.`);
+	if (matches.length > 1) throw new Error(`Session prefix ${JSON.stringify(selector)} is ambiguous.`);
+	return matches[0];
+}
+function usage() {
+	console.error(`Usage:
+  diffing sessions [list] [--json]
+  diffing sessions use <id>
+  diffing sessions open [<id>|active] [--no-open]
+  diffing sessions stop|kill <id>|active|all`);
+}
+/** Repository-local task manager for every live web, TUI, and PR session. */
+async function runSessionsCommand(args) {
+	if (args.includes("--help") || args.includes("-h")) {
+		usage();
+		return EXIT_OK;
+	}
+	const action = args[0] && !args[0].startsWith("-") ? args[0] : "list";
+	const rest = action === "list" && args[0] !== "list" ? args : args.slice(1);
+	const sessions = listServerLocks();
+	const active = resolveActiveServerLock();
+	if (action === "list") {
+		if (rest.filter((arg) => arg !== "--json").length > 0) {
+			usage();
+			return EXIT_USAGE;
+		}
+		if (rest.includes("--json")) process.stdout.write(JSON.stringify(sessions.map((lock) => summarize(lock, active)), null, 2) + "\n");
+		else printSessions(sessions, active);
+		return EXIT_OK;
+	}
+	if (action === "use") {
+		if (rest.length !== 1) {
+			usage();
+			return EXIT_USAGE;
+		}
+		try {
+			const selected = findSession(rest[0], sessions, active);
+			activateServerLock(selected);
+			console.log(`Active diffing session set to ${serverSessionId(selected).slice(0, 8)} (${selected.mode ?? "web"}).`);
+			return EXIT_OK;
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : String(error));
+			return EXIT_NOT_FOUND;
+		}
+	}
+	if (action === "open") {
+		const noOpen = rest.includes("--no-open");
+		const positionals = rest.filter((arg) => arg !== "--no-open");
+		if (positionals.length > 1) {
+			usage();
+			return EXIT_USAGE;
+		}
+		try {
+			const selected = findSession(positionals[0] ?? "active", sessions, active);
+			activateServerLock(selected);
+			await openExistingSession(selected, { noOpen });
+			return EXIT_OK;
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : String(error));
+			return EXIT_NOT_FOUND;
+		}
+	}
+	if (action === "stop" || action === "kill") {
+		if (rest.length !== 1) {
+			usage();
+			return EXIT_USAGE;
+		}
+		let targets;
+		try {
+			targets = rest[0] === "all" ? sessions : [findSession(rest[0], sessions, active)];
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : String(error));
+			return EXIT_NOT_FOUND;
+		}
+		if (targets.length === 0) {
+			console.log("No diffing sessions are running for this repository.");
+			return EXIT_OK;
+		}
+		let failed = false;
+		for (const target of targets) {
+			const id = serverSessionId(target).slice(0, 8);
+			try {
+				console.error(`Stopping ${id} (${target.mode ?? "web"}, pid ${target.pid})…`);
+				await stopLockOwner(target);
+			} catch (error) {
+				failed = true;
+				console.error(error instanceof Error ? error.message : String(error));
+			}
+		}
+		if (!failed) console.log(`Stopped ${targets.length} diffing session${targets.length === 1 ? "" : "s"}.`);
+		return failed ? 1 : EXIT_OK;
+	}
+	usage();
+	return EXIT_USAGE;
+}
+//#endregion
+export { runSessionsCommand };

package/dist/settings-yK0GYpbn.mjs

@@ -0,0 +1,60 @@
+import { join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+//#region src/lib/settings.ts
+const CONFIG_DIR = join(homedir(), ".config", "diffing");
+const SETTINGS_FILE = join(CONFIG_DIR, "settings.json");
+const DEFAULTS = {
+	defaultMode: "web",
+	staged: true,
+	untracked: true,
+	diffStyle: "split",
+	defaultTabSize: 4,
+	theme: "rose-pine",
+	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,
+	sounds: true,
+	uiFont: null,
+	monoFont: null,
+	density: "comfortable",
+	autoCollapseLineThreshold: 400,
+	requireViewAllBeforeSend: false,
+	showStatusBar: true,
+	savedReplies: [],
+	ignoreSpaceChange: false,
+	ignoreAllSpace: false
+};
+function loadSettings() {
+	try {
+		const data = readFileSync(SETTINGS_FILE, "utf-8");
+		const settings = {
+			...DEFAULTS,
+			...JSON.parse(data)
+		};
+		if (settings.defaultMode !== "web" && settings.defaultMode !== "tui") settings.defaultMode = DEFAULTS.defaultMode;
+		return settings;
+	} 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
+export { saveSettings as n, loadSettings as t };