forgemap 0.7.0-dev.128-e6bed71 → 0.7.0-dev.130-c6860f2

package/README.md

@@ -88,6 +88,7 @@ Prints where a repo lives — or *would* live, if it isn't cloned yet, which mak
 forgemap list                       # every repo as a pretty tree
 forgemap list forgemap              # pretty tree (one line per match)
 forgemap list forgemap | fzf        # pipe-friendly path output
+forgemap ls                         # `ls` is an alias for `list`
 forgemap pick                       # interactive picker (consola prompt)
 forgemap pick kirch                 # picker pre-filtered by fuzzy query
 ```

package/dist/bin/forgemap.mjs

@@ -76,7 +76,8 @@ function findConfigUp(start) {
 }
 /** Fallback config under $XDG_CONFIG_HOME/forgemap (or ~/.config/forgemap). */
 function findGlobalConfig() {
-	const dir = join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "forgemap");
+	const base = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+	const dir = join(base, "forgemap");
 	for (const baseName of CONFIG_BASENAMES) {
 		const candidate = join(dir, baseName);
 		if (existsSync(candidate)) return candidate;
@@ -1516,7 +1517,8 @@ function resolveSlug(parsed, options) {
 	}
 	const depthError = checkNamespaceDepth(forgeName, forge.type, parsed.owner);
 	if (depthError) throw new Error(depthError);
-	const localPath = join(resolveRoot(config.root, configDir), forge.dir, parsed.owner, parsed.repo);
+	const root = resolveRoot(config.root, configDir);
+	const localPath = join(root, forge.dir, parsed.owner, parsed.repo);
 	return {
 		forgeName,
 		forge,
@@ -1700,7 +1702,8 @@ ${forgeEntries}
 /** Write a `forgemap.config.ts` into `outDir`. Returns null when the file
 *  already exists and `force` is not set (the caller decides how to report). */
 async function writeConfigFile(config, options) {
-	const target = join(resolve(process.cwd(), options.outDir), "forgemap.config.ts");
+	const outDir = resolve(process.cwd(), options.outDir);
+	const target = join(outDir, "forgemap.config.ts");
 	await mkdir(dirname(target), { recursive: true });
 	try {
 		await writeFile(target, renderConfigModule(config), {
@@ -1724,6 +1727,57 @@ var DEFAULT_CONFIG = {
 		dir: "comGithub"
 	} }
 };
+var configInitCommand = defineCommand({
+	meta: {
+		name: "init",
+		description: "Create a forgemap.config.ts in the current (or given) directory"
+	},
+	args: {
+		out: {
+			type: "string",
+			description: "Directory to write forgemap.config.ts into",
+			default: "."
+		},
+		force: {
+			type: "boolean",
+			description: "Overwrite if forgemap.config.ts already exists",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const result = await writeConfigFile(DEFAULT_CONFIG, {
+			outDir: args.out,
+			force: args.force
+		});
+		if (!result) {
+			const target = join(resolve(process.cwd(), args.out), "forgemap.config.ts");
+			consola.error(`${target} already exists. Use --force to overwrite.`);
+			process.exitCode = 1;
+			return;
+		}
+		consola.success(`Wrote ${result.path}`);
+	}
+});
+//#endregion
+//#region src/commands/config/show.ts
+var configShowCommand = defineCommand({
+	meta: {
+		name: "show",
+		description: "Print the resolved forgemap config and its source path"
+	},
+	args: { config: {
+		type: "string",
+		description: "Path to forgemap.config.ts (overrides walk-up discovery)"
+	} },
+	async run({ args }) {
+		const loaded = await loadForgeMapConfig({ configFile: args.config });
+		process.stdout.write(JSON.stringify({
+			configFile: loaded.configFile ?? null,
+			cwd: loaded.cwd,
+			config: loaded.config
+		}, null, 2) + "\n");
+	}
+});
 //#endregion
 //#region src/commands/config/index.ts
 var configCommand = defineCommand({
@@ -1732,55 +1786,8 @@ var configCommand = defineCommand({
 		description: "Manage the forgemap config file"
 	},
 	subCommands: {
-		init: defineCommand({
-			meta: {
-				name: "init",
-				description: "Create a forgemap.config.ts in the current (or given) directory"
-			},
-			args: {
-				out: {
-					type: "string",
-					description: "Directory to write forgemap.config.ts into",
-					default: "."
-				},
-				force: {
-					type: "boolean",
-					description: "Overwrite if forgemap.config.ts already exists",
-					default: false
-				}
-			},
-			async run({ args }) {
-				const result = await writeConfigFile(DEFAULT_CONFIG, {
-					outDir: args.out,
-					force: args.force
-				});
-				if (!result) {
-					const target = join(resolve(process.cwd(), args.out), "forgemap.config.ts");
-					consola.error(`${target} already exists. Use --force to overwrite.`);
-					process.exitCode = 1;
-					return;
-				}
-				consola.success(`Wrote ${result.path}`);
-			}
-		}),
-		show: defineCommand({
-			meta: {
-				name: "show",
-				description: "Print the resolved forgemap config and its source path"
-			},
-			args: { config: {
-				type: "string",
-				description: "Path to forgemap.config.ts (overrides walk-up discovery)"
-			} },
-			async run({ args }) {
-				const loaded = await loadForgeMapConfig({ configFile: args.config });
-				process.stdout.write(JSON.stringify({
-					configFile: loaded.configFile ?? null,
-					cwd: loaded.cwd,
-					config: loaded.config
-				}, null, 2) + "\n");
-			}
-		})
+		init: configInitCommand,
+		show: configShowCommand
 	}
 });
 //#endregion
@@ -2498,14 +2505,16 @@ var forgeRemoveCommand = defineCommand({
 		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.`);
