@heyitsiveen/dotfiles 1.0.4 → 1.1.1

package/dist/prompts-CzEUjeU4.mjs

@@ -0,0 +1,1195 @@
+import { a as readManifest, c as ASCII_BANNER, d as VERSION, i as install, l as MANIFEST_DIR, n as deleteManifest, o as uninstallGroups, r as findAllBackups, s as updateManifest, t as createManifest, u as THEMES } from "./index.mjs";
+import { cancel, confirm, intro, isCancel, log, multiselect, outro, select, spinner } from "@clack/prompts";
+import pc from "picocolors";
+import { join } from "node:path";
+import fse from "fs-extra";
+import { readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+//#region src/platform.ts
+function getDependencyTools(platform) {
+	if (platform === "macos") return [
+		{
+			name: "Git",
+			binary: "git",
+			description: "Version control + Neovim plugins",
+			installCmd: "brew install git",
+			required: true
+		},
+		{
+			name: "fd",
+			binary: "fd",
+			description: "File finder used by FZF",
+			installCmd: "brew install fd",
+			required: false
+		},
+		{
+			name: "eza",
+			binary: "eza",
+			description: "Modern ls for FZF tree preview",
+			installCmd: "brew install eza",
+			required: false
+		},
+		{
+			name: "fastfetch",
+			binary: "fastfetch",
+			description: "System info tool",
+			installCmd: "brew install fastfetch",
+			required: false
+		},
+		{
+			name: "tree-sitter-cli",
+			binary: "tree-sitter",
+			description: "LazyVim parser compiler (requires C compiler — included in Xcode CLT)",
+			installCmd: "brew install tree-sitter-cli",
+			required: true,
+			forGroup: "Neovim"
+		}
+	];
+	return [
+		{
+			name: "Git",
+			binary: "git",
+			description: "Version control + Neovim plugins",
+			installCmd: "winget install Git.Git",
+			required: true
+		},
+		{
+			name: "fd",
+			binary: "fd",
+			description: "File finder used by FZF",
+			installCmd: "winget install sharkdp.fd",
+			required: false
+		},
+		{
+			name: "eza",
+			binary: "eza",
+			description: "Modern ls for FZF tree preview",
+			installCmd: "winget install eza-community.eza",
+			required: false
+		},
+		{
+			name: "fastfetch",
+			binary: "fastfetch",
+			description: "System info tool",
+			installCmd: "winget install Fastfetch-cli.Fastfetch",
+			required: false
+		},
+		{
+			name: "tree-sitter-cli",
+			binary: "tree-sitter",
+			description: "LazyVim parser compiler (requires C compiler — VS Build Tools or scoop install gcc)",
+			installCmd: "npm i -g tree-sitter-cli",
+			required: true,
+			forGroup: "Neovim"
+		}
+	];
+}
+function detectPlatform() {
+	switch (process.platform) {
+		case "darwin": return "macos";
+		case "win32": return "windows";
+		default: return null;
+	}
+}
+function getHomedir() {
+	return homedir();
+}
+function detectTool(binary) {
+	try {
+		execSync(process.platform === "win32" ? `where.exe ${binary}` : `which ${binary}`, { stdio: "ignore" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getDotfileGroups(platform) {
+	const home = getHomedir();
+	const config = join(home, ".config");
+	if (platform === "macos") return [
+		{
+			name: "Fish Shell",
+			source: ".config/fish",
+			target: join(config, "fish"),
+			description: "Config, 8 modules, Tide palettes",
+			toolBinary: "fish",
+			toolDescription: "Modern shell with autosuggestions",
+			installCmd: "brew install fish",
+			required: true,
+			themeSupport: true
+		},
+		{
+			name: "Ghostty",
+			source: ".config/ghostty",
+			target: join(config, "ghostty"),
+			description: "Terminal emulator",
+			toolBinary: "ghostty",
+			toolDescription: "GPU-accelerated terminal emulator",
+			installCmd: "brew install --cask ghostty",
+			required: true,
+			themeSupport: true
+		},
+		{
+			name: "WezTerm",
+			source: ".config/wezterm",
+			target: join(config, "wezterm"),
+			description: "Cross-platform terminal",
+			toolBinary: "wezterm",
+			toolDescription: "Cross-platform terminal emulator",
+			installCmd: "brew install --cask wezterm",
+			required: true,
+			themeSupport: true
+		},
+		{
+			name: "tmux",
+			source: ".config/tmux",
+			target: join(config, "tmux"),
+			description: "7 config files + keybinds",
+			toolBinary: "tmux",
+			toolDescription: "Terminal multiplexer",
+			installCmd: "brew install tmux",
+			required: false,
+			themeSupport: true
+		},
+		{
+			name: "Neovim",
+			source: ".config/nvim",
+			target: join(config, "nvim"),
+			description: "LazyVim + solarized-osaka",
+			toolBinary: "nvim",
+			toolDescription: "Hyperextensible text editor",
+			installCmd: "brew install neovim",
+			required: true,
+			themeSupport: true,
+			extraBackupPaths: [{
+				label: "data",
+				path: join(home, ".local", "share", "nvim")
+			}]
+		},
+		{
+			name: "bat",
+			source: ".config/bat",
+			target: join(config, "bat"),
+			description: "Config + custom themes",
+			toolBinary: "bat",
+			toolDescription: "Cat clone with syntax highlighting",
+			installCmd: "brew install bat",
+			required: false,
+			themeSupport: true
+		},
+		{
+			name: "btop",
+			source: ".config/btop",
+			target: join(config, "btop"),
+			description: "System monitor + themes",
+			toolBinary: "btop",
+			toolDescription: "System resource monitor",
+			installCmd: "brew install btop",
+			required: false,
+			themeSupport: true
+		},
+		{
+			name: "ripgrep",
+			source: ".config/ripgrep",
+			target: join(config, "ripgrep"),
+			description: "Search config",
+			toolBinary: "rg",
+			toolDescription: "Fast search tool",
+			installCmd: "brew install ripgrep",
+			required: false,
+			themeSupport: false
+		},
+		{
+			name: "Claude Code",
+			source: [".claude.json", ".claude"],
+			target: home,
+			description: "MCP servers + settings",
+			required: false,
+			themeSupport: false
+		}
+	];
+	return [
+		{
+			name: "PowerShell",
+			source: "powershell",
+			target: join(home, "Documents", "PowerShell"),
+			description: "Profile, 5 modules, 3 functions",
+			toolBinary: "pwsh",
+			toolDescription: "Modern cross-platform shell",
+			installCmd: "winget install Microsoft.PowerShell",
+			required: true,
+			themeSupport: true
+		},
+		{
+			name: "oh-my-posh",
+			source: ".config/omp-themes",
+			target: join(config, "omp-themes"),
+			description: "3 TOML prompt themes",
+			toolBinary: "oh-my-posh",
+			toolDescription: "Prompt theme engine",
+			installCmd: "winget install JanDeDobbeleer.OhMyPosh",
+			required: false,
+			themeSupport: true
+		},
+		{
+			name: "WezTerm",
+			source: ".config/wezterm",
+			target: join(config, "wezterm"),
+			description: "Terminal config",
+			toolBinary: "wezterm",
+			toolDescription: "Cross-platform terminal emulator",
+			installCmd: "winget install wez.wezterm",
+			required: true,
+			themeSupport: true
+		},
+		{
+			name: "Neovim",
+			source: ".config/nvim",
+			target: join(process.env.LOCALAPPDATA || join(home, "AppData", "Local"), "nvim"),
+			description: "LazyVim + solarized-osaka",
+			toolBinary: "nvim",
+			toolDescription: "Hyperextensible text editor",
+			installCmd: "winget install Neovim.Neovim",
+			required: true,
+			themeSupport: true,
+			extraBackupPaths: [{
+				label: "data",
+				path: join(process.env.LOCALAPPDATA || join(home, "AppData", "Local"), "nvim-data")
+			}]
+		},
+		{
+			name: "bat",
+			source: ".config/bat",
+			target: join(process.env.APPDATA || join(home, "AppData", "Roaming"), "bat"),
+			description: "Config + custom themes",
+			toolBinary: "bat",
+			toolDescription: "Cat clone with syntax highlighting",
+			installCmd: "winget install sharkdp.bat",
+			required: false,
+			themeSupport: true
+		},
+		{
+			name: "btop",
+			source: ".config/btop",
+			target: join(process.env.APPDATA || join(home, "AppData", "Roaming"), "btop"),
+			description: "System monitor + themes",
+			toolBinary: "btop",
+			toolDescription: "System resource monitor",
+			installCmd: "winget install aristocratos.btop4win",
+			required: false,
+			themeSupport: true
+		},
+		{
+			name: "ripgrep",
+			source: ".config/ripgrep",
+			target: join(config, "ripgrep"),
+			description: "Search config",
+			toolBinary: "rg",
+			toolDescription: "Fast search tool",
+			installCmd: "winget install BurntSushi.ripgrep.MSVC",
+			required: false,
+			themeSupport: false
+		},
+		{
+			name: "Claude Code",
+			source: [".claude.json", ".claude"],
+			target: home,
+			description: "MCP servers + settings",
+			required: false,
+			themeSupport: false
+		}
+	];
+}
+//#endregion
+//#region src/theme.ts
+const { ensureDir, pathExists: pathExists$1 } = fse;
+const ghosttyThemes = {
+	"solarized-dark": "Solarized Dark Patched",
+	vercel: "Vercel",
+	vesper: "Vesper"
+};
+const batThemes = {
+	"solarized-dark": "Solarized (dark)",
+	vercel: "Vercel",
+	vesper: "Vesper"
+};
+const btopThemes = {
+	"solarized-dark": "Solarized_Dark",
+	vercel: "Vercel",
+	vesper: "Vesper"
+};
+const weztermThemes = {
+	"solarized-dark": "Solarized Dark (Gogh)",
+	vercel: "Vercel",
+	vesper: "Vesper"
+};
+const nvimPlugins = {
+	"solarized-dark": "craftzdog/solarized-osaka.nvim",
+	vercel: "tiesen243/vercel.nvim",
+	vesper: "datsfilipe/vesper.nvim"
+};
+const tidePalettes = {
+	"solarized-dark": "heyitsiveen",
+	vercel: "vercel",
+	vesper: "vesper"
+};
+const themeHeaderPatterns = {
+	"solarized-dark": "SOLARIZED",
+	vercel: "VERCEL",
+	vesper: "VESPER"
+};
+function skipped(tool, path) {
+	return `${tool} → skipped (config missing at ${path.replace(homedir(), "~")})`;
+}
+async function switchTheme(theme, installedGroups, platform, dryRun) {
+	const results = [];
+	for (const group of installedGroups) try {
+		switch (group.name) {
+			case "Ghostty": {
+				const missing = dryRun ? null : await switchGhosttyTheme(group.target, theme);
+				results.push(missing ? skipped("Ghostty", missing) : `Ghostty → ${ghosttyThemes[theme]}`);
+				break;
+			}
+			case "bat": {
+				const missing = dryRun ? null : await switchBatTheme(group.target, theme);
+				results.push(missing ? skipped("bat", missing) : `bat → ${batThemes[theme]}`);
+				break;
+			}
+			case "btop": {
+				const missing = dryRun ? null : await switchSingleLine(join(group.target, "btop.conf"), /^color_theme = .*$/m, `color_theme = "${btopThemes[theme]}"`);
+				results.push(missing ? skipped("btop", missing) : `btop → ${btopThemes[theme]}`);
+				break;
+			}
+			case "WezTerm": {
+				const missing = dryRun ? null : await switchSingleLine(join(group.target, "wezterm.lua"), /^config\.color_scheme = .*$/m, `config.color_scheme = '${weztermThemes[theme]}'`);
+				results.push(missing ? skipped("WezTerm", missing) : `WezTerm → ${weztermThemes[theme]}`);
+				break;
+			}
+			case "Neovim": {
+				const missing = dryRun ? null : await switchNeovimTheme(group.target, theme);
+				results.push(missing ? skipped("Neovim", missing) : `Neovim → ${nvimPlugins[theme]}`);
+				break;
+			}
+			case "Fish Shell": {
+				if (dryRun) {
+					results.push(`Fish/Tide palette → ${tidePalettes[theme]}`);
+					results.push(`FZF → ${theme}`);
+					break;
+				}
+				const tideMissing = await switchTideTheme(group.target, theme);
+				const fzfMissing = await switchFzfTheme(join(group.target, "conf.d", "40-fzf.fish"), theme, /^set -gx FZF_DEFAULT_OPTS/);
+				results.push(tideMissing ? skipped("Fish/Tide palette", tideMissing) : `Fish/Tide palette → ${tidePalettes[theme]}`);
+				results.push(fzfMissing ? skipped("FZF", fzfMissing) : `FZF → ${theme}`);
+				break;
+			}
+			case "tmux": {
+				const missing = dryRun ? null : await switchTmuxTheme(group.target, theme);
+				results.push(missing ? skipped("tmux statusbar", missing) : `tmux statusbar → ${theme}`);
+				break;
+			}
+			case "PowerShell": {
+				const missing = dryRun ? null : await switchFzfTheme(join(group.target, "modules", "fzf.ps1"), theme, /^\$env:FZF_DEFAULT_OPTS/);
+				results.push(missing ? skipped("FZF (PowerShell)", missing) : `FZF (PowerShell) → ${theme}`);
+				break;
+			}
+			case "oh-my-posh":
+				if (!dryRun) await switchOmpTheme(theme);
+				results.push(`oh-my-posh → ${theme}`);
+				break;
+		}
+	} catch (err) {
+		results.push(`${group.name} — failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	return results;
+}
+async function switchGhosttyTheme(targetDir, theme) {
+	const filePath = join(targetDir, "config");
+	if (!await pathExists$1(filePath)) return filePath;
+	let content = await readFile(filePath, "utf-8");
+	content = content.replace(/^theme = .*$/m, `theme = "${ghosttyThemes[theme]}"`);
+	if (theme === "solarized-dark") {
+		if (!/^background = /m.test(content)) content = content.replace(/^(theme = .*)$/m, "$1\n\n# Window\nbackground = #031219");
+	} else content = content.replace(/^background = #031219\n/m, "");
+	await writeFile(filePath, content, "utf-8");
+	return null;
+}
+async function switchSingleLine(filePath, pattern, replacement) {
+	if (!await pathExists$1(filePath)) return filePath;
+	await writeFile(filePath, (await readFile(filePath, "utf-8")).replace(pattern, replacement), "utf-8");
+	return null;
+}
+async function switchBatTheme(targetDir, theme) {
+	const filePath = join(targetDir, "config");
+	if (!await pathExists$1(filePath)) return filePath;
+	let content = await readFile(filePath, "utf-8");
+	content = content.replace(/^(--theme=.*)$/m, "# $1");
+	const targetValue = batThemes[theme];
+	content = content.replace(new RegExp(`^# (--theme="${targetValue.replace(/[()]/g, "\\$&")}")$`, "m"), "$1");
+	await writeFile(filePath, content, "utf-8");
+	return null;
+}
+async function switchNeovimTheme(targetDir, theme) {
+	const filePath = join(targetDir, "lua", "plugins", "colorscheme.lua");
+	if (!await pathExists$1(filePath)) return filePath;
+	const content = await readFile(filePath, "utf-8");
+	const allPlugins = Object.values(nvimPlugins);
+	const pluginPattern = new RegExp(`"(${allPlugins.map((p) => p.replace(/[/.]/g, "\\$&")).join("|")})"`);
+	await writeFile(filePath, content.replace(pluginPattern, `"${nvimPlugins[theme]}"`), "utf-8");
+	return null;
+}
+async function switchTideTheme(targetDir, theme) {
+	const filePath = join(targetDir, "conf.d", "70-tide.fish");
+	if (!await pathExists$1(filePath)) return filePath;
+	await writeFile(filePath, (await readFile(filePath, "utf-8")).replace(/^(set -l tide_default_palette )\S+$/m, `$1${tidePalettes[theme]}`), "utf-8");
+	return null;
+}
+async function switchOmpTheme(theme) {
+	const themeDir = join(homedir(), MANIFEST_DIR, "oh-my-posh");
+	await ensureDir(themeDir);
+	await writeFile(join(themeDir, "prompt-theme.txt"), theme, "utf-8");
+}
+async function switchFzfTheme(filePath, theme, commandStart) {
+	if (!await pathExists$1(filePath)) return filePath;
+	await writeFile(filePath, toggleThemeBlocks(await readFile(filePath, "utf-8"), theme, commandStart), "utf-8");
+	return null;
+}
+async function switchTmuxTheme(targetDir, theme) {
+	const filePath = join(targetDir, "statusbar.conf");
+	if (!await pathExists$1(filePath)) return filePath;
+	await writeFile(filePath, toggleThemeBlocks(await readFile(filePath, "utf-8"), theme, /^(set|setw) -g /), "utf-8");
+	return null;
+}
+function toggleThemeBlocks(content, theme, commandStart) {
+	const lines = content.split("\n");
+	const result = [];
+	const targetHeader = themeHeaderPatterns[theme];
+	let currentSection = null;
+	let inMultiline = false;
+	let inHereString = false;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const headerMatch = line.match(/║\s+(\S+)/);
+		if (headerMatch) {
+			const headerName = headerMatch[1];
+			for (const [, pattern] of Object.entries(themeHeaderPatterns)) if (headerName.startsWith(pattern)) {
+				currentSection = pattern;
+				break;
+			}
+			if (headerName === "STATUS" || headerName === "WINDOW" || headerName === "FZF") {}
+		}
+		if (currentSection === null) {
+			result.push(line);
+			inMultiline = line.replace(/^# /, "").endsWith("\\");
+			continue;
+		}
+		const shouldBeActive = currentSection === targetHeader;
+		const stripped = line.replace(/^# /, "");
+		const isCommented = line !== stripped && line.startsWith("# ");
+		const isCommandStart = commandStart.test(stripped);
+		if (isCommandStart || inMultiline) if (shouldBeActive && isCommented) result.push(stripped);
+		else if (!shouldBeActive && !isCommented && !line.match(/^\s*$/)) result.push(`# ${line}`);
+		else result.push(line);
+		else result.push(line);
+		const contentForState = isCommented ? stripped : line;
+		if (isCommandStart || inMultiline) if (!inHereString && contentForState.trimEnd().endsWith("\\")) inMultiline = true;
+		else if (contentForState.trim() === "\"@") {
+			inMultiline = false;
+			inHereString = false;
+		} else if (contentForState.includes("@\"")) {
+			inMultiline = true;
+			inHereString = true;
+		} else if (inHereString) inMultiline = true;
+		else inMultiline = false;
+	}
+	return result.join("\n");
+}
+//#endregion
+//#region src/prompts.ts
+const { copy, pathExists } = fse;
+function handleCancel(value) {
+	if (isCancel(value)) {
+		cancel("Operation cancelled.");
+		process.exit(0);
+	}
+}
+function showBanner() {
+	console.log(pc.cyan(ASCII_BANNER));
+	console.log(pc.dim(`  v${VERSION}`));
+	console.log();
+}
+function showPrerequisites(platform) {
+	const items = [{
+		name: "Nerd Font",
+		description: "required for icons (Tide, oh-my-posh, Neovim)",
+		link: "https://www.nerdfonts.com/",
+		ok: true
+	}];
+	if (platform === "macos") items.push({
+		name: "Homebrew",
+		description: "package manager for macOS",
+		link: "https://brew.sh/",
+		ok: detectTool("brew")
+	});
+	else items.push({
+		name: "winget",
+		description: "package manager for Windows",
+		link: "https://aka.ms/getwinget",
+		ok: detectTool("winget")
+	});
+	log.info("Prerequisites:");
+	for (const item of items) {
+		const marker = item.ok ? pc.green("◆") : pc.yellow("⚠");
+		const label = item.ok ? item.name : pc.yellow(item.name);
+		log.message(`  ${marker} ${pc.bold(label)} — ${item.description}`);
+		log.message(`    ${pc.cyan(item.link)}`);
+	}
+}
+/** Detect tools and show status. Returns missing tools (no install). */
+async function showToolStatus(groups, platform) {
+	const allTools = [];
+	const groupNames = new Set(groups.map((g) => g.name));
+	const subTools = /* @__PURE__ */ new Map();
+	for (const dep of getDependencyTools(platform)) if (dep.forGroup) {
+		if (!groupNames.has(dep.forGroup)) continue;
+		const ok = detectTool(dep.binary);
+		const bucket = subTools.get(dep.forGroup) ?? [];
+		subTools.set(dep.forGroup, bucket);
+		bucket.push({
+			...dep,
+			ok
+		});
+		allTools.push(dep);
+	} else allTools.push(dep);
+	for (const g of groups) if (g.toolBinary && g.installCmd) allTools.push({
+		name: g.name,
+		binary: g.toolBinary,
+		description: g.toolDescription,
+		installCmd: g.installCmd,
+		required: g.required
+	});
+	if (allTools.length === 0) return [];
+	const forGroupNames = new Set([...subTools.values()].flat().map((t) => t.name));
+	const requiredTools = [];
+	const optionalTools = [];
+	const missing = [];
+	for (const t of allTools) {
+		const ok = detectTool(t.binary);
+		const entry = {
+			...t,
+			ok
+		};
+		if (!forGroupNames.has(t.name)) if (t.required) requiredTools.push(entry);
+		else optionalTools.push(entry);
+		if (!ok) missing.push(t);
+	}
+	const showTool = (t) => {
+		const marker = t.ok ? pc.green("◆") : pc.yellow("⚠");
+		const label = t.ok ? t.name : pc.yellow(t.name);
+		log.message(`    ${marker} ${pc.bold(label)} — ${t.description}`);
+	};
+	const showSubTool = (t) => {
+		const marker = t.ok ? pc.green("◆") : pc.yellow("⚠");
+		const label = t.ok ? t.name : pc.yellow(t.name);
+		log.message(`      ${marker} ${label} — ${pc.dim(t.description)}`);
+	};
+	log.info("Tools:");
+	log.message(`  ${pc.bold("Required")}`);
+	for (const t of requiredTools) {
+		showTool(t);
+		const subs = subTools.get(t.name);
+		if (subs) for (const st of subs) showSubTool(st);
+	}
+	log.message("");
+	log.message(`  ${pc.bold("Optional")}`);
+	for (const t of optionalTools) {
+		showTool(t);
+		const subs = subTools.get(t.name);
+		if (subs) for (const st of subs) showSubTool(st);
+	}
+	if (missing.length === 0) log.success("All tools installed!");
+	return missing;
+}
+/** Show multiselect picker for missing tools. Returns tools to install (no execution). */
+async function pickMissingTools(missing) {
+	const selectedNames = await multiselect({
+		message: "Install missing tools?",
+		options: missing.map((t) => ({
+			value: t.name,
+			label: t.name,
+			hint: t.installCmd
+		})),
+		initialValues: missing.map((t) => t.name),
+		required: false
+	});
+	handleCancel(selectedNames);
+	const toInstall = missing.filter((t) => selectedNames.includes(t.name));
+	const brewFirst = toInstall.filter((t) => t.name === "Homebrew");
+	const rest = toInstall.filter((t) => t.name !== "Homebrew");
+	return [...brewFirst, ...rest];
+}
+const groupCategories = {
+	"Shell & Terminal": [
+		"Fish Shell",
+		"PowerShell",
+		"Ghostty",
+		"WezTerm",
+		"tmux"
+	],
+	Editor: ["Neovim"],
+	"CLI Tools": [
+		"bat",
+		"btop",
+		"ripgrep",
+		"oh-my-posh"
+	],
+	Other: ["Claude Code"]
+};
+function showOverview(groups) {
+	log.info("Available configurations:");
+	for (const [category, names] of Object.entries(groupCategories)) {
+		const categoryGroups = groups.filter((g) => names.includes(g.name));
+		if (categoryGroups.length === 0) continue;
+		log.message(`  ${pc.bold(category)}`);
+		for (const g of categoryGroups) {
+			log.message(`    ${pc.green("◆")} ${pc.bold(g.name)} — ${pc.dim(g.description)}`);
+			log.message(`      ${pc.dim("→")} ${pc.dim(g.target)}`);
+		}
+		log.message("");
+	}
+}
+function showReloadCommands(groups) {
+	const reloads = [];
+	for (const g of groups) switch (g.name) {
+		case "Fish Shell":
+			reloads.push({
+				name: "Fish Shell",
+				cmd: "exec fish"
+			});
+			break;
+		case "tmux":
+			reloads.push({
+				name: "tmux",
+				cmd: "tmux source ~/.config/tmux/tmux.conf"
+			});
+			break;
+		case "Neovim":
+			reloads.push({
+				name: "Neovim",
+				cmd: "restart nvim, then run :Lazy sync"
+			});
+			break;
+	}
+	if (reloads.length > 0) {
+		log.info("Reload your configs:");
+		for (const r of reloads) log.message(`      ${r.name.padEnd(12)} →  ${pc.cyan(r.cmd)}`);
+	}
+	const restartMsg = "Restart your terminal for all changes to take effect.";
+	const w = 57;
+	log.message([
+		"",
+		`    ${pc.dim("╭" + "─".repeat(w) + "╮")}`,
+		`    ${pc.dim("│")}  ${pc.bold(restartMsg)}  ${pc.dim("│")}`,
+		`    ${pc.dim("╰" + "─".repeat(w) + "╯")}`
+	].join("\n"));
+}
+async function resolvePlatform(flagPlatform) {
+	if (flagPlatform === "macos" || flagPlatform === "windows") return flagPlatform;
+	const detected = detectPlatform();
+	if (detected) {
+		log.info(`Detected platform: ${pc.bold(detected === "macos" ? "macOS" : "Windows 11")}`);
+		return detected;
+	}
+	if (process.platform === "linux") {
+		log.info("Linux detected — macOS configs will be used (most tools are shared).");
+		return "macos";
+	}
+	const chosen = await select({
+		message: "Which platform?",
+		options: [{
+			value: "macos",
+			label: "macOS"
+		}, {
+			value: "windows",
+			label: "Windows 11"
+		}]
+	});
+	handleCancel(chosen);
+	return chosen;
+}
+async function showUpdateNotification(updatePromise) {
+	if (!updatePromise) return;
+	const latest = await updatePromise;
+	if (!latest) return;
+	const msg = `Update available: ${VERSION} → ${latest}`;
+	const cmd = "Run: bunx @heyitsiveen/dotfiles@latest";
+	const w = Math.max(msg.length, 38) + 4;
+	log.message([
+		`  ${pc.dim("╭" + "─".repeat(w) + "╮")}`,
+		`  ${pc.dim("│")}  ${pc.yellow(msg.padEnd(w - 2))}${pc.dim("│")}`,
+		`  ${pc.dim("│")}  ${pc.cyan(cmd.padEnd(w - 2))}${pc.dim("│")}`,
+		`  ${pc.dim("╰" + "─".repeat(w) + "╯")}`
+	].join("\n"));
+}
+async function firstRunFlow(flagPlatform, dryRun = false, updatePromise) {
+	showBanner();
+	intro(pc.bold("heyitsiveen"));
+	await showUpdateNotification(updatePromise);
+	const platform = await resolvePlatform(flagPlatform);
+	showPrerequisites(platform);
+	const allGroups = getDotfileGroups(platform);
+	const missingTools = await showToolStatus(allGroups, platform);
+	const toolsToInstall = missingTools.length > 0 ? await pickMissingTools(missingTools) : [];
+	showOverview(allGroups);
+	const depTools = getDependencyTools(platform);
+	const groupOptions = allGroups.map((g) => {
+		const toolMissing = g.toolBinary && !detectTool(g.toolBinary);
+		const missingDeps = depTools.filter((d) => d.forGroup === g.name && !detectTool(d.binary)).map((d) => d.name);
+		const warnings = [];
+		if (toolMissing) warnings.push("not installed");
+		if (missingDeps.length > 0) warnings.push(`${missingDeps.join(", ")} missing`);
+		const hint = warnings.length > 0 ? `⚠ ${warnings.join(", ")}` : g.description;
+		return {
+			value: g.name,
+			label: g.name,
+			hint
+		};
+	});
+	if (allGroups.some((g) => g.name === "Claude Code")) log.warn(pc.yellow("Claude Code config is the author's personal setup (see README) — deselect if you want defaults."));
+	const selectedNames = await multiselect({
+		message: "Which dotfiles would you like to install?",
+		options: groupOptions,
+		initialValues: allGroups.map((g) => g.name),
+		required: true
+	});
+	handleCancel(selectedNames);
+	const selectedGroups = allGroups.filter((g) => selectedNames.includes(g.name));
+	const theme = await select({
+		message: "Which color theme would you like?",
+		options: [
+			{
+				value: "solarized-dark",
+				label: "Solarized Dark",
+				hint: "default"
+			},
+			{
+				value: "vercel",
+				label: "Vercel"
+			},
+			{
+				value: "vesper",
+				label: "Vesper"
+			}
+		]
+	});
+	handleCancel(theme);
+	let shouldBackup = false;
+	for (const g of selectedGroups) {
+		const sources = Array.isArray(g.source) ? g.source : [g.source];
+		const isMultiSource = Array.isArray(g.source);
+		for (const source of sources) if (await pathExists(isMultiSource ? join(g.target, source.split("/").pop()) : g.target)) {
+			shouldBackup = true;
+			break;
+		}
+		if (shouldBackup) break;
+	}
+	if (shouldBackup) {
+		const doBackup = await confirm({ message: "Existing dotfiles found. Create backup?" });
+		handleCancel(doBackup);
+		shouldBackup = doBackup;
+	}
+	if (dryRun) log.info(pc.yellow("Dry run — showing planned operations:"));
+	if (toolsToInstall.length > 0) {
+		log.info("Installing tools...");
+		let toolsInstalled = 0;
+		for (const t of toolsToInstall) {
+			log.message(`    ${pc.dim("○")} ${t.name}...`);
+			try {
+				execSync(t.installCmd, {
+					stdio: "pipe",
+					encoding: "utf-8",
+					timeout: 3e5
+				});
+				toolsInstalled++;
+				log.message(`    ${pc.green("◆")} ${t.name} installed`);
+			} catch (err) {
+				log.message(`    ${pc.yellow("⚠")} ${t.name} failed`);
+				log.message(`      ${pc.dim(t.installCmd)} — ${pc.dim(err instanceof Error ? err.message : String(err))}`);
+			}
+		}
+		log.message(`  ${pc.green("◆")} ${toolsInstalled}/${toolsToInstall.length} tools installed`);
+	}
+	log.info("Installing dotfiles...");
+	const result = await install({
+		platform,
+		selectedGroups,
+		theme,
+		backup: shouldBackup,
+		dryRun
+	});
+	for (const ig of result.installedGroups) log.message(`    ${pc.green("◆")} ${ig.name} → ${pc.dim(ig.target)}`);
+	log.message(`  ${pc.green("◆")} ${result.installedGroups.length}/${selectedGroups.length} configs installed`);
+	const themeGroups = selectedGroups.filter((g) => g.themeSupport);
+	if (themeGroups.length > 0) {
+		log.info("Applying theme...");
+		const themeResults = await switchTheme(theme, result.installedGroups.filter((ig) => themeGroups.some((sg) => sg.name === ig.name)), platform, dryRun);
+		for (const r of themeResults) log.message(`    ${pc.green("◆")} ${r}`);
+		log.message(`  ${pc.green("◆")} Theme: ${theme} activated`);
+	}
+	if (result.backedUp.length > 0) {
+		const unique = [...new Set(result.backedUp)];
+		log.info("Backed up existing configs:");
+		for (const name of unique) log.message(`    ${pc.green("◆")} ${name}`);
+		log.message(`  ${pc.green("◆")} ${unique.length} configs → ${pc.dim("~/.config/heyitsiveen/dotfiles/backup/")}`);
+	}
+	if (!dryRun) await createManifest(result, {
+		platform,
+		selectedGroups,
+		theme,
+		backup: shouldBackup,
+		dryRun
+	});
+	if (result.errors.length > 0) for (const err of result.errors) log.message(`    ${pc.yellow("⚠")} ${err.file}: ${pc.dim(err.error)}`);
+	showReloadCommands(selectedGroups);
+	outro("Done! Your dotfiles are installed.");
+}
+async function reRunFlow(manifest, flagPlatform, dryRun = false, updatePromise) {
+	showBanner();
+	intro(pc.bold("heyitsiveen"));
+	await showUpdateNotification(updatePromise);
+	showPrerequisites(manifest.platform);
+	log.info(`Existing installation detected (v${manifest.version}, installed ${manifest.installedAt.split("T")[0]})`);
+	const mode = await select({
+		message: "What would you like to do?",
+		options: [
+			{
+				value: "fresh",
+				label: "Fresh install (backup + overwrite all)"
+			},
+			{
+				value: "update",
+				label: "Update (apply changes from new package version)"
+			},
+			{
+				value: "theme",
+				label: "Change theme"
+			},
+			{
+				value: "uninstall",
+				label: "Uninstall"
+			},
+			{
+				value: "restore",
+				label: "Restore from backup"
+			}
+		]
+	});
+	handleCancel(mode);
+	switch (mode) {
+		case "fresh":
+			await firstRunFlow(flagPlatform, dryRun);
+			break;
+		case "update":
+			await updateFlow(manifest, dryRun);
+			break;
+		case "theme":
+			await themeFlow(manifest, dryRun);
+			break;
+		case "uninstall":
+			await uninstallFlow(manifest, dryRun);
+			break;
+		case "restore":
+			await restoreFlow(dryRun);
+			break;
+	}
+}
+async function themeFlow(manifest, dryRun = false, flagTheme) {
+	let theme;
+	if (flagTheme && THEMES.includes(flagTheme)) theme = flagTheme;
+	else {
+		if (!flagTheme) {
+			showBanner();
+			intro(pc.bold("heyitsiveen"));
+		}
+		const chosen = await select({
+			message: "Which color theme would you like?",
+			options: [
+				{
+					value: "solarized-dark",
+					label: "Solarized Dark"
+				},
+				{
+					value: "vercel",
+					label: "Vercel"
+				},
+				{
+					value: "vesper",
+					label: "Vesper"
+				}
+			]
+		});
+		handleCancel(chosen);
+		theme = chosen;
+	}
+	const s = spinner();
+	s.start(`Switching theme → ${theme}...`);
+	const results = await switchTheme(theme, manifest.groups, manifest.platform, dryRun);
+	if (!dryRun) await updateManifest({ theme });
+	s.stop("Theme updated!");
+	for (const r of results) log.success(r);
+	outro(`Theme switched to ${theme}. Restart your terminal to apply.`);
+}
+async function uninstallFlow(manifest, dryRun = false) {
+	const mode = await select({
+		message: "What would you like to uninstall?",
+		options: [
+			{
+				value: "configs",
+				label: "Configs only",
+				hint: "remove installed dotfiles"
+			},
+			{
+				value: "tools",
+				label: "Tools only",
+				hint: "uninstall via brew/winget"
+			},
+			{
+				value: "both",
+				label: "Both",
+				hint: "remove configs and uninstall tools"
+			}
+		]
+	});
+	handleCancel(mode);
+	const uninstallConfigs = mode === "configs" || mode === "both";
+	const uninstallTools = mode === "tools" || mode === "both";
+	let selectedConfigGroups = manifest.groups;
+	let configNames = manifest.groups.map((g) => g.name);
+	if (uninstallConfigs) {
+		const selected = await multiselect({
+			message: "Which configs to remove?",
+			options: manifest.groups.map((g) => ({
+				value: g.name,
+				label: g.name,
+				hint: g.target
+			})),
+			initialValues: manifest.groups.map((g) => g.name),
+			required: true
+		});
+		handleCancel(selected);
+		configNames = selected;
+		selectedConfigGroups = manifest.groups.filter((g) => configNames.includes(g.name));
+	}
+	let selectedTools = [];
+	if (uninstallTools) {
+		const allGroups = getDotfileGroups(manifest.platform);
+		const allDeps = getDependencyTools(manifest.platform);
+		const toolOptions = [];
+		for (const g of allGroups) if (g.installCmd && g.toolBinary && detectTool(g.toolBinary)) {
+			const cmd = g.installCmd.replace(/\binstall\b/, "uninstall");
+			toolOptions.push({
+				value: {
+					name: g.name,
+					uninstallCmd: cmd
+				},
+				label: g.name,
+				hint: cmd
+			});
+		}
+		for (const d of allDeps) if (d.installCmd && detectTool(d.binary)) {
+			const cmd = d.installCmd.replace(/\binstall\b/, "uninstall");
+			toolOptions.push({
+				value: {
+					name: d.name,
+					uninstallCmd: cmd
+				},
+				label: d.name,
+				hint: cmd
+			});
+		}
+		if (toolOptions.length === 0) log.info("No installed tools found to uninstall.");
+		else {
+			const selected = await multiselect({
+				message: "Which tools to uninstall?",
+				options: toolOptions,
+				required: false
+			});
+			handleCancel(selected);
+			selectedTools = selected;
+		}
+	}
+	if (uninstallConfigs && selectedConfigGroups.length > 0) {
+		log.warn(pc.yellow("This will permanently delete the following:"));
+		const maxName = Math.max(...selectedConfigGroups.map((g) => g.name.length));
+		for (const g of selectedConfigGroups) log.message(`    ${pc.bold(g.name.padEnd(maxName))}  ${pc.dim("→")}  ${g.target}`);
+		log.message(`  ${pc.dim("Backups remain in")} ${pc.dim("~/.config/heyitsiveen/dotfiles/backup/")}`);
+		const confirmed = await confirm({ message: "Continue with uninstall?" });
+		handleCancel(confirmed);
+		if (!confirmed) {
+			outro("Uninstall cancelled.");
+			return;
+		}
+	}
+	if (dryRun) {
+		log.info(pc.yellow("Dry run — would remove:"));
+		if (uninstallConfigs) for (const g of selectedConfigGroups) log.info(`  ${g.name}: ${g.files.length} config files`);
+		for (const t of selectedTools) log.info(`  ${t.name}: ${t.uninstallCmd}`);
+		return;
+	}
+	if (uninstallConfigs) {
+		const s = spinner();
+		s.start("Removing configs...");
+		const errors = await uninstallGroups(selectedConfigGroups);
+		s.stop("Configs removed!");
+		for (const g of selectedConfigGroups) log.success(`Removed ${g.name} config`);
+		for (const err of errors) log.warn(err);
+	}
+	if (selectedTools.length > 0) for (const t of selectedTools) {
+		log.message(`  ${pc.dim("○")} Uninstalling ${t.name}...`);
+		try {
+			execSync(t.uninstallCmd, {
+				stdio: "pipe",
+				encoding: "utf-8",
+				timeout: 3e5
+			});
+			log.message(`  ${pc.green("◆")} ${t.name} uninstalled`);
+		} catch (err) {
+			log.message(`  ${pc.yellow("⚠")} ${t.name} failed`);
+			log.message(`    ${pc.dim(t.uninstallCmd)} — ${pc.dim(err instanceof Error ? err.message : String(err))}`);
+		}
+	}
+	if (uninstallConfigs) {
+		if ((await findAllBackups()).size > 0) {
+			const doRestore = await confirm({ message: "Restore from backup?" });
+			handleCancel(doRestore);
+			if (doRestore) await restoreFlow(dryRun);
+		}
+		if (configNames.length === manifest.groups.length) await deleteManifest();
+		else await updateManifest({ groups: manifest.groups.filter((g) => !configNames.includes(g.name)) });
+	}
+	outro("Uninstall complete.");
+}
+async function updateFlow(manifest, dryRun = false) {
+	log.info(`Installed: v${manifest.version} → Current: v${VERSION}`);
+	const allGroups = getDotfileGroups(manifest.platform);
+	const installedNames = manifest.groups.map((g) => g.name);
+	const updatableGroups = allGroups.filter((g) => installedNames.includes(g.name));
+	if (updatableGroups.length === 0) {
+		log.info("No groups to update.");
+		return;
+	}
+	const selectedNames = await multiselect({
+		message: "Which groups would you like to update?",
+		options: updatableGroups.map((g) => ({
+			value: g.name,
+			label: g.name
+		})),
+		initialValues: updatableGroups.map((g) => g.name),
+		required: true
+	});
+	handleCancel(selectedNames);
+	const selected = updatableGroups.filter((g) => selectedNames.includes(g.name));
+	if (dryRun) {
+		log.info(pc.yellow("Dry run — would update:"));
+		for (const g of selected) log.info(`  ${g.name} → ${g.target}`);
+		return;
+	}
+	const s = spinner();
+	s.start("Updating...");
+	const result = await install({
+		platform: manifest.platform,
+		selectedGroups: selected,
+		theme: manifest.theme,
+		backup: true,
+		dryRun: false
+	});
+	const themeGroups = selected.filter((g) => g.themeSupport);
+	if (themeGroups.length > 0) {
+		const themeInstalledGroups = result.installedGroups.filter((ig) => themeGroups.some((sg) => sg.name === ig.name));
+		await switchTheme(manifest.theme, themeInstalledGroups, manifest.platform, false);
+	}
+	await updateManifest({
+		version: VERSION,
+		installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		groups: result.installedGroups
+	});
+	s.stop("Update complete!");
+	for (const g of result.installedGroups) log.success(`Updated ${g.name} → ${g.target}`);
+	if (result.errors.length > 0) for (const err of result.errors) log.warn(`${err.file}: ${err.error}`);
+	outro("Update complete.");
+}
+async function restoreFlow(dryRun = false) {
+	const allBackups = await findAllBackups();
+	if (allBackups.size === 0) {
+		log.info("No backups found. Nothing to restore.");
+		process.exit(0);
+	}
+	const manifest = await readManifest();
+	if (!manifest) log.warn("No installation record found. Restore may overwrite untracked files.");
+	const selectedGroups = await multiselect({
+		message: "Which configs to restore?",
+		options: [...allBackups.entries()].map(([group, entries]) => ({
+			value: group,
+			label: `${group.padEnd(16)} (${entries.length} backup${entries.length > 1 ? "s" : ""})`,
+			hint: `★ latest: ${entries[0].name}`
+		})),
+		initialValues: [...allBackups.keys()],
+		required: true
+	});
+	handleCancel(selectedGroups);
+	const toRestore = [];
+	for (const group of selectedGroups) {
+		const entries = allBackups.get(group);
+		const chosen = await select({
+			message: `Which ${group} backup to restore?`,
+			options: entries.map((e, i) => ({
+				value: e,
+				label: e.name,
+				hint: i === 0 ? "★ latest" : void 0
+			}))
+		});
+		handleCancel(chosen);
+		toRestore.push(chosen);
+	}
+	const doConfirm = await confirm({ message: `Restore ${toRestore.length} config${toRestore.length > 1 ? "s" : ""}?` });
+	handleCancel(doConfirm);
+	if (!doConfirm) return;
+	if (dryRun) {
+		log.info(pc.yellow("Dry run — would restore:"));
+		for (const b of toRestore) log.info(`  ${b.group} → ${b.name}`);
+		return;
+	}
+	const s = spinner();
+	s.start("Restoring...");
+	const errors = [];
+	for (const backup of toRestore) {
+		const matchingGroup = manifest?.groups.find((g) => g.name === backup.group);
+		if (!matchingGroup) {
+			errors.push(`Skipped ${backup.group} — no matching installation record`);
+			continue;
+		}
+		try {
+			const configSubdir = join(backup.path, "config");
+			if (matchingGroup.extraBackupPaths && await pathExists(configSubdir)) {
+				await copy(configSubdir, matchingGroup.target, { overwrite: true });
+				log.success(`Restored ${backup.group} config → ${matchingGroup.target}`);
+				for (const extra of matchingGroup.extraBackupPaths) {
+					const extraSubdir = join(backup.path, extra.label);
+					if (await pathExists(extraSubdir)) {
+						await copy(extraSubdir, extra.path, { overwrite: true });
+						log.success(`Restored ${backup.group} ${extra.label} → ${extra.path}`);
+					}
+				}
+			} else {
+				await copy(backup.path, matchingGroup.target, { overwrite: true });
+				log.success(`Restored ${backup.group} → ${matchingGroup.target}`);
+			}
+		} catch (err) {
+			errors.push(`Failed to restore ${backup.group}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	s.stop(errors.length === 0 ? "Restore complete!" : `Restore complete (${errors.length} failed)`);
+	for (const msg of errors) log.warn(msg);
+	outro(errors.length === 0 ? "Dotfiles restored from backup." : `Restore finished with ${errors.length} error(s). Run with --dry-run to diagnose.`);
+}
+//#endregion
+export { firstRunFlow, reRunFlow, restoreFlow, themeFlow, uninstallFlow };