forgemap 0.5.0-dev.95-3a3ea5e → 0.5.0-dev.97-def4d25

package/dist/bin/forgemap.mjs

@@ -3,12 +3,13 @@ import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import { access, mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
 import { colors, formatTree } from "consola/utils";
-import { dirname, isAbsolute, join, resolve } from "pathe";
+import { dirname, extname, isAbsolute, join, relative, resolve } from "pathe";
 import { homedir } from "node:os";
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { loadConfig } from "c12";
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
+import { updateConfig } from "c12/update";
 import Fuse from "fuse.js";
 //#region src/commands/cd.ts
 /**
@@ -81,6 +82,39 @@ function findGlobalConfig() {
 		if (existsSync(candidate)) return candidate;
 	}
 }
+/**
+* Every `forgemap.config.*` a change could be written to, in resolution order:
+* one per directory walking up from `start` (nearest first, mirroring the
+* loader's first-basename-wins rule), then the global config. Used by the
+* `forge` command to let the user pick a target when more than one exists.
+*/
+function discoverConfigFiles(start = process.cwd()) {
+	const found = [];
+	const seen = /* @__PURE__ */ new Set();
+	let dir = resolve(start);
+	for (;;) {
+		for (const base of CONFIG_BASENAMES) {
+			const candidate = join(dir, base);
+			if (existsSync(candidate)) {
+				seen.add(candidate);
+				found.push({
+					path: candidate,
+					source: "walk-up"
+				});
+				break;
+			}
+		}
+		const parent = dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	const global = findGlobalConfig();
+	if (global && !seen.has(global)) found.push({
+		path: global,
+		source: "global"
+	});
+	return found;
+}
 var DEFAULT_CONFIG$1 = {
 	root: ".",
 	defaultForge: "github",
@@ -117,6 +151,7 @@ async function loadForgeMapConfig(options = {}) {
 			}
 		}
 	}
+	if (explicit) explicit = resolve(startDir, explicit);
 	const cwd = explicit ? dirname(explicit) : startDir;
 	const { config, configFile } = await loadConfig({
 		name: "forgemap",
@@ -1589,6 +1624,627 @@ var deleteCommand = defineCommand({
 	}
 });
 //#endregion
+//#region src/config/forges.ts
+/** Every forge `type` the config schema accepts, in prompt/display order. */
+var FORGE_TYPES = [
+	"github",
+	"gitlab",
+	"gitea",
+	"codeberg",
+	"git"
+];
+/** Canonical host per forge type, offered as the host prompt's default. The
+*  self-hosted flavors (`gitea`, plain `git`) have no universal host, so none
+*  is suggested for them. */
+var DEFAULT_HOSTS = {
+	github: "github.com",
+	gitlab: "gitlab.com",
+	codeberg: "codeberg.org"
+};
+/** Git clone protocols, in prompt order (`ssh` is the schema default). */
+var GIT_PROTOCOLS = ["ssh", "https"];
+/** Reject empty / whitespace-only keys; any other string is a valid map key.
+*  Returns an error message, or `null` when the key is acceptable. */
+function validateForgeKey(raw) {
+	if (raw.trim().length === 0) return "Forge key must not be empty.";
+	return null;
+}
+/** Whether `value` is one of the schema's forge types (narrows a raw flag). */
+function isForgeType(value) {
+	return FORGE_TYPES.includes(value);
+}
+/** Whether `value` is a supported git protocol. */
+function isGitProtocol(value) {
+	return GIT_PROTOCOLS.includes(value);
+}
+/** Build a `ForgeConfig` from collected input, keeping `protocol` only when it
+*  is the non-default (`https`) git protocol. */
+function buildForge(input) {
+	if (input.type === "git") {
+		const forge = {
+			type: "git",
+			host: input.host,
+			dir: input.dir
+		};
+		if (input.protocol === "https") forge.protocol = "https";
+		return forge;
+	}
+	return {
+		type: input.type,
+		host: input.host,
+		dir: input.dir
+	};
+}
+function addForge(config, key, forge) {
+	if (!config.forges) config.forges = {};
+	config.forges[key] = forge;
+}
+function removeForge(config, key) {
+	if (config.forges) delete config.forges[key];
+}
+function setDefaultForge(config, key) {
+	config.defaultForge = key;
+}
+/** Apply a partial change to an existing forge in place. Clears `protocol`
+*  whenever the resulting type is not `git`, since it is meaningless there. */
+function editForge(config, key, patch) {
+	const forge = config.forges?.[key];
+	if (!forge) return;
+	if (patch.type !== void 0) forge.type = patch.type;
+	if (patch.host !== void 0) forge.host = patch.host;
+	if (patch.dir !== void 0) forge.dir = patch.dir;
+	if (forge.type !== "git") delete forge.protocol;
+	else if (patch.protocol === null) delete forge.protocol;
+	else if (patch.protocol !== void 0) forge.protocol = patch.protocol;
+}
+//#endregion
+//#region src/config/mutate.ts
+/**
+* Apply an in-place mutation to a `forgemap.config.*` file, preserving its
+* formatting and comments.
+*
+* `.ts`/`.mts`/`.js`/… are round-tripped through c12's `updateConfig`, which
+* parses the module with magicast and edits the exported object literal — it
+* transparently unwraps a `defineForgeMapConfig(...)` call. Plain `.json`
+* configs, which magicast/updateConfig refuse, are read, mutated and written
+* back directly.
+*
+* Rejects when the source can't be edited safely (e.g. forges built dynamically
+* rather than declared as a literal); callers surface that as a manual-edit
+* fallback rather than crashing.
+*/
+async function mutateConfigFile(path, mutate) {
+	if (extname(path) === ".json") {
+		const current = JSON.parse(await readFile(path, "utf8"));
+		mutate(current);
+		await writeFile(path, `${JSON.stringify(current, null, 2)}\n`, "utf8");
+		return;
+	}
+	await updateConfig({
+		cwd: dirname(path),
+		configFile: "forgemap.config",
+		onUpdate: (config) => {
+			mutate(config);
+		}
+	});
+}
+//#endregion
+//#region src/repos/picker.ts
+/**
+* Show the interactive repo picker and return the chosen local path
+* (undefined when the user cancels).
+*
+* `$(forgemap pick)` / `$(forgemap path <q>)` captures stdout, so the
+* interactive TUI must not go there. consola/clack writes the UI to stdout AND
+* reads stdout.rows/columns for layout — but a captured stdout is a pipe (no
+* rows → nothing renders). So for the duration of the prompt: route stdout
+* writes to stderr (the real TTY) and borrow stderr's dimensions, then
+* restore. stdout stays clean for the chosen path only.
+*
+* Callers must check {@link canPrompt} first — without a TTY on stdin there is
+* nobody to answer.
+*/
+async function promptRepoChoice(candidates) {
+	const out = process.stdout;
+	const realWrite = out.write;
+	const saved = {
+		rows: Object.getOwnPropertyDescriptor(out, "rows"),
+		columns: Object.getOwnPropertyDescriptor(out, "columns"),
+		isTTY: Object.getOwnPropertyDescriptor(out, "isTTY")
+	};
+	const fake = (key, value) => {
+		Object.defineProperty(out, key, {
+			configurable: true,
+			value
+		});
+	};
+	const restore = (key) => {
+		if (saved[key]) Object.defineProperty(out, key, saved[key]);
+		else delete out[key];
+	};
+	out.write = process.stderr.write.bind(process.stderr);
+	fake("rows", process.stderr.rows ?? 24);
+	fake("columns", process.stderr.columns ?? 80);
+	fake("isTTY", true);
+	let choice;
+	try {
+		choice = await consola.prompt("Select a repo", {
+			type: "select",
+			options: candidates.map((r) => ({
+				label: `${colors.gray(`${r.forgeName}:`)}${r.slug}`,
+				value: r.localPath,
+				hint: r.localPath
+			}))
+		});
+	} finally {
+		out.write = realWrite;
+		restore("rows");
+		restore("columns");
+		restore("isTTY");
+	}
+	return typeof choice === "string" && choice ? choice : void 0;
+}
+/** Whether an interactive prompt can be shown at all. */
+function canPrompt() {
+	return Boolean(process.stdin.isTTY);
+}
+//#endregion
+//#region src/commands/forge/shared.ts
+/** Whether interactive prompts can be shown (a TTY on stdin to answer them). */
+function interactive() {
+	return canPrompt();
+}
+/** Prompt for free text. Returns the raw string, or `null` when cancelled. */
+async function promptText(message, placeholder) {
+	const answer = await consola.prompt(message, {
+		type: "text",
+		placeholder,
+		cancel: "null"
+	});
+	return typeof answer === "string" ? answer : null;
+}
+/** Prompt to pick one of `options`. Returns the value, or `null` when cancelled. */
+async function promptSelect(message, options) {
+	const answer = await consola.prompt(message, {
+		type: "select",
+		options: [...options],
+		cancel: "null"
+	});
+	return typeof answer === "string" && answer ? answer : null;
+}
+/** Yes/no confirmation. Returns `false` when declined or cancelled. */
+async function confirmChange(message) {
+	return await consola.prompt(message, {
+		type: "confirm",
+		cancel: "null"
+	}) === true;
+}
+/**
+* Choose which config file `add` writes to.
+*  - `--config <path>` always wins (created when it does not exist).
+*  - otherwise discover candidates: one → use it; several with a TTY → present a
+*    select (the final step before confirming); several without a TTY → nearest.
+*  - nothing discovered → a fresh `forgemap.config.ts` in the cwd.
+*
+* Returns `null` when the user cancels the select.
+*/
+async function resolveAddTarget(explicit) {
+	if (explicit) {
+		const path = resolve(process.cwd(), explicit);
+		return {
+			path,
+			create: !existsSync(path)
+		};
+	}
+	const candidates = discoverConfigFiles();
+	if (candidates.length === 0) return {
+		path: join(process.cwd(), "forgemap.config.ts"),
+		create: true
+	};
+	if (candidates.length === 1 || !interactive()) return {
+		path: candidates[0].path,
+		create: false
+	};
+	const choice = await consola.prompt("Which config file should this change be written to?", {
+		type: "select",
+		options: candidates.map((c) => ({
+			label: relative(process.cwd(), c.path) || c.path,
+			value: c.path,
+			hint: c.source
+		})),
+		cancel: "null"
+	});
+	if (typeof choice !== "string" || !choice) {
+		consola.info("Aborted — nothing changed.");
+		return null;
+	}
+	return {
+		path: choice,
+		create: false
+	};
+}
+/**
+* The config file `edit`/`remove` operate on — the forge already lives in a real
+* file, so `--config` or the resolved config file is used. Prints an error and
+* returns `null` when only the built-in defaults are in effect (no file).
+*/
+function existingConfigFile(loaded, explicit) {
+	if (explicit) return resolve(process.cwd(), explicit);
+	if (!loaded.configFile) {
+		consola.error("No forgemap config file found. Run `forgemap config init` or `forgemap forge add` first.");
+		return null;
+	}
+	return loaded.configFile;
+}
+/**
+* Round-trip `mutate` into `path`; on failure (a config too dynamic to rewrite)
+* report it and print the change for manual application instead of crashing.
+* Returns whether the file was updated.
+*/
+async function applyChange(path, mutate, manualHint) {
+	try {
+		await mutateConfigFile(path, mutate);
+		return true;
+	} catch (error) {
+		consola.error(`Could not update ${path} automatically: ${error.message}`);
+		consola.info("Apply this change by hand instead:");
+		manualHint();
+		return false;
+	}
+}
+/** Print a forge as a `forgemap.config` block (the manual-edit fallback). */
+function printManualForge(key, forge) {
+	consola.log(`  ${key}: {`);
+	consola.log(`    type: '${forge.type}',`);
+	consola.log(`    host: '${forge.host}',`);
+	consola.log(`    dir: '${forge.dir}'${forge.protocol ? "," : ""}`);
+	if (forge.protocol) consola.log(`    protocol: '${forge.protocol}'`);
+	consola.log("  }");
+}
+//#endregion
+//#region src/commands/forge/add.ts
+var forgeAddCommand = defineCommand({
+	meta: {
+		name: "add",
+		description: "Add a forge to the config (prompts for anything not passed)"
+	},
+	args: {
+		key: {
+			type: "positional",
+			required: false,
+			description: "Forge key, e.g. github or work"
+		},
+		type: {
+			type: "string",
+			description: `Forge type (${FORGE_TYPES.join(", ")})`
+		},
+		host: {
+			type: "string",
+			description: "Forge host, e.g. github.com"
+		},
+		dir: {
+			type: "string",
+			description: "Directory under root, e.g. comGithub"
+		},
+		protocol: {
+			type: "string",
+			description: `Clone protocol for type=git (${GIT_PROTOCOLS.join(", ")})`
+		},
+		default: {
+			type: "boolean",
+			description: "Set this forge as the default",
+			default: false
+		},
+		config: {
+			type: "string",
+			description: "Path to the forgemap config file to modify"
+		},
+		yes: {
+			type: "boolean",
+			description: "Skip the confirmation prompt",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const loaded = await loadForgeMapConfig({ configFile: args.config });
+		const tty = interactive();
+		let key = typeof args.key === "string" ? args.key.trim() : "";
+		if (!key && tty) {
+			const answer = await promptText("Forge key (e.g. github, work):");
+			if (answer === null) return abort$2();
+			key = answer.trim();
+		}
+		const keyError = validateForgeKey(key);
+		if (keyError) return fail$2(keyError);
+		if (loaded.configFile && key in loaded.config.forges) return fail$2(`Forge "${key}" already exists. Use \`forgemap forge edit ${key}\` to change it.`);
+		let type;
+		if (typeof args.type === "string") {
+			if (!isForgeType(args.type)) return fail$2(invalidType$1(args.type));
+			type = args.type;
+		} else if (tty) {
+			const answer = await promptSelect("Forge type:", FORGE_TYPES);
+			if (answer === null || !isForgeType(answer)) return abort$2();
+			type = answer;
+		}
+		if (!type) return fail$2("Missing forge type. Pass --type.");
+		const suggestedHost = DEFAULT_HOSTS[type] ?? "";
+		let host = typeof args.host === "string" ? args.host.trim() : "";
+		if (!host && tty) {
+			const answer = await promptText("Host:", suggestedHost);
+			if (answer === null) return abort$2();
+			host = answer.trim() || suggestedHost;
+		} else if (!host) host = suggestedHost;
+		if (!host) return fail$2("Missing host. Pass --host.");
+		let dir = typeof args.dir === "string" ? args.dir.trim() : "";
+		if (!dir && tty) {
+			const answer = await promptText("Directory (under root):");
+			if (answer === null) return abort$2();
+			dir = answer.trim();
+		}
+		if (!dir) return fail$2("Missing directory. Pass --dir.");
+		let protocol;
+		if (type === "git") {
+			if (typeof args.protocol === "string") {
+				if (!isGitProtocol(args.protocol)) return fail$2(invalidProtocol$1(args.protocol));
+				protocol = args.protocol;
+			} else if (tty) {
+				const answer = await promptSelect("Clone protocol:", GIT_PROTOCOLS);
+				if (answer !== null && isGitProtocol(answer)) protocol = answer;
+			}
+		}
+		let makeDefault = args.default === true;
+		if (!loaded.configFile) makeDefault = true;
+		else if (!makeDefault && tty) makeDefault = await confirmChange(`Set "${key}" as the default forge?`);
+		const forge = buildForge({
+			type,
+			host,
+			dir,
+			protocol
+		});
+		const target = await resolveAddTarget(args.config);
+		if (!target) return;
+		consola.info(`Add forge "${key}" (${type} → ${host}) into ${target.create ? "new " : ""}${target.path}`);
+		if (tty && !args.yes && !await confirmChange("Apply this change?")) return abort$2();
+		if (target.create) {
+			const written = await writeConfigFile({
+				root: loaded.config.root,
+				defaultForge: key,
+				forges: { [key]: forge }
+			}, { outDir: dirname(target.path) });
+			if (!written) return fail$2(`${target.path} already exists.`);
+			consola.success(`Added forge "${key}" — wrote ${written.path}`);
+			return;
+		}
+		if (await applyChange(target.path, (c) => {
+			addForge(c, key, forge);
+			if (makeDefault) setDefaultForge(c, key);
+		}, () => printManualForge(key, forge))) consola.success(`Added forge "${key}" to ${target.path}`);
+		else process.exitCode = 1;
+	}
+});
+function fail$2(message) {
+	consola.error(message);
+	process.exitCode = 1;
+}
+function abort$2() {
+	consola.info("Aborted — nothing changed.");
+}
+function invalidType$1(value) {
+	return `Invalid type "${value}". Expected one of: ${FORGE_TYPES.join(", ")}.`;
+}
+function invalidProtocol$1(value) {
+	return `Invalid protocol "${value}". Expected one of: ${GIT_PROTOCOLS.join(", ")}.`;
+}
+//#endregion
+//#region src/commands/forge/edit.ts
+var forgeEditCommand = defineCommand({
+	meta: {
+		name: "edit",
+		description: "Edit an existing forge (prompts for fields when none are passed)"
+	},
+	args: {
+		key: {
+			type: "positional",
+			required: false,
+			description: "Forge key to edit"
+		},
+		type: {
+			type: "string",
+			description: `New forge type (${FORGE_TYPES.join(", ")})`
+		},
+		host: {
+			type: "string",
+			description: "New host"
+		},
+		dir: {
+			type: "string",
+			description: "New directory under root"
+		},
+		protocol: {
+			type: "string",
+			description: `New clone protocol for type=git (${GIT_PROTOCOLS.join(", ")})`
+		},
+		config: {
+			type: "string",
+			description: "Path to the forgemap config file to modify"
+		},
+		yes: {
+			type: "boolean",
+			description: "Skip the confirmation prompt",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const loaded = await loadForgeMapConfig({ configFile: args.config });
+		const tty = interactive();
+		const file = existingConfigFile(loaded, args.config);
+		if (!file) {
+			process.exitCode = 1;
+			return;
+		}
+		const forges = loaded.config.forges;
+		let key = typeof args.key === "string" ? args.key.trim() : "";
+		if (!key && tty) {
+			const answer = await promptSelect("Which forge should be edited?", Object.keys(forges));
+			if (answer === null) return abort$1();
+			key = answer;
+		}
+		if (!key) return fail$1("Missing forge key. Pass it as an argument.");
+		const current = forges[key];
+		if (!current) return fail$1(`No forge "${key}" in ${file}. Configured: ${Object.keys(forges).join(", ")}.`);
+		const currentProtocol = current.type === "git" ? current.protocol : void 0;
+		const patch = {};
+		if (typeof args.type === "string") {
+			if (!isForgeType(args.type)) return fail$1(invalidType(args.type));
+			patch.type = args.type;
+		} else if (tty) {
+			const answer = await promptSelect(`Type (current: ${current.type}):`, FORGE_TYPES);
+			if (answer === null) return abort$1();
+			if (isForgeType(answer)) patch.type = answer;
+		}
+		const resultType = patch.type ?? current.type;
+		if (typeof args.host === "string") patch.host = args.host.trim();
+		else if (tty) {
+			const answer = await promptText(`Host (current: ${current.host}):`, current.host);
+			if (answer === null) return abort$1();
+			if (answer.trim()) patch.host = answer.trim();
+		}
+		if (typeof args.dir === "string") patch.dir = args.dir.trim();
+		else if (tty) {
+			const answer = await promptText(`Directory (current: ${current.dir}):`, current.dir);
+			if (answer === null) return abort$1();
+			if (answer.trim()) patch.dir = answer.trim();
+		}
+		if (resultType === "git") {
+			if (typeof args.protocol === "string") {
+				if (!isGitProtocol(args.protocol)) return fail$1(invalidProtocol(args.protocol));
+				patch.protocol = args.protocol;
+			} else if (tty) {
+				const answer = await promptSelect("Clone protocol:", GIT_PROTOCOLS);
+				if (answer !== null && isGitProtocol(answer)) patch.protocol = answer;
+			}
+		}
+		if (!hasChanges(patch)) return fail$1("Nothing to change. Pass --type, --host, --dir or --protocol.");
+		consola.info(`Edit forge "${key}" in ${file}`);
+		if (tty && !args.yes && !await confirmChange("Apply this change?")) return abort$1();
+		const merged = mergeForge(current, currentProtocol, patch, resultType);
+		if (await applyChange(file, (c) => editForge(c, key, patch), () => {
+			consola.log(`Update the "${key}" entry to:`);
+			printManualForge(key, merged);
+		})) consola.success(`Edited forge "${key}" in ${file}`);
+		else process.exitCode = 1;
+	}
+});
+function hasChanges(patch) {
+	return patch.type !== void 0 || patch.host !== void 0 || patch.dir !== void 0 || patch.protocol !== void 0;
+}
+function mergeForge(current, currentProtocol, patch, resultType) {
+	const protocol = resultType === "git" ? patch.protocol ?? currentProtocol : void 0;
+	return {
+		type: resultType,
+		host: patch.host ?? current.host,
+		dir: patch.dir ?? current.dir,
+		...protocol ? { protocol } : {}
+	};
+}
+function fail$1(message) {
+	consola.error(message);
+	process.exitCode = 1;
+}
+function abort$1() {
+	consola.info("Aborted — nothing changed.");
+}
+function invalidType(value) {
+	return `Invalid type "${value}". Expected one of: ${FORGE_TYPES.join(", ")}.`;
+}
+function invalidProtocol(value) {
+	return `Invalid protocol "${value}". Expected one of: ${GIT_PROTOCOLS.join(", ")}.`;
+}
+//#endregion
+//#region src/commands/forge/remove.ts
+var LEAVE_UNSET = "— leave unset —";
+var forgeRemoveCommand = defineCommand({
+	meta: {
+		name: "remove",
+		description: "Remove a forge from the config"
+	},
+	args: {
+		key: {
+			type: "positional",
+			required: false,
+			description: "Forge key to remove"
+		},
+		default: {
+			type: "string",
+			description: "When removing the default forge, reassign the default to this"
+		},
+		config: {
+			type: "string",
+			description: "Path to the forgemap config file to modify"
+		},
+		yes: {
+			type: "boolean",
+			description: "Skip the confirmation prompt",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const loaded = await loadForgeMapConfig({ configFile: args.config });
+		const tty = interactive();
+		const file = existingConfigFile(loaded, args.config);
+		if (!file) {
+			process.exitCode = 1;
+			return;
+		}
+		const forges = loaded.config.forges;
+		let key = typeof args.key === "string" ? args.key.trim() : "";
+		if (!key && tty) {
+			const answer = await promptSelect("Which forge should be removed?", Object.keys(forges));
+			if (answer === null) return abort();
+			key = answer;
+		}
+		if (!key) return fail("Missing forge key. Pass it as an argument.");
+		if (!(key in forges)) return fail(`No forge "${key}" in ${file}. Configured: ${Object.keys(forges).join(", ")}.`);
+		const remaining = Object.keys(forges).filter((k) => k !== key);
+		let newDefault;
+		if (loaded.config.defaultForge === key && remaining.length > 0) if (typeof args.default === "string") {
+			if (!remaining.includes(args.default)) return fail(`Cannot set default to "${args.default}" — not a remaining forge (${remaining.join(", ")}).`);
+			newDefault = args.default;
+		} else if (tty) {
+			const answer = await promptSelect(`"${key}" is the default forge. Pick a new default:`, [...remaining, LEAVE_UNSET]);
+			if (answer === null) return abort();
+			if (answer !== LEAVE_UNSET) newDefault = answer;
+		} else consola.warn(`Removing the default forge "${key}"; defaultForge now points at a missing forge. Pass --default to reassign it.`);
+		consola.info(`Remove forge "${key}" from ${file}${newDefault ? ` (new default: "${newDefault}")` : ""}`);
+		if (tty && !args.yes && !await confirmChange("Apply this change?")) return abort();
+		if (await applyChange(file, (c) => {
+			removeForge(c, key);
+			if (newDefault) setDefaultForge(c, newDefault);
+		}, () => consola.log(`Remove the "${key}" entry from \`forges\` in ${file}.`))) consola.success(`Removed forge "${key}" from ${file}`);
+		else process.exitCode = 1;
+	}
+});
+function fail(message) {
+	consola.error(message);
+	process.exitCode = 1;
+}
+function abort() {
+	consola.info("Aborted — nothing changed.");
+}
+//#endregion
+//#region src/commands/forge/index.ts
+var forgeCommand = defineCommand({
+	meta: {
+		name: "forge",
+		description: "Add, remove or edit forges in the config"
+	},
+	subCommands: {
+		add: forgeAddCommand,
+		remove: forgeRemoveCommand,
+		edit: forgeEditCommand
+	}
+});
+//#endregion
 //#region src/repos/import.ts
 async function listDirs(path) {
 	try {
@@ -2279,7 +2935,7 @@ var infoCommand = defineCommand({
 	async run({ args }) {
 		const binary = resolveBinary(process.argv[1]);
 		const info = {
-			version: "0.5.0-dev.95-3a3ea5e",
+			version: "0.5.0-dev.97-def4d25",
 			build: detectBuild(binary.resolved),
 			binary,
 			node: process.version,
@@ -2463,66 +3119,6 @@ var listCommand = defineCommand({
 	}
 });
 //#endregion
-//#region src/repos/picker.ts
-/**
-* Show the interactive repo picker and return the chosen local path
-* (undefined when the user cancels).
-*
-* `$(forgemap pick)` / `$(forgemap path <q>)` captures stdout, so the
-* interactive TUI must not go there. consola/clack writes the UI to stdout AND
-* reads stdout.rows/columns for layout — but a captured stdout is a pipe (no
-* rows → nothing renders). So for the duration of the prompt: route stdout
-* writes to stderr (the real TTY) and borrow stderr's dimensions, then
-* restore. stdout stays clean for the chosen path only.
-*
-* Callers must check {@link canPrompt} first — without a TTY on stdin there is
-* nobody to answer.
-*/
-async function promptRepoChoice(candidates) {
-	const out = process.stdout;
-	const realWrite = out.write;
-	const saved = {
-		rows: Object.getOwnPropertyDescriptor(out, "rows"),
-		columns: Object.getOwnPropertyDescriptor(out, "columns"),
-		isTTY: Object.getOwnPropertyDescriptor(out, "isTTY")
-	};
-	const fake = (key, value) => {
-		Object.defineProperty(out, key, {
-			configurable: true,
-			value
-		});
-	};
-	const restore = (key) => {
-		if (saved[key]) Object.defineProperty(out, key, saved[key]);
-		else delete out[key];
-	};
-	out.write = process.stderr.write.bind(process.stderr);
-	fake("rows", process.stderr.rows ?? 24);
-	fake("columns", process.stderr.columns ?? 80);
-	fake("isTTY", true);
-	let choice;
-	try {
-		choice = await consola.prompt("Select a repo", {
-			type: "select",
-			options: candidates.map((r) => ({
-				label: `${colors.gray(`${r.forgeName}:`)}${r.slug}`,
-				value: r.localPath,
-				hint: r.localPath
-			}))
-		});
-	} finally {
-		out.write = realWrite;
-		restore("rows");
-		restore("columns");
-		restore("isTTY");
-	}
-	return typeof choice === "string" && choice ? choice : void 0;
-}
-/** Whether an interactive prompt can be shown at all. */
-function canPrompt() {
-	return Boolean(process.stdin.isTTY);
-}
-//#endregion
 //#region src/slug/locate.ts
 /**
 * Turn user input into a repo location.
@@ -3287,7 +3883,8 @@ function commandSpecs() {
 		["info", infoCommand],
 		["completion", completionCommand],
 		["shell-init", shellInitCommand],
-		["config", configCommand]
+		["config", configCommand],
+		["forge", forgeCommand]
 	].map(([name, cmd]) => ({
 		name,
 		flags: flagsOf(cmd),
@@ -3476,7 +4073,7 @@ var completionCommand = defineCommand({
 runMain(defineCommand({
 	meta: {
 		name: "forgemap",
-		version: "0.5.0-dev.95-3a3ea5e",
+		version: "0.5.0-dev.97-def4d25",
 		description: "Manage a local repo layout of the form <root>/<forge.dir>/<owner>/<repo>"
 	},
 	subCommands: {
@@ -3495,7 +4092,8 @@ runMain(defineCommand({
 		info: infoCommand,
 		completion: completionCommand,
 		"shell-init": shellInitCommand,
-		config: configCommand
+		config: configCommand,
+		forge: forgeCommand
 	}
 }));
 //#endregion