zod-args-parser 2.0.0-beta.1 → 2.0.0-beta.3

package/src/definitions/validate-cli-definition.ts

@@ -1,12 +1,19 @@
+import { CliError } from "../cli-error/cli-error.ts";
+import { ErrorCause } from "../cli-error/error-cause.ts";
+import { DefinitionErrorCode } from "../cli-error/error-code/definition-error-code.ts";
+import { InternalErrorCode } from "../cli-error/error-code/internal-error-code.ts";
 import { transformOptionToArgument } from "../parse/parser-utilities.ts";
-import { findDuplicateStrings } from "../utilities.ts";
 
 import type { Cli, Subcommand } from "../types/definitions-types.ts";
 
-/** @throws {Error} If validation fails. */
+/** @throws {CliError} If validation fails. */
 export function validateCliDefinition(cliDefinition: Cli) {
   if (!cliDefinition.cliName) {
-    throw new Error(`invalid cli definition: "cliName" property is required.`);
+    throw new CliError({
+      cause: ErrorCause.Definition,
+      code: DefinitionErrorCode.MissingDefinitionName,
+      context: { commandKind: "command" },
+    });
   }
 
   // validate cli options
@@ -20,52 +27,86 @@ export function validateCliDefinition(cliDefinition: Cli) {
 
   // no empty subcommands array
   if (subcommands.length === 0) {
-    throw new Error(
-      `invalid cli definition "${cliDefinition.cliName}": "subcommands" property is optional but cannot be empty.`,
-    );
+    throw new CliError({
+      cause: ErrorCause.Definition,
+      code: DefinitionErrorCode.EmptyDefinitionGroup,
+      context: { commandKind: "command", commandName: cliDefinition.cliName, kind: "subcommands" },
+    });
   }
 
-  const commandsNames = subcommands.map(c => c.name);
+  const commandsNames = new Set(subcommands.map(c => c.name));
 
-  // required subcommand name
-  if (commandsNames.some(c => !c)) {
-    throw new Error(`invalid subcommand definition: subcommand's "name" property is required.`);
-  }
-
-  // no duplicate subcommand names
-  const commandsNamesDuplicates = findDuplicateStrings(commandsNames).map(c => `"${c}"`);
-  if (commandsNamesDuplicates.length > 0) {
-    throw new Error(
-      `invalid cli definition "${cliDefinition.cliName}" has duplicated subcommands: ${commandsNamesDuplicates.join(", ")}.`,
-    );
-  }
+  const visitedSubcommandNames = new Set<string>();
 
   for (const subcommand of subcommands) {
+    if (!subcommand.name) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.MissingDefinitionName,
+        context: { commandKind: "subcommand" },
+      });
+    }
+
+    // no duplicate subcommand names
+    if (visitedSubcommandNames.has(subcommand.name)) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.DuplicateDefinitionName,
+        context: {
+          commandKind: "command",
+          commandName: cliDefinition.cliName,
+          kind: "subcommand",
+          name: subcommand.name,
+          foundInKind: "subcommand",
+        },
+      });
+    }
+    visitedSubcommandNames.add(subcommand.name);
+
     // command aliases check
     if (subcommand.aliases) {
-      // no duplicated aliases
-      const aliasesDuplicates = findDuplicateStrings(subcommand.aliases).map(c => `"${c}"`);
-      if (aliasesDuplicates.length > 0) {
-        throw new Error(`subcommand "${subcommand.name}" has duplicated aliases: ${aliasesDuplicates.join(", ")}.`);
-      }
-
       for (const alias of subcommand.aliases) {
         // no empty alias
         if (alias === "") {
-          throw new Error(`subcommand "${subcommand.name}" has an empty string alias.`);
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.EmptyStringAliasName,
+            context: { commandKind: "subcommand", commandName: subcommand.name },
+          });
         }
 
         // no conflict with subcommand name
