fix(yok): record hierarchical subcommands on registerCommand

Only requireCommand populated hierarchicalCommands, so a hierarchical
command registered directly (without a require step) never routed
through its parent name and was missing from the children listing. The
push is guarded because the legacy flow reaches registerCommand for a
name that requireCommand already recorded.

Author: edusperoni

lib/common/yok.ts

@@ -239,7 +239,28 @@ export class Yok extends Injector implements IInjector {
 			this.register(this.createCommandName(name), resolver);
 
 			if (commands.length > 1) {
-				this.createHierarchicalCommand(commands[0]);
+				const parentCommandName = commands[0];
+				const subCommandName = _.tail(commands).join(
+					CommandsDelimiters.HierarchicalCommand,
+				);
+
+				if (!this.hierarchicalCommands[parentCommandName]) {
+					this.hierarchicalCommands[parentCommandName] = [];
+				}
+
+				// Guarded: the legacy flow reaches here twice for one command —
+				// requireCommand records the subcommand, then the required module
+				// registers itself through this method.
+				if (
+					!_.includes(
+						this.hierarchicalCommands[parentCommandName],
+						subCommandName,
+					)
+				) {
+					this.hierarchicalCommands[parentCommandName].push(subCommandName);
+				}
+
+				this.createHierarchicalCommand(parentCommandName);
 			}
 		});
 	}

test/command-registration.ts

@@ -0,0 +1,62 @@
+import { assert } from "chai";
+import { Yok } from "../lib/common/yok";
+
+const noopCommandFactory = () => ({
+	execute: async (): Promise<void> => undefined,
+});
+
+describe("yok: command registration", () => {
+	let injector: Yok;
+
+	beforeEach(() => {
+		injector = new Yok();
+	});
+
+	describe("registerCommand with a hierarchical name", () => {
+		it("records the subcommand under its parent", () => {
+			injector.registerCommand("dev|test", noopCommandFactory);
+
+			assert.deepStrictEqual(injector.getChildrenCommandsNames("dev"), [
+				"test",
+			]);
+		});
+
+		it("routes arguments through the parent name", () => {
+			injector.registerCommand("dev|test", noopCommandFactory);
+
+			const built = injector.buildHierarchicalCommand("dev", ["test", "extra"]);
+
+			assert.deepStrictEqual(built, {
+				commandName: "dev|test",
+				remainingArguments: ["extra"],
+			});
+		});
+
+		it("synthesizes a dispatcher for the parent", () => {
+			injector.registerCommand("dev|test", noopCommandFactory);
+
+			const parent = injector.resolveCommand("dev");
+
+			assert.isTrue((<any>parent).isHierarchicalCommand);
+		});
+
+		it("records each sibling once, including default commands", () => {
+			injector.registerCommand("dev|*test", noopCommandFactory);
+			injector.registerCommand("dev|lint", noopCommandFactory);
+
+			assert.deepStrictEqual(injector.getChildrenCommandsNames("dev"), [
+				"*test",
+				"lint",
+			]);
+		});
+
+		it("does not duplicate a subcommand already recorded by requireCommand", () => {
+			injector.requireCommand("dev|test", "some-file");
+			injector.registerCommand("dev|test", noopCommandFactory);
+
+			assert.deepStrictEqual(injector.getChildrenCommandsNames("dev"), [
+				"test",
+			]);
+		});
+	});
+});