cli-kiss 0.2.6 → 0.2.8

package/src/lib/Reader.ts

@@ -1,3 +1,4 @@
+import { suggestTextPushMessage } from "./Suggest";
 import {
   TypoError,
   TypoString,
@@ -7,54 +8,55 @@ import {
 } from "./Typo";
 
 /**
- * Opaque key returned by {@link ReaderArgs.registerOption}.
  */
-export type ReaderOptionKey = (string | { __brand: "ReaderOptionKey" }) & {
-  __brand: "ReaderOptionKey";
+export type ReaderOptionLongSpec = {
+  key: string;
+  nextGuard: ReaderOptionNextGuard;
 };
 
 /**
- * Parsing behaviour for a registered option, passed to {@link ReaderArgs.registerOption}.
  */
-export type ReaderOptionParsing = {
-  consumeShortGroup: boolean; // TODO - this doesnt matter when no short option
-  consumeNextArg: (
-    inlined: string | null,
-    separated: Array<string>,
-    nextArg: string | undefined,
-  ) => boolean;
+export type ReaderOptionShortSpec = {
+  key: string;
+  restGuard: ReaderOptionRestGuard;
+  nextGuard: ReaderOptionNextGuard;
+};
+
+/**
+ */
+export type ReaderOptionRestGuard = (rest: string) => boolean;
+
+/**
+ */
+export type ReaderOptionNextGuard = (
+  value: ReaderOptionValue,
+  next: string | undefined,
+) => boolean;
+
+/**
+ */
+export type ReaderOptionResult = {
+  identifier: string;
+  values: ReadonlyArray<ReaderOptionValue>;
 };
 
 /**
- * Result of parsing an option, including its inlined value and any following separated values.
  */
 export type ReaderOptionValue = {
   inlined: string | null;
-  separated: Array<string>;
+  separated: ReadonlyArray<string>;
 };
 
+/**
+ */
+export type ReaderOptionGetter = () => ReaderOptionResult;
+
 /**
  * Option registration/query interface. Subset of {@link ReaderArgs}.
  */
 export type ReaderOptions = {
-  /**
-   * Registers an option; all `longs` and `shorts` share the same key.
-   *
-   * @param definition.longs - Long-form names (without `--`).
-   * @param definition.shorts - Short-form names (without `-`).
-   * @param definition.parsing - Parsing behaviour.
-   * @returns A {@link ReaderOptionKey} for later retrieval.
-   * @throws `Error` if a name is already registered or short names overlap.
-   */
-  registerOption(definition: {
-    longs: Array<string>;
-    shorts: Array<string>;
-    parsing: ReaderOptionParsing;
-  }): ReaderOptionKey;
-  /**
-   * Returns all values collected for `key`.
-   */
-  getOptionValues(key: ReaderOptionKey): Array<ReaderOptionValue>;
+  registerOptionLong(longSpec: ReaderOptionLongSpec): ReaderOptionGetter;
+  registerOptionShort(shortSpec: ReaderOptionShortSpec): ReaderOptionGetter;
 };
 
 /**
@@ -65,7 +67,7 @@ export type ReaderPositionals = {
    * Returns the next positional token, parsing intervening options as side-effects.
    *
    * @returns The next positional, or `undefined` when exhausted.
-   * @throws {@link TypoError} on an unrecognised option.
+   * @throws on an unrecognised option.
    */
   consumePositional(): string | undefined;
 };
@@ -80,102 +82,74 @@ export type ReaderPositionals = {
  * Created internally by {@link runAndExit}; exposed for advanced / custom runners.
  */
 export class ReaderArgs {
-  #args: ReadonlyArray<string>;
+  #tokens: ReadonlyArray<string>;
   #parsedIndex: number;
   #parsedDouble: boolean;
-  #optionContextByLong: Map<string, ReaderOptionContext>;
-  #optionContextByShort: Map<string, ReaderOptionContext>;
-  #optionContextByKey: Map<ReaderOptionKey, ReaderOptionContext>;
+  #optionLongContextByIdentifier: Map<string, Context<ReaderOptionLongSpec>>;
+  #optionShortContextByIdentifier: Map<string, Context<ReaderOptionShortSpec>>;
 
   /**
-   * @param args - Raw CLI tokens (e.g. `process.argv.slice(2)`). Not mutated.
+   * @param tokens - Raw CLI tokens (e.g. `process.argv.slice(2)`).
    */
-  constructor(args: ReadonlyArray<string>) {
-    this.#args = args;
+  constructor(tokens: ReadonlyArray<string>) {
+    this.#tokens = tokens;
     this.#parsedIndex = 0;
     this.#parsedDouble = false;
-    this.#optionContextByLong = new Map();
-    this.#optionContextByShort = new Map();
-    this.#optionContextByKey = new Map();
+    this.#optionLongContextByIdentifier = new Map();
+    this.#optionShortContextByIdentifier = new Map();
   }
 
   /**
-   * Registers an option; all `longs` and `shorts` share the same key.
-   * Short names must not be prefixes of one another.
-   *
-   * @param definition.longs - Long-form names (without `--`).
-   * @param definition.shorts - Short-form names (without `-`).
-   * @param definition.parsing - Parsing behaviour.
-   * @returns A {@link ReaderOptionKey} for {@link ReaderArgs.getOptionValues}.
-   * @throws `Error` if any name is already registered or short names overlap.
    */
-  registerOption(definition: {
-    longs: Array<string>;
-    shorts: Array<string>;
-    parsing: ReaderOptionParsing;
-  }) {
-    const key = [
-      ...definition.longs.map((long) => `--${long}`),
-      ...definition.shorts.map((short) => `-${short}`),
-    ].join(", ") as ReaderOptionKey;
-    for (const long of definition.longs) {
-      if (!this.#isValidOptionName(long)) {
-        throw new Error(`Invalid option name: --${long}`);
-      }
-      if (this.#optionContextByLong.has(long)) {
-        throw new Error(`Option already registered: --${long}`);
-      }
+  registerOptionLong(longSpec: ReaderOptionLongSpec): ReaderOptionGetter {
+    const identifier = `--${longSpec.key}`;
+    if (!isValidOptionKey(longSpec.key)) {
+      throw new Error(`Option identifier is invalid: ${identifier}.`);
     }
-    for (const short of definition.shorts) {
-      if (!this.#isValidOptionName(short)) {
-        throw new Error(`Invalid option name: -${short}`);
-      }
-      if (this.#optionContextByShort.has(short)) {
-        throw new Error(`Option already registered: -${short}`);
-      }
-      for (let i = 0; i < short.length; i++) {
-        const shortSlice = short.slice(0, i);
-        if (this.#optionContextByShort.has(shortSlice)) {
-          throw new Error(
-            `Option -${short} overlap with shorter option: -${shortSlice}`,
-          );
-        }
-      }
-      for (const shortOther of this.#optionContextByShort.keys()) {
-        if (shortOther.startsWith(short)) {
-          throw new Error(
-            `Option -${short} overlap with longer option: -${shortOther}`,
-          );
-        }
-      }
-    }
-    const optionContext = {
-      parsing: definition.parsing,
-      results: new Array<ReaderOptionValue>(),
-    };
-    for (const long of definition.longs) {
-      this.#optionContextByLong.set(long, optionContext);
+    if (this.#optionLongContextByIdentifier.has(identifier)) {
+      throw new Error(`Option already registered: ${identifier}.`);
     }
-    for (const short of definition.shorts) {
-      this.#optionContextByShort.set(short, optionContext);
-    }
-    this.#optionContextByKey.set(key, optionContext);
-    return key;
+    const values = new Array<ReaderOptionValue>();
+    this.#optionLongContextByIdentifier.set(identifier, {
+      identifier,
+      spec: longSpec,
+      values,
+    });
+    return () => ({ identifier, values });
   }
 
   /**
-   * Returns all values collected for `key`.
-   *
-   * @param key - Key from {@link ReaderArgs.registerOption}.
-   * @returns One entry per occurrence.
-   * @throws `Error` if `key` was not registered.
    */
-  getOptionValues(key: ReaderOptionKey): Array<ReaderOptionValue> {
-    const optionContext = this.#optionContextByKey.get(key);
-    if (optionContext === undefined) {
-      throw new Error(`Unregistered option: ${key}`);
+  registerOptionShort(shortSpec: ReaderOptionShortSpec): ReaderOptionGetter {
+    const identifier = `-${shortSpec.key}`;
+    if (!isValidOptionKey(shortSpec.key)) {
+      throw new Error(`Option identifier is invalid: ${identifier}.`);
     }
-    return optionContext.results;
+    if (this.#optionShortContextByIdentifier.has(identifier)) {
+      throw new Error(`Option already registered: ${identifier}.`);
+    }
+    for (let i = 0; i < identifier.length; i++) {
+      const slicedIdentifier = identifier.slice(0, 1 + i);
+      if (this.#optionShortContextByIdentifier.has(slicedIdentifier)) {
+        throw new Error(
+          `Option ${identifier} overlap with shorter option: ${slicedIdentifier}.`,
+        );
+      }
+    }
+    for (const otherIdentifier of this.#optionShortContextByIdentifier.keys()) {
+      if (otherIdentifier.startsWith(identifier)) {
+        throw new Error(
+          `Option ${identifier} overlap with longer option: ${otherIdentifier}.`,
+        );
+      }
+    }
+    const values = new Array<ReaderOptionValue>();
+    this.#optionShortContextByIdentifier.set(identifier, {
+      identifier,
+      spec: shortSpec,
+      values,
+    });
+    return () => ({ identifier, values });
   }
 
   /**
@@ -183,168 +157,181 @@ export class ReaderArgs {
    * All tokens after `--` are treated as positionals.
    *
    * @returns The next positional, or `undefined` when exhausted.
-   * @throws {@link TypoError} on an unrecognised option.
+   * @throws on an unrecognised option.
    */
   consumePositional(): string | undefined {
     while (true) {
-      const arg = this.#consumeArg();
-      if (arg === undefined) {
+      const token = this.#consumeToken();
+      if (token === undefined) {
         return undefined;
       }
-      if (!this.#tryConsumeAsOption(arg)) {
-        return arg;
+      if (!this.#tryConsumeAsOption(token)) {
+        return token;
       }
     }
   }
 
-  #consumeArg(): string | undefined {
-    const arg = this.#args[this.#parsedIndex];
-    if (arg === undefined) {
+  #consumeToken(): string | undefined {
+    const token = this.#tokens[this.#parsedIndex];
+    if (token === undefined) {
       return undefined;
     }
     this.#parsedIndex++;
     if (!this.#parsedDouble) {
-      if (arg === "--") {
+      if (token === "--") {
         this.#parsedDouble = true;
-        return this.#consumeArg();
+        return this.#consumeToken();
       }
     }
-    return arg;
+    return token;
   }
 
-  #tryConsumeAsOption(arg: string): boolean {
+  #tryConsumeAsOption(token: string): boolean {
     if (this.#parsedDouble) {
       return false;
     }
-    if (arg.startsWith("--")) {
-      const valueIndexStart = arg.indexOf("=");
+    if (token.startsWith("--")) {
+      const valueIndexStart = token.indexOf("=");
       if (valueIndexStart === -1) {
-        this.#consumeOptionLong(arg.slice(2), null);
+        this.#consumeOptionLong(token, null);
       } else {
         this.#consumeOptionLong(
-          arg.slice(2, valueIndexStart),
-          arg.slice(valueIndexStart + 1),
+          token.slice(0, valueIndexStart),
+          token.slice(valueIndexStart + 1),
         );
       }
       return true;
     }
-    if (arg.startsWith("-")) {
+    if (token.startsWith("-")) {
       let shortIndexStart = 1;
       let shortIndexEnd = 2;
-      while (shortIndexEnd <= arg.length) {
-        const short = arg.slice(shortIndexStart, shortIndexEnd);
-        const optionContext = this.#optionContextByShort.get(short);
-        if (optionContext !== undefined) {
-          const rest = arg.slice(shortIndexEnd);
-          if (this.#tryConsumeOptionShort(optionContext, short, rest)) {
+      while (shortIndexEnd <= token.length) {
+        const identifier = `-${token.slice(shortIndexStart, shortIndexEnd)}`;
+        const shortContext =
+          this.#optionShortContextByIdentifier.get(identifier);
+        if (shortContext !== undefined) {
+          const tokenRest = token.slice(shortIndexEnd);
+          if (this.#tryConsumeOptionShort(shortContext, tokenRest)) {
             return true;
           }
           shortIndexStart = shortIndexEnd;
         }
         shortIndexEnd++;
       }
-      throw new TypoError(
-        new TypoText(
-          new TypoString(`Unexpected unknown option(s): `),
-          new TypoString(`-${arg.slice(shortIndexStart)}`, typoStyleQuote),
-        ),
-      );
+      this.#throwUnknownOptionError(`-${token.slice(shortIndexStart)}`);
     }
     return false;
   }
 
-  #consumeOptionLong(long: string, inlined: string | null): void {
-    const constant = `--${long}`;
-    const optionContext = this.#optionContextByLong.get(long);
-    if (optionContext !== undefined) {
-      return this.#consumeOptionValues(optionContext, constant, inlined);
+  #consumeOptionLong(identifier: string, valueInlined: string | null): void {
+    const longContext = this.#optionLongContextByIdentifier.get(identifier);
+    if (longContext !== undefined) {
+      return this.#consumeOptionValues(longContext, valueInlined);
     }
-    throw new TypoError(
-      new TypoText(
-        new TypoString(`Unexpected unknown option: `),
-        new TypoString(constant, typoStyleQuote),
-      ),
-    );
+    this.#throwUnknownOptionError(identifier);
   }
 
   #tryConsumeOptionShort(
-    optionContext: ReaderOptionContext,
-    short: string,
-    rest: string,
+    shortContext: Context<ReaderOptionShortSpec>,
+    tokenRest: string,
   ): boolean {
-    const constant = `-${short}`;
-    if (rest.startsWith("=")) {
-      this.#consumeOptionValues(optionContext, constant, rest.slice(1));
+    if (tokenRest.startsWith("=")) {
+      this.#consumeOptionValues(shortContext, tokenRest.slice(1));
       return true;
     }
-    if (rest.length === 0) {
-      this.#consumeOptionValues(optionContext, constant, null);
+    if (tokenRest.length === 0) {
+      this.#consumeOptionValues(shortContext, null);
       return true;
     }
-    if (optionContext.parsing.consumeShortGroup) {
-      this.#consumeOptionValues(optionContext, constant, rest);
+    if (shortContext.spec.restGuard(tokenRest)) {
+      this.#consumeOptionValues(shortContext, tokenRest);
       return true;
     }
-    this.#consumeOptionValues(optionContext, constant, null);
+    this.#consumeOptionValues(shortContext, null);
     return false;
   }
 
   #consumeOptionValues(
-    optionContext: ReaderOptionContext,
-    constant: string,
-    inlined: string | null,
+    context: Context<{ nextGuard: ReaderOptionNextGuard }>,
+    valueInlined: string | null,
   ) {
-    const separated = new Array<string>();
-    while (
-      optionContext.parsing.consumeNextArg(
-        inlined,
-        separated,
-        this.#args[this.#parsedIndex],
-      )
-    ) {
-      separated.push(this.#consumeOptionValue(constant));
+    const value = { inlined: valueInlined, separated: new Array<string>() };
+    const { identifier, values, spec } = context;
+    values.push(value);
+    while (true) {
+      const nextToken = this.#tokens[this.#parsedIndex];
+      if (!spec.nextGuard(value, nextToken)) {
+        return;
+      }
+      const token = this.#consumeToken();
+      if (this.#parsedDouble) {
+        throw new TypoError(
+          new TypoText(
+            new TypoString(identifier, typoStyleConstants),
+            new TypoString(`: Requires a value but got: `),
+            new TypoString(`"--"`, typoStyleQuote),
+            new TypoString(`.`),
+          ),
+        );
+      }
+      // TODO - should we allow consuming the EOF token ?
+      if (token === undefined) {
+        throw new TypoError(
+          new TypoText(
+            new TypoString(identifier, typoStyleConstants),
+            new TypoString(`: Requires a value, but got end of input.`), // TODO - hint at option value syntax ?
+          ),
+        );
+      }
+      // TODO - is that weird, could a valid value start with dash ?
+      if (token.startsWith("-")) {
+        throw new TypoError(
+          new TypoText(
+            new TypoString(identifier, typoStyleConstants),
+            new TypoString(`: Requires a value, but got: `),
+            new TypoString(`"${token}"`, typoStyleQuote),
+            new TypoString(`.`),
+          ),
+        );
+      }
+      value.separated.push(token);
     }
-    optionContext.results.push({ inlined, separated });
   }
 
-  #consumeOptionValue(constant: string): string {
-    const arg = this.#consumeArg();
-    if (arg === undefined) {
-      throw new TypoError(
-        new TypoText(
-          new TypoString(constant, typoStyleConstants),
-          new TypoString(`: Requires a value, but got end of input`),
-        ),
-      );
+  #throwUnknownOptionError(inputIdentifier: string): never {
+    const candidatesIdentifiers = [];
+    for (const identifier of this.#optionLongContextByIdentifier.keys()) {
+      candidatesIdentifiers.push(identifier);
     }
-    if (this.#parsedDouble) {
-      throw new TypoError(
-        new TypoText(
-          new TypoString(constant, typoStyleConstants),
-          new TypoString(`: Requires a value before `),
-          new TypoString(`"--"`, typoStyleQuote),
-        ),
-      );
+    for (const identifier of this.#optionShortContextByIdentifier.keys()) {
+      candidatesIdentifiers.push(identifier);
     }
-    // TODO - is that weird, could a valid value start with dash ?
-    if (arg.startsWith("-")) {
-      throw new TypoError(
-        new TypoText(
-          new TypoString(constant, typoStyleConstants),
-          new TypoString(`: Requires a value, but got: `),
-          new TypoString(`"${arg}"`, typoStyleQuote),
-        ),
+    const errorText = new TypoText();
+    errorText.push(new TypoString(`Unknown option: `));
+    errorText.push(new TypoString(`"${inputIdentifier}"`, typoStyleQuote));
+    if (candidatesIdentifiers.length === 0) {
+      errorText.push(new TypoString(`, no options are registered.`));
+    } else {
+      errorText.push(new TypoString(`.`));
+      suggestTextPushMessage(
+        errorText,
+        inputIdentifier,
+        candidatesIdentifiers.map((candidateIdentifier) => ({
+          reference: candidateIdentifier,
+          hint: new TypoString(candidateIdentifier, typoStyleConstants),
+        })),
       );
     }
-    return arg;
+    throw new TypoError(errorText);
   }
+}
 
-  #isValidOptionName(name: string): boolean {
-    return name.length > 0 && !name.includes("=") && !name.includes("\0");
-  }
+function isValidOptionKey(name: string): boolean {
+  return name.length > 0 && !name.includes("=") && !name.includes("\0");
 }
 
-type ReaderOptionContext = {
-  parsing: ReaderOptionParsing;
-  results: Array<ReaderOptionValue>;
+type Context<Spec> = {
+  identifier: string;
+  spec: Spec;
+  values: Array<ReaderOptionValue>;
 };

package/src/lib/Run.ts

@@ -75,9 +75,9 @@ export async function runAndExit<Context>(
   if (colorSetup === "flag") {
     const colorOption = optionSingleValue<"auto" | RunColorMode>({
       long: "color",
-      type: typeChoice("color-mode", ["auto", "always", "never", "mock"]),
-      defaultWhenNotDefined: () => "auto",
-      defaultWhenNotInlined: () => "always",
+      type: typeChoice("color-mode", ["auto", "always", "never"]),
+      fallbackValueIfAbsent: () => "auto",
+      impliedValueIfNotInlined: () => "always",
     }).registerAndMakeDecoder(readerArgs);
     preprocessors.push(() => {
       try {
@@ -103,7 +103,7 @@ export async function runAndExit<Context>(
       return 0;
     });
   }
-  if (options?.buildVersion) {
+  if (options?.buildVersion !== undefined) {
     const versionOption = optionFlag({
       long: "version",
     }).registerAndMakeDecoder(readerArgs);
@@ -115,6 +115,8 @@ export async function runAndExit<Context>(
       return 0;
     });
   }
+  // TODO - the lifecycle of this function should be improved
+  // TODO - how to pass the color information to the command logic ?
   /*
   // TODO - handle completions ?
   readerArgs.registerFlag({
@@ -145,27 +147,36 @@ export async function runAndExit<Context>(
       await commandInterpreter.executeWithContext(context);
       return onExit(0);
     } catch (executionError) {
-      handleError(options?.onError, executionError, typoSupport);
+      handleError(cliName, options?.onError, executionError, typoSupport);
       return onExit(1);
     }
   } catch (parsingError) {
     if (options?.usageOnError ?? true) {
       console.error(computeUsageString(cliName, commandDecoder, typoSupport));
     }
-    handleError(options?.onError, parsingError, typoSupport);
+    handleError(cliName, options?.onError, parsingError, typoSupport);
     return onExit(1);
   }
 }
 
 function handleError(
+  _cliName: string,
   onError: ((error: unknown) => void) | undefined,
   error: unknown,
   typoSupport: TypoSupport,
 ) {
+  // TODO - should the cliName be part of the error message for logs ?
+  const finalError = error;
+  /*
+  const finalError = new TypoError(
+    new TypoText(new TypoString(cliName, typoStyleConstants)),
+    error,
+  );
+  */
   if (onError !== undefined) {
-    onError(error);
+    onError(finalError);
   } else {
-    console.error(typoSupport.computeStyledErrorMessage(error));
+    console.error(typoSupport.computeStyledErrorMessage(finalError));
   }
 }
 

package/src/lib/Suggest.ts

@@ -0,0 +1,78 @@
+import { TypoSegment, TypoString, TypoText } from "./Typo";
+
+export function suggestTextPushMessage(
+  text: TypoText,
+  query: string,
+  candidates: Array<{ reference: string; hint: TypoSegment }>,
+) {
+  const reasonableHints = suggestReasonablePayloads(
+    query,
+    candidates.map(({ reference, hint }) => ({ reference, payload: hint })),
+  );
+  if (reasonableHints.length === 0) {
+    return;
+  }
+  text.push(new TypoString(" Did you mean: "));
+  text.pushJoined(reasonableHints, new TypoString(", "), 3);
+  text.push(new TypoString(` ?`));
+}
+
+function suggestReasonablePayloads<Payload>(
+  query: string,
+  candidates: Array<{ reference: string; payload: Payload }>,
+): Array<Payload> {
+  if (candidates.length === 0) {
+    return [];
+  }
+  const sortedAlternatives = computeAndSortByDivergences(query, candidates);
+  const divergenceThreshold = sortedAlternatives[0]!.divergence + 0.25;
+  const acceptablePayloads = new Array<Payload>();
+  for (const { divergence, payload } of sortedAlternatives) {
+    if (divergence > divergenceThreshold) {
+      break;
+    }
+    acceptablePayloads.push(payload);
+  }
+  return acceptablePayloads;
+}
+
+function computeAndSortByDivergences<Payload>(
+  query: string,
+  candidates: Array<{ reference: string; payload: Payload }>,
+): Array<{ divergence: number; payload: Payload }> {
+  const queryNormalized = query.toLowerCase().slice(0, 100);
+  const scored = candidates.map(({ reference, payload }) => {
+    const referenceNormalized = reference.toLowerCase().slice(0, 100);
+    const divergence =
+      distanceDamerauLevenshtein(queryNormalized, referenceNormalized) /
+      Math.max(queryNormalized.length, referenceNormalized.length);
+    return { divergence, reference, payload };
+  });
+  return scored.sort((a, b) => a.divergence - b.divergence);
+}
+
+function distanceDamerauLevenshtein(a: string, b: string): number {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array<number>(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) {
+    dp[i]![0] = i;
+  }
+  for (let j = 0; j <= n; j++) {
+    dp[0]![j] = j;
+  }
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i]![j] = Math.min(
+        dp[i - 1]![j]! + 1,
+        dp[i]![j - 1]! + 1,
+        dp[i - 1]![j - 1]! + cost,
+      );
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        dp[i]![j] = Math.min(dp[i]![j]!, dp[i - 2]![j - 2]! + cost);
+      }
+    }
+  }
+  return dp[m]![n]!;
+}