-        if (commandsNames.includes(alias)) {
-          throw new Error(`subcommand "${subcommand.name}" alias "${alias}" conflicts with another subcommand name.`);
+        if (commandsNames.has(alias)) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.DuplicateDefinitionName,
+            context: {
+              commandKind: "command",
+              commandName: cliDefinition.cliName,
+              kind: "subcommand",
+              name: subcommand.name,
+              foundInKind: "subcommand",
+              duplicatedAlias: alias,
+            },
+          });
         }
 
         // no conflict with another alias
         const aliasConflicts = subcommands.filter(c => c.name !== subcommand.name && c.aliases?.includes(alias));
         if (aliasConflicts.length > 0) {
-          throw new Error(
-            `subcommand "${subcommand.name}" alias "${alias}" conflicts with another subcommand alias: "${aliasConflicts[0].name}".`,
-          );
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.DuplicateDefinitionName,
+            context: {
+              commandKind: "command",
+              commandName: cliDefinition.cliName,
+              kind: "subcommand",
+              name: subcommand.name,
+              foundInKind: "subcommand",
+              duplicatedAlias: alias,
+              foundInName: aliasConflicts[0].name,
+            },
+          });
         }
       }
     }
@@ -82,74 +123,124 @@ function validateOptions(commandDefinition: Cli | Subcommand) {
   if (!commandDefinition.options) return; // ok
 
   const isCli = "cliName" in commandDefinition;
-  const name = isCli ? commandDefinition.cliName : commandDefinition.name;
-
-  const createError = (message: string) => {
-    return new Error(`invalid ${isCli ? "cli" : "subcommand"} definition "${name}": ${message}`);
-  };
+  const commandName = isCli ? commandDefinition.cliName : commandDefinition.name;
+  const commandKind = isCli ? "command" : "subcommand";
 
   const optionsDefinitionEntries = Object.entries(commandDefinition.options);
 
   // no empty options
   if (optionsDefinitionEntries.length === 0) {
-    throw createError(`"options" property is optional but cannot be empty.`);
+    throw new CliError({
+      cause: ErrorCause.Definition,
+      code: DefinitionErrorCode.EmptyDefinitionGroup,
+      context: { commandKind, commandName, kind: "option" },
+    });
   }
 
   for (const [name, option] of optionsDefinitionEntries) {
     // required type
     if (!option.schema) {
-      throw createError(`the option "${name}" missing a required property: "schema".`);
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.MissingSchema,
+        context: { commandKind, commandName, kind: "option", name },
+      });
     }
 
     // should not happen
     if (!option._preparedType) {
-      throw createError(`internal error: missing prepared type for option "${name}".`);
+      throw new CliError({
+        cause: ErrorCause.Internal,
+        code: InternalErrorCode.MissingPreparedTypes,
+        context: { commandKind, commandName, kind: "option", name },
+      });
     }
 
     // no negated option name for boolean options
     if (isNegatedOptionName(name)) {
-      throw createError(`the option "${name}" is a negated option name.`);
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.InvalidDefinitionOptionName,
+        context: { commandKind, commandName, optionName: name },
+      });
     }
 
     // no conflict with argument name
     if (commandDefinition.arguments && name in commandDefinition.arguments) {
-      throw createError(`the option "${name}" name conflicts with an argument name.`);
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.DuplicateDefinitionName,
+        context: { commandKind, commandName, kind: "option", name, foundInKind: "argument" },
+      });
     }
 
     if (option.aliases) {
-      // no duplicate aliases
-      const aliasesDuplicates = findDuplicateStrings(option.aliases);
-      if (aliasesDuplicates.length > 0) {
-        throw createError(`the option "${name}" has duplicated aliases: ${aliasesDuplicates.join(", ")}.`);
-      }
-
-      for (const alias of option.aliases) {
+      for (const aliasName of option.aliases) {
         // no empty string aliases
-        if (alias === "") {
-          throw createError(`the option "${name}" has an empty string alias.`);
+        if (aliasName === "") {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.EmptyStringAliasName,
+            context: { commandKind, commandName, optionName: name },
+          });
         }
 
         // no negated alias name for boolean options
-        if (isNegatedOptionName(alias)) {
-          throw createError(`the alias "${alias}" of the option "${name}" is a negated option name.`);
+        if (isNegatedOptionName(aliasName)) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.InvalidDefinitionOptionName,
+            context: { commandKind, commandName, optionName: name, negatedAliasName: aliasName },
+          });
         }
 
         // no alias name should conflict with any option name
