dotswitch 1.0.0

package/dist/cli.js

@@ -0,0 +1,586 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command } from "commander";
+import fs from "node:fs";
+import path from "node:path";
+import pc from "picocolors";
+import select from "@inquirer/select";
+
+//#region src/lib/constants.ts
+const ENV_LOCAL = ".env.local";
+const TRACKER_PREFIX = "# dotswitch:";
+const EXCLUDED_ENV_FILES = new Set([
+	".env",
+	".env.local",
+	".env.local.backup",
+	".env.example"
+]);
+
+//#endregion
+//#region src/lib/tracker.ts
+function createTrackerHeader(env) {
+	return `${TRACKER_PREFIX}${env}`;
+}
+function parseTrackerHeader(content) {
+	const firstLine = content.split("\n")[0];
+	if (firstLine?.startsWith(TRACKER_PREFIX)) return firstLine.slice(TRACKER_PREFIX.length).trim();
+	return null;
+}
+function addTrackerHeader(content, env) {
+	const header = createTrackerHeader(env);
+	if (parseTrackerHeader(content) !== null) {
+		const lines = content.split("\n");
+		lines[0] = header;
+		return lines.join("\n");
+	}
+	return `${header}\n${content}`;
+}
+function removeTrackerHeader(content) {
+	if (parseTrackerHeader(content) !== null) {
+		const lines = content.split("\n");
+		lines.shift();
+		return lines.join("\n");
+	}
+	return content;
+}
+
+//#endregion
+//#region src/lib/logger.ts
+const logger = {
+	success(message) {
+		console.log(pc.green(`✓ ${message}`));
+	},
+	info(message) {
+		console.log(pc.cyan(message));
+	},
+	warn(message) {
+		console.log(pc.yellow(`⚠ ${message}`));
+	},
+	error(message) {
+		console.error(pc.red(`✗ ${message}`));
+	}
+};
+
+//#endregion
+//#region src/lib/config.ts
+const CONFIG_FILENAME = ".dotswitchrc.json";
+const DEFAULT_CONFIG = {
+	target: ".env.local",
+	exclude: [],
+	hooks: {}
+};
+function loadConfig(dir, fsModule = fs) {
+	const configPath = path.join(dir, CONFIG_FILENAME);
+	try {
+		if (fsModule.existsSync(configPath)) {
+			const raw = JSON.parse(fsModule.readFileSync(configPath, "utf-8"));
+			return {
+				target: raw.target ?? DEFAULT_CONFIG.target,
+				exclude: raw.exclude ?? DEFAULT_CONFIG.exclude,
+				hooks: raw.hooks ?? DEFAULT_CONFIG.hooks
+			};
+		}
+	} catch {}
+	return { ...DEFAULT_CONFIG };
+}
+function getTargetFile(config) {
+	return config.target;
+}
+function getBackupFile(config) {
+	return `${config.target}.backup`;
+}
+
+//#endregion
+//#region src/lib/env.ts
+function resolveConfig(dir, config, fsModule) {
+	return config ?? loadConfig(dir, fsModule);
+}
+function listEnvFiles(dir, fsModule = fs, config) {
+	const cfg = resolveConfig(dir, config, fsModule);
+	const entries = fsModule.readdirSync(dir);
+	const activeEnv = getActiveEnv(dir, fsModule, cfg);
+	const target = getTargetFile(cfg);
+	const backup = getBackupFile(cfg);
+	const excluded = new Set([
+		...EXCLUDED_ENV_FILES,
+		...cfg.exclude,
+		target,
+		backup
+	]);
+	return entries.filter((name) => name.startsWith(".env.") && !excluded.has(name)).sort().map((name) => {
+		const env = name.replace(/^\.env\./, "");
+		return {
+			name,
+			env,
+			path: path.join(dir, name),
+			active: env === activeEnv
+		};
+	});
+}
+function getActiveEnv(dir, fsModule = fs, config) {
+	const cfg = resolveConfig(dir, config, fsModule);
+	const targetPath = path.join(dir, getTargetFile(cfg));
+	try {
+		return parseTrackerHeader(fsModule.readFileSync(targetPath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function backupEnvLocal(dir, fsModule = fs, config) {
+	const cfg = resolveConfig(dir, config, fsModule);
+	const target = getTargetFile(cfg);
+	const targetPath = path.join(dir, target);
+	const backupPath = path.join(dir, getBackupFile(cfg));
+	try {
+		if (fsModule.existsSync(targetPath)) {
+			fsModule.copyFileSync(targetPath, backupPath);
+			return true;
+		}
+		return false;
+	} catch (error) {
+		logger.warn(`Failed to back up ${target}: ${error instanceof Error ? error.message : String(error)}`);
+		return false;
+	}
+}
+function restoreEnvLocal(dir, fsModule = fs, config) {
+	const cfg = resolveConfig(dir, config, fsModule);
+	const target = getTargetFile(cfg);
+	const backup = getBackupFile(cfg);
+	const backupPath = path.join(dir, backup);
+	const targetPath = path.join(dir, target);
+	if (!fsModule.existsSync(backupPath)) throw new Error(`No backup file found (${backup})`);
+	fsModule.copyFileSync(backupPath, targetPath);
+}
+function switchEnv(dir, env, options = { backup: true }, fsModule = fs, config) {
+	const cfg = resolveConfig(dir, config, fsModule);
+	const sourcePath = path.join(dir, `.env.${env}`);
+	const targetPath = path.join(dir, getTargetFile(cfg));
+	if (!fsModule.existsSync(sourcePath)) throw new Error(`Environment file .env.${env} does not exist`);
+	if (options.backup) backupEnvLocal(dir, fsModule, cfg);
+	const tracked = addTrackerHeader(fsModule.readFileSync(sourcePath, "utf-8"), env);
+	fsModule.writeFileSync(targetPath, tracked, "utf-8");
+}
+
+//#endregion
+//#region src/lib/paths.ts
+/**
+* Resolve a path pattern that may contain a simple glob (* wildcard).
+* Returns an array of matching directories.
+* Non-glob paths return a single-element array.
+*/
+function resolvePaths(pattern) {
+	if (!pattern.includes("*")) return [path.resolve(pattern)];
+	const parts = pattern.split("*");
+	if (parts.length !== 2) return [path.resolve(pattern)];
+	const baseDir = path.resolve(parts[0]);
+	const suffix = parts[1];
+	if (!fs.existsSync(baseDir)) return [];
+	return fs.readdirSync(baseDir).map((entry) => path.join(baseDir, entry) + suffix).filter((p) => {
+		try {
+			return fs.statSync(p).isDirectory();
+		} catch {
+			return false;
+		}
+	}).sort();
+}
+
+//#endregion
+//#region src/lib/prompt.ts
+async function promptEnvSelection(envFiles) {
+	return await select({
+		message: "Select an environment:",
+		choices: envFiles.map((file) => ({
+			name: file.active ? `${file.env} (active)` : file.env,
+			value: file.env
+		}))
+	});
+}
+
+//#endregion
+//#region src/commands/use.ts
+async function useSinglePath(env, options, dir, showPrefix) {
+	const prefix = showPrefix ? `[${dir}] ` : "";
+	const files = listEnvFiles(dir);
+	if (files.length === 0) {
+		logger.error(`${prefix}No .env.* files found`);
+		process.exitCode = 1;
+		return;
+	}
+	if (!env) {
+		if (!process.stdin.isTTY) {
+			logger.error(`${prefix}No environment specified. Usage: dotswitch use <env>`);
+			process.exitCode = 1;
+			return;
+		}
+		env = await promptEnvSelection(files);
+	}
+	if (!files.find((f) => f.env === env)) {
+		logger.error(`${prefix}Environment "${env}" not found. Available: ${files.map((f) => f.env).join(", ")}`);
+		process.exitCode = 1;
+		return;
+	}
+	if (getActiveEnv(dir) === env && !options.force) {
+		logger.info(`${prefix}Already using "${env}"`);
+		return;
+	}
+	if (options.dryRun) {
+		logger.info(`${prefix}Would switch to ${env}`);
+		if (options.backup) logger.info(`${prefix}Would back up .env.local to .env.local.backup`);
+		return;
+	}
+	try {
+		switchEnv(dir, env, { backup: options.backup });
+		logger.success(`${prefix}Switched to ${env}`);
+	} catch (error) {
+		logger.error(`${prefix}${error instanceof Error ? error.message : "Failed to switch environment"}`);
+		process.exitCode = 1;
+	}
+}
+async function useCommand(env, options) {
+	const dirs = resolvePaths(options.path);
+	if (dirs.length === 0) {
+		logger.error("No directories match the given path pattern");
+		process.exitCode = 1;
+		return;
+	}
+	const showPrefix = dirs.length > 1;
+	for (const dir of dirs) await useSinglePath(env, options, dir, showPrefix);
+}
+
+//#endregion
+//#region src/commands/ls.ts
+function lsCommand(options) {
+	const files = listEnvFiles(options.path);
+	if (options.json) {
+		const output = files.map(({ name, env, active }) => ({
+			name,
+			env,
+			active
+		}));
+		console.log(JSON.stringify(output));
+		if (files.length === 0) process.exitCode = 1;
+		return;
+	}
+	if (files.length === 0) {
+		logger.warn("No .env.* files found");
+		process.exitCode = 1;
+		return;
+	}
+	console.log(pc.bold("Available environments:\n"));
+	for (const file of files) {
+		const marker = file.active ? pc.green("▸ ") : "  ";
+		const name = file.active ? pc.green(pc.bold(file.env)) : file.env;
+		const label = file.active ? ` ${pc.dim("(active)")}` : "";
+		console.log(`${marker}${name}${label}`);
+	}
+}
+
+//#endregion
+//#region src/commands/current.ts
+function currentCommand(options) {
+	const activeEnv = getActiveEnv(options.path);
+	if (options.json) {
+		console.log(JSON.stringify({ active: activeEnv ?? null }));
+		if (!activeEnv) process.exitCode = 1;
+		return;
+	}
+	const isTTY = process.stdout.isTTY;
+	if (activeEnv) if (isTTY) logger.info(`Active environment: ${activeEnv}`);
+	else console.log(activeEnv);
+	else {
+		if (isTTY) logger.warn("No active environment detected");
+		process.exitCode = 1;
+	}
+}
+
+//#endregion
+//#region src/commands/restore.ts
+function restoreCommand(options) {
+	try {
+		restoreEnvLocal(options.path);
+		const activeEnv = getActiveEnv(options.path);
+		if (activeEnv) logger.success(`Restored .env.local from backup (now: ${activeEnv})`);
+		else logger.success("Restored .env.local from backup");
+	} catch (error) {
+		logger.error(error instanceof Error ? error.message : "Failed to restore backup");
+		process.exitCode = 1;
+	}
+}
+
+//#endregion
+//#region src/lib/parser.ts
+/**
+* Parse a .env file into a key-value map.
+* Strips comments (lines starting with #) and empty lines.
+*/
+function parseEnvContent(content) {
+	const result = /* @__PURE__ */ new Map();
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const eqIndex = trimmed.indexOf("=");
+		if (eqIndex === -1) continue;
+		const key = trimmed.slice(0, eqIndex).trim();
+		const value = trimmed.slice(eqIndex + 1).trim();
+		if (key) result.set(key, value);
+	}
+	return result;
+}
+/**
+* Compute the diff between two parsed env maps.
+* "added" = keys in `to` but not in `from`.
+* "removed" = keys in `from` but not in `to`.
+* "changed" = keys in both with different values.
+*/
+function diffEnvMaps(from, to) {
+	const added = [];
+	const removed = [];
+	const changed = [];
+	const unchanged = [];
+	for (const key of from.keys()) if (!to.has(key)) removed.push(key);
+	else if (from.get(key) !== to.get(key)) changed.push(key);
+	else unchanged.push(key);
+	for (const key of to.keys()) if (!from.has(key)) added.push(key);
+	return {
+		added: added.sort(),
+		removed: removed.sort(),
+		changed: changed.sort(),
+		unchanged: unchanged.sort()
+	};
+}
+
+//#endregion
+//#region src/commands/diff.ts
+function readEnvFile(dir, name) {
+	const filePath = name === ".env.local" ? path.join(dir, ENV_LOCAL) : path.join(dir, `.env.${name}`);
+	if (!fs.existsSync(filePath)) {
+		const literal = path.join(dir, name);
+		if (fs.existsSync(literal)) return removeTrackerHeader(fs.readFileSync(literal, "utf-8"));
+		throw new Error(`File not found: ${name}`);
+	}
+	return removeTrackerHeader(fs.readFileSync(filePath, "utf-8"));
+}
+function diffCommand(env1, env2, options) {
+	try {
+		const fromName = env2 ? env1 : ".env.local";
+		const toName = env2 ?? env1;
+		const fromContent = readEnvFile(options.path, fromName);
+		const toContent = readEnvFile(options.path, toName);
+		const fromMap = parseEnvContent(fromContent);
+		const toMap = parseEnvContent(toContent);
+		const diff = diffEnvMaps(fromMap, toMap);
+		if (options.json) {
+			const output = {
+				from: fromName,
+				to: toName,
+				added: diff.added,
+				removed: diff.removed,
+				changed: diff.changed
+			};
+			if (options.showValues) output.details = {
+				added: Object.fromEntries(diff.added.map((k) => [k, toMap.get(k)])),
+				removed: Object.fromEntries(diff.removed.map((k) => [k, fromMap.get(k)])),
+				changed: Object.fromEntries(diff.changed.map((k) => [k, {
+					from: fromMap.get(k),
+					to: toMap.get(k)
+				}]))
+			};
+			console.log(JSON.stringify(output));
+			return;
+		}
+		if (!(diff.added.length > 0 || diff.removed.length > 0 || diff.changed.length > 0)) {
+			logger.success(`${fromName} and ${toName} are identical`);
+			return;
+		}
+		console.log(pc.bold(`\nComparing ${fromName} → ${toName}\n`));
+		if (diff.added.length > 0) {
+			console.log(pc.green(`Added (${diff.added.length}):`));
+			for (const key of diff.added) {
+				const val = options.showValues ? ` = ${toMap.get(key)}` : "";
+				console.log(pc.green(`  + ${key}${val}`));
+			}
+			console.log();
+		}
+		if (diff.removed.length > 0) {
+			console.log(pc.red(`Removed (${diff.removed.length}):`));
+			for (const key of diff.removed) {
+				const val = options.showValues ? ` = ${fromMap.get(key)}` : "";
+				console.log(pc.red(`  - ${key}${val}`));
+			}
+			console.log();
+		}
+		if (diff.changed.length > 0) {
+			console.log(pc.yellow(`Changed (${diff.changed.length}):`));
+			for (const key of diff.changed) if (options.showValues) console.log(pc.yellow(`  ~ ${key}: ${fromMap.get(key)} → ${toMap.get(key)}`));
+			else console.log(pc.yellow(`  ~ ${key}`));
+			console.log();
+		}
+	} catch (error) {
+		logger.error(error instanceof Error ? error.message : "Failed to diff environments");
+		process.exitCode = 1;
+	}
+}
+
+//#endregion
+//#region src/lib/hooks.ts
+const HOOK_FILENAME = "post-checkout";
+const HOOK_MARKER_START = "# >>> dotswitch hook >>>";
+const HOOK_MARKER_END = "# <<< dotswitch hook <<<";
+function getHookScript() {
+	return `${HOOK_MARKER_START}
+# Auto-switch .env files based on branch name
+BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null)
+if [ -n "$BRANCH" ] && command -v dotswitch >/dev/null 2>&1; then
+  dotswitch use --hook-branch "$BRANCH" 2>/dev/null || true
+fi
+${HOOK_MARKER_END}`;
+}
+function getHooksDir(dir) {
+	const gitDir = path.join(dir, ".git");
+	if (!fs.existsSync(gitDir)) return null;
+	return path.join(gitDir, "hooks");
+}
+function installHook(dir) {
+	const hooksDir = getHooksDir(dir);
+	if (!hooksDir) throw new Error("Not a git repository");
+	if (!fs.existsSync(hooksDir)) fs.mkdirSync(hooksDir, { recursive: true });
+	const hookPath = path.join(hooksDir, HOOK_FILENAME);
+	const hookScript = getHookScript();
+	if (fs.existsSync(hookPath)) {
+		const existing = fs.readFileSync(hookPath, "utf-8");
+		if (existing.includes(HOOK_MARKER_START)) {
+			const before = existing.slice(0, existing.indexOf(HOOK_MARKER_START));
+			const after = existing.slice(existing.indexOf(HOOK_MARKER_END) + 24);
+			fs.writeFileSync(hookPath, before + hookScript + after, { mode: 493 });
+			return {
+				created: false,
+				path: hookPath
+			};
+		}
+		fs.appendFileSync(hookPath, `\n${hookScript}\n`);
+		fs.chmodSync(hookPath, 493);
+		return {
+			created: false,
+			path: hookPath
+		};
+	}
+	fs.writeFileSync(hookPath, `#!/bin/sh\n${hookScript}\n`, { mode: 493 });
+	return {
+		created: true,
+		path: hookPath
+	};
+}
+function removeHook(dir) {
+	const hooksDir = getHooksDir(dir);
+	if (!hooksDir) throw new Error("Not a git repository");
+	const hookPath = path.join(hooksDir, HOOK_FILENAME);
+	if (!fs.existsSync(hookPath)) return false;
+	const content = fs.readFileSync(hookPath, "utf-8");
+	if (!content.includes(HOOK_MARKER_START)) return false;
+	const remaining = (content.slice(0, content.indexOf(HOOK_MARKER_START)) + content.slice(content.indexOf(HOOK_MARKER_END) + 24)).trim();
+	if (!remaining || remaining === "#!/bin/sh") fs.unlinkSync(hookPath);
+	else fs.writeFileSync(hookPath, remaining + "\n", { mode: 493 });
+	return true;
+}
+/**
+* Match a branch name against hook patterns from config.
+* Supports simple glob patterns: "staging/*" matches "staging/feat-x".
+*/
+function matchBranchToEnv(branch, hooks) {
+	if (hooks[branch]) return hooks[branch];
+	for (const [pattern, env] of Object.entries(hooks)) if (pattern.endsWith("/*")) {
+		const prefix = pattern.slice(0, -2);
+		if (branch.startsWith(`${prefix}/`)) return env;
+	} else if (pattern.endsWith("*")) {
+		const prefix = pattern.slice(0, -1);
+		if (branch.startsWith(prefix)) return env;
+	}
+	return null;
+}
+
+//#endregion
+//#region src/commands/hook.ts
+function hookInstallCommand(options) {
+	try {
+		const config = loadConfig(options.path);
+		if (Object.keys(config.hooks).length === 0) {
+			logger.warn("No hook mappings defined. Add \"hooks\" to .dotswitchrc.json first.");
+			logger.info("Example: { \"hooks\": { \"staging/*\": \"staging\" } }");
+			process.exitCode = 1;
+			return;
+		}
+		if (installHook(options.path).created) logger.success("Installed post-checkout hook");
+		else logger.success("Updated post-checkout hook");
+	} catch (error) {
+		logger.error(error instanceof Error ? error.message : "Failed to install hook");
+		process.exitCode = 1;
+	}
+}
+function hookRemoveCommand(options) {
+	try {
+		if (removeHook(options.path)) logger.success("Removed dotswitch post-checkout hook");
+		else logger.info("No dotswitch hook found");
+	} catch (error) {
+		logger.error(error instanceof Error ? error.message : "Failed to remove hook");
+		process.exitCode = 1;
+	}
+}
+function hookBranchCommand(branch, options) {
+	const env = matchBranchToEnv(branch, loadConfig(options.path).hooks);
+	if (!env) return;
+	try {
+		switchEnv(options.path, env, { backup: true });
+		logger.success(`Auto-switched to ${env} (branch: ${branch})`);
+	} catch {}
+}
+
+//#endregion
+//#region src/cli.ts
+const pkg = createRequire(import.meta.url)("../package.json");
+const program = new Command();
+program.name("dotswitch").description("Quickly switch between .env files").version(pkg.version);
+program.command("use [env]").description("Switch to a .env.<env> file (interactive if no env given)").option("-f, --force", "skip confirmation if already active", false).option("--no-backup", "skip .env.local backup").option("-n, --dry-run", "show what would happen without making changes", false).option("-p, --path <dir>", "project directory", process.cwd()).option("--hook-branch <branch>", "internal: auto-switch by branch name").action(async (env, opts) => {
+	if (opts.hookBranch) {
+		hookBranchCommand(opts.hookBranch, { path: opts.path });
+		return;
+	}
+	await useCommand(env, {
+		force: opts.force,
+		backup: opts.backup,
+		dryRun: opts.dryRun,
+		path: opts.path
+	});
+});
+program.command("ls").description("List available .env.* files").option("-p, --path <dir>", "project directory", process.cwd()).option("--json", "output as JSON", false).action((opts) => {
+	lsCommand({
+		path: opts.path,
+		json: opts.json
+	});
+});
+program.command("current").description("Show the currently active environment").option("-p, --path <dir>", "project directory", process.cwd()).option("--json", "output as JSON", false).action((opts) => {
+	currentCommand({
+		path: opts.path,
+		json: opts.json
+	});
+});
+program.command("restore").description("Restore .env.local from the backup file").option("-p, --path <dir>", "project directory", process.cwd()).action((opts) => {
+	restoreCommand({ path: opts.path });
+});
+program.command("diff <env1> [env2]").description("Compare keys between two env files (defaults: .env.local vs env1)").option("-p, --path <dir>", "project directory", process.cwd()).option("--show-values", "show actual values in the diff", false).option("--json", "output as JSON", false).action((env1, env2, opts) => {
+	diffCommand(env1, env2, {
+		path: opts.path,
+		showValues: opts.showValues,
+		json: opts.json
+	});
+});
+const hookCmd = program.command("hook").description("Manage git post-checkout hook for auto-switching");
+hookCmd.command("install").description("Install the post-checkout git hook").option("-p, --path <dir>", "project directory", process.cwd()).action((opts) => {
+	hookInstallCommand({ path: opts.path });
+});
+hookCmd.command("remove").description("Remove the post-checkout git hook").option("-p, --path <dir>", "project directory", process.cwd()).action((opts) => {
+	hookRemoveCommand({ path: opts.path });
+});
+program.parse();
+
+//#endregion
+export {  };