forgemap 0.7.0-dev.128-e6bed71 → 0.7.0-dev.129-714bb16

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

@@ -3243,7 +3243,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.129-714bb16",
 			build: detectBuild(binary.resolved),
 			binary,
 			node: process.version,
@@ -3369,6 +3369,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: {
@@ -4219,6 +4220,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 +4273,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 +4281,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 +4326,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 +4355,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 +4379,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 +4394,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 +4405,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
@@ -4443,7 +4460,7 @@ var completionCommand = defineCommand({
 runMain(defineCommand({
 	meta: {
 		name: "forgemap",
-		version: "0.7.0-dev.128-e6bed71",
+		version: "0.7.0-dev.129-714bb16",
 		description: "Manage a local repo layout of the form <root>/<forge.dir>/<owner>/<repo>"
 	},
 	subCommands: {