diffing 0.12.0 → 0.13.0

package/dist/session-url-B8TrGGeE.mjs

@@ -0,0 +1,33 @@
+import { g as SESSION_TOKEN_QUERY, x as isLoopbackHost } from "./server-lock-BNI8FKV1.mjs";
+//#region src/lib/session-url.ts
+/** Loopback-safe review URL for web / gh-pr locks; null for TUI or invalid ports. */
+function reviewSessionBaseUrl(lock) {
+	if ((lock.mode ?? "web") === "tui" || !(lock.port > 0)) return null;
+	if (!isLoopbackHost(lock.host) && lock.host !== "0.0.0.0" && lock.host !== "::") return null;
+	const host = lock.host === "0.0.0.0" || lock.host === "::" ? "127.0.0.1" : lock.host;
+	const path = lock.mode === "gh-pr" ? "/gh/pr" : "";
+	return `http://${host}:${lock.port}${path}`;
+}
+/** Browseable review URL without auth query params (auth uses cookie + header). */
+function appendSessionToken(url, _token) {
+	try {
+		const parsed = new URL(url);
+		parsed.searchParams.delete(SESSION_TOKEN_QUERY);
+		const search = parsed.searchParams.toString();
+		return `${parsed.origin}${parsed.pathname}${search ? `?${search}` : ""}${parsed.hash}`;
+	} catch {
+		return url;
+	}
+}
+/** Public review URL for humans (no `?token=` — session cookie is set when HTML is served). */
+function reviewSessionUrl(lock) {
+	const base = reviewSessionBaseUrl(lock);
+	if (!base) return null;
+	return base;
+}
+/** Join an API path to a session base URL (origin only; strips any legacy `?token=`). */
+function joinSessionApiUrl(base, path) {
+	return `${new URL(base).origin}${path.startsWith("/") ? path : `/${path}`}`;
+}
+//#endregion
+export { reviewSessionUrl as i, joinSessionApiUrl as n, reviewSessionBaseUrl as r, appendSessionToken as t };

package/dist/{session-url-sr7lXXVc.mjs → settings-DkPDB_hS.mjs}

@@ -1,4 +1,3 @@
-import { g as SESSION_TOKEN_QUERY, x as isLoopbackHost } from "./server-lock-BNI8FKV1.mjs";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -13,7 +12,14 @@ function writeJsonAtomically(path, value) {
 }
 //#endregion
 //#region src/lib/settings.ts
