diffing 0.11.0 → 0.13.0

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 };

package/dist/terminal-BroplOnw.mjs

@@ -0,0 +1,116 @@
+import { stdout } from "node:process";
+//#region src/lib/terminal.ts
+const reset = "\x1B[0m";
+const GOLD = 220;
+const OK = 82;
+const OK_BRIGHT = 118;
+const WARN = 214;
+const WARN_BRIGHT = 220;
+const ERROR = 196;
+const INFO = 75;
+/** Whether ANSI styling is allowed (TTY, no NO_COLOR, TERM≠dumb). */
+function isColorEnabled(stream = stdout) {
+	if (!stream.isTTY) return false;
+	if (process.env.NO_COLOR !== void 0) return false;
+	if (process.env.TERM === "dumb") return false;
+	return true;
+}
+function fg256(code, enabled = isColorEnabled()) {
+	return enabled ? `\x1b[38;5;${code}m` : "";
+}
+function bold(text, enabled = isColorEnabled()) {
+	return enabled ? `\x1b[1m${text}${reset}` : text;
+}
+function dim(text, enabled = isColorEnabled()) {
+	return enabled ? `\x1b[2m${text}${reset}` : text;
+}
+function stripAnsi(str) {
+	return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+function borderColor(enabled) {
+	return fg256(GOLD, enabled);
+}
+function visibleLength(text) {
+	return stripAnsi(text).length;
+}
+function padRow(content, innerWidth) {
+	const pad = Math.max(0, innerWidth - visibleLength(content));
+	return content + " ".repeat(pad);
+}
+/** Gold Unicode box (╭─╮╰─╯│) with optional title row. */
+function box(title, lines, options = {}) {
+	const color = options.color ?? isColorEnabled();
+	const innerWidth = options.width ?? 62;
+	const border = borderColor(color);
+	const r = color ? reset : "";
+	const top = `${border}╭${"─".repeat(innerWidth)}╮${r}`;
+	const bottom = `${border}╰${"─".repeat(innerWidth)}╯${r}`;
+	const side = `${border}│${r}`;
+	const body = [];
+	if (title) {
+		body.push(padRow(bold(title, color), innerWidth - 4));
+		if (lines.length > 0) body.push("");
+	}
+	body.push(...lines);
+	return [
+		"",
+		top,
+		...body.map((line) => {
+			if (!line) return `${side}  ${" ".repeat(innerWidth - 4)}  ${side}`;
+			return `${side}  ${padRow(line, innerWidth - 4)}  ${side}`;
+		}),
+		bottom,
+		""
+	].join("\n");
+}
+/** Horizontal gold rule. */
+function rule(options = {}) {
+	const color = options.color ?? isColorEnabled();
+	const border = borderColor(color);
+	const r = color ? reset : "";
+	return `${border}${"─".repeat(40)}${r}`;
+}
+const TONE_ICON = {
+	ok: "✓",
+	warn: "!",
+	error: "✗",
+	info: "▌"
+};
+const TONE_COLOR = {
+	ok: OK,
+	warn: WARN,
+	error: ERROR,
+	info: INFO
+};
+/** Semantic status line with icon and 256-color foreground. */
+function tone(level, text, options = {}) {
+	const color = options.color ?? isColorEnabled();
+	const icon = TONE_ICON[level];
+	if (!color) return `${icon} ${text}`;
+	const accent = fg256(level === "ok" && text.includes("Overall: OK") ? OK_BRIGHT : TONE_COLOR[level], true);
+	return `${level === "warn" ? fg256(WARN_BRIGHT, true) : accent}${icon}${reset} ${accent}${text}${reset}`;
+}
+/** Faint hint row: bold keys with dim labels (e.g. Y yes · n no). */
+function hintLine(parts, options = {}) {
+	const color = options.color ?? isColorEnabled();
+	const sep = color ? dim(" · ", true) : " · ";
+	return parts.map(({ key, label }) => {
+		return `${bold(key, color)} ${color ? dim(label, true) : label}`;
+	}).join(sep);
+}
+/** Step focus rail: ▌ Step 2/5 · Title */
+function stepHeader(step, total, title, options = {}) {
+	if (!(options.color ?? isColorEnabled())) return `Step ${step}/${total} · ${title}`;
+	const rail = fg256(INFO, true);
+	const label = fg256(INFO, true);
+	const r = reset;
+	return `${rail}▌${r} ${label}Step ${step}/${total}${r} ${dim("·", true)} ${title}`;
+}
+/** Bordered “copy me” block with dim label above content lines. */
+function copyBlock(label, content, options = {}) {
+	const color = options.color ?? isColorEnabled();
+	const lines = content.trimEnd().split("\n");
+	return box(void 0, [color ? dim(label, true) : label, ...lines], options);
+}
+//#endregion
+export { hintLine as a, stepHeader as c, dim as i, tone as l, box as n, isColorEnabled as o, copyBlock as r, rule as s, bold as t };

package/dist/{tui-search-bridge-Bfb2ktdA.mjs → tui-search-bridge-fFKqX4Fi.mjs}

@@ -1,4 +1,4 @@
-import { o as getFileContent } from "./git-Czo96ymM.mjs";
+import { s as getFileContent } from "./git-BGj31GX-.mjs";
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 //#region src/lib/tui-search-bridge.ts
@@ -26,7 +26,7 @@ async function readJson(request) {
 	return JSON.parse(Buffer.concat(chunks).toString("utf8"));
 }
 async function runSearch(body) {
-	const { searchAll, searchContent, searchFiles, searchSymbols } = await import("./search-BO9Im7eu.mjs");
+	const { searchAll, searchContent, searchFiles, searchSymbols } = await import("./search-CQ4nsjBX.mjs");
 	const scope = body.scope ?? "all";
 	const query = typeof body.query === "string" ? body.query : "";
 	const limit = typeof body.limit === "number" ? body.limit : void 0;
@@ -100,7 +100,7 @@ async function startTuiSearchBridge() {
 			if (request.method === "POST" && request.url === "/track") {
 				const body = await readJson(request);
 				if (typeof body.path === "string") {
-					const { trackSelection } = await import("./search-BO9Im7eu.mjs");
+					const { trackSelection } = await import("./search-CQ4nsjBX.mjs");
 					await trackSelection(typeof body.query === "string" ? body.query : "", body.path);
 				}
 				sendJson(response, 200, { ok: true });