-        if (commandDefinition.options[alias]) {
-          throw createError(`the alias "${alias}" of the option "${name}" conflicts with another option name.`);
+        if (commandDefinition.options[aliasName]) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.DuplicateDefinitionName,
+            context: {
+              commandKind,
+              commandName,
+              kind: "option",
+              name,
+              duplicatedAlias: aliasName,
+              foundInKind: "option",
+            },
+          });
         }
 
         // no alias name should conflict with any argument name
-        if (commandDefinition.arguments && alias in commandDefinition.arguments) {
-          throw createError(`the alias "${alias}" of the option "${name}" conflicts with an argument name.`);
+        if (commandDefinition.arguments && aliasName in commandDefinition.arguments) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.DuplicateDefinitionName,
+            context: {
+              commandKind,
+              commandName,
+              kind: "option",
+              name,
+              duplicatedAlias: aliasName,
+              foundInKind: "argument",
+            },
+          });
         }
 
         // no alias name should conflict with any other alias name
-        const findConflict = optionsDefinitionEntries.find(([n, d]) => n !== name && d.aliases?.includes(alias));
+        const findConflict = optionsDefinitionEntries.find(([n, d]) => n !== name && d.aliases?.includes(aliasName));
         if (findConflict) {
-          throw createError(
-            `the alias "${alias}" of the option "${name}" conflicts with another alias name of the option "${findConflict[0]}".`,
-          );
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.DuplicateDefinitionName,
+            context: {
+              commandKind,
+              commandName,
+              kind: "option",
+              name: aliasName,
+              foundInKind: "option",
+              foundInName: findConflict[0],
+            },
+          });
         }
       }
     }
@@ -157,20 +248,22 @@ function validateOptions(commandDefinition: Cli | Subcommand) {
     if (option.requires) {
       // no self require
       if (option.requires.includes(name)) {
-        throw createError(`the option "${name}" cannot require itself.`);
-      }
-
-      // no duplicate requires
-      const duplicateRequires = findDuplicateStrings(option.requires).map(required => `"${required}"`);
-      if (duplicateRequires.length > 0) {
-        throw createError(`the option "${name}" has duplicate requires: ${duplicateRequires.join(", ")}.`);
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.SelfRequire,
+          context: { commandKind, commandName, kind: "option", name: name },
+        });
       }
 
       // no unknown required name
-      for (const required of option.requires) {
-        const exits = required in commandDefinition.options || required in (commandDefinition.arguments ?? []);
+      for (const requiredName of option.requires) {
+        const exits = requiredName in commandDefinition.options || requiredName in (commandDefinition.arguments ?? []);
         if (!exits) {
-          throw createError(`the option "${name}" requires "${required}", but it does not exist.`);
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.UnknownRequireName,
+            context: { commandKind, commandName, kind: "option", name: name, requiredName },
+          });
         }
       }
     }
@@ -178,20 +271,22 @@ function validateOptions(commandDefinition: Cli | Subcommand) {
     if (option.conflictWith) {
       // no self conflict
       if (option.conflictWith.includes(name)) {
-        throw createError(`the option "${name}" cannot conflict itself.`);
-      }
-
-      // no duplicate conflicts
-      const duplicateRequires = findDuplicateStrings(option.conflictWith).map(conflict => `"${conflict}"`);
-      if (duplicateRequires.length > 0) {
-        throw createError(`the option "${name}" has duplicate conflicts: ${duplicateRequires.join(", ")}.`);
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.SelfConflict,
+          context: { commandKind, commandName, kind: "option", name: name },
+        });
       }
 
       // no unknown conflict name