-const SETTINGS_FILE = join(join(homedir(), ".config", "diffing"), "settings.json");
+const CONFIG_DIR = join(homedir(), ".config", "diffing");
+const SETTINGS_FILE = join(CONFIG_DIR, "settings.json");
+/** Human-facing label for stored mode values (`tui` → `TUI`, `web` → `Web`). */
+function formatModeLabel(mode) {
+	if (mode === "tui") return "TUI";
+	if (mode === "web") return "Web";
+	return mode;
+}
 const DEFAULTS = {
 	defaultMode: "web",
 	staged: true,
@@ -65,36 +71,18 @@ function saveSettings(settings) {
 	writeJsonAtomically(SETTINGS_FILE, merged);
 	return merged;
 }
-//#endregion
-//#region src/lib/session-url.ts
-/** Loopback-safe review URL for web / gh-pr locks; null for TUI or invalid ports. */
-function reviewSessionBaseUrl(lock) {
-	if ((lock.mode ?? "web") === "tui" || !(lock.port > 0)) return null;
-	if (!isLoopbackHost(lock.host) && lock.host !== "0.0.0.0" && lock.host !== "::") return null;
-	const host = lock.host === "0.0.0.0" || lock.host === "::" ? "127.0.0.1" : lock.host;
-	const path = lock.mode === "gh-pr" ? "/gh/pr" : "";
-	return `http://${host}:${lock.port}${path}`;
+function ensureConfigDir() {
+	mkdirSync(CONFIG_DIR, { recursive: true });
 }
-/** Browseable review URL without auth query params (auth uses cookie + header). */
-function appendSessionToken(url, _token) {
-	try {
-		const parsed = new URL(url);
-		parsed.searchParams.delete(SESSION_TOKEN_QUERY);
-		const search = parsed.searchParams.toString();
-		return `${parsed.origin}${parsed.pathname}${search ? `?${search}` : ""}${parsed.hash}`;
-	} catch {
-		return url;
-	}
+function isSetupCompleted() {
+	const at = loadSettings().setupCompletedAt;
+	return typeof at === "string" && at.length > 0;
 }
-/** Public review URL for humans (no `?token=` — session cookie is set when HTML is served). */
-function reviewSessionUrl(lock) {
-	const base = reviewSessionBaseUrl(lock);
-	if (!base) return null;
-	return base;
+function markSetupCompleted() {
+	return saveSettings({ setupCompletedAt: (/* @__PURE__ */ new Date()).toISOString() });
 }
-/** Join an API path to a session base URL (origin only; strips any legacy `?token=`). */
-function joinSessionApiUrl(base, path) {
-	return `${new URL(base).origin}${path.startsWith("/") ? path : `/${path}`}`;
+function resetSetupCompleted() {
+	return saveSettings({ setupCompletedAt: null });
 }
 //#endregion
-export { loadSettings as a, reviewSessionUrl as i, joinSessionApiUrl as n, saveSettings as o, reviewSessionBaseUrl as r, appendSessionToken as t };
+export { markSetupCompleted as a, loadSettings as i, formatModeLabel as n, resetSetupCompleted as o, isSetupCompleted as r, saveSettings as s, ensureConfigDir as t };

package/dist/setup-BiwX7vdd.mjs

@@ -0,0 +1,446 @@
+import { S as isGitRepo, h as getRepoRoot } from "./git-BGj31GX-.mjs";
+import { a as markSetupCompleted, i as loadSettings, n as formatModeLabel, o as resetSetupCompleted, r as isSetupCompleted, s as saveSettings, t as ensureConfigDir } from "./settings-DkPDB_hS.mjs";
+import { n as completionFor } from "./completions-7YSX1neu.mjs";
+import { a as hintLine, c as stepHeader, i as dim, l as tone, n as box, o as isColorEnabled, r as copyBlock, s as rule, t as bold } from "./terminal-BroplOnw.mjs";
+import { n as runDoctor, t as formatDoctorReport } from "./doctor-BMfx7_GY.mjs";
+import { t as DOCS_GETTING_STARTED_URL } from "./setup-first-run-i1o7DBki.mjs";
+import { execFileSync, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+//#region src/lib/setup-mcp.ts
+const DIFFING_SERVER_KEY = "diffing";
+function buildDiffingMcpEntry(repoPath) {
+	if (repoPath) return {
+		command: "diffing",
+		args: [
+			"mcp",
+			"--repo",
+			repoPath
+		]
+	};
+	return {
+		command: "diffing",
+		args: ["mcp"]
+	};
+}
+function formatMcpSnippet(entry) {
+	return JSON.stringify({ mcpServers: { [DIFFING_SERVER_KEY]: entry } }, null, 2);
+}
+function detectGlobalMcpClients(home = homedir()) {
+	const clients = [];
+	const cursor = join(home, ".cursor", "mcp.json");
+	clients.push({
+		id: "cursor",
+		label: "Cursor",
+		path: cursor,
+		scope: "global"
+	});
+	const claude = claudeDesktopConfigPath(home);
+	if (claude) clients.push({
+		id: "claude-desktop",
+		label: "Claude Desktop",
+		path: claude,
+		scope: "global"
+	});
+	return clients;
+}
+function projectMcpPath(cwd) {
+	return join(cwd, ".cursor", "mcp.json");
+}
+function claudeDesktopConfigPath(home) {
+	const os = platform();
+	if (os === "darwin") return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+	if (os === "win32") {
+		const appData = process.env.APPDATA;
+		if (!appData) return null;
+		return join(appData, "Claude", "claude_desktop_config.json");
+	}
+	return join(home, ".config", "Claude", "claude_desktop_config.json");
+}
+function readMcpConfig(path) {
+	if (!existsSync(path)) return {};
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch {
+		return {};
+	}
+}
+/** Merge only `mcpServers.diffing`; preserve every other server and top-level key. */
+function mergeDiffingMcpConfig(existing, entry) {
+	const servers = { ...existing.mcpServers ?? {} };
+	servers[DIFFING_SERVER_KEY] = entry;
+	return {
+		...existing,
+		mcpServers: servers
+	};
+}
+function backupMcpConfig(path, backupsRoot = join(homedir(), ".diffing", "backups")) {
+	if (!existsSync(path)) return null;
+	mkdirSync(backupsRoot, { recursive: true });
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+	const backupPath = join(backupsRoot, `${path.replaceAll(/[/\\:]/g, "_")}.${stamp}.json`);
+	copyFileSync(path, backupPath);
+	return backupPath;
+}
+function writeMcpConfig(target, entry, options) {
+	const merged = mergeDiffingMcpConfig(readMcpConfig(target.path), entry);
+	const created = !existsSync(target.path);
+	if (options?.dryRun) return {
+		path: target.path,
+		written: false,
+		backupPath: null,
+		created
+	};
+	mkdirSync(join(target.path, ".."), { recursive: true });
+	const backupPath = backupMcpConfig(target.path, options?.backupsRoot);
+	writeFileSync(target.path, `${JSON.stringify(merged, null, 2)}\n`, "utf-8");
+	return {
+		path: target.path,
+		written: true,
+		backupPath,
+		created
+	};
+}
+function writeGlobalMcpConfigs(entry, options) {
+	return detectGlobalMcpClients(options?.home).map((target) => writeMcpConfig(target, entry, options));
+}
+function writeProjectMcpConfig(cwd, entry, options) {
+	return writeMcpConfig({
+		id: "cursor-project",
+		label: "Cursor (project)",
+		path: projectMcpPath(cwd),
+		scope: "project"
+	}, entry, options);
+}
+//#endregion
+//#region src/lib/setup-skills.ts
+const SKILLS_PACKAGE = "ahmedragab20/diffing";
+function buildSkillsInstallCommand() {
+	return {
+		command: "npx",
+		args: [
+			"skills",
+			"add",
+			SKILLS_PACKAGE
+		]
+	};
+}
+function formatSkillsInstallCommand() {
+	const { command, args } = buildSkillsInstallCommand();
+	return [command, ...args].join(" ");
+}
+function runSkillsInstall(options = {}) {
+	if (options.dryRun) return Promise.resolve(0);
+	const { command, args } = buildSkillsInstallCommand();
+	return new Promise((resolve) => {
+		const child = spawn(command, args, {
+			cwd: options.cwd ?? process.cwd(),
+			env: options.env ?? process.env,
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		child.on("error", () => resolve(1));
+		child.on("exit", (code) => resolve(code ?? 1));
+	});
+}
+//#endregion
+//#region src/lib/setup.ts
+const SETUP_STEPS = 6;
+function packageVersion(cliImportMetaUrl) {
+	const candidates = [];
+	if (cliImportMetaUrl) {
+		const base = dirname(fileURLToPath(cliImportMetaUrl));
+		candidates.push(resolve(base, "..", "package.json"), resolve(base, "..", "..", "package.json"));
+	}
+	candidates.push(resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json"));
+	for (const path of candidates) try {
+		const pkg = JSON.parse(readFileSync(path, "utf-8"));
+		if (pkg.version) return pkg.version;
+	} catch {}
+	return "unknown";
+}
+function gitOnPath() {
+	try {
+		execFileSync("git", ["--version"], { stdio: [
+			"ignore",
+			"ignore",
+			"ignore"
+		] });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function nodeVersionOk() {
+	const major = Number(process.versions.node.split(".")[0]);
+	return Number.isFinite(major) && major >= 20;
+}
+function printStep(step, title, color) {
+	console.log("");
+	console.log(stepHeader(step, SETUP_STEPS, title, { color }));
+}
+async function askYesNo(question, defaultYes, interactive, color) {
+	if (!interactive || !process.stdin.isTTY) return defaultYes;
+	const rl = createInterface({
+		input: stdin,
+		output: stdout
+	});
+	try {
+		const suffix = defaultYes ? `[${bold("Y", color)}/${bold("n", color)}]` : `[${bold("y", color)}/${bold("N", color)}]`;
+		console.log(hintLine([
+			{
+				key: "Y",
+				label: "yes"
+			},
+			{
+				key: "n",
+				label: "no"
+			},
+			{
+				key: "?",
+				label: "help"
+			}
+		], { color }));
+		while (true) {
+			const answer = (await rl.question(`${question} ${suffix} `)).trim().toLowerCase();
+			if (!answer) return defaultYes;
+			if (answer === "?" || answer === "help") {
+				console.log(dim("Answer y/yes or n/no; Enter accepts the default in brackets.", color));
+				continue;
+			}
+			if (answer === "y" || answer === "yes") return true;
+			if (answer === "n" || answer === "no") return false;
+			console.log(dim("Please answer y or n (or ? for help).", color));
+		}
+	} finally {
+		rl.close();
+	}
+}
+async function askDefaultMode(interactive, color) {
+	if (!interactive || !process.stdin.isTTY) return;
+	const current = loadSettings().defaultMode;
+	console.log("");
+	console.log(tone("info", "Default interactive mode:", { color }));
+	console.log(`  ${bold("Web", color)}  ${dim("— browser review UI (supported)", color)}`);
+	console.log(`  ${bold("TUI", color)}  ${dim("— native terminal UI (experimental)", color)}`);
+	console.log(dim(`Current: ${formatModeLabel(current)}`, color));
+	if (await askYesNo(`Switch to TUI?`, false, interactive, color)) {
+		saveSettings({ defaultMode: "tui" });
+		console.log(tone("ok", "Default mode set to TUI", { color }));
+		return;
+	}
+	if (!await askYesNo("Keep Web as the default interactive mode?", true, interactive, color)) {
+		saveSettings({ defaultMode: "tui" });
+		console.log(tone("ok", "Default mode set to TUI", { color }));
+	}
+}
+function runSetupCheck(options = {}) {
+	const cwd = options.cwd ?? process.cwd();
+	const messages = [];
+	const nodeOk = nodeVersionOk();
+	if (!nodeOk) messages.push(`Node.js >= 20 required (found ${process.versions.node})`);
+	const gitOk = gitOnPath();
+	if (!gitOk) messages.push("git not found on PATH");
+	const inGitRepo = isGitRepo();
+	if (!inGitRepo) messages.push(`${cwd} is not inside a Git repository (setup can continue)`);
+	ensureConfigDir();
+	const configDirReady = true;
+	const setupCompleted = isSetupCompleted();
+	return {
+		ok: nodeOk && gitOk && configDirReady,
+		nodeOk,
+		gitOk,
+		inGitRepo,
+		setupCompleted,
+		configDirReady,
+		messages
+	};
+}
+async function runSetup(options = {}) {
+	const cwd = options.cwd ?? process.cwd();
+	const interactive = options.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+	const color = interactive && isColorEnabled();
+	const version = packageVersion(options.cliImportMetaUrl);
+	if (options.reset) {
+		resetSetupCompleted();
+		console.log(tone("ok", "Setup marker cleared. Run `diffing setup` to configure again.", { color }));
+		return 0;
+	}
+	const preflight = runSetupCheck({ cwd });
+	if (options.check) {
+		printCheckReport(preflight, version, color);
+		return preflight.ok ? 0 : 1;
+	}
+	console.log(box("diffing setup", [dim(`v${version} — first-time configuration wizard`, color)], { color }));
+	printStep(1, "Environment", color);
+	if (!preflight.nodeOk) {
+		console.error(tone("error", `Node.js >= 20 required (found ${process.versions.node})`, { color }));
+		return 1;
+	}
+	if (!preflight.gitOk) {
+		console.error(tone("error", "git not found on PATH — install git and retry.", { color }));
+		return 1;
+	}
+	ensureConfigDir();
+	console.log(tone("ok", "Config directory ready (~/.config/diffing/)", { color }));
+	if (preflight.inGitRepo) try {
+		console.log(tone("ok", `Git repository: ${getRepoRoot()}`, { color }));
+	} catch {
+		console.log(tone("warn", "Not inside a Git repository — review commands need a repo later", { color }));
+	}
+	else console.log(tone("warn", "Not inside a Git repository — you can still finish setup", { color }));
+	if (options.skillsOnly) return runSkillsStep(options, interactive, color, 5);
+	if (options.mcpOnly) return runMcpStep(cwd, options, interactive, preflight.inGitRepo, color, 6);
+	printStep(2, "Environment checks", color);
+	console.log(dim("Running `diffing doctor`…", color));
+	const doctor = await runDoctor({
+		cwd,
+		cliImportMetaUrl: options.cliImportMetaUrl
+	});
+	console.log(formatDoctorReport(doctor, { color }));
+	printStep(3, "Default mode", color);
+	if (!options.yes) await askDefaultMode(interactive, color);
+	else console.log(tone("ok", `Default mode: ${formatModeLabel(loadSettings().defaultMode)} (unchanged)`, { color }));
+	printStep(4, "Shell completions", color);
+	await runCompletionsStep(options, interactive, color);
+	printStep(5, "Agent skills", color);
+	const skillsCode = await runSkillsStep(options, interactive, color, 5);
+	if (skillsCode !== 0) return skillsCode;
+	printStep(6, "MCP registration", color);
+	const mcpCode = await runMcpStep(cwd, options, interactive, preflight.inGitRepo, color, 6);
+	if (mcpCode !== 0) return mcpCode;
+	markSetupCompleted();
+	printDoneChecklist(preflight.inGitRepo, cwd, color);
+	return 0;
+}
+async function runSkillsStep(options, interactive, color, _step) {
+	const cmd = formatSkillsInstallCommand();
+	if (!(options.yes || await askYesNo(`Install agent skills via \`${cmd}\`?`, true, interactive, color))) {
+		console.log(dim("Skipped skills install.", color));
+		return 0;
+	}
+	if (options.yes && !process.stdin.isTTY) console.log(dim(`Running: ${cmd}`, color));
+	const code = await runSkillsInstall({ cwd: options.cwd });
+	if (code === 0) console.log(tone("ok", "Skills installed (or already present)", { color }));
+	else {
+		console.error(tone("error", `Skills install exited with code ${code}`, { color }));
+		console.error(dim(`  You can retry manually: ${cmd}`, color));
+		return options.yes ? 0 : code;
+	}
+	return 0;
+}
+async function runMcpStep(cwd, options, interactive, inGitRepo, color, _step) {
+	let repoPath;
+	if (inGitRepo) try {
+		repoPath = getRepoRoot();
+	} catch {
+		repoPath = void 0;
+	}
+	const entry = buildDiffingMcpEntry(repoPath);
+	const snippet = formatMcpSnippet(entry);
+	if (options.writeMcp || options.writeProjectMcp) {
+		if (options.writeMcp) {
+			const results = writeGlobalMcpConfigs(entry);
+			for (const r of results) if (r.written) {
+				const backup = r.backupPath ? ` (backup: ${r.backupPath})` : "";
+				console.log(tone("ok", `Wrote MCP config: ${r.path}${backup}`, { color }));
+			}
+		}
+		if (options.writeProjectMcp) {
+			const r = writeProjectMcpConfig(cwd, entry);
+			const backup = r.backupPath ? ` (backup: ${r.backupPath})` : "";
+			console.log(tone("ok", `Wrote project MCP config: ${r.path}${backup}`, { color }));
+		}
+		return 0;
+	}
+	console.log(tone("info", "MCP registration (paste into your agent client):", { color }));
+	console.log(copyBlock("Copy MCP JSON", snippet, { color }));
+	const detected = detectGlobalMcpClients().filter((c) => c.id === "cursor" || c.id === "claude-desktop");
+	if (detected.length > 0) {
+		console.log("");
+		console.log(tone("info", "Detected clients:", { color }));
+		for (const c of detected) console.log(dim(`  • ${c.label}: ${c.path}`, color));
+	}
+	if (options.yes) {
+		console.log(dim("\n(--yes prints MCP JSON only; pass --write-mcp to merge into IDE configs)", color));
+		return 0;
+	}
+	if (await askYesNo("Write diffing MCP entry to global IDE configs?", false, interactive, color)) writeGlobalMcpConfigs(entry).forEach((r) => {
+		if (r.written) console.log(tone("ok", `Wrote ${r.path}`, { color }));
+	});
+	if (await askYesNo("Also write project-local .cursor/mcp.json in the current directory?", false, interactive, color)) {
+		const r = writeProjectMcpConfig(cwd, entry);
+		if (r.written) console.log(tone("ok", `Wrote ${r.path}`, { color }));
+	}
+	return 0;
+}
+async function runCompletionsStep(options, interactive, color) {
+	const shells = [
+		"bash",
+		"zsh",
+		"fish"
+	];
+	if (options.writeCompletions) {
+		for (const shell of shells) {
+			const script = completionFor(shell);
+			if (script) console.log(copyBlock(`${shell} completion`, script, { color }));
+		}
+		return;
+	}
+	if (options.yes) {
+		console.log(dim("Shell completions: run `diffing completion <bash|zsh|fish>` and append to your shell rc.", color));
+		return;
+	}
+	if (!await askYesNo("Print shell completion scripts?", false, interactive, color)) return;
+	for (const shell of shells) {
+		const script = completionFor(shell);
+		if (script) console.log(copyBlock(`${shell} completion`, script, { color }));
+	}
+}
+function printCheckReport(result, version, color) {
+	console.log(box("diffing setup --check", [dim(`v${version}`, color)], { color }));
+	console.log(rule({ color }));
+	console.log(result.nodeOk ? tone("ok", "Node.js >= 20", { color }) : tone("error", "Node.js >= 20", { color }));
+	console.log(result.gitOk ? tone("ok", "git on PATH", { color }) : tone("error", "git on PATH", { color }));
+	console.log(result.configDirReady ? tone("ok", "~/.config/diffing/", { color }) : tone("error", "config dir", { color }));
+	console.log(result.inGitRepo ? tone("ok", "inside Git repository", { color }) : tone("warn", "not in a Git repository", { color }));
+	console.log(result.setupCompleted ? tone("ok", "setup completed previously", { color }) : tone("warn", "setup not completed", { color }));
+	for (const msg of result.messages) console.log(dim(`  ${msg}`, color));
+}
+function printDoneChecklist(inGitRepo, cwd, color) {
+	const nextSteps = inGitRepo ? ["diffing              Open the review UI", "diffing doctor       Re-run diagnostics anytime"] : ["cd <your-repo> && diffing", `# current directory: ${cwd}`];
+	console.log(box("Setup complete", [
+		tone("ok", "Settings saved", { color }),
+		tone("ok", "Environment checked (`diffing doctor`)", { color }),
+		"",
+		tone("info", "Next steps:", { color }),
+		...nextSteps.map((line) => `  ${line}`),
+		"",
+		`Docs: ${DOCS_GETTING_STARTED_URL}`,
+		dim("CLI reference: docs/cli.md", color)
+	], { color }));
+}
+async function handleFirstRunGate(options) {
+	const { shouldOfferFirstRunSetup, promptFirstRunSetup, DOCS_GETTING_STARTED_URL } = await import("./setup-first-run-DyT0PlOZ.mjs");
+	if (!shouldOfferFirstRunSetup({ skipSetup: options.skipSetup })) return;
+	while (true) {
+		const choice = await promptFirstRunSetup();
+		if (choice === "skip") return;
+		if (choice === "docs") {
+			console.log(`\nGetting started: ${DOCS_GETTING_STARTED_URL}\n`);
+			continue;
+		}
+		const code = await runSetup({
+			cliImportMetaUrl: options.cliImportMetaUrl,
+			interactive: true
+		});
+		if (code !== 0) process.exit(code);
+		return;
+	}
+}
+//#endregion
+export { handleFirstRunGate, runSetup };

package/dist/setup-first-run-DyT0PlOZ.mjs

@@ -0,0 +1,2 @@
+import { a as shouldOfferFirstRunSetup, i as promptFirstRunSetup, t as DOCS_GETTING_STARTED_URL } from "./setup-first-run-i1o7DBki.mjs";
+export { DOCS_GETTING_STARTED_URL, promptFirstRunSetup, shouldOfferFirstRunSetup };

package/dist/setup-first-run-i1o7DBki.mjs

@@ -0,0 +1,74 @@
+import { r as isSetupCompleted } from "./settings-DkPDB_hS.mjs";
+import { a as hintLine, i as dim, n as box, o as isColorEnabled } from "./terminal-BroplOnw.mjs";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+//#region src/lib/setup-first-run.ts
+const DOCS_GETTING_STARTED_URL = "https://github.com/ahmedragab20/diffing/blob/main/docs/getting-started.md";
+function isCiEnvironment(env = process.env) {
+	return Boolean(env.CI || env.CONTINUOUS_INTEGRATION || env.BUILD_NUMBER || env.GITHUB_ACTIONS || env.GITLAB_CI || env.CIRCLECI || env.JENKINS_URL);
+}
+function shouldOfferFirstRunSetup(options = {}) {
+	const env = options.env ?? process.env;
+	const tty = options.isTTY ?? Boolean(process.stdout.isTTY);
+	const stdinTty = options.isStdinTTY ?? Boolean(process.stdin.isTTY);
+	if (options.skipSetup) return false;
+	if (!tty || !stdinTty) return false;
+	if (isCiEnvironment(env)) return false;
+	return !(options.setupCompleted ?? isSetupCompleted());
+}
+function formatFirstRunWelcome(options = {}) {
+	const color = options.color ?? isColorEnabled();
+	return box("diffing", [
+		"Welcome — local-first code review for git diffs and AI handoff.",
+		"",
+		hintLine([
+			{
+				key: "Y",
+				label: "Run setup now"
+			},
+			{
+				key: "n",
+				label: "Skip"
+			},
+			{
+				key: "?",
+				label: "Docs"
+			}
+		], { color }),
+		dim(`Getting started: ${DOCS_GETTING_STARTED_URL}`, color)
+	], { color });
+}
+async function promptFirstRunSetup(write = (line) => stdout.write(line)) {
+	const color = isColorEnabled();
+	write(formatFirstRunWelcome({ color }));
+	const rl = createInterface({
+		input: stdin,
+		output: stdout
+	});
+	try {
+		while (true) {
+			const answer = (await rl.question("> ")).trim().toLowerCase();
+			if (!answer || answer === "y" || answer === "yes") return "run";
+			if (answer === "n" || answer === "no") return "skip";
+			if (answer === "?" || answer === "docs" || answer === "help") return "docs";
+			write(hintLine([
+				{
+					key: "Y",
+					label: "yes"
+				},
+				{
+					key: "n",
+					label: "no"
+				},
+				{
+					key: "?",
+					label: "help"
+				}
+			], { color }) + "\n");
+		}
+	} finally {
+		rl.close();
+	}
+}
+//#endregion
+export { shouldOfferFirstRunSetup as a, promptFirstRunSetup as i, formatFirstRunWelcome as n, isCiEnvironment as r, DOCS_GETTING_STARTED_URL as t };