+		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) => {
@@ -2721,13 +2730,11 @@ function pushRemoteFinding(report, parsed, result, path) {
 				message: `remote ${parsed.owner}/${parsed.repo} no longer exists`
 			});
 			break;
-		case "unknown":
-			report.findings.push({
-				kind: "remote-check-unknown",
-				severity: "warn",
-				message: `remote check inconclusive: ${result.reason}`
-			});
-			break;
+		case "unknown": report.findings.push({
+			kind: "remote-check-unknown",
+			severity: "warn",
+			message: `remote check inconclusive: ${result.reason}`
+		});
 	}
 }
 /** Run the network check for one forge's repos, preferring the batched
@@ -3243,7 +3250,7 @@ var infoCommand = defineCommand({
 	async run({ args }) {
 		const binary = resolveBinary(process.argv[1]);
 		const info = {
-			version: "0.7.0-dev.128-e6bed71",
+			version: "0.7.0-dev.130-c6860f2",
 			build: detectBuild(binary.resolved),
 			binary,
 			node: process.version,
@@ -3369,6 +3376,7 @@ function renderTree$1(repos) {
 var listCommand = defineCommand({
 	meta: {
 		name: "list",
+		alias: "ls",
 		description: "List cloned repos; with a query, fuzzy-match by owner/repo and print matches"
 	},
 	args: {
@@ -4064,55 +4072,59 @@ async function runChecks(config, configDir) {
 		severity: "fail",
 		message: "install from https://git-scm.com/"
 	});
-	if (needsGh) if (await hasCommand("gh")) {
-		checks.push({
-			name: "gh CLI",
-			severity: "ok",
-			message: "on PATH"
-		});
-		const auth = await execCapture("gh", ["auth", "status"]);
-		checks.push(auth.code === 0 ? {
-			name: "gh auth",
-			severity: "ok",
-			message: "authenticated"
-		} : {
-			name: "gh auth",
-			severity: "warn",
-			message: "not logged in — run `gh auth login`"
-		});
-	} else checks.push({
-		name: "gh CLI",
-		severity: "fail",
-		message: "install from https://cli.github.com/"
-	});
-	if (gitlabForges.length > 0) if (await hasCommand("glab")) {
-		checks.push({
-			name: "glab CLI",
-			severity: "ok",
-			message: "on PATH"
-		});
-		for (const [name, forge] of gitlabForges) {
-			const auth = await execCapture("glab", [
-				"auth",
-				"status",
-				"--hostname",
-				forge.host
-			]);
+	if (needsGh) {
+		if (await hasCommand("gh")) {
+			checks.push({
+				name: "gh CLI",
+				severity: "ok",
+				message: "on PATH"
+			});
+			const auth = await execCapture("gh", ["auth", "status"]);
 			checks.push(auth.code === 0 ? {
-				name: `glab auth (${name})`,
+				name: "gh auth",
 				severity: "ok",
-				message: `authenticated at ${forge.host}`
+				message: "authenticated"
 			} : {
-				name: `glab auth (${name})`,
+				name: "gh auth",
 				severity: "warn",
-				message: `not logged in — run \`glab auth login --hostname ${forge.host}\``
+				message: "not logged in — run `gh auth login`"
 			});
-		}
-	} else checks.push({
-		name: "glab CLI",
-		severity: "fail",
-		message: "install from https://gitlab.com/gitlab-org/cli"
-	});
+		} else checks.push({
+			name: "gh CLI",
+			severity: "fail",
+			message: "install from https://cli.github.com/"
+		});
+	}
+	if (gitlabForges.length > 0) {
+		if (await hasCommand("glab")) {
+			checks.push({
+				name: "glab CLI",
+				severity: "ok",
+				message: "on PATH"
+			});
+			for (const [name, forge] of gitlabForges) {
+				const auth = await execCapture("glab", [
+					"auth",
+					"status",
+					"--hostname",
+					forge.host
+				]);
+				checks.push(auth.code === 0 ? {
+					name: `glab auth (${name})`,
+					severity: "ok",
+					message: `authenticated at ${forge.host}`
+				} : {
+					name: `glab auth (${name})`,
+					severity: "warn",
+					message: `not logged in — run \`glab auth login --hostname ${forge.host}\``
+				});
+			}
+		} else checks.push({
+			name: "glab CLI",
+			severity: "fail",
+			message: "install from https://gitlab.com/gitlab-org/cli"
+		});
+	}
 	checks.push(await layoutCheck(config, configDir));
 	return checks;
 }
@@ -4219,6 +4231,21 @@ var SHELL_POSITIONAL = /* @__PURE__ */ new Set(["completion", "shell-init"]);
 function argsOf(cmd) {
 	return cmd.args ?? {};
 }