-      for (const required of option.conflictWith) {
-        const exits = required in commandDefinition.options || required in (commandDefinition.arguments ?? []);
+      for (const requiredName of option.conflictWith) {
+        const exits = requiredName in commandDefinition.options || requiredName in (commandDefinition.arguments ?? []);
         if (!exits) {
-          throw createError(`the option "${name}" conflict with "${required}", but it does not exist.`);
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.UnknownConflictName,
+            context: { commandKind, commandName, kind: "option", name: name, requiredName },
+          });
         }
       }
     }
@@ -202,13 +297,14 @@ function validateOptions(commandDefinition: Cli | Subcommand) {
       const conflictsSet = new Set(option.conflictWith);
 
       const intersection = requiresSet.intersection(conflictsSet);
-      const intersectionArray = Array.from(intersection).map(name => `"${name}"`);
-
-      if (intersectionArray.length > 0) {
-        const s = intersectionArray.length > 1 ? "s" : "";
-        throw createError(
-          `the option "${name}" cannot require and conflict with the same name${s}: ${intersectionArray.join(", ")}.`,
-        );
+      const intersectedNames = Array.from(intersection).map(name => `"${name}"`);
+
+      if (intersectedNames.length > 0) {
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.DefinitionRequiresConflictOverlap,
+          context: { commandKind, commandName, kind: "option", name: name, intersectedNames },
+        });
       }
     }
   }
@@ -218,109 +314,128 @@ function validateArguments(commandDefinition: Cli | Subcommand) {
   if (!commandDefinition.arguments) return; // ok
 
   const isCli = "cliName" in commandDefinition;
-  const name = isCli ? commandDefinition.cliName : commandDefinition.name;
-
-  const createError = (message: string) => {
-    return new Error(`invalid ${isCli ? "cli" : "subcommand"} definition "${name}": ${message}`);
-  };
-
-  if (commandDefinition.arguments) {
-    const argumentsDefinitionEntries = Object.entries(commandDefinition.arguments);
+  const commandName = isCli ? commandDefinition.cliName : commandDefinition.name;
+  const commandKind = isCli ? "command" : "subcommand";
+
+  const argumentsDefinitionEntries = Object.entries(commandDefinition.arguments);
+
+  // no empty arguments record
+  if (argumentsDefinitionEntries.length === 0) {
+    throw new CliError({
+      cause: ErrorCause.Definition,
+      code: DefinitionErrorCode.EmptyDefinitionGroup,
+      context: { commandKind, commandName, kind: "argument" },
+    });
+  }
 
-    // no empty arguments record
-    if (argumentsDefinitionEntries.length === 0) {
-      throw createError(`"arguments" property is optional but cannot be empty.`);
+  for (const [index, [name, argument]] of argumentsDefinitionEntries.entries()) {
+    // no number key name
+    if (/^\d+$/.test(name)) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.InvalidDefinitionArgumentName,
+        context: { commandKind, commandName, name },
+      });
     }
 
-    for (const [index, [name, argument]] of argumentsDefinitionEntries.entries()) {
-      // no number key name
-      if (/^\d+$/.test(name)) {
-        throw createError(`the argument "${name}" name cannot be a number.`);
-      }
-
-      // should not happen
-      if (!argument._preparedType) {
-        throw createError(`internal error: missing prepared type for argument "${name}".`);
-      }
+    // should not happen
+    if (!argument._preparedType) {
+      throw new CliError({
+        cause: ErrorCause.Internal,
+        code: InternalErrorCode.MissingPreparedTypes,
+        context: { commandKind, commandName, kind: "argument", name },
+      });
+    }
 
-      // no missing type
-      if (!argument.schema) {
-        throw createError(`the argument "${name}" missing a required property: "schema".`);
-      }
+    // no missing schema
+    if (!argument.schema) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.MissingSchema,
+        context: { commandKind, commandName, kind: "argument", name },
+      });
+    }
 
-      // no conflicting option
-      if (commandDefinition.options && name in commandDefinition.options) {
-        throw createError(`the argument "${name}" name conflicts with an option name.`);
-      }
+    if (!argument._preparedType.optional) continue; // ok
 
