diffing 0.6.0 → 0.7.0

package/dist/server-lock-uqSdDYeR.mjs

@@ -0,0 +1,153 @@
+import { d as getProjectStorageDir, p as getRepoRoot } from "./git-Czo96ymM.mjs";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, 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, 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 writeServerLock(lock) {
+	const path = lockPath(lock.repoRoot);
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, JSON.stringify(lock, null, 2), "utf-8");
+}
+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;
+	}
+}
+/**
+* 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 server.json only while holding the startup lease and only if exact ownership still matches. */
+function removeServerLockIfOwned(repoRoot, pid, ownerId) {
+	const cleanupLease = acquireServerStartupLease(repoRoot, `cleanup-${ownerId}`);
+	if (!cleanupLease) return false;
+	try {
+		const lock = readServerLock(repoRoot);
+		if (!lock || lock.pid !== pid || lock.ownerId !== ownerId) return false;
+		removeServerLock(repoRoot);
+		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 { removeServerLock as a, readServerLock as i, diffScopeKey as n, removeServerLockIfOwned as o, isLockAlive as r, writeServerLock as s, acquireServerStartupLease as t };

package/dist/settings-BVnzGFL7.mjs

@@ -0,0 +1,478 @@
+import { d as getProjectStorageDir, p as getRepoRoot } from "./git-Czo96ymM.mjs";
+import { join } from "node:path";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+//#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 `~/.diffing/<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", "diffing");
+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,
+	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");
+		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
+export { searchContent as a, trackSelection as c, searchAll as i, saveSettings as n, searchFiles as o, getSearchStatus as r, searchSymbols as s, loadSettings as t };