@flowscripter/dynamic-cli-framework 1.1.6 → 1.2.0

package/src/service/argumentPrompter/ArgumentPrompterServiceProvider.ts

@@ -0,0 +1,34 @@
+import type Context from "../../api/Context.ts";
+import type {
+  ServiceInfo,
+  ServiceProvider,
+} from "../../api/service/ServiceProvider.ts";
+import type ArgumentPrompterService from "../../api/service/core/ArgumentPrompterService.ts";
+import { ARGUMENT_PROMPTER_SERVICE_ID } from "../../api/service/core/ArgumentPrompterService.ts";
+import type CLIConfig from "../../api/CLIConfig.ts";
+
+export default class ArgumentPrompterServiceProvider
+  implements ServiceProvider {
+  readonly serviceId: string = ARGUMENT_PROMPTER_SERVICE_ID;
+  readonly servicePriority: number;
+  readonly argumentPrompterService: ArgumentPrompterService;
+
+  public constructor(
+    servicePriority: number,
+    argumentPrompterService: ArgumentPrompterService,
+  ) {
+    this.servicePriority = servicePriority;
+    this.argumentPrompterService = argumentPrompterService;
+  }
+
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+    return Promise.resolve({
+      service: this.argumentPrompterService,
+      commands: [],
+    });
+  }
+
+  initService(_context: Context): Promise<void> {
+    return Promise.resolve();
+  }
+}

package/src/service/argumentPrompter/DefaultArgumentPrompterService.ts