-      if (!argument._preparedType.optional) continue; // ok
+    // no optional argument when "allowPositionals" is enabled
+    if (commandDefinition.allowPositionals) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.InvalidOptionalArgumentDefinition,
+        context: { commandKind, commandName, name, allowPositionals: true },
+      });
+    }
 
-      // no optional argument when "allowPositionals" is enabled
-      if (commandDefinition.allowPositionals) {
-        throw createError(`the argument "${name}" cannot be optional when "allowPositionals" is enabled.`);
-      }
+    // only last argument can be optional
+    if (index !== argumentsDefinitionEntries.length - 1) {
+      throw new CliError({
+        cause: ErrorCause.Definition,
+        code: DefinitionErrorCode.InvalidOptionalArgumentDefinition,
+        context: { commandKind, commandName, name, allowPositionals: false },
+      });
+    }
 
-      // only last argument can be optional
-      if (index !== argumentsDefinitionEntries.length - 1) {
-        throw createError(`the argument "${name}" cannot be optional unless it is the last argument.`);
+    if (argument.requires) {
+      // no self require
+      if (argument.requires.includes(name)) {
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.SelfRequire,
+          context: { commandKind, commandName, kind: "argument", name },
+        });
       }
 
-      if (argument.requires) {
-        // no self require
-        if (argument.requires.includes(name)) {
-          throw createError(`the argument "${name}" cannot require itself.`);
-        }
-
-        // no duplicate requires
-        const duplicateRequires = findDuplicateStrings(argument.requires).map(required => `"${required}"`);
-        if (duplicateRequires.length > 0) {
-          throw createError(`the argument "${name}" has duplicate requires: ${duplicateRequires.join(", ")}.`);
-        }
-
-        // no unknown require
-        for (const required of argument.requires) {
-          const exits = required in (commandDefinition.options ?? {}) || required in commandDefinition.arguments;
-          if (!exits) {
-            throw createError(`the argument "${name}" requires "${required}", but it does not exist.`);
-          }
+      // no unknown require
+      for (const requiredName of argument.requires) {
+        const exits = requiredName in (commandDefinition.options ?? {}) || requiredName in commandDefinition.arguments;
+        if (!exits) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.UnknownRequireName,
+            context: { commandKind, commandName, kind: "argument", name, requiredName },
+          });
         }
       }
+    }
 
-      if (argument.conflictWith) {
-        // no self conflict
-        if (argument.conflictWith.includes(name)) {
-          throw createError(`the argument "${name}" cannot conflict itself.`);
-        }
-
-        // no duplicate conflicts
-        const duplicateRequires = findDuplicateStrings(argument.conflictWith).map(conflict => `"${conflict}"`);
-        if (duplicateRequires.length > 0) {
-          throw createError(`the argument "${name}" has duplicate conflicts: ${duplicateRequires.join(", ")}.`);
-        }
+    if (argument.conflictWith) {
+      // no self conflict
+      if (argument.conflictWith.includes(name)) {
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.SelfConflict,
+          context: { commandKind, commandName, kind: "argument", name },
+        });
+      }
 
-        // no unknown conflict
-        for (const required of argument.conflictWith) {
-          const exits = required in (commandDefinition.options ?? {}) || required in commandDefinition.arguments;
-          if (!exits) {
-            throw createError(`the argument "${name}" conflict with "${required}", but it does not exist.`);
-          }
+      // no unknown conflict
+      for (const requiredName of argument.conflictWith) {
+        const exits = requiredName in (commandDefinition.options ?? {}) || requiredName in commandDefinition.arguments;
+        if (!exits) {
+          throw new CliError({
+            cause: ErrorCause.Definition,
+            code: DefinitionErrorCode.UnknownConflictName,
+            context: { commandKind, commandName, kind: "argument", name, requiredName },
+          });
         }
       }
+    }
 
