fix: 存在しないサブコマンドへの --help をエラー扱いにして exit 1 を返す

Commander は --help/-h を検出すると、残りの operand が既知のサブコマンドか
検証せずにヘルプを表示して exit 0 していた (例: geonic hello --help)。
サブコマンドを持つコマンドの outputHelp をラップし、未解決の operand が
残っている場合は 'geonic help <unknown>' と同じエラー形式で exit 1 にする。

Author: miya0001

src/cli.ts

@@ -15,7 +15,7 @@ import { registerRulesCommand } from "./commands/rules.js";
 import { registerModelsCommand } from "./commands/models.js";
 import { registerCatalogCommand } from "./commands/catalog.js";
 import { registerHealthCommand, registerVersionCommand } from "./commands/health.js";
-import { registerHelpCommand } from "./commands/help.js";
+import { enforceKnownCommandHelp, registerHelpCommand } from "./commands/help.js";
 import { registerCliCommand } from "./commands/cli.js";
 import { addAttrsSubcommands } from "./commands/attrs.js";
 
@@ -62,5 +62,7 @@ export function createProgram(): Command {
   addAttrsSubcommands(hiddenAttrs);
   program.addCommand(hiddenAttrs, { hidden: true });
 
+  enforceKnownCommandHelp(program);
+
   return program;
 }

src/commands/help.ts

@@ -1,5 +1,5 @@
 import chalk from "chalk";
-import type { Command, Help, Option } from "commander";
+import type { Command, Help, HelpContext, Option } from "commander";
 
 interface Example {
   description: string;
@@ -249,6 +249,42 @@ 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);
+}
+
+export function enforceKnownCommandHelp(program: Command): void {
+  // Commander prints help and exits 0 when --help/-h is present, even if the
+  // remaining operand is not a known subcommand (e.g. `geonic hello --help`).
+  // Wrap outputHelp() on every command group so that case errors with exit 1,
+  // matching `geonic help <unknown>`. Call after all commands are registered.
+  const visit = (cmd: Command): void => {
+    if (cmd.commands.length > 0) {
+      const originalOutputHelp = cmd.outputHelp.bind(cmd);
+      // Same parameter type as Command.outputHelp (including deprecated overload)
+      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);
+        }
+        originalOutputHelp(contextOptions as HelpContext | undefined);
+      };
+    }
+    for (const sub of cmd.commands) {
+      visit(sub);
+    }
+  };
+  visit(program);
+}
+
 export function registerHelpCommand(program: Command): void {
   // Disable Commander's built-in help command
   program.addHelpCommand(false);

tests/help.test.ts

@@ -683,6 +683,60 @@ describe("help", () => {
     });
   });
 
+  describe("unknown subcommand with --help", () => {
+    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;
+    }
+
+    it("errors for unknown top-level command with --help", async () => {
+      const output = await runExpectingError(["hello", "--help"]);
+      expect(output).toContain("'hello' is not a geonic command");
+      expect(output).toContain("geonic help");
+    });
+
+    it("errors for unknown top-level command with -h", async () => {
+      const output = await runExpectingError(["hello", "-h"]);
+      expect(output).toContain("'hello' is not a geonic command");
+    });
+
+    it("errors for unknown nested subcommand with --help", async () => {
+      const output = await runExpectingError(["entities", "hello", "--help"]);
+      expect(output).toContain("'entities hello' is not a geonic command");
+    });
+
+    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(""));
+      expect(output).toContain("geonic entities get");
+      expect(errSpy).not.toHaveBeenCalled();
+      writeSpy.mockRestore();
+      errSpy.mockRestore();
+    });
+  });
+
   describe("no-args handler", () => {
     it("shows help when geonic is run with no arguments", async () => {
       const prog = createProgram();