fix: --help エラー処理のレビュー指摘対応

- operand 判定を cmd.args 先頭トークンに限定し、未知オプションの値を
  サブコマンド名と誤認しないようにする (--bogus json --help 等)。
  副作用として --help が先行する場合 (geonic --help hello) は
  従来どおりヘルプ表示に戻る
- エラーメッセージはユーザーが入力したエイリアス (models, batch) を
  そのまま echo し、正規名に置換しない (rawArgs から復元)
- unknown-command エラー出力を unknownCommandError() に統合し、
  showHelp との重複を解消
- テストの spy ボイラープレートを runExpectingError/runExpectingHelp に
  集約し、既存テストも移行

Author: miya0001

src/commands/help.ts

@@ -220,6 +220,12 @@ export function formatCommandDetails(
   return lines.join("\n");
 }
 
+function unknownCommandError(attempted: string): never {
+  console.error(chalk.red(`Error: '${attempted}' is not a geonic command.`));
+  console.error(`\nSee 'geonic help' for available commands.`);
+  process.exit(1);
+}
+
 function showHelp(program: Command, args: string[]): void {
   if (args.length === 0) {
     console.log(formatTopLevelHelp(program));
@@ -232,12 +238,7 @@ function showHelp(program: Command, args: string[]): void {
   for (let i = 0; i < args.length; i++) {
     const found = findCommand(current, args[i]);
     if (!found) {
-      const attempted = args.slice(0, i + 1).join(" ");
-      console.error(
-        chalk.red(`Error: '${attempted}' is not a geonic command.`),
-      );
-      console.error(`\nSee 'geonic help' for available commands.`);
-      process.exit(1);
+      unknownCommandError(args.slice(0, i + 1).join(" "));
     }
     resolved.push(found);
     current = found;
@@ -249,13 +250,31 @@ function showHelp(program: Command, args: string[]): void {
   console.log(formatCommandDetails(program, target, path));
 }
 
-function reportUnknownCommand(cmd: Command, operand: string): never {
-  // getCommandPath() starts with the program name ("geonic"); drop it
-  const prefix = getCommandPath(cmd).split(" ").slice(1);
-  const attempted = [...prefix, operand].join(" ");
-  console.error(chalk.red(`Error: '${attempted}' is not a geonic command.`));
-  console.error(`\nSee 'geonic help' for available commands.`);
-  process.exit(1);
+// Resolve the chain from the program down to cmd back to the tokens the user
+// actually typed (rawArgs), so aliases are echoed as typed (e.g. "models"),
+// not as their canonical name ("custom-data-models").
+function typedCommandPath(cmd: Command): string[] {
+  const chain: Command[] = [];
+  let current: Command | null = cmd;
+  while (current && current.parent) {
+    chain.unshift(current);
+    current = current.parent;
+  }
+
+  // rawArgs exists at runtime but is missing from commander's typings
+  const root = getRootProgram(cmd) as Command & { rawArgs: string[] };
+  const rawArgs = root.rawArgs.slice(2); // drop node + script
+
+  const typed: string[] = [];
+  let i = 0;
+  for (const c of chain) {
+    const names = [c.name(), ...c.aliases()];
+    while (i < rawArgs.length && !names.includes(rawArgs[i])) {
+      i++;
+    }
+    typed.push(i < rawArgs.length ? rawArgs[i] : c.name());
+  }
+  return typed;
 }
 
 export function enforceKnownCommandHelp(program: Command): void {
@@ -270,10 +289,16 @@ export function enforceKnownCommandHelp(program: Command): void {
       cmd.outputHelp = (
         contextOptions?: HelpContext | ((str: string) => string),
       ): void => {
-        // cmd.args is operands followed by unparsed options such as --help
-        const operand = cmd.args.find((arg) => !arg.startsWith("-"));
-        if (operand !== undefined && !findCommand(cmd, operand)) {
-          reportUnknownCommand(cmd, operand);
+        // cmd.args lists operands first, then unparsed options such as --help.
+        // Only a leading non-dash token is a genuine operand — a non-dash token
+        // found later may be the value of an unrecognized option.
+        const operand = cmd.args[0];
+        if (
+          operand !== undefined &&
+          !operand.startsWith("-") &&
+          !findCommand(cmd, operand)
+        ) {
+          unknownCommandError([...typedCommandPath(cmd), operand].join(" "));
         }
         originalOutputHelp(contextOptions as HelpContext | undefined);
       };

tests/help.test.ts

@@ -16,6 +16,27 @@ function findCommand(program: ReturnType<typeof createProgram>, ...names: string
   return current;
 }
 
+// Parses argv expecting the unknown-command error path: captures stderr,
+// asserts process.exit(1), and returns the stripped stderr output.
+async function runExpectingError(argv: string[]): Promise<string> {
+  const prog = createProgram();
+  prog.exitOverride();
+  const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+  const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+    throw new Error("process.exit");
+  });
+  try {
+    await prog.parseAsync(["node", "geonic", ...argv]);
+  } catch {
+    // expected
+  }
+  const output = stripAnsi(errSpy.mock.calls.map((c) => c[0]).join("\n"));
+  expect(exitSpy).toHaveBeenCalledWith(1);
+  errSpy.mockRestore();
+  exitSpy.mockRestore();
+  return output;
+}
+
 describe("help", () => {
   const program = createProgram();
 
@@ -609,21 +630,8 @@ describe("help", () => {
     });
 
     it("shows error for invalid command name in help", async () => {
-      const prog = createProgram();
-      prog.exitOverride();
-      const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
-        throw new Error("process.exit");
-      });
-      try {
-        await prog.parseAsync(["node", "geonic", "help", "nonexistent"]);
-      } catch {
-        // expected
-      }
-      const output = errSpy.mock.calls.map((c) => c[0]).join("\n");
-      expect(stripAnsi(output)).toContain("'nonexistent' is not a geonic command");
-      errSpy.mockRestore();
-      exitSpy.mockRestore();
+      const output = await runExpectingError(["help", "nonexistent"]);
+      expect(output).toContain("'nonexistent' is not a geonic command");
     });
 
     it("shows top-level help when help is called with no args", async () => {
@@ -684,22 +692,22 @@ describe("help", () => {
   });
 
   describe("unknown subcommand with --help", () => {
-    async function runExpectingError(argv: string[]): Promise<string> {
+    // Parses argv expecting help to be shown: captures stdout and returns it,
+    // asserting no error was printed.
+    async function runExpectingHelp(argv: string[]): Promise<string> {
       const prog = createProgram();
       prog.exitOverride();
+      const writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
       const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
-        throw new Error("process.exit");
-      });
       try {
         await prog.parseAsync(["node", "geonic", ...argv]);
       } catch {
-        // expected
+        // exitOverride throws on help
       }
-      const output = stripAnsi(errSpy.mock.calls.map((c) => c[0]).join("\n"));
-      expect(exitSpy).toHaveBeenCalledWith(1);
+      const output = stripAnsi(writeSpy.mock.calls.map((c) => c[0]).join(""));
+      expect(errSpy).not.toHaveBeenCalled();
+      writeSpy.mockRestore();
       errSpy.mockRestore();
-      exitSpy.mockRestore();
       return output;
     }
 
@@ -720,20 +728,25 @@ describe("help", () => {
     });
 
     it("still shows help for a leaf command with an argument and --help", async () => {
-      const prog = createProgram();
-      prog.exitOverride();
-      const writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
-      const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-      try {
-        await prog.parseAsync(["node", "geonic", "entities", "get", "urn:x", "--help"]);
-      } catch {
-        // exitOverride throws on help
-      }
-      const output = stripAnsi(writeSpy.mock.calls.map((c) => c[0]).join(""));
+      const output = await runExpectingHelp(["entities", "get", "urn:x", "--help"]);
       expect(output).toContain("geonic entities get");
-      expect(errSpy).not.toHaveBeenCalled();
-      writeSpy.mockRestore();
-      errSpy.mockRestore();
+    });
+
+    it("echoes the alias the user typed, not the canonical command name", async () => {
+      const output = await runExpectingError(["models", "badsub", "--help"]);
+      expect(output).toContain("'models badsub' is not a geonic command");
+      expect(output).not.toContain("custom-data-models");
+    });
+
+    it("does not mistake an unknown option's value for a subcommand", async () => {
+      // "--bogus json" must not be reported as `geonic entities json`
+      const output = await runExpectingHelp(["entities", "--bogus", "json", "--help"]);
+      expect(output).toContain("geonic entities");
+    });
+
+    it("shows top-level help when --help precedes a non-command token", async () => {
+      const output = await runExpectingHelp(["--help", "hello"]);
+      expect(output).toContain("AVAILABLE COMMANDS");
     });
   });