@@ -0,0 +1,330 @@
+import type ArgumentPrompterService from "../../api/service/core/ArgumentPrompterService.ts";
+import type { ParseResult } from "../../runtime/parser.ts";
+import type PrompterService from "../../api/service/core/PrompterService.ts";
+import {
+  type Prompt,
+  type PromptOption,
+  PromptType,
+} from "../../api/service/core/PrompterService.ts";
+import { InvalidArgumentReason } from "../../api/RunResult.ts";
+import type { InvalidArgument } from "../../api/RunResult.ts";
+import {
+  type ArgumentSingleValueType,
+  ArgumentValueTypeName,
+  ComplexValueTypeName,
+  type PopulatedArgumentSingleValueType,
+  type PopulatedArgumentValues,
+} from "../../api/argument/ArgumentValueTypes.ts";
+import type Argument from "../../api/argument/Argument.ts";
+import type Option from "../../api/argument/Option.ts";
+import type Positional from "../../api/argument/Positional.ts";
+import type ComplexOption from "../../api/argument/ComplexOption.ts";
+import type SubCommand from "../../api/command/SubCommand.ts";
+import type GlobalCommand from "../../api/command/GlobalCommand.ts";
+import {
+  isGlobalCommand,
+  isSubCommand,
+} from "../../runtime/command/CommandTypeGuards.ts";
+
+export default class DefaultArgumentPrompterService
+  implements ArgumentPrompterService {
+  readonly #prompterService: PrompterService;
+
+  public constructor(prompterService: PrompterService) {
+    this.#prompterService = prompterService;
+  }
+
+  async promptForMissingArguments(
+    parseResult: ParseResult,
+  ): Promise<ParseResult> {
+    if (!this.#prompterService.promptEnabled) {
+      return parseResult;
+    }
+
+    const allMissingValue = parseResult.invalidArguments.every(
+      (ia) => ia.reason === InvalidArgumentReason.MISSING_VALUE,
+    );
+    if (!allMissingValue) {
+      return parseResult;
+    }
+
+    if (parseResult.invalidArguments.length === 0) {
+      return parseResult;
+    }
+
+    try {
+      if (isGlobalCommand(parseResult.command)) {
+        return await this.#promptForGlobalCommand(parseResult);
+      }
+      if (isSubCommand(parseResult.command)) {
+        return await this.#promptForSubCommand(parseResult);
+      }
+    } catch (error) {
+      if ((error as Error).message === "Interrupted") {
+        throw error;
+      }
+      return parseResult;
+    }
+
+    return parseResult;
+  }
+
+  async #promptForGlobalCommand(
+    parseResult: ParseResult,
+  ): Promise<ParseResult> {
+    const command = parseResult.command as GlobalCommand;
+    if (!command.argument) {
+      return parseResult;
+    }
+
+    const prompt = DefaultArgumentPrompterService.#argumentToPrompt(
+      command.name,
+      command.name,
+      command.argument,
+    );
+    const result = await this.#prompterService.prompt(prompt);
+    const value = DefaultArgumentPrompterService.#coerceValue(
+      result.value as ArgumentSingleValueType,
+      command.argument.type,
+    );
+
+    return {
+      command: parseResult.command,
+      groupCommand: parseResult.groupCommand,
+      populatedArgumentValues: value as PopulatedArgumentSingleValueType,
+      invalidArguments: [],
+      unusedArgs: parseResult.unusedArgs,
+    };
+  }
+
+  async #promptForSubCommand(
+    parseResult: ParseResult,
+  ): Promise<ParseResult> {
+    const command = parseResult.command as SubCommand;
+    const existingValues = (parseResult.populatedArgumentValues ??
+      {}) as PopulatedArgumentValues;
+    const newValues: Record<
+      string,
+      PopulatedArgumentValues[string]
+    > = { ...existingValues };
+    const remainingInvalid: InvalidArgument[] = [];
+
+    for (const invalid of parseResult.invalidArguments) {
+      if (
+        invalid.reason !== InvalidArgumentReason.MISSING_VALUE ||
+        !invalid.name
+      ) {
+        remainingInvalid.push(invalid);
+        continue;
+      }
+
+      const arg = DefaultArgumentPrompterService.#findArgument(
+        command,
+        invalid.name,
+      );
+      if (!arg) {
+        remainingInvalid.push(invalid);
+        continue;
+      }
+
+      if (
+        "type" in arg &&
+        (arg as ComplexOption).type === ComplexValueTypeName.COMPLEX
+      ) {
+        const complexValues = await this.#promptForComplexOption(
+          invalid.name,
+          arg as ComplexOption,
+        );
+        newValues[invalid.name] = complexValues;
+      } else if (
+        DefaultArgumentPrompterService.#isArrayArgument(arg)
+      ) {
+        const arrayValues = await this.#promptForArrayArgument(
+          invalid.name,
+          arg as Option | Positional,
+        );
+        newValues[invalid.name] = arrayValues;
+      } else {
+        const prompt = DefaultArgumentPrompterService.#argumentToPrompt(
+          invalid.name,
+          (arg as Option | Positional).description ?? invalid.name,
+          arg as Argument,
+        );
+        const result = await this.#prompterService.prompt(prompt);
+        newValues[invalid.name] = DefaultArgumentPrompterService.#coerceValue(
+          result.value as ArgumentSingleValueType,
+          (arg as Argument).type,
+        );
+      }
+    }
+
+    return {
+      command: parseResult.command,
+      groupCommand: parseResult.groupCommand,
+      populatedArgumentValues: newValues as PopulatedArgumentValues,
+      invalidArguments: remainingInvalid,
+      unusedArgs: parseResult.unusedArgs,
+    };
+  }
+
+  async #promptForComplexOption(
+    name: string,
+    complexOption: ComplexOption,
+  ): Promise<PopulatedArgumentValues> {
+    const values: Record<string, PopulatedArgumentValues[string]> = {};
+
+    for (const prop of complexOption.properties) {
+      if (
+        "type" in prop &&
+        (prop as ComplexOption).type === ComplexValueTypeName.COMPLEX
+      ) {
+        values[(prop as ComplexOption).name] = await this
+          .#promptForComplexOption(
+            `${name}.${(prop as ComplexOption).name}`,
+            prop as ComplexOption,
+          );
+      } else {
+        const option = prop as Option;
+        if (option.isOptional && option.defaultValue !== undefined) {
+          continue;
+        }
+        const prompt = DefaultArgumentPrompterService.#argumentToPrompt(
+          `${name}.${option.name}`,
+          option.description ?? `${name}.${option.name}`,
+          option,
+        );
+        const result = await this.#prompterService.prompt(prompt);
+        values[option.name] = DefaultArgumentPrompterService.#coerceValue(
+          result.value as ArgumentSingleValueType,
+          option.type,
+        );
+      }
+    }
+
+    return values as PopulatedArgumentValues;
+  }
+
+  async #promptForArrayArgument(
+    name: string,
+    arg: Option | Positional,
+  ): Promise<Array<ArgumentSingleValueType>> {
+    const values: ArgumentSingleValueType[] = [];
+
+    while (true) {
+      const prompt = DefaultArgumentPrompterService.#argumentToPrompt(
+        name,
+        `${arg.description ?? name}${
+          values.length > 0 ? ` [${values.length + 1}]` : ""
+        }`,
+        arg as Argument,
+      );
+      const result = await this.#prompterService.prompt(prompt);
+      values.push(
+        DefaultArgumentPrompterService.#coerceValue(
+          result.value as ArgumentSingleValueType,
+          (arg as Argument).type,
+        ),
+      );
+
+      const addAnother: Prompt = {
+        name: `${name}_more`,
+        promptText: `Add another value for ${name}?`,
+        type: PromptType.ACKNOWLEDGE,
+        options: [],
+      };
+      const moreResult = await this.#prompterService.prompt(addAnother);
+      if (moreResult.value !== true) {
+        break;
+      }
+    }
+
+    return values;
+  }
+
+  static #argumentToPrompt(
+    name: string,
+    description: string,
+    arg: Argument,
+  ): Prompt {
+    if (arg.type === ArgumentValueTypeName.BOOLEAN) {
+      return {
+        name,
+        promptText: description,
+        type: PromptType.TOGGLE,
+        options: [],
+      };
+    }
+
+    if (arg.allowableValues && arg.allowableValues.length > 0) {
+      const options: PromptOption[] = arg.allowableValues.map((v) => ({
+        displayValue: String(v),
+        returnedValue: v,
+      }));
+      return {
+        name,
+        promptText: description,
+        type: PromptType.SINGLE_SELECT,
+        options,
+      };
+    }
+
+    const validationOption: PromptOption = {
+      displayValue: arg.type === ArgumentValueTypeName.SECRET
+        ? "__SECRET__"
+        : name,
+      returnedValue: "",
+      min: arg.minValueInclusive,
+      max: arg.maxValueInclusive,
+      validate: arg.validate ? (v) => arg.validate!(v) : undefined,
+    };
+
+    return {
+      name,
+      promptText: description,
+      type: PromptType.TEXT,
+      options: [validationOption],
+    };
+  }
+
+  static #coerceValue(
+    value: ArgumentSingleValueType,
+    type: ArgumentValueTypeName,
+  ): ArgumentSingleValueType {
+    if (typeof value === "string") {
+      switch (type) {
+        case ArgumentValueTypeName.INTEGER:
+          return parseInt(value, 10);
+        case ArgumentValueTypeName.NUMBER:
+          return parseFloat(value);
+        case ArgumentValueTypeName.BOOLEAN:
+          return value.toLowerCase() === "true";
+      }
+    }
+    return value;
+  }
+
+  static #findArgument(
+    command: SubCommand,
+    name: string,
+  ): Option | Positional | ComplexOption | undefined {
+    for (const opt of command.options) {
+      if (opt.name === name) return opt;
+    }
+    for (const pos of command.positionals) {
+      if (pos.name === name) return pos;
+    }
+    return undefined;
+  }
+
+  static #isArrayArgument(
+    arg: Option | Positional | ComplexOption,
+  ): boolean {
+    if ("isArray" in arg && (arg as Option).isArray) {
+      return true;
+    }
+    if ("isVarargMultiple" in arg && (arg as Positional).isVarargMultiple) {
+      return true;
+    }
+    return false;
+  }
+}