+/** Subcommand aliases, read off citty's own `meta.alias` so the completion and
+*  the dispatcher cannot disagree about what `ls` means. Every forgemap command
+*  declares `meta` as a plain object literal, never a thunk. */
+function aliasesOf(cmd) {
+	const alias = cmd.meta?.alias;
+	if (!alias) return [];
+	return Array.isArray(alias) ? [...alias] : [alias];
+}
+/** Every name that reaches a command on the command line: its own, plus its
+*  aliases. This is what the *recognition* arms key on — `commandSpecs()`'s
+*  `name` alone is what the depth-1 *suggestion* list offers, which is how an
+*  alias completes its arguments without being advertised as a command. */
+function namesOf(spec) {
+	return [spec.name, ...spec.aliases];
+}
 /** Flag names a command exposes, derived from its `defineCommand` args so a new
 *  flag surfaces in completion automatically. Positionals are handled
 *  separately; negatable booleans (those with a `negativeDescription`) also get
@@ -4257,6 +4284,7 @@ function commandSpecs() {
 		["forge", forgeCommand]
 	].map(([name, cmd]) => ({
 		name,
+		aliases: aliasesOf(cmd),
 		flags: flagsOf(cmd),
 		flagValues: STATIC_FLAG_VALUES[name] ?? {},
 		positionalValues: SHELL_POSITIONAL.has(name) ? [...SUPPORTED_SHELLS] : [],
@@ -4264,17 +4292,17 @@ function commandSpecs() {
 	}));
 }
 function flagValuePairs(specs) {
-	return specs.flatMap((s) => Object.entries(s.flagValues).map(([flag, values]) => [
-		s.name,
+	return specs.flatMap((s) => namesOf(s).flatMap((name) => Object.entries(s.flagValues).map(([flag, values]) => [
+		name,
 		flag,
 		values
-	]));
+	])));
 }
 function renderBash(specs) {
 	const names = specs.map((s) => s.name).join(" ");
 	const valueArms = flagValuePairs(specs).map(([cmd, flag, values]) => `    ${cmd}:${flag}) COMPREPLY=( $(compgen -W "${values.join(" ")}" -- "$cur") ); return ;;`).join("\n");
-	const flagArms = specs.filter((s) => s.flags.length > 0).map((s) => `    ${s.name}) flags="${s.flags.join(" ")}" ;;`).join("\n");
-	const slugCmds = specs.filter((s) => s.slugs).map((s) => s.name);
+	const flagArms = specs.filter((s) => s.flags.length > 0).flatMap((s) => namesOf(s).map((name) => `    ${name}) flags="${s.flags.join(" ")}" ;;`)).join("\n");
+	const slugCmds = specs.filter((s) => s.slugs).flatMap(namesOf);
 	return `# forgemap bash completion — drop into your ~/.bashrc:
 #   eval "$(forgemap completion bash)"
 _forgemap_completion() {
@@ -4309,7 +4337,7 @@ ${[slugCmds.length > 0 ? `    ${slugCmds.join("|")})
       local slugs
       slugs=$(forgemap list --format slug 2>/dev/null)
       COMPREPLY=( $(compgen -W "$slugs" -- "$cur") )
-      ;;` : "", ...specs.filter((s) => s.positionalValues.length > 0).map((s) => `    ${s.name}) COMPREPLY=( $(compgen -W "${s.positionalValues.join(" ")}" -- "$cur") ) ;;`)].filter(Boolean).join("\n")}
+      ;;` : "", ...specs.filter((s) => s.positionalValues.length > 0).map((s) => `    ${namesOf(s).join("|")}) COMPREPLY=( $(compgen -W "${s.positionalValues.join(" ")}" -- "$cur") ) ;;`)].filter(Boolean).join("\n")}
   esac
 }
 complete -F _forgemap_completion forgemap
@@ -4338,19 +4366,19 @@ ${flagValuePairs(specs).map(([cmd, flag, values]) => `    ${cmd}:${flag}) compad
   # Flag names for the current subcommand.
   if [[ "$cur" == -* ]]; then
     case "$cmd" in
-${specs.filter((s) => s.flags.length > 0).map((s) => `    ${s.name}) compadd -- ${s.flags.join(" ")}; return ;;`).join("\n")}
+${specs.filter((s) => s.flags.length > 0).flatMap((s) => namesOf(s).map((name) => `    ${name}) compadd -- ${s.flags.join(" ")}; return ;;`)).join("\n")}
     esac
     return
   fi
 
   # Positional values (repo slugs, or a shell name).
   case "$cmd" in
-    ${specs.filter((s) => s.slugs).map((s) => s.name).join("|")})
+    ${specs.filter((s) => s.slugs).flatMap(namesOf).join("|")})
       local -a slugs
       slugs=("\${(@f)$(forgemap list --format slug 2>/dev/null)}")
       _describe 'slug' slugs
       ;;
-${specs.filter((s) => s.positionalValues.length > 0).map((s) => `    ${s.name}) compadd ${s.positionalValues.join(" ")} ;;`).join("\n")}
+${specs.filter((s) => s.positionalValues.length > 0).map((s) => `    ${namesOf(s).join("|")}) compadd ${s.positionalValues.join(" ")} ;;`).join("\n")}
   esac
 }
 compdef _forgemap forgemap
@@ -4362,7 +4390,7 @@ function renderFish(specs) {
 		const long = flag.replace(/^--/, "");
 		const values = s.flagValues[flag];
 		const valuePart = values ? ` -x -a '${values.join(" ")}'` : "";
-		return `complete -c forgemap -n '__fish_seen_subcommand_from ${s.name}' -l ${long}${valuePart}`;
+		return `complete -c forgemap -n '__fish_seen_subcommand_from ${namesOf(s).join(" ")}' -l ${long}${valuePart}`;
 	})).join("\n");
 	const shellCmds = specs.filter((s) => s.positionalValues.length > 0);
 	return `# forgemap fish completion — drop into your ~/.config/fish/config.fish:
@@ -4377,7 +4405,7 @@ ${flagLines}
 # Shell flavor for completion / shell-init (depth 2).
 function __forgemap_needs_shell
   set -l tokens (commandline -opc)
-  set -l shell_cmds ${shellCmds.map((s) => `"${s.name}"`).join(" ")}
+  set -l shell_cmds ${shellCmds.flatMap(namesOf).map((name) => `"${name}"`).join(" ")}
   if test (count $tokens) -ge 2; and contains $tokens[2] $shell_cmds
     return 0
   end
@@ -4388,7 +4416,7 @@ complete -c forgemap -f -n '__forgemap_needs_shell' -a '${shellCmds[0]?.position
 # Slugs (depth 2) for commands that take one.
 function __forgemap_needs_slug
   set -l tokens (commandline -opc)
-  set -l slug_cmds ${specs.filter((s) => s.slugs).map((s) => `"${s.name}"`).join(" ")}
+  set -l slug_cmds ${specs.filter((s) => s.slugs).flatMap(namesOf).map((name) => `"${name}"`).join(" ")}
   if test (count $tokens) -ge 2; and contains $tokens[2] $slug_cmds
     return 0
   end
@@ -4439,11 +4467,11 @@ var completionCommand = defineCommand({
 	}
 });
 //#endregion
-//#region src/bin/forgemap.ts
-runMain(defineCommand({
+//#region src/cli.ts
+var rootCommand = defineCommand({
 	meta: {
 		name: "forgemap",
-		version: "0.7.0-dev.128-e6bed71",
+		version: "0.7.0-dev.130-c6860f2",
 		description: "Manage a local repo layout of the form <root>/<forge.dir>/<owner>/<repo>"
 	},
 	subCommands: {
@@ -4465,7 +4493,10 @@ runMain(defineCommand({
 		config: configCommand,
 		forge: forgeCommand
 	}
-}));
+});
+//#endregion
+//#region src/bin/forgemap.ts
+runMain(rootCommand);
 //#endregion
 
 //# sourceMappingURL=forgemap.mjs.map