-      // no intersection between requires and conflicts
-      if (argument.requires && argument.conflictWith) {
-        const requiresSet = new Set(argument.requires);
-        const conflictsSet = new Set(argument.conflictWith);
-
-        const intersection = requiresSet.intersection(conflictsSet);
-        const intersectionArray = Array.from(intersection).map(name => `"${name}"`);
+    // no intersection between requires and conflicts
+    if (argument.requires && argument.conflictWith) {
+      const requiresSet = new Set(argument.requires);
+      const conflictsSet = new Set(argument.conflictWith);
 
-        if (intersectionArray.length > 0) {
-          const s = intersectionArray.length > 1 ? "s" : "";
-          throw createError(
-            `the argument "${name}" cannot require and conflict with the same name${s}: ${intersectionArray.join(", ")}.`,
-          );
-        }
+      const intersection = requiresSet.intersection(conflictsSet);
+      const intersectedNames = Array.from(intersection).map(name => `"${name}"`);
+
+      if (intersectedNames.length > 0) {
+        throw new CliError({
+          cause: ErrorCause.Definition,
+          code: DefinitionErrorCode.DefinitionRequiresConflictOverlap,
+          context: { commandKind, commandName, kind: "argument", name, intersectedNames },
+        });
       }
     }
   }

package/src/help-message/format-arguments.ts

@@ -1,4 +1,4 @@
-import { indent, indentLines, insertAtEndOfFirstLine, ln, toKebabCase } from "../utilities.ts";
+import { indent, indentLines, insertAtEndOfFirstLine, ln, toKebabCase } from "../utilities/utilities.ts";
 import { terminalMarkdown } from "./terminal-markdown.ts";
 
 import type { ArgumentMetadata } from "../types/metadata-types.ts";

package/src/help-message/format-options.ts

@@ -1,4 +1,4 @@
-import { indent, indentLines, insertAtEndOfFirstLine, ln } from "../utilities.ts";
+import { indent, indentLines, insertAtEndOfFirstLine, ln } from "../utilities/utilities.ts";
 import { terminalMarkdown } from "./terminal-markdown.ts";
 
 import type { OptionMetadata } from "../types/metadata-types.ts";

package/src/help-message/format-subcommands.ts

@@ -1,4 +1,4 @@
-import { indent, indentLines, ln, subcommandPlaceholder } from "../utilities.ts";
+import { indent, indentLines, ln, subcommandPlaceholder } from "../utilities/utilities.ts";
 import { terminalMarkdown } from "./terminal-markdown.ts";
 
 import type { SubcommandMetadata } from "../types/metadata-types.ts";

package/src/help-message/generate-for-cli.ts

@@ -1,5 +1,5 @@
 import { getCliMetadata } from "../metadata/cli-metadata.ts";
-import { indent, indentLines, ln, subcommandPlaceholder } from "../utilities.ts";
+import { indent, indentLines, ln, subcommandPlaceholder } from "../utilities/utilities.ts";
 import { formatHelpMessageArguments } from "./format-arguments.ts";
 import { formatHelpMessageOptions } from "./format-options.ts";
 import { formatHelpMessageCommands } from "./format-subcommands.ts";

package/src/help-message/terminal-markdown.ts

@@ -7,7 +7,7 @@ const markdownStyle: Record<string, ColorFunctionType> = {
   bold: c.bold,
   italic: c.italic,
   boldItalic: c.bold.italic,
-  code: (...string) => c.bgHex("#333333").whiteBright(` ${string.join(" ")} `),
+  code: (...string) => c.bgHex("#282828").whiteBright(` ${string.join(" ")} `),
   strikethrough: c.strikethrough,
   link: c.underline,
   listBullet: c.whiteBright,
@@ -125,9 +125,6 @@ const terminalRenderer: RendererObject<string, string> = {
   },
 };
 
-const terminalMarked = new Marked();
-terminalMarked.use({ renderer: terminalRenderer });
-
 export function terminalMarkdown(
   text: string,
   renderer: "terminal" | "html" = "terminal",
@@ -138,6 +135,8 @@ export function terminalMarkdown(
   }
 
   if (renderer === "terminal") {
+    const terminalMarked = new Marked();
+    terminalMarked.use({ renderer: terminalRenderer });
     return ansiTextColor(terminalMarked.parse(text) as string);
   }