cli-kiss 0.2.6 → 0.2.8

package/tests/unit.runner.cycle.ts

@@ -1,4 +1,4 @@
-import { it } from "@jest/globals";
+import { expect, it } from "@jest/globals";
 import {
   command,
   commandWithSubcommands,
@@ -18,110 +18,102 @@ import {
 
 it("run", async function () {
   const rootUsage = [
-    "Usage: my-cli <required1> <subcommand>",
+    "Usage: my-cli <req1> <subcommand>",
     "",
     "Root Description",
     "",
     "Positionals:",
-    "  <required1>  Required1 positional description",
+    "  <req1>  Required1 positional description",
     "",
     "Subcommands:",
-    "  subcommand  Subcommand Description",
+    "  sub  Subcommand Description",
     "",
     "Options:",
-    "  --flag[=no]                    Option flag description",
-    "  --repeatable <string> [*]      Option repeatable description",
-    "  --single-value <enum(number)>  Option single value description",
+    "  -ff, --flag[=no]                    Option flag description",
+    "  -r,  --repeatable <string> [*]      Option repeatable description",
+    "  -s,  --single-value <enum(number)>  Option single value description",
     "",
   ].join("\n");
-  const subcommandUsage = [
-    "Usage: my-cli <required1> subcommand <required2> [optional] [variadic]...",
+  const subUsage = [
+    "Usage: my-cli <req1> sub <req2> [optional] [variadic]...",
     "",
     "Subcommand Description",
     "",
     "Positionals:",
-    "  <required1>    Required1 positional description",
-    "  <required2>    Required2 positional description",
+    "  <req1>         Required1 positional description",
+    "  <req2>         Required2 positional description",
     "  [optional]     Optional positional description",
     "  [variadic]...  Variadics positional description",
     "",
     "Options:",
-    "  --flag[=no]                    Option flag description",
-    "  --repeatable <string> [*]      Option repeatable description",
-    "  --single-value <enum(number)>  Option single value description",
-    "  --url <url> [*]                Option url description",
+    "  -ff, --flag[=no]                    Option flag description",
+    "  -r,  --repeatable <string> [*]      Option repeatable description",
+    "  -s,  --single-value <enum(number)>  Option single value description",
+    "  -u,  --url <url> [*]                Option url description",
     "",
   ].join("\n");
 
   // Test that everything could work normally
   await testCase(
-    ["required1", "subcommand", "required2"],
-    ["Has executed root command", "Has executed subcommand"],
+    ["req1", "sub", "req2"],
+    ["Has executed root command", "Has executed sub"],
     [],
     0,
   );
 
   // Check that version flag takes precedence over execution
   await testCase(["--version"], ["my-cli 1.0.0"], [], 0);
-  await testCase(["required1", "--version"], ["my-cli 1.0.0"], [], 0);
-  await testCase(
-    ["required1", "subcommand", "--version"],
-    ["my-cli 1.0.0"],
-    [],
-    0,
-  );
-  await testCase(
-    ["required1", "subcommand", "required2", "--version"],
-    ["my-cli 1.0.0"],
-    [],
-    0,
-  );
+  await testCase(["req1", "--version"], ["my-cli 1.0.0"], [], 0);
+  await testCase(["req1", "sub", "--version"], ["my-cli 1.0.0"], [], 0);
+  await testCase(["req1", "sub", "req2", "--version"], ["my-cli 1.0.0"], [], 0);
 
   // Check that help flag takes precedence over execution
   await testCase(["--help"], [rootUsage], [], 0);
-  await testCase(["required1", "--help"], [rootUsage], [], 0);
-  await testCase(
-    ["required1", "subcommand", "--help"],
-    [subcommandUsage],
-    [],
-    0,
-  );
-  await testCase(
-    ["required1", "subcommand", "required2", "--help"],
-    [subcommandUsage],
-    [],
-    0,
-  );
+  await testCase(["req1", "--help"], [rootUsage], [], 0);
+  await testCase(["req1", "sub", "--help"], [subUsage], [], 0);
+  await testCase(["req1", "sub", "req2", "--help"], [subUsage], [], 0);
 
   // Help takes precedence over version
   await testCase(["--version", "--help"], [rootUsage], [], 0);
   await testCase(["--help", "--version"], [rootUsage], [], 0);
 
+  // Help still works after failed parsing (should show usage for the right command)
+  await testCase(["--invalid", "--help"], [rootUsage], [], 0);
+  await testCase(["invalid", "--help"], [rootUsage], [], 0);
+  await testCase(["req1", "sub", "--invalid", "--help"], [subUsage], [], 0);
+  await testCase(["req1", "sub", "invalid", "--help"], [subUsage], [], 0);
+
   // Weird help/version values inputs
   await testCase(
     ["--help=invalid"],
     [],
-    [rootUsage, `Error: --help: value: Not a boolean: "invalid"`],
+    [rootUsage, `Error: --help: value: Not a boolean: "invalid".`],
     1,
   );
   await testCase(
     ["--version=invalid"],
     [],
-    [rootUsage, `Error: --version: value: Not a boolean: "invalid"`],
+    [rootUsage, `Error: --version: value: Not a boolean: "invalid".`],
     1,
   );
 
   // Test multiple errors at once (first one should show only)
   await testCase(
-    ["--invalid1", "--invalid2", "required1", "--invalid3"],
+    ["--invalid1", "--invalid2", "req1", "--invalid3"],
     [],
-    [rootUsage, "Error: Unexpected unknown option: --invalid1"],
+    [
+      rootUsage,
+      'Error: Unknown option: "--invalid1". Did you mean: --single-value, --help, --version, ... ?',
+    ],
     1,
   );
   await testCase(
-    ["required1", "unknown", "-wut", "--flag", "--single-value"],
+    ["req1", "unknown", "-wut", "--flag", "--single-value"],
     [],
-    [rootUsage, 'Error: <subcommand>: Invalid value: "unknown"'],
+    [
+      rootUsage,
+      'Error: <subcommand>: Unknown name: "unknown". Did you mean: sub ?',
+    ],
     1,
   );
 
@@ -129,109 +121,130 @@ it("run", async function () {
   await testCase(
     [],
     [],
-    [rootUsage, "Error: <required1>: Is required, but was not provided"],
+    [
+      rootUsage,
+      "Error: <req1>: Is required, but was not provided. (Required1 positional description)",
+    ],
     1,
   );
   await testCase(
-    ["required1"],
+    ["req1"],
     [],
-    [rootUsage, "Error: <subcommand>: Is required, but was not provided"],
+    [rootUsage, "Error: <subcommand>: Missing argument. Did you mean: sub ?"],
     1,
   );
   await testCase(
-    ["required1", "subcommand"],
+    ["req1", "sub"],
     [],
-    [subcommandUsage, "Error: <required2>: Is required, but was not provided"],
+    [
+      subUsage,
+      "Error: <req2>: Is required, but was not provided. (Required2 positional description)",
+    ],
     1,
   );
 
-  // Test that flags become available when subcommand is known
+  // Test that flags become available when sub is known
   await testCase(
     ["--url", "https://example.com"],
     [],
-    [rootUsage, "Error: Unexpected unknown option: --url"],
+    [
+      rootUsage,
+      'Error: Unknown option: "--url". Did you mean: --help, -r, --version, ... ?',
+    ],
     1,
   );
   await testCase(
-    ["required1", "--url", "https://example.com"],
+    ["req1", "--url", "https://example.com"],
     [],
-    [rootUsage, "Error: Unexpected unknown option: --url"],
+    [
+      rootUsage,
+      'Error: Unknown option: "--url". Did you mean: --help, -r, --version, ... ?',
+    ],
     1,
   );
   await testCase(
-    ["required1", "subcommand", "--url", "https://example.com"],
+    ["req1", "sub", "--url", "https://example.com"],
     [],
-    [subcommandUsage, "Error: <required2>: Is required, but was not provided"],
+    [
+      subUsage,
+      "Error: <req2>: Is required, but was not provided. (Required2 positional description)",
+    ],
     1,
   );
   await testCase(
-    ["required1", "subcommand", "required2", "--url", "https://example.com"],
-    ["Has executed root command", "Has executed subcommand"],
+    ["req1", "sub", "req2", "--url", "https://example.com"],
+    ["Has executed root command", "Has executed sub"],
     [],
     0,
   );
 
   // Test option as flag parsing cases
   await testCase(
-    ["--flag", "--flag", "required1", "subcommand", "required2"],
+    ["--flag", "--flag", "req1", "sub", "req2"],
     [],
-    [subcommandUsage, "Error: --flag: Must not be set multiple times"],
+    [subUsage, "Error: --flag: Must not be set multiple times."],
     1,
   );
   await testCase(
-    ["--flag=42", "required1", "subcommand", "required2"],
+    ["--flag=42", "req1", "sub", "req2"],
     [],
-    [subcommandUsage, 'Error: --flag: value: Not a boolean: "42"'],
+    [subUsage, 'Error: --flag: value: Not a boolean: "42".'],
     1,
   );
   await testCase(
-    ["--flag=no", "required1", "subcommand", "required2"],
-    ["Has executed root command", "Has executed subcommand"],
+    ["--flag=no", "req1", "sub", "req2"],
+    ["Has executed root command", "Has executed sub"],
     [],
     0,
   );
   await testCase(
-    ["--flag=yes", "required1", "subcommand", "required2"],
-    ["Has executed root command", "Has executed subcommand"],
+    ["--flag=yes", "req1", "sub", "req2"],
+    ["Has executed root command", "Has executed sub"],
     [],
     0,
   );
   await testCase(
-    ["--flag", "required1", "subcommand", "required2"],
-    ["Has executed root command", "Has executed subcommand"],
+    ["--flag", "req1", "sub", "req2"],
+    ["Has executed root command", "Has executed sub"],
     [],
     0,
   );
 
   // Test option parsing errors
   await testCase(
-    ["--invalid", "required1", "subcommand", "required2"],
+    ["--invalid", "req1", "sub", "req2"],
     [],
-    [rootUsage, "Error: Unexpected unknown option: --invalid"],
+    [
+      rootUsage,
+      'Error: Unknown option: "--invalid". Did you mean: --single-value, --help, --flag, ... ?',
+    ],
     1,
   );
   await testCase(
-    ["required1", "subcommand", "required2", "--nope"],
+    ["req1", "sub", "req2", "--nope"],
     [],
-    [subcommandUsage, "Error: Unexpected unknown option: --nope"],
+    [
+      subUsage,
+      'Error: Unknown option: "--nope". Did you mean: --help, --flag, --repeatable, ... ?',
+    ],
     1,
   );
   await testCase(
-    ["required1", "subcommand", "required2", "--url"],
+    ["req1", "sub", "req2", "--url"],
     [],
-    [subcommandUsage, "Error: --url: Requires a value, but got end of input"],
+    [subUsage, "Error: --url: Requires a value, but got end of input."],
     1,
   );
   await testCase(
-    ["required1", "subcommand", "required2", "--url", "--", "url"],
+    ["req1", "sub", "req2", "--url", "--", "url"],
     [],
-    [subcommandUsage, 'Error: --url: Requires a value before "--"'],
+    [subUsage, 'Error: --url: Requires a value but got: "--".'],
     1,
   );
   await testCase(
-    ["required1", "subcommand", "required2", "--url", "--url"],
+    ["req1", "sub", "req2", "--url", "--url"],
     [],
-    [subcommandUsage, 'Error: --url: Requires a value, but got: "--url"'],
+    [subUsage, 'Error: --url: Requires a value, but got: "--url".'],
     1,
   );
 
@@ -239,105 +252,141 @@ it("run", async function () {
   await testCase(
     ["invalid"],
     [],
-    [rootUsage, "Error: <subcommand>: Is required, but was not provided"],
+    [rootUsage, "Error: <subcommand>: Missing argument. Did you mean: sub ?"],
     1,
   );
   await testCase(
-    ["invalid", "subcommand"],
+    ["invalid", "sub"],
     [],
     [
-      subcommandUsage,
-      'Error: <required1>: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+      subUsage,
+      'Error: <req1>: Unknown value: "invalid". Did you mean: "req1-bis", "req1" ?',
     ],
     1,
   );
   await testCase(
-    ["invalid", "subcommand", "required2"],
+    ["invalid", "sub", "req2"],
     [],
     [
-      subcommandUsage,
-      'Error: <required1>: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+      subUsage,
+      'Error: <req1>: Unknown value: "invalid". Did you mean: "req1-bis", "req1" ?',
     ],
     1,
   );
   await testCase(
-    ["required1", "subcommand", "invalid"],
+    ["req1", "sub", "invalid"],
     [],
     [
-      subcommandUsage,
-      'Error: <required2>: Invalid value: "invalid" (expected one of: "required2" | "required2-bis")',
+      subUsage,
+      'Error: <req2>: Unknown value: "invalid". Did you mean: "req2-bis", "req2" ?',
     ],
     1,
   );
   await testCase(
-    ["invalid", "subcommand", "invalid"],
+    ["invalid", "sub", "invalid"],
     [],
     [
-      subcommandUsage,
-      'Error: <required1>: Invalid value: "invalid" (expected one of: "required1" | "required1-bis")',
+      subUsage,
+      'Error: <req1>: Unknown value: "invalid". Did you mean: "req1-bis", "req1" ?',
     ],
     1,
   );
 
   // Test root command option invalid values (must not block parsing)
   await testCase(
-    ["--single-value=dodo", "required1", "subcommand", "required2"],
+    ["--single-value=dodo", "req1", "sub", "req2"],
     [],
     [
-      subcommandUsage,
-      'Error: --single-value: <enum(number)>: from: enum(string): Invalid value: "dodo" (expected one of: "42" | "43")',
+      subUsage,
+      'Error: --single-value: <enum(number)>: from: enum(string): Unknown value: "dodo". Did you mean: "42", "43" ?',
     ],
     1,
   );
   await testCase(
-    ["required1", "subcommand", "required2", "--single-value=44"],
+    ["req1", "sub", "req2", "--single-value=44"],
     [],
     [
-      subcommandUsage,
-      'Error: --single-value: <enum(number)>: from: enum(string): Invalid value: "44" (expected one of: "42" | "43")',
+      subUsage,
+      'Error: --single-value: <enum(number)>: from: enum(string): Unknown value: "44". Did you mean: "42", "43" ?',
     ],
     1,
   );
 
-  // Test subcommand-only option failures
+  // Test sub-only option failures
   await testCase(
-    ["--url", "not-a-url", "required1", "subcommand", "required2"],
+    ["--url", "not-a-url", "req1", "sub", "req2"],
     [],
-    [rootUsage, "Error: Unexpected unknown option: --url"],
+    [
+      rootUsage,
+      'Error: Unknown option: "--url". Did you mean: --help, -r, --version, ... ?',
+    ],
     1,
   );
   await testCase(
-    ["required1", "subcommand", "required2", "--url", "not-a-url"],
+    ["req1", "sub", "req2", "--url", "not-a-url"],
     [],
-    [subcommandUsage, 'Error: --url: <url>: Not an URL: "not-a-url"'],
+    [subUsage, 'Error: --url: <url>: Not an URL: "not-a-url".'],
     1,
   );
 
   // Test option multiple value parsing cases
   await testCase(
-    [
-      "required1",
-      "subcommand",
-      "required2",
-      "--repeatable=42",
-      "--repeatable",
-      "43",
-    ],
-    ["Has executed root command", "Has executed subcommand"],
+    ["req1", "sub", "req2", "--repeatable=42", "--repeatable", "43"],
+    ["Has executed root command", "Has executed sub"],
     [],
     0,
   );
   await testCase(
+    ["req1", "sub", "req2", "--single-value=42", "--single-value", "43"],
+    [],
+    [subUsage, "Error: --single-value: Must not be set multiple times."],
+    1,
+  );
+
+  // Test suggestions
+  await testCase(
+    ["req1", "sub", "req2", "-f"],
+    [],
+    [subUsage, 'Error: Unknown option: "-f". Did you mean: -ff, -r, -s, ... ?'],
+    1,
+  );
+  await testCase(
+    ["req1", "sub", "req2", "-flag"],
+    [],
+    [subUsage, 'Error: Unknown option: "-flag". Did you mean: --flag ?'],
+    1,
+  );
+  await testCase(
+    ["req1", "sub", "req2", "--uri"],
+    [],
+    [subUsage, 'Error: Unknown option: "--uri". Did you mean: --url ?'],
+    1,
+  );
+  await testCase(
+    ["req1", "sub", "req2", "--single-"],
+    [],
     [
-      "required1",
-      "subcommand",
-      "required2",
-      "--single-value=42",
-      "--single-value",
-      "43",
+      subUsage,
+      'Error: Unknown option: "--single-". Did you mean: --single-value ?',
     ],
+    1,
+  );
+  await testCase(
+    ["1req", "sub", "req2"],
     [],
-    [subcommandUsage, "Error: --single-value: Must not be set multiple times"],
+    [
+      subUsage,
+      'Error: <req1>: Unknown value: "1req". Did you mean: "req1", "req1-bis" ?',
+    ],
+    1,
+  );
+  await testCase(
+    ["req1", "subcomm"],
+    [],
+    [
+      rootUsage,
+      'Error: <subcommand>: Unknown name: "subcomm". Did you mean: sub ?',
+    ],
     1,
   );
 });
@@ -364,27 +413,30 @@ async function testCase(
         options: {
           optionFlag: optionFlag({
             long: "flag",
+            short: "ff",
             description: "Option flag description",
           }),
           optionRepeatable: optionRepeatable({
             long: "repeatable",
+            short: "r",
             type: type(),
             description: "Option repeatable description",
           }),
           optionSingleValue: optionSingleValue({
             long: "single-value",
+            short: "s",
             type: typeConverted(
               "enum(number)",
               typeChoice("enum(string)", ["42", "43"]),
               (value) => Number(value),
             ),
             description: "Option single value description",
-            defaultWhenNotDefined: () => 42,
+            fallbackValueIfAbsent: () => 42,
           }),
         },
         positionals: [
           positionalRequired({
-            type: typeChoice("required1", ["required1", "required1-bis"]),
+            type: typeChoice("req1", ["req1", "req1-bis"]),
             description: "Required1 positional description",
           }),
         ],
@@ -394,20 +446,21 @@ async function testCase(
       },
     ),
     {
-      subcommand: command(
+      sub: command(
         { description: "Subcommand Description" },
         operation(
           {
             options: {
               optionExtra: optionRepeatable({
                 long: "url",
+                short: "u",
                 description: "Option url description",
-                type: typeUrl("url"),
+                type: typeUrl(),
               }),
             },
             positionals: [
               positionalRequired({
-                type: typeChoice("required2", ["required2", "required2-bis"]),
+                type: typeChoice("req2", ["req2", "req2-bis"]),
                 description: "Required2 positional description",
               }),
               positionalOptional({
@@ -422,7 +475,7 @@ async function testCase(
             ],
           },
           async function (_, _inputs) {
-            console.log(`Has executed subcommand`);
+            console.log(`Has executed sub`);
           },
         ),
       ),

package/tests/unit.runner.errors.ts

@@ -1,4 +1,4 @@
-import { it } from "@jest/globals";
+import { expect, it } from "@jest/globals";
 import {
   command,
   operation,
@@ -13,35 +13,43 @@ import {
 it("run", async function () {
   await testCase(
     ["hello"],
-    '{{Error:}@darkRed}+ Unexpected argument: {{"hello"}@darkYellow}+',
+    '{{Error:}@darkRed}+ Unexpected argument: {{"hello"}@darkYellow}+.', // TODO - should we recommend help here ?
   );
   await testCase(
     ["--nope"],
-    "{{Error:}@darkRed}+ Unexpected unknown option: {{--nope}@darkYellow}+",
+    '{{Error:}@darkRed}+ Unknown option: {{"--nope"}@darkYellow}+. Did you mean: {{--help}@darkCyan}+, {{--flag}@darkCyan}+, {{--repeatable}@darkCyan}+, {{...}-}* ?',
   );
   await testCase(
-    ["--flag", "--flag"],
-    "{{Error:}@darkRed}+ {{--flag}@darkCyan}+: Must not be set multiple times",
-  );
-  await testCase(
-    ["--flag=invalid"],
-    '{{Error:}@darkRed}+ {{--flag}@darkCyan}+: {{value}@darkMagenta}+: Not a boolean: {{"invalid"}@darkYellow}+',
+    ["--repeat"],
+    '{{Error:}@darkRed}+ Unknown option: {{"--repeat"}@darkYellow}+. Did you mean: {{--repeatable}@darkCyan}+ ?',
   );
   await testCase(
     ["--single-value=a", "--single-value=b"],
-    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Must not be set multiple times",
+    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Must not be set multiple times.",
   );
   await testCase(
     ["--single-value"],
-    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Requires a value, but got end of input",
+    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: Requires a value, but got end of input.",
+  );
+  await testCase(
+    [],
+    "{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: {{<location>}@darkBlue}+: Is required, but was not set.",
   );
   await testCase(
     ["--single-value=invalid"],
-    '{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: {{<location>}@darkBlue}+: Not an URL: {{"invalid"}@darkYellow}+',
+    '{{Error:}@darkRed}+ {{--single-value}@darkCyan}+: {{<location>}@darkBlue}+: Not an URL: {{"invalid"}@darkYellow}+.',
   );
   await testCase(
     ["--repeatable=invalid"],
-    '{{Error:}@darkRed}+ {{--repeatable}@darkCyan}+: {{<index>}@darkBlue}+: Not a number: {{"invalid"}@darkYellow}+',
+    '{{Error:}@darkRed}+ {{--repeatable}@darkCyan}+: {{<index>}@darkBlue}+: Not a number: {{"invalid"}@darkYellow}+.',
+  );
+  await testCase(
+    ["--flag", "-f"],
+    "{{Error:}@darkRed}+ {{--flag}@darkCyan}+, {{-f}@darkCyan}+: Must not be set multiple times.",
+  );
+  await testCase(
+    ["--flag=invalid"],
+    '{{Error:}@darkRed}+ {{--flag}@darkCyan}+: {{value}@darkMagenta}+: Not a boolean: {{"invalid"}@darkYellow}+.',
   );
 });
 
@@ -54,16 +62,15 @@ async function testCase(args: Array<string>, error: string) {
     operation(
       {
         options: {
-          optionFlag: optionFlag({ long: "flag" }),
-          optionSingleValue: optionSingleValue({
-            long: "single-value",
-            type: typeUrl("location"),
-            defaultWhenNotDefined: () => undefined,
-          }),
+          optionFlag: optionFlag({ long: "flag", short: "f" }),
           optionRepeatable: optionRepeatable({
             long: "repeatable",
             type: typeNumber("index"),
           }),
+          optionSingleValue: optionSingleValue({
+            long: "single-value",
+            type: typeUrl("location"),
+          }),
         },
         positionals: [],
       },