@avandar/acclimate 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,5 +1,7 @@
 import { camelCase } from 'change-case';
 import { match } from 'ts-pattern';
+import { stdout, stdin } from 'process';
+import { createInterface } from 'readline/promises';
 
 // src/CLIError.ts
 var CLIError = class _CLIError extends Error {
@@ -172,14 +174,224 @@ var defaultCLIState = {
   positionalArgs: [],
   optionArgs: {},
   globalOptionArgs: {},
-  action: () => {
-  }
+  action: void 0
 };
 
 // src/AcclimateCLI/createCLI/createCLI.ts
 function createCLI(name) {
   return AcclimateCLI({ ...defaultCLIState, name });
 }
+
+// src/generateTerminalMessage/generateTerminalMessage.ts
+var COLOR_CODES = {
+  reset: "\x1B[0m",
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  bright_black: "\x1B[90m",
+  gray: "\x1B[90m",
+  grey: "\x1B[90m",
+  bright_red: "\x1B[91m",
+  bright_green: "\x1B[92m",
+  bright_yellow: "\x1B[93m",
+  bright_blue: "\x1B[94m",
+  bright_magenta: "\x1B[95m",
+  bright_cyan: "\x1B[96m",
+  bright_white: "\x1B[97m"
+};
+var PARAM_TOKEN_REGEX = /\$([a-zA-Z0-9_]+)\$/g;
+var COLOR_TOKEN_REGEX = /\|([a-zA-Z_]+)\|/g;
+function interpolateParams(message, params) {
+  return message.replace(PARAM_TOKEN_REGEX, (match2, key) => {
+    const value = params[key];
+    if (value === void 0) {
+      return "";
+    }
+    return value;
+  });
+}
+function applyColors(message) {
+  return message.replace(COLOR_TOKEN_REGEX, (match2, colorName) => {
+    const code = COLOR_CODES[colorName.toLowerCase()];
+    return code ?? match2;
+  });
+}
+function generateTerminalMessage(message, params = {}) {
+  const hasColorToken = Boolean(message.match(COLOR_TOKEN_REGEX));
+  const endsWithReset = message.trimEnd().endsWith("|reset|");
+  const withReset = hasColorToken && !endsWithReset ? `${message}|reset|` : message;
+  const interpolated = interpolateParams(withReset, params);
+  return applyColors(interpolated);
+}
+
+// src/AcclimateCLI/generateHelpText/generateHelpText.ts
+function formatSectionTitle(title) {
+  return `|bright_yellow|${title}|reset|`;
+}
+function formatNoneLine() {
+  return "  |gray|None|reset|";
+}
+function formatDefaultValue(value) {
+  return `|gray|[default: ${JSON.stringify(value)}]|reset|`;
+}
+function formatParamLine(param) {
+  const description = param.description ?? "No description";
+  const requiredLabel = param.required ? "|red|required|reset|" : "|gray|optional|reset|";
+  const defaultLabel = param.defaultValue !== void 0 ? formatDefaultValue(param.defaultValue) : void 0;
+  const aliasList = param.aliases && param.aliases.length > 0 ? param.aliases.join(", ") : "";
+  const displayName = aliasList ? `${param.name}, ${aliasList}` : param.name;
+  const segments = [
+    `  |bright_white|${displayName}|reset|`,
+    `(${param.type})|reset| ${requiredLabel}`,
+    `- |gray|${description}|reset|`,
+    defaultLabel
+  ].filter(Boolean);
+  return segments.join(" ");
+}
+function formatSection(title, params) {
+  if (params.length === 0) {
+    return [formatSectionTitle(title), formatNoneLine()];
+  }
+  return [formatSectionTitle(title), ...params.map(formatParamLine)];
+}
+function formatCommandLine(options) {
+  const { name, description } = options;
+  const label = description ?? "No description";
+  return `  |bright_white|${name}|reset| - |gray|${label}|reset|`;
+}
+function formatAvailableCommandsLine(commands) {
+  const label = commands.length === 0 ? "None" : commands.map((cmd) => {
+    return cmd;
+  }).join(", ");
+  return `|bright_yellow|Available Commands:|reset| |gray|${label}|reset|`;
+}
+function _generateHelpTextHelper(cli, options) {
+  const name = cli.getName();
+  const description = cli.state.description;
+  const level = Number(options.level);
+  const positionalParams = cli.state.positionalArgs;
+  const optionParams = Object.values(
+    cli.state.optionArgs
+  );
+  const globalOptionParams = Object.values(
+    cli.state.globalOptionArgs
+  );
+  const sortedCommands = Object.entries(cli.state.commands).sort(([a], [b]) => {
+    return a.localeCompare(b);
+  });
+  const commandNames = sortedCommands.map(([commandName]) => {
+    return commandName;
+  });
+  const headerLines = [`|bright_cyan|${name}|reset|`];
+  if (description !== void 0) {
+    headerLines.push(`  |gray|${description}|reset|`);
+  }
+  let commandSection;
+  if (level === 2) {
+    commandSection = [
+      formatSectionTitle("Commands"),
+      `  ${formatAvailableCommandsLine(commandNames)}`
+    ];
+  } else if (sortedCommands.length === 0) {
+    commandSection = [formatSectionTitle("Commands"), formatNoneLine()];
+  } else {
+    commandSection = [
+      formatSectionTitle("Commands"),
+      ...sortedCommands.map(([commandName, commandCLI]) => {
+        return formatCommandLine({
+          name: commandName,
+          description: commandCLI.state.description
+        });
+      })
+    ];
+  }
+  const sections = [
+    formatSection("Positional Arguments", positionalParams),
+    formatSection("Options", optionParams),
+    formatSection("Global Options", globalOptionParams),
+    commandSection
+  ];
+  const lines = [...headerLines, ""];
+  sections.forEach((section, idx) => {
+    lines.push(...section);
+    if (idx < sections.length - 1) {
+      lines.push("");
+    }
+  });
+  if (level === 1) {
+    const subCommandHelpText = sortedCommands.map(([, commandCLI]) => {
+      return _generateHelpTextHelper(commandCLI, { level: 2 });
+    });
+    if (subCommandHelpText.length > 0) {
+      subCommandHelpText.forEach((text) => {
+        lines.push("", ...text.split("\n"));
+      });
+    }
+  }
+  const indent = "    ".repeat(Math.max(0, level - 1));
+  return lines.map((line) => {
+    return line === "" ? "" : `${indent}${line}`;
+  }).join("\n");
+}
+function generateHelpText(cli) {
+  return generateTerminalMessage(_generateHelpTextHelper(cli, { level: 1 }));
+}
+var COLOR_TOKEN_REGEX2 = /\|[a-zA-Z_]+\|/g;
+function messageHasPunctuation(message) {
+  const stripped = message.replace(COLOR_TOKEN_REGEX2, "").trimEnd();
+  return stripped.endsWith(":") || stripped.endsWith("?");
+}
+async function requestTerminalInput(options) {
+  const { message, params, options: promptOptions } = options;
+  const notice = promptOptions.required ? "" : " |gray|(press Enter to leave empty)|reset|";
+  const booleanNotice = promptOptions.type === "boolean" ? " |reset|(y/n)" : "";
+  const promptMessage = `${message}${booleanNotice}${notice}`;
+  const promptText = messageHasPunctuation(message) ? `${promptMessage} ` : `${promptMessage}: `;
+  const prompt = generateTerminalMessage(promptText, params);
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    while (true) {
+      const answer = await rl.question(prompt);
+      const trimmed = answer.trim();
+      if (trimmed.length === 0) {
+        if (promptOptions.required) {
+          stdout.write(
+            generateTerminalMessage(
+              "|red|This value is required.|reset| Please enter a value.\n"
+            )
+          );
+          continue;
+        }
+        return void 0;
+      }
+      if (promptOptions.type === "boolean") {
+        const normalized = trimmed.toLowerCase();
+        if (normalized === "y" || normalized === "yes") {
+          return "true";
+        }
+        if (normalized === "n" || normalized === "no") {
+          return "false";
+        }
+        stdout.write(
+          generateTerminalMessage(
+            "|red|That was not a valid response.|reset| Please enter y or n.\n"
+          )
+        );
+        continue;
+      }
+      return answer;
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// src/AcclimateCLI/runCLI/runCLI.ts
 function _isValidFullOptionName(name) {
   return name.startsWith("--");
 }
@@ -248,7 +460,19 @@ function _replaceAliases({
     {}
   );
 }
-function _runCLIHelper(options) {
+async function askForValue(options) {
+  const { argConfig } = options;
+  const askIfEmpty = argConfig.askIfEmpty;
+  const description = argConfig.description ? ` (${argConfig.description})` : "";
+  const baseMessage = typeof askIfEmpty === "object" ? askIfEmpty.message : `Please enter a value for ${argConfig.name}${description}`;
+  const coloredMessage = `|bright_cyan|${baseMessage}|reset|`;
+  return requestTerminalInput({
+    message: coloredMessage,
+    params: {},
+    options: { required: argConfig.required, type: argConfig.type }
+  });
+}
+async function _runCLIHelper(options) {
   const { rawGlobalOptionArgs, rawOptionArgs, rawPositionalArgs, cli } = {
     ...options,
     rawGlobalOptionArgs: _replaceAliases({
@@ -285,74 +509,79 @@ function _runCLIHelper(options) {
       count: rawPositionalArgs.length
     });
   }
-  const parsedPositionalArgs = cli.state.positionalArgs.reduce(
-    (acc, argConfig, idx) => {
-      const rawVal = rawPositionalArgs[idx];
-      if (argConfig.required && rawVal === void 0) {
-        throw CLIError.missingRequiredPositionalArg({
-          cliName,
-          positionalArgName: argConfig.name
-        });
-      }
-      acc[argConfig.name] = _parseAndValidateValue({
+  const parsedPositionalArgs = {};
+  for (const [idx, argConfig] of cli.state.positionalArgs.entries()) {
+    let rawVal = rawPositionalArgs[idx];
+    if (argConfig.askIfEmpty && rawVal === void 0) {
+      rawVal = await askForValue({ argConfig });
+    }
+    if (argConfig.required && rawVal === void 0) {
+      throw CLIError.missingRequiredPositionalArg({
         cliName,
-        inputValue: rawVal,
-        defaultValue: argConfig.defaultValue,
-        paramConfig: argConfig
+        positionalArgName: argConfig.name
       });
-      return acc;
-    },
-    {}
-  );
-  const parsedOptionArgs = Object.values(
+    }
+    parsedPositionalArgs[argConfig.name] = _parseAndValidateValue({
+      cliName,
+      inputValue: rawVal,
+      defaultValue: argConfig.defaultValue,
+      paramConfig: argConfig
+    });
+  }
+  const parsedOptionArgs = {};
+  for (const argConfig of Object.values(
     cli.state.optionArgs
-  ).reduce(
-    (acc, argConfig) => {
-      const rawVal = rawOptionArgs[argConfig.name];
-      if (argConfig.required && rawVal === void 0) {
-        throw CLIError.missingRequiredOption({
-          cliName,
-          optionName: argConfig.name
-        });
-      }
-      acc[camelCase(argConfig.name)] = _parseAndValidateValue({
+  )) {
+    let rawVal = rawOptionArgs[argConfig.name];
+    if (argConfig.askIfEmpty && rawVal === void 0) {
+      rawVal = await askForValue({ argConfig });
+    }
+    if (argConfig.required && rawVal === void 0) {
+      throw CLIError.missingRequiredOption({
         cliName,
-        inputValue: rawVal,
-        defaultValue: argConfig.defaultValue,
-        paramConfig: argConfig
+        optionName: argConfig.name
       });
-      return acc;
-    },
-    {}
-  );
-  const parsedGlobalOptionArgs = Object.values(
+    }
+    parsedOptionArgs[camelCase(argConfig.name)] = _parseAndValidateValue({
+      cliName,
+      inputValue: rawVal,
+      defaultValue: argConfig.defaultValue,
+      paramConfig: argConfig
+    });
+  }
+  const parsedGlobalOptionArgs = {};
+  for (const argConfig of Object.values(
     cli.state.globalOptionArgs
-  ).reduce(
-    (acc, argConfig) => {
-      const rawVal = rawGlobalOptionArgs[argConfig.name];
-      if (argConfig.required && rawVal === void 0) {
-        throw CLIError.missingRequiredOption({
-          cliName,
-          optionName: argConfig.name
-        });
-      }
-      acc[camelCase(argConfig.name)] = _parseAndValidateValue({
+  )) {
+    let rawVal = rawGlobalOptionArgs[argConfig.name];
+    if (argConfig.askIfEmpty && rawVal === void 0) {
+      rawVal = await askForValue({ argConfig });
+    }
+    if (argConfig.required && rawVal === void 0) {
+      throw CLIError.missingRequiredOption({
         cliName,
-        inputValue: rawVal,
-        defaultValue: argConfig.defaultValue,
-        paramConfig: argConfig
+        optionName: argConfig.name
       });
-      return acc;
-    },
-    {}
-  );
-  cli.state.action({
-    ...parsedPositionalArgs,
-    ...parsedOptionArgs,
-    ...parsedGlobalOptionArgs
-  });
+    }
+    parsedGlobalOptionArgs[camelCase(argConfig.name)] = _parseAndValidateValue({
+      cliName,
+      inputValue: rawVal,
+      defaultValue: argConfig.defaultValue,
+      paramConfig: argConfig
+    });
+  }
+  const action = cli.state.action;
+  if (action) {
+    action({
+      ...parsedPositionalArgs,
+      ...parsedOptionArgs,
+      ...parsedGlobalOptionArgs
+    });
+    return;
+  }
+  console.log(generateHelpText(cli));
 }
-function runCLI(options) {
+async function runCLI(options) {
   const { input, cli } = options;
   const firstOptionIdx = input.findIndex((token) => {
     return token.startsWith("-");
@@ -380,57 +609,25 @@ function runCLI(options) {
       currentVals.push(argVal);
     }
   }
-  _runCLIHelper({ rawPositionalArgs, rawOptionArgs, rawGlobalOptionArgs, cli });
+  await _runCLIHelper({
+    rawPositionalArgs,
+    rawOptionArgs,
+    rawGlobalOptionArgs,
+    cli
+  });
 }
 
 // src/Acclimate.ts
-var COLOR_CODES = {
-  reset: "\x1B[0m",
-  black: "\x1B[30m",
-  red: "\x1B[31m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  magenta: "\x1B[35m",
-  cyan: "\x1B[36m",
-  white: "\x1B[37m",
-  bright_black: "\x1B[90m",
-  gray: "\x1B[90m",
-  grey: "\x1B[90m",
-  bright_red: "\x1B[91m",
-  bright_green: "\x1B[92m",
-  bright_yellow: "\x1B[93m",
-  bright_blue: "\x1B[94m",
-  bright_magenta: "\x1B[95m",
-  bright_cyan: "\x1B[96m",
-  bright_white: "\x1B[97m"
-};
-var PARAM_TOKEN_REGEX = /\$([a-zA-Z0-9_]+)\$/g;
-var COLOR_TOKEN_REGEX = /\|([a-zA-Z_]+)\|/g;
-function interpolateParams(message, params) {
-  return message.replace(PARAM_TOKEN_REGEX, (match2, key) => {
-    const value = params[key];
-    return value ?? match2;
-  });
-}
-function applyColors(message) {
-  return message.replace(COLOR_TOKEN_REGEX, (match2, colorName) => {
-    const code = COLOR_CODES[colorName.toLowerCase()];
-    return code ?? match2;
-  });
-}
 var Acclimate = {
   createCLI,
   run: (cli) => {
-    runCLI({ cli, input: process.argv.slice(2) });
+    void runCLI({ cli, input: process.argv.slice(2) });
   },
   log: (message, params = {}) => {
-    const hasColorToken = Boolean(message.match(COLOR_TOKEN_REGEX));
-    const endsWithReset = message.trimEnd().endsWith("|reset|");
-    const withReset = hasColorToken && !endsWithReset ? `${message}|reset|` : message;
-    const interpolated = interpolateParams(withReset, params);
-    const colorized = applyColors(interpolated);
-    console.log(colorized);
+    console.log(generateTerminalMessage(message, params));
+  },
+  requestInput: (options) => {
+    return requestTerminalInput(options);
   }
 };