@heyitsiveen/dotfiles 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1445 @@
+#!/usr/bin/env node
+import { cancel, confirm, intro, isCancel, log, multiselect, outro, select, spinner } from "@clack/prompts";
+import { defineCommand, runMain } from "citty";
+import pc from "picocolors";
+import { readFileSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import fse from "fs-extra";
+import { readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+//#region src/constants.ts
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
+const PACKAGE_NAME = "@heyitsiveen/dotfiles";
+const VERSION = pkg.version;
+const BACKUP_DIR = ".config/heyitsiveen/dotfiles/backup";
+const MANIFEST_DIR = ".config/heyitsiveen/dotfiles";
+const MANIFEST_FILENAME = "manifest.json";
+const THEMES = [
+	"solarized-dark",
+	"vercel",
+	"vesper"
+];
+const DOTFILES_DIR = join(__dirname, "..", "dotfiles");
+const COPY_EXCLUDE = new Set([
+	".DS_Store",
+	"Thumbs.db",
+	"desktop.ini"
+]);
+const ASCII_BANNER = `  ██╗  ██╗███████╗██╗   ██╗██╗████████╗███████╗██╗   ██╗███████╗███████╗███╗   ██╗
+  ██║  ██║██╔════╝╚██╗ ██╔╝██║╚══██╔══╝██╔════╝╚██╗ ██╔╝██╔════╝██╔════╝████╗  ██║
+  ███████║█████╗   ╚████╔╝ ██║   ██║   ███████╗ ╚████╔╝ █████╗  █████╗  ██╔██╗ ██║
+  ██╔══██║██╔══╝    ╚██╔╝  ██║   ██║   ╚════██║  ╚██╔╝  ██╔══╝  ██╔══╝  ██║╚██╗██║
+  ██║  ██║███████╗   ██║   ██║   ██║   ███████║   ██║   ███████╗███████╗██║ ╚████║
+  ╚═╝  ╚═╝╚══════╝   ╚═╝   ╚═╝   ╚═╝   ╚══════╝   ╚═╝   ╚══════╝╚══════╝╚═╝  ╚═══╝`;
+//#endregion
+//#region src/installer.ts
+const { copy: copy$1, ensureDir: ensureDir$1, pathExists: pathExists$2, readJson, remove, writeJson } = fse;
+function copyFilter(src) {
+	return !COPY_EXCLUDE.has(basename(src));
+}
+async function collectFiles(dir) {
+	const files = [];
+	const entries = await readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (COPY_EXCLUDE.has(entry.name)) continue;
+		const fullPath = join(dir, entry.name);
+		if (entry.isDirectory()) files.push(...await collectFiles(fullPath));
+		else files.push(fullPath);
+	}
+	return files;
+}
+async function install(options) {
+	const { platform, selectedGroups, backup, dryRun } = options;
+	const home = homedir();
+	const platformDir = join(DOTFILES_DIR, platform);
+	const result = {
+		installed: [],
+		backedUp: [],
+		errors: [],
+		installedGroups: []
+	};
+	const dateStamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+	for (const group of selectedGroups) {
+		const sources = Array.isArray(group.source) ? group.source : [group.source];
+		const isMultiSource = Array.isArray(group.source);
+		const installedFiles = [];
+		let groupBackupDir = null;
+		if (backup) {
+			const baseName = `${isMultiSource ? group.name.toLowerCase().replace(/\s+/g, "-") : basename(sources[0])}-backup-${dateStamp}`;
+			const groupDir = join(home, BACKUP_DIR, group.name);
+			let backupName = baseName;
+			let counter = 2;
+			while (await pathExists$2(join(groupDir, backupName))) {
+				backupName = `${baseName}-${counter}`;
+				counter++;
+			}
+			groupBackupDir = join(groupDir, backupName);
+		}
+		for (const source of sources) {
+			const sourcePath = join(platformDir, source);
+			if (!await pathExists$2(sourcePath)) {
+				result.errors.push({
+					file: source,
+					error: "Source not found"
+				});
+				continue;
+			}
+			const targetPath = isMultiSource ? join(group.target, basename(source)) : group.target;
+			if (backup && groupBackupDir && await pathExists$2(targetPath)) {
+				const backupTarget = group.extraBackupPaths && group.extraBackupPaths.length > 0 ? join(groupBackupDir, "config") : join(groupBackupDir, basename(source));
+				if (!dryRun) try {
+					await ensureDir$1(groupBackupDir);
+					await copy$1(targetPath, backupTarget, { filter: copyFilter });
+					result.backedUp.push(group.name);
+				} catch (err) {
+					result.errors.push({
+						file: `backup:${group.name}`,
+						error: err instanceof Error ? err.message : String(err)
+					});
+				}
+				else result.backedUp.push(group.name);
+			}
+			if (!dryRun) try {
+				const sourceIsDir = (await stat(sourcePath)).isDirectory();
+				if (sourceIsDir) await ensureDir$1(targetPath);
+				else await ensureDir$1(join(targetPath, ".."));
+				if (await pathExists$2(targetPath)) {
+					if (sourceIsDir !== (await stat(targetPath)).isDirectory()) await remove(targetPath);
+				}
+				await copy$1(sourcePath, targetPath, {
+					filter: copyFilter,
+					overwrite: true
+				});
+				if ((await stat(sourcePath)).isDirectory()) {
+					const sourceFiles = await collectFiles(sourcePath);
+					for (const f of sourceFiles) installedFiles.push(join(targetPath, relative(sourcePath, f)));
+				} else installedFiles.push(targetPath);
+			} catch (err) {
+				result.errors.push({
+					file: source,
+					error: err instanceof Error ? err.message : String(err)
+				});
+			}
+			else installedFiles.push(`${sourcePath} → ${targetPath}`);
+		}
+		if (backup && groupBackupDir && group.extraBackupPaths) {
+			for (const extra of group.extraBackupPaths) if (await pathExists$2(extra.path)) {
+				const extraTarget = join(groupBackupDir, extra.label);
+				if (!dryRun) try {
+					await ensureDir$1(extraTarget);
+					await copy$1(extra.path, extraTarget, { filter: copyFilter });
+				} catch (err) {
+					result.errors.push({
+						file: `backup:${group.name}/${extra.label}`,
+						error: err instanceof Error ? err.message : String(err)
+					});
+				}
+			}
+		}
+		result.installed.push(...installedFiles);
+		result.installedGroups.push({
+			name: group.name,
+			files: installedFiles,
+			target: group.target,
+			extraBackupPaths: group.extraBackupPaths
+		});
+	}
+	return result;
+}
+function getManifestPath() {
+	return join(homedir(), MANIFEST_DIR, MANIFEST_FILENAME);
+}
+async function readManifest() {
+	const manifestPath = getManifestPath();
+	if (await pathExists$2(manifestPath)) try {
+		return await readJson(manifestPath);
+	} catch {
+		return null;
+	}
+	return null;
+}
+async function createManifest(result, options) {
+	const manifest = {
+		version: VERSION,
+		installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		platform: options.platform,
+		theme: options.theme,
+		groups: result.installedGroups
+	};
+	const manifestPath = getManifestPath();
+	await ensureDir$1(join(manifestPath, ".."));
+	await writeJson(manifestPath, manifest, { spaces: 2 });
+}
+async function updateManifest(updates) {
+	const manifest = await readManifest();
+	if (!manifest) return;
+	const updated = {
+		...manifest,
+		...updates
+	};
+	await writeJson(getManifestPath(), updated, { spaces: 2 });
+}
+async function deleteManifest() {
+	const manifestPath = getManifestPath();
+	if (await pathExists$2(manifestPath)) await remove(manifestPath);
+}
+async function uninstallGroups(groups) {
+	const errors = [];
+	for (const group of groups) for (const file of group.files) try {
+		if (await pathExists$2(file)) await remove(file);
+	} catch (err) {
+		errors.push(`${file}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	return errors;
+}
+/** Scan ~/.config/heyitsiveen/dotfiles/backup/ and return all backups grouped by tool */
+async function findAllBackups() {
+	const backupRoot = join(homedir(), BACKUP_DIR);
+	const result = /* @__PURE__ */ new Map();
+	if (!await pathExists$2(backupRoot)) return result;
+	const groups = await readdir(backupRoot, { withFileTypes: true });
+	for (const group of groups) {
+		if (!group.isDirectory()) continue;
+		const groupPath = join(backupRoot, group.name);
+		const entries = (await readdir(groupPath, { withFileTypes: true })).filter((b) => b.isDirectory() && b.name.includes("-backup-")).map((b) => ({
+			group: group.name,
+			name: b.name,
+			path: join(groupPath, b.name)
+		})).sort((a, b) => b.name.localeCompare(a.name));
+		if (entries.length > 0) result.set(group.name, entries);
+	}
+	return result;
+}
+//#endregion
+//#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 terminal greeting",
+			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 terminal greeting",
+			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"
+};
+async function switchTheme(theme, installedGroups, platform, dryRun) {
+	const results = [];
+	for (const group of installedGroups) try {
+		switch (group.name) {
+			case "Ghostty":
+				if (!dryRun) await switchGhosttyTheme(group.target, theme);
+				results.push(`Ghostty → ${ghosttyThemes[theme]}`);
+				break;
+			case "bat":
+				if (!dryRun) await switchBatTheme(group.target, theme);
+				results.push(`bat → ${batThemes[theme]}`);
+				break;
+			case "btop":
+				if (!dryRun) await switchSingleLine(join(group.target, "btop.conf"), /^color_theme = .*$/m, `color_theme = "${btopThemes[theme]}"`);
+				results.push(`btop → ${btopThemes[theme]}`);
+				break;
+			case "WezTerm":
+				if (!dryRun) await switchSingleLine(join(group.target, "wezterm.lua"), /^config\.color_scheme = .*$/m, `config.color_scheme = '${weztermThemes[theme]}'`);
+				results.push(`WezTerm → ${weztermThemes[theme]}`);
+				break;
+			case "Neovim":
+				if (!dryRun) await switchNeovimTheme(group.target, theme);
+				results.push(`Neovim → ${nvimPlugins[theme]}`);
+				break;
+			case "Fish Shell":
+				if (!dryRun) {
+					await switchTideTheme(group.target, theme);
+					await switchFzfTheme(join(group.target, "conf.d", "40-fzf.fish"), theme, /^set -gx FZF_DEFAULT_OPTS/);
+				}
+				results.push(`Fish/Tide palette → ${tidePalettes[theme]}`);
+				results.push(`FZF → ${theme}`);
+				break;
+			case "tmux":
+				if (!dryRun) await switchTmuxTheme(group.target, theme);
+				results.push(`tmux statusbar → ${theme}`);
+				break;
+			case "PowerShell":
+				if (!dryRun) await switchFzfTheme(join(group.target, "modules", "fzf.ps1"), theme, /^\$env:FZF_DEFAULT_OPTS/);
+				results.push(`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;
+	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");
+}
+async function switchSingleLine(filePath, pattern, replacement) {
+	if (!await pathExists$1(filePath)) return;
+	await writeFile(filePath, (await readFile(filePath, "utf-8")).replace(pattern, replacement), "utf-8");
+}
+async function switchBatTheme(targetDir, theme) {
+	const filePath = join(targetDir, "config");
+	if (!await pathExists$1(filePath)) return;
+	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");
+}
+async function switchNeovimTheme(targetDir, theme) {
+	const filePath = join(targetDir, "lua", "plugins", "colorscheme.lua");
+	if (!await pathExists$1(filePath)) return;
+	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");
+}
+async function switchTideTheme(targetDir, theme) {
+	const filePath = join(targetDir, "conf.d", "70-tide.fish");
+	if (!await pathExists$1(filePath)) return;
+	await writeFile(filePath, (await readFile(filePath, "utf-8")).replace(/^(set -l tide_default_palette )\S+$/m, `$1${tidePalettes[theme]}`), "utf-8");
+}
+async function switchOmpTheme(theme) {
+	const themeDir = join(homedir(), ".config", "dotfiles");
+	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;
+	await writeFile(filePath, toggleThemeBlocks(await readFile(filePath, "utf-8"), theme, commandStart), "utf-8");
+}
+async function switchTmuxTheme(targetDir, theme) {
+	const filePath = join(targetDir, "statusbar.conf");
+	if (!await pathExists$1(filePath)) return;
+	await writeFile(filePath, toggleThemeBlocks(await readFile(filePath, "utf-8"), theme, /^(set|setw) -g /), "utf-8");
+}
+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)}`);
+	}
+}
+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);
+		if (!subTools.has(dep.forGroup)) subTools.set(dep.forGroup, []);
+		subTools.get(dep.forGroup).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) {
+		const selectedNames = await multiselect({
+			message: "Install missing tools?",
+			options: missing.map((t) => ({
+				value: t.name,
+				label: `${t.name} — ${t.description}`,
+				hint: t.installCmd
+			})),
+			initialValues: missing.map((t) => t.name),
+			required: false
+		});
+		handleCancel(selectedNames);
+		const toInstall = missing.filter((t) => selectedNames.includes(t.name));
+		if (toInstall.length > 0) {
+			const brewFirst = toInstall.filter((t) => t.name === "Homebrew");
+			const rest = toInstall.filter((t) => t.name !== "Homebrew");
+			const ordered = [...brewFirst, ...rest];
+			const total = ordered.length;
+			let installed = 0;
+			for (const t of ordered) {
+				log.message(`  ${pc.dim("○")} Installing ${t.name}...`);
+				try {
+					execSync(t.installCmd, {
+						stdio: "pipe",
+						encoding: "utf-8",
+						timeout: 3e5
+					});
+					installed++;
+					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("");
+			if (installed === total) log.message(`  ${pc.green("◆")} ${installed} tool${installed > 1 ? "s" : ""} installed successfully`);
+			else log.message(`  ${pc.yellow("⚠")} ${installed}/${total} tools installed (${total - installed} failed)`);
+		}
+	} else log.success("All tools installed!");
+}
+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.message(pc.bold("\n  Reload your configs:"));
+		for (const r of reloads) log.message(`    ${r.name.padEnd(12)} →  ${pc.cyan(r.cmd)}`);
+	}
+}
+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 firstRunFlow(flagPlatform, dryRun = false) {
+	showBanner();
+	intro(pc.bold("heyitsiveen"));
+	const platform = await resolvePlatform(flagPlatform);
+	showPrerequisites(platform);
+	const allGroups = getDotfileGroups(platform);
+	await showToolStatus(allGroups, platform);
+	showOverview(allGroups);
+	const depTools = getDependencyTools(platform);
+	const selectedNames = await multiselect({
+		message: "Which dotfiles would you like to install?",
+		options: 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 suffix = warnings.length > 0 ? pc.yellow(` ⚠ (${warnings.join(", ")})`) : "";
+			return {
+				value: g.name,
+				label: `${g.name} — ${g.description}${suffix}`
+			};
+		}),
+		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:"));
+	const s = spinner();
+	s.start("Installing dotfiles...");
+	const result = await install({
+		platform,
+		selectedGroups,
+		theme,
+		backup: shouldBackup,
+		dryRun
+	});
+	const themeGroups = selectedGroups.filter((g) => g.themeSupport);
+	if (themeGroups.length > 0) await switchTheme(theme, result.installedGroups.filter((ig) => themeGroups.some((sg) => sg.name === ig.name)), platform, dryRun);
+	if (!dryRun) await createManifest(result, {
+		platform,
+		selectedGroups,
+		theme,
+		backup: shouldBackup,
+		dryRun
+	});
+	s.stop("Installation complete!");
+	if (result.backedUp.length > 0) {
+		const unique = [...new Set(result.backedUp)];
+		log.message(`  ${pc.green("◆")} Backed up ${unique.length} existing configs → ${pc.dim("~/.config/heyitsiveen/dotfiles/backup/")}`);
+	}
+	for (const [category, names] of Object.entries(groupCategories)) {
+		const installed = result.installedGroups.filter((ig) => names.includes(ig.name));
+		if (installed.length === 0) continue;
+		log.message(`  ${pc.bold(category)}`);
+		for (const ig of installed) log.message(`    ${pc.green("◆")} ${ig.name} → ${pc.dim(ig.target)}`);
+	}
+	log.message(`  ${pc.green("◆")} Theme: ${theme} activated`);
+	if (result.errors.length > 0) for (const err of result.errors) log.message(`    ${pc.yellow("⚠")} ${err.file}: ${pc.dim(err.error)}`);
+	showReloadCommands(selectedGroups);
+	log.message("");
+	log.info(pc.bold("Restart your terminal for all changes to take effect."));
+	outro("Done! Your dotfiles are installed.");
+}
+async function reRunFlow(manifest, flagPlatform, dryRun = false) {
+	showBanner();
+	intro(pc.bold("heyitsiveen"));
+	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} — ${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 (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...");
+	for (const backup of toRestore) {
+		const matchingGroup = manifest?.groups.find((g) => g.name === backup.group);
+		if (matchingGroup) 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) {
+			log.warn(`Failed to restore ${backup.group}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		else log.warn(`Skipped ${backup.group} — no matching installation record`);
+	}
+	s.stop("Restore complete!");
+	outro("Dotfiles restored from backup.");
+}
+//#endregion
+//#region src/update-check.ts
+async function checkForUpdate() {
+	try {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), 3e3);
+		const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, { signal: controller.signal });
+		clearTimeout(timeout);
+		if (!res.ok) return null;
+		const data = await res.json();
+		return data.version !== VERSION ? data.version : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/index.ts
+runMain(defineCommand({
+	meta: {
+		name: PACKAGE_NAME,
+		version: VERSION,
+		description: "Interactive CLI to set up dotfiles for macOS and Windows 11"
+	},
+	args: {
+		platform: {
+			type: "string",
+			description: "Skip OS detection: macos or windows"
+		},
+		"dry-run": {
+			type: "boolean",
+			description: "Show planned operations without writing files",
+			default: false
+		},
+		restore: {
+			type: "boolean",
+			description: "Restore from backup (bypasses mode menu)",
+			default: false
+		},
+		uninstall: {
+			type: "boolean",
+			description: "Remove installed dotfiles (bypasses mode menu)",
+			default: false
+		},
+		theme: {
+			type: "string",
+			description: "Switch theme in-place: solarized-dark, vercel, vesper"
+		}
+	},
+	async run({ args }) {
+		const updatePromise = checkForUpdate();
+		try {
+			const dryRun = args["dry-run"];
+			const manifest = await readManifest();
+			if (args.restore) {
+				await restoreFlow(dryRun);
+				return;
+			}
+			if (args.uninstall) {
+				if (!manifest) {
+					log.error("No installation found. Run `npx @heyitsiveen/dotfiles` to install.");
+					process.exit(1);
+				}
+				await uninstallFlow(manifest, dryRun);
+				return;
+			}
+			if (args.theme) {
+				if (!THEMES.includes(args.theme)) {
+					log.error(`Invalid theme "${args.theme}".`);
+					const label = "─ Available themes: ";
+					const longest = Math.max(...THEMES.map((t) => `  ◆ ${t}`.length));
+					const w = Math.max(20, longest) + 2;
+					const box = [
+						"",
+						`  ${pc.dim("╭" + label + "─".repeat(w - 20) + "╮")}`,
+						...THEMES.map((t) => `  ${pc.dim("│")}  ${pc.green("◆")} ${t.padEnd(w - 4)}${pc.dim("│")}`),
+						`  ${pc.dim("╰" + "─".repeat(w) + "╯")}`
+					];
+					console.log(box.join("\n"));
+					process.exit(1);
+				}
+				if (!manifest) {
+					log.error("No installation found. Install dotfiles first, then switch theme.");
+					process.exit(1);
+				}
+				await themeFlow(manifest, dryRun, args.theme);
+				return;
+			}
+			if (manifest) await reRunFlow(manifest, args.platform, dryRun);
+			else await firstRunFlow(args.platform, dryRun);
+			const latest = await updatePromise;
+			if (latest) {
+				const msg = `Update available: ${VERSION} → ${latest}`;
+				const cmd = "Run: bunx @heyitsiveen/dotfiles@latest";
+				const w = Math.max(msg.length, 38) + 4;
+				console.log([
+					"",
+					`  ${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"));
+			}
+		} catch (err) {
+			if (err.code === "ERR_USE_AFTER_CLOSE") process.exit(0);
+			log.error(pc.red(err instanceof Error ? err.message : "An unexpected error occurred."));
+			process.exit(1);
+		}
+	}
+}));
+//#endregion
+export {};