package/src/service/asciiBannerGenerator/AsciiBannerGeneratorServiceProvider.ts

@@ -32,7 +32,7 @@ export default class AsciiBannerGeneratorServiceProvider
       new DefaultAsciiBannerGeneratorService();
   }
 
-  public provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
     return Promise.resolve({
       service: this.#asciiBannerGeneratorService,
       commands: [],

package/src/service/asciiBannerGenerator/DefaultAsciiBannerGeneratorService.ts

@@ -1,12 +1,94 @@
 import type AsciiBannerGeneratorService from "../../api/service/core/AsciiBannerGeneratorService.ts";
+import type {
+  BannerGenerateOptions,
+  ColorEffect,
+} from "../../api/service/core/AsciiBannerGeneratorService.ts";
+import {
+  BACKGROUND_COLOR_END,
+  backgroundColorStart,
+  FOREGROUND_COLOR_END,
+  foregroundColorStart,
+} from "../../terminal/Ansi.ts";
 import figlet from "figlet";
-// FIGlet font is converted to a JSON string and embedded in a simple JSON file: `{ "font": "<figlet font definition>" }`
 import standardFont from "./standard.flf.json" with { type: "json" };
 
-/**
- * Default implementation of {@link AsciiBannerGeneratorService} which has a font definition
- * for the FIGlet "standard" font already registered.
- */
+function hslToRgb(h: number, s: number, l: number): [number, number, number] {
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(((h * 6) % 2) - 1));
+  const m = l - c / 2;
+  let r = 0, g = 0, b = 0;
+  if (h < 1 / 6) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (h < 2 / 6) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (h < 3 / 6) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (h < 4 / 6) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (h < 5 / 6) {
+    r = x;
+    g = 0;
+    b = c;
+  } else {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  return [
+    Math.round((r + m) * 255),
+    Math.round((g + m) * 255),
+    Math.round((b + m) * 255),
+  ];
+}
+
+function parseHex(hex: string): [number, number, number] {
+  const v = parseInt(hex.slice(1), 16);
+  return [(v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF];
+}
+
+function interpolateColors(
+  colorStops: [number, number, number][],
+  position: number,
+  total: number,
+): [number, number, number] {
+  const first = colorStops[0];
+  if (total <= 1 || first === undefined) return first ?? [0, 0, 0];
+  const t = position / (total - 1);
+  const scaledT = t * (colorStops.length - 1);
+  const idx = Math.min(Math.floor(scaledT), colorStops.length - 2);
+  const localT = scaledT - idx;
+  const stop1 = colorStops[idx];
+  const stop2 = colorStops[idx + 1];
+  if (stop1 === undefined || stop2 === undefined) return first;
+  const [r1, g1, b1] = stop1;
+  const [r2, g2, b2] = stop2;
+  return [
+    Math.round(r1 + (r2 - r1) * localT),
+    Math.round(g1 + (g2 - g1) * localT),
+    Math.round(b1 + (b2 - b1) * localT),
+  ];
+}
+
+function rainbowColor(
+  freq: number,
+  spread: number,
+  seed: number,
+  x: number,
+  y: number,
+): [number, number, number] {
+  const h = ((freq * (x / spread) + seed + y * freq / spread) % 1.0 + 1.0) %
+    1.0;
+  return hslToRgb(h, 1.0, 0.5);
+}
+
 export default class DefaultAsciiBannerGeneratorService
   implements AsciiBannerGeneratorService {
   #registeredFontNames: Array<string> = [];
@@ -28,22 +110,177 @@ export default class DefaultAsciiBannerGeneratorService
     figlet.parseFont(fontName, fontDefinition);
   }
 
-  async generate(message: string, fontName: string): Promise<string> {
-    const name = fontName.toLowerCase();
-    if (!this.getRegisteredFonts().includes(name)) {
-      throw new Error(`Font name is not registered: ${name}`);
+  protected applyForegroundEffect(
+    lines: string[],
+    effect: ColorEffect,
+  ): string[] {
+    if (effect.type === "fixed") {
+      const [r, g, b] = parseHex(effect.color);
+      const code = foregroundColorStart(r, g, b);
+      return lines.map((line) =>
+        line.split("").map((ch) =>
+          ch === " " ? ch : code + ch + FOREGROUND_COLOR_END
+        ).join(
+          "",
+        )
+      );
+    }
+    if (effect.type === "gradient") {
+      const colorStops = effect.colors.map(parseHex);
+      return lines.map((line, yi) => {
+        if (effect.direction === "vertical") {
+          const [r, g, b] = interpolateColors(
+            colorStops,
+            yi,
+            Math.max(lines.length, 1),
+          );
+          const code = foregroundColorStart(r, g, b);
+          return line.split("").map((ch) =>
+            ch === " " ? ch : code + ch + FOREGROUND_COLOR_END
+          ).join("");
+        }
+        const nonSpaceCount = line.split("").filter((c) => c !== " ").length;
+        let charIdx = 0;
+        return line.split("").map((ch) => {
+          if (ch === " ") return ch;
+          const [r, g, b] = interpolateColors(
+            colorStops,
+            charIdx,
+            Math.max(nonSpaceCount, 1),
+          );
+          charIdx++;
+          return foregroundColorStart(r, g, b) + ch + FOREGROUND_COLOR_END;
+        }).join("");
+      });
+    }
+    const freq = effect.frequency ?? 0.3;
+    const spread = effect.spread ?? 8.0;
+    const seed = effect.seed ?? Math.random();
+    return lines.map((line, yi) => {
+      if (effect.direction === "vertical") {
+        const [r, g, b] = rainbowColor(freq, spread, seed, 0, yi);
+        const code = foregroundColorStart(r, g, b);
+        return line.split("").map((ch) =>
+          ch === " " ? ch : code + ch + FOREGROUND_COLOR_END
+        ).join("");
+      }
+      let charIdx = 0;
+      return line.split("").map((ch) => {
+        if (ch === " ") return ch;
+        const [r, g, b] = rainbowColor(freq, spread, seed, charIdx, yi);
+        charIdx++;
+        return foregroundColorStart(r, g, b) + ch + FOREGROUND_COLOR_END;
+      }).join("");
+    });
+  }
+
+  protected applyBackgroundEffect(
+    lines: string[],
+    effect: ColorEffect,
+  ): string[] {
+    if (effect.type === "fixed") {
+      const [r, g, b] = parseHex(effect.color);
+      const code = backgroundColorStart(r, g, b);
+      return lines.map((line) => code + line + BACKGROUND_COLOR_END);
+    }
+    if (effect.type === "gradient") {
+      const colorStops = effect.colors.map(parseHex);
+      return lines.map((line, yi) => {
+        if (effect.direction === "vertical") {
+          const [r, g, b] = interpolateColors(
+            colorStops,
+            yi,
+            Math.max(lines.length, 1),
+          );
+          return backgroundColorStart(r, g, b) + line + BACKGROUND_COLOR_END;
+        }
+        const totalChars = Math.max(line.length, 1);
+        return line.split("").map((ch, xi) => {
+          const [r, g, b] = interpolateColors(colorStops, xi, totalChars);
+          return backgroundColorStart(r, g, b) + ch + BACKGROUND_COLOR_END;
+        }).join("");
+      });
+    }
+    const freq = effect.frequency ?? 0.3;
+    const spread = effect.spread ?? 8.0;
+    const seed = effect.seed ?? Math.random();
+    return lines.map((line, yi) => {
+      if (effect.direction === "vertical") {
+        const [r, g, b] = rainbowColor(freq, spread, seed, 0, yi);
+        return backgroundColorStart(r, g, b) + line + BACKGROUND_COLOR_END;
+      }
+      return line.split("").map((ch, xi) => {
+        const [r, g, b] = rainbowColor(freq, spread, seed, xi, yi);
+        return backgroundColorStart(r, g, b) + ch + BACKGROUND_COLOR_END;
+      }).join("");
+    });
+  }
+
+  async generate(
+    message: string,
+    options?: BannerGenerateOptions,
+  ): Promise<string> {
+    const fontName = (options?.fontName ?? "standard").toLowerCase();
+    if (!this.getRegisteredFonts().includes(fontName)) {
+      throw new Error(`Font name is not registered: ${fontName}`);
+    }
+
+    const bannerText = await figlet.text(message, { font: fontName });
+    let titleLines = bannerText.split("\n");
+
+    while (titleLines.length > 0) {
+      const last = titleLines[titleLines.length - 1];
+      if (last === undefined || last.trim().length > 0) break;
+      titleLines.pop();
+    }
+
+    let subMessageLine: string | undefined;
+    if (options?.subMessage) {
+      subMessageLine = options.subMessage
+        .toUpperCase()
+        .split("")
+        .map((c) => c === " " ? "  " : c + " ")
+        .join("")
+        .trimEnd();
+
+      const bannerWidth = Math.max(...titleLines.map((l) => l.length));
+      const subWidth = subMessageLine.length;
+
+      if (bannerWidth >= subWidth) {
+        const pad = Math.floor((bannerWidth - subWidth) / 2);
+        subMessageLine = " ".repeat(pad) + subMessageLine;
+      } else {
+        const pad = Math.floor((subWidth - bannerWidth) / 2);
+        titleLines = titleLines.map((l) => " ".repeat(pad) + l);
+      }
+    }
+
+    const colorEffects = options?.colorEffects;
+
+    if (colorEffects?.messageForeground) {
+      titleLines = this.applyForegroundEffect(
+        titleLines,
+        colorEffects.messageForeground,
+      );
+    }
+
+    let subLines: string[] | undefined;
+    if (subMessageLine !== undefined) {
+      subLines = [subMessageLine];
+      if (colorEffects?.subMessageForeground) {
+        subLines = this.applyForegroundEffect(
+          subLines,
+          colorEffects.subMessageForeground,
+        );
+      }
     }
 
-    const bannerText = await figlet.text(message, { font: name });
-    const lines = bannerText.split("\n");
+    let allLines = subLines ? [...titleLines, ...subLines] : titleLines;
 
-    // Remove any whitespace lines from the end
-    while (
-      (lines.length > 0) && (lines[lines.length - 1].trim().length === 0)
-    ) {
-      lines.pop();
+    if (colorEffects?.background) {
+      allLines = this.applyBackgroundEffect(allLines, colorEffects.background);
     }
 
-    return "\n" + lines.join("\n") + "\n";
+    return "\n" + allLines.join("\n") + "\n";
   }
 }

package/src/service/banner/BannerServiceProvider.ts

@@ -46,7 +46,7 @@ export default class BannerServiceProvider implements ServiceProvider {
     this.#configurationServiceProvider = configurationServiceProvider;
   }
 
-  public provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+  public getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
     return Promise.resolve({
       commands: [
         new NoBannerCommand(this, this.servicePriority),
@@ -70,7 +70,7 @@ export default class BannerServiceProvider implements ServiceProvider {
     const { cliConfig } = context;
     const bannerText = await asciiBannerGeneratorService.generate(
       cliConfig.name.toUpperCase(),
-      this.fontName,
+      { fontName: this.fontName, subMessage: cliConfig.subMessage },
     );
 
     await printerService.info(printerService.blue(bannerText));