meocord 1.2.1 → 1.2.2

package/dist/esm/decorator/guard.decorator.js

@@ -0,0 +1,165 @@
+import 'reflect-metadata';
+import { injectable } from 'inversify';
+import { mainContainer } from './container.js';
+import { BaseInteraction, Message, MessageReaction } from 'discord.js';
+import { getCommandMap, getMessageHandlers, getReactionHandlers } from './controller.decorator.js';
+
+function isValidContext(context) {
+    return context instanceof BaseInteraction || context instanceof Message || context instanceof MessageReaction;
+}
+function applyGuards(descriptor, guards, propertyKey) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+        const [context] = args;
+        if (!isValidContext(context)) {
+            throw new Error(`The first argument of ${String(propertyKey)} must be an instance of Interaction, Message, or MessageReaction.`);
+        }
+        // Iterate over each guard and check if it allows the method to proceed
+        for (const guard of guards){
+            let guardInstance;
+            if (isGuardWithParams(guard)) {
+                const { provide, params } = guard;
+                guardInstance = mainContainer.get(provide, {
+                    autobind: true
+                });
+                // Inject the parameters into the guard instance
+                Object.assign(guardInstance, params);
+            } else {
+                // Resolve guard without parameters
+                guardInstance = mainContainer.get(guard, {
+                    autobind: true
+                });
+            }
+            // Ensure the guard has the necessary method `canActivate`
+            if (!guardInstance.canActivate) {
+                throw new Error(`Guard ${guard.constructor.name} applied to ${String(propertyKey)} does not have a valid canActivate method.`);
+            }
+            // Check if the guard allows the method to proceed
+            const canActivate = await guardInstance.canActivate(...args);
+            if (!canActivate) {
+                return; // Prevent method execution if the guard fails
+            }
+        }
+        // Call the original method if all guards pass
+        return originalMethod.apply(this, args);
+    };
+}
+/**
+ * `@Guard()` decorator to mark a class as a Guard that later can be added on `@UseGuard` decorator.
+ *
+ * @example
+ * ```typescript
+ * @Guard()
+export class ButtonInteractionGuard implements GuardInterface {
+  private readonly logger = new Logger(ButtonInteractionGuard.name)
+
+  async canActivate(context: ButtonInteraction, { ownerId }: { ownerId: string }): Promise<boolean> {
+    if (context.user.id !== ownerId) {
+      this.logger.error(
+        `User with id ${context.user.id} is not allowed to use this command that initiated by user with id ${ownerId}.`,
+      )
+      const embed = generateErrorEmbed(
+        `Hi <@${context.user.id}>, this command can only be used by the person who initiated it: <@${ownerId}>.`,
+      )
+      await context.reply({
+        embeds: [embed],
+        flags: MessageFlagsBitField.Flags.Ephemeral,
+      })
+      return false
+    }
+    return true
+  }
+}
+ * ```
+ */ function Guard() {
+    return function(target) {
+        // Check if the class is already injectable; if not, make it injectable dynamically
+        if (!Reflect.hasMetadata('inversify:injectable', target)) {
+            injectable()(target);
+        }
+        mainContainer.bind(target).toSelf().inTransientScope();
+        // Bind any dependencies that the guard requires
+        const injectables = Reflect.getMetadata('design:paramtypes', target) || [];
+        injectables.forEach((dep)=>{
+            if (!mainContainer.isBound(dep)) {
+                mainContainer.bind(dep).toSelf().inSingletonScope();
+            }
+        });
+    };
+}
+/**
+ * Type guard to check if the object is a GuardWithParams.
+ * This function helps to check whether a guard is parameterized or not.
+ *
+ * @param guard - The guard to check.
+ * @returns `true` if the guard has parameters, otherwise `false`.
+ */ function isGuardWithParams(guard) {
+    return typeof guard === 'object' && 'provide' in guard && 'params' in guard;
+}
+/**
+ * `@UseGuard()` decorator to apply one or more guards to methods.
+ * Guards are used to handle permission checks before executing a method.
+ * Each guard must use `@Guard` decorator and implement the `canActivate` method, which determines
+ * whether the method should be allowed to execute based on the provided context (Interaction, Message, or Reaction) and arguments.
+ * This decorator ensures that all guards pass validation before calling the original method.
+ * Supports guards that are parameterized (accepting additional parameters).
+ *
+ * @param guards - One or more guard classes to apply. These can be regular guards or guards with additional parameters.
+ *                 - If providing a guard with parameters, it should be an object with:
+ *                   - `provide`: The guard class to instantiate. Must implement `GuardInterface`.
+ *                   - `params`: A record of key-value pairs to be passed as additional properties to the guard instance.
+ * @returns A method decorator function that applies the guards to the method.
+ *
+ * @example
+ * ```typescript
+ * // Method-level usage
+ * @Command('profile-{id}', CommandType.BUTTON)
+ * @UseGuard(
+ *   { provide: RateLimiterGuard, params: { limit: 2, window: 3000 } },
+ *   ButtonInteractionGuard
+ * )
+ * async showProfileById(interaction: ButtonInteraction, { id }: { id: string }) {
+ *   await interaction.reply(`Profile ID: ${id}`)
+ * }
+ *
+ * // Class-level usage
+ * @Controller()
+ * @UseGuard(GlobalGuard)
+ * class MyController {
+ *   @Command('ping', CommandType.SLASH)
+ *   async ping(interaction: ChatInputCommandInteraction) {
+ *     await interaction.reply('Pong!')
+ *   }
+ * }
+ * ```
+ */ function UseGuard(...guards) {
+    return function(target, propertyKey, descriptor) {
+        if (descriptor && propertyKey) {
+            // Method Decorator
+            applyGuards(descriptor, guards, String(propertyKey));
+            // Store guard metadata for later access (if needed)
+            Reflect.defineMetadata('guards', guards, target, propertyKey);
+        } else if (typeof target === 'function' && !propertyKey && !descriptor) {
+            // Class Decorator
+            const prototype = target.prototype;
+            // 1. Get all methods to guard
+            const methods = new Set();
+            const commandMap = getCommandMap(prototype) || {};
+            Object.values(commandMap).flat().forEach((cmd)=>methods.add(cmd.methodName));
+            const messageHandlers = getMessageHandlers(prototype) || [];
+            messageHandlers.forEach((handler)=>methods.add(handler.method));
+            const reactionHandlers = getReactionHandlers(prototype) || [];
+            reactionHandlers.forEach((handler)=>methods.add(handler.method));
+            for (const methodName of methods){
+                const methodDescriptor = Object.getOwnPropertyDescriptor(prototype, methodName);
+                if (methodDescriptor) {
+                    applyGuards(methodDescriptor, guards, methodName);
+                    Object.defineProperty(prototype, methodName, methodDescriptor);
+                    Reflect.defineMetadata('guards', guards, prototype, methodName);
+                }
+            }
+        }
+    };
+}
+
+export { Guard, UseGuard };

package/dist/esm/decorator/index.js

@@ -0,0 +1,6 @@
+export { Service } from './service.decorator.js';
+export { CommandBuilder } from './command-builder.decorator.js';
+export { Command, Controller, MessageHandler, ReactionHandler, getCommandMap, getMessageHandlers, getReactionHandlers } from './controller.decorator.js';
+export { Guard, UseGuard } from './guard.decorator.js';
+export { MeoCord } from './app.decorator.js';
+export { mainContainer } from './container.js';

package/dist/esm/decorator/service.decorator.js

@@ -0,0 +1,58 @@
+import 'reflect-metadata';
+import { mainContainer } from './container.js';
+import { injectable } from 'inversify';
+import { Client } from 'discord.js';
+
+/**
+ * `@Service()` decorator to mark a class as a service that can be injected into controllers or used as standalone services.
+ *
+ * @example
+ * ```typescript
+ * @Service()
+ * class MyService {
+ *   constructor(private anotherService: AnotherService) {}
+ *
+ *   doSomething() {
+ *     this.anotherService.alsoDoSomething()
+ *     console.log('Hello, World!')
+ *   }
+ * }
+ * ```
+ * @returns A decorator function to apply to the class.
+ */ function Service() {
+    return function(target) {
+        // Check if the class is already injectable; if not, make it injectable dynamically
+        if (!Reflect.hasMetadata('inversify:injectable', target)) {
+            injectable()(target);
+        }
+        // Check if the class is already injectable; if not, make it injectable dynamically
+        if (!mainContainer.isBound(target)) {
+            // Bind the target class to the container in a singleton scope
+            mainContainer.bind(target).toSelf().inSingletonScope();
+        }
+        // Recursively bind dependencies
+        bindDependencies(target);
+    };
+}
+function bindDependencies(target) {
+    // Get the constructor parameter types using Reflect metadata
+    const dependencies = Reflect.getMetadata('design:paramtypes', target) || [];
+    dependencies.forEach((dep)=>{
+        // Bind the dependency if not already bound
+        if (!mainContainer.isBound(dep)) {
+            if (dep.name === Client.name) return;
+            try {
+                // Check if the class is already injectable; if not, make it injectable dynamically
+                if (!Reflect.hasMetadata('inversify:injectable', dep)) {
+                    injectable()(dep);
+                }
+                mainContainer.bind(dep).toSelf().inSingletonScope();
+                bindDependencies(dep); // Recur for the dependencies of the current dependency
+            } catch (error) {
+                console.warn(`Could not bind dependency: ${dep?.name || dep}`, error);
+            }
+        }
+    });
+}
+
+export { Service };

package/dist/esm/enum/controller.enum.js

@@ -0,0 +1,43 @@
+/**
+ * MeoCord Framework
+ * Copyright (C) 2025 Ukasyah Rahmatullah Zada
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */ var ControllerType = /*#__PURE__*/ function(ControllerType) {
+    ControllerType["BUTTON"] = "button";
+    ControllerType["MODAL_SUBMIT"] = "modal-submit";
+    ControllerType["SELECT_MENU"] = "select-menu";
+    ControllerType["REACTION"] = "reaction";
+    ControllerType["MESSAGE"] = "message";
+    ControllerType["SLASH"] = "slash";
+    ControllerType["CONTEXT_MENU"] = "context-menu";
+    return ControllerType;
+}({});
+var CommandType = /*#__PURE__*/ function(CommandType) {
+    CommandType["SLASH"] = "SLASH";
+    CommandType["BUTTON"] = "BUTTON";
+    CommandType["CONTEXT_MENU"] = "CONTEXT_MENU";
+    CommandType["SELECT_MENU"] = "SELECT_MENU";
+    CommandType["MODAL_SUBMIT"] = "MODAL_SUBMIT";
+    return CommandType;
+}({});
+/**
+ * Enum representing actions that can be performed on a message reaction.
+ */ var ReactionHandlerAction = /*#__PURE__*/ function(ReactionHandlerAction) {
+    /** Reaction added to a message. */ ReactionHandlerAction["ADD"] = "ADD";
+    /** Reaction removed from a message. */ ReactionHandlerAction["REMOVE"] = "REMOVE";
+    return ReactionHandlerAction;
+}({});
+
+export { CommandType, ControllerType, ReactionHandlerAction };

package/dist/esm/enum/index.js

@@ -0,0 +1 @@
+export { CommandType, ReactionHandlerAction } from './controller.enum.js';

package/dist/esm/interface/index.js

@@ -0,0 +1 @@
+

package/dist/esm/package.json.js

@@ -0,0 +1,5 @@
+var version = "1.2.2-0";
+var packageJson = {
+	version: version};
+
+export { packageJson as default, version };

package/dist/esm/util/common.util.js

@@ -0,0 +1,68 @@
+import fs from 'fs';
+import path from 'path';
+import { loadMeoCordConfig } from './meocord-config-loader.util.js';
+import wait from './wait.util.js';
+import chalk from 'chalk';
+
+/**
+ * Finds the package directory for the given module name
+ * @param {string} moduleName - The name of the module to find
+ * @param {string} baseDir - The starting directory to search from (defaults to process.cwd())
+ * @returns {string} - The directory path where the module's package.json is located
+ */ const findModulePackageDir = (moduleName, baseDir = process.cwd())=>{
+    try {
+        // Resolve the node_modules directory from the base directory
+        let currentDir = baseDir;
+        // Traverse the node_modules directories upwards until the package is found
+        while(currentDir !== path.parse(currentDir).root){
+            const modulePath = path.join(currentDir, 'node_modules', moduleName);
+            if (fs.existsSync(modulePath)) {
+                return modulePath // Return the full path to the module directory
+                ;
+            }
+            // Move up one level in the directory structure
+            currentDir = path.join(currentDir, '..');
+        }
+        throw new Error(`Module ${moduleName} not found in node_modules.`);
+    } catch (error) {
+        if (error instanceof Error) {
+            console.error(chalk.red(`Error finding package directory for ${moduleName}:`, error.message));
+        } else {
+            console.error(chalk.red(`Error finding package directory for ${moduleName}:`, error));
+        }
+        return null;
+    }
+};
+/**
+ * Compiles and validates the MeoCord configuration file.
+ * Ensures that `meocord.config.ts` exists, compiles it, and checks
+ * the presence of essential configuration properties like `discordToken`.
+ *
+ * @throws Will exit the process if the `meocord.config.ts` file is missing or
+ *         if the `discordToken` property is not found in the configuration.
+ */ async function compileAndValidateConfig() {
+    const meocordConfigPath = path.resolve(process.cwd(), 'meocord.config.ts');
+    if (!fs.existsSync(meocordConfigPath)) {
+        console.error(chalk.red('Configuration file "meocord.config.ts" is missing!'));
+        await wait(100);
+        process.exit(1);
+    }
+    const meocordConfig = loadMeoCordConfig();
+    if (!meocordConfig?.discordToken) {
+        console.error(chalk.red('Discord token is missing!'));
+        await wait(100);
+        process.exit(1);
+    }
+}
+/**
+ * Sets the environment mode for the application.
+ * Assigns the provided mode to `process.env.NODE_ENV` if it hasn't been set already.
+ *
+ * @param {'production' | 'development'} mode - The desired environment mode.
+ */ function setEnvironment(mode) {
+    if (!process.env.NODE_ENV) {
+        process.env.NODE_ENV = mode;
+    }
+}
+
+export { compileAndValidateConfig, findModulePackageDir, setEnvironment };

package/dist/esm/util/embed.util.js

@@ -0,0 +1,13 @@
+import { EmbedBuilder } from 'discord.js';
+import '../common/logger.js';
+import { Theme } from '../common/theme.js';
+
+const createErrorEmbed = (description)=>{
+    const embed = new EmbedBuilder();
+    embed.setColor(Theme.errorColor);
+    embed.setTitle('Oops!');
+    embed.setDescription(description);
+    return embed;
+};
+
+export { createErrorEmbed };

package/dist/esm/util/generator-cli.util.js

@@ -0,0 +1,107 @@
+import fs from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+import { Logger } from '../common/logger.js';
+import '../common/theme.js';
+import { kebabCase, startCase, camelCase } from 'lodash-es';
+import { fileURLToPath } from 'url';
+
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+const logger = new Logger('MeoCord');
+/**
+ * Converts a given name to a properly formatted class name.
+ * @param originalName - The original name to be converted to a class name.
+ * @returns The formatted class name.
+ * @throws Will exit the process if the generated class name is invalid.
+ */ function toClassName(originalName) {
+    const className = startCase(camelCase(originalName)).replace(/\s/g, '');
+    const classNameRegex = /^[A-Z][A-Za-z0-9]*$/;
+    if (!classNameRegex.test(className)) {
+        logger.error(`Invalid class name "${originalName}". Must start with a letter and contain alphanumeric characters.`);
+        process.exit(1);
+    }
+    return className;
+}
+/**
+ * Validates and formats a given name, splitting it into parts,
+ * converting it to kebab-case, and generating a class name.
+ * @param originalName - The name to validate and format. It can include slashes for nested paths.
+ * @returns An object containing the name parts, kebab-case name, and class name.
+ * @throws Will exit the process if the name is undefined, invalid,
+ *         or the generated class name is invalid.
+ */ function validateAndFormatName(originalName) {
+    if (!originalName) {
+        logger.error('Guard name is required.');
+        process.exit(1);
+    }
+    const parts = originalName.split('/');
+    const fileName = parts.pop();
+    if (!fileName) {
+        logger.error('Invalid guard name.');
+        process.exit(1);
+    }
+    const kebabCaseName = kebabCase(fileName);
+    const className = toClassName(fileName);
+    return {
+        parts,
+        kebabCaseName,
+        className
+    };
+}
+/**
+ * Ensures that a given directory exists. Creates the directory and any necessary parent directories if they do not exist.
+ * @param directory - The absolute path of the directory to create.
+ */ function createDirectoryIfNotExists(directory) {
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory, {
+            recursive: true
+        });
+    }
+}
+/**
+ * Writes the provided content to a file and runs ESLint on the file for formatting.
+ * @param filePath - The absolute path of the file to create or overwrite.
+ * @param content - The content to write to the file.
+ * @throws Logs an error if the file creation or ESLint command fails.
+ */ function generateFile(filePath, content) {
+    try {
+        fs.writeFileSync(filePath, content);
+        logger.log(`Guard file created at: ${path.relative(process.cwd(), filePath)}`);
+        exec(`npx eslint --fix ${filePath}`);
+    } catch (error) {
+        logger.error(`Failed to create guard file at ${filePath}`, error);
+    }
+}
+/**
+ * Builds and returns a template string for a given class name using a specific template file.
+ * @param className - The name of the class to insert into the template.
+ * @param templateFileName - The name of the template file to use.
+ * @returns The populated template string.
+ * @throws Will throw an error if the template file cannot be read.
+ */ function buildTemplate(className, templateFileName) {
+    const filePath = path.resolve(__dirname$1, '..', 'bin', 'builder-template', templateFileName);
+    let template = fs.readFileSync(filePath, 'utf-8');
+    const variables = {
+        className
+    };
+    for (const [key, value] of Object.entries(variables)){
+        template = template.replaceAll(`{{${key}}}`, value);
+    }
+    return template;
+}
+/**
+ * Populates a template file with the provided variables by replacing placeholders in the template.
+ * @param filePath - The path to the template file.
+ * @param variables - An object containing variable names and their replacement values.
+ * @returns The populated template string.
+ * @throws Will throw an error if the template file cannot be read.
+ */ function populateTemplate(filePath, variables) {
+    let template = fs.readFileSync(filePath, 'utf-8');
+    for (const [key, value] of Object.entries(variables)){
+        template = template.replaceAll(`{{${key}}}`, value);
+    }
+    return template;
+}
+
+export { buildTemplate, createDirectoryIfNotExists, generateFile, populateTemplate, toClassName, validateAndFormatName };

package/dist/{util → esm/util}/json.util.js

@@ -14,7 +14,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
- *//**
+ */ /**
  * Helper function to fix common JSON formatting issues in tsconfig.json, such as:
  * - Removing single-line comments.
  * - Removing trailing commas.
@@ -22,8 +22,12 @@
  *
  * @param {string} jsonString - The raw JSON string to fix.
  * @returns {string} The corrected JSON string.
- */export function fixJSON(a){return a.replace(/\/\/.*$/gm,"")// Remove single-line comments
-.replace(/,(\s*[}\]])/g,"$1")// Remove trailing commas before } or ]
-.replace(/,\s*$/,"")// Remove trailing commas at the end of the file
-.replace(/^\s*[\r\n]/gm,"");// Replace empty lines only
-}
+ */ function fixJSON(jsonString) {
+    return jsonString.replace(/\/\/.*$/gm, '') // Remove single-line comments
+    .replace(/,(\s*[}\]])/g, '$1') // Remove trailing commas before } or ]
+    .replace(/,\s*$/, '') // Remove trailing commas at the end of the file
+    .replace(/^\s*[\r\n]/gm, '') // Replace empty lines only
+    ;
+}
+
+export { fixJSON };

package/dist/esm/util/meocord-cli.util.js

@@ -0,0 +1,172 @@
+import CliTable3 from 'cli-table3';
+import { findModulePackageDir } from './common.util.js';
+import path from 'node:path';
+import fs__default from 'node:fs';
+import wait from './wait.util.js';
+import chalk from 'chalk';
+
+function configureCommandHelp(command) {
+    command.configureHelp({
+        formatHelp: (cmd, helper)=>{
+            return formatHelp(cmd, helper, command.options);
+        }
+    });
+    command.commands.forEach((cmd)=>{
+        configureCommandHelp(cmd);
+    });
+}
+/**
+ * Formats the help output for a command.
+ *
+ * @param cmd - The command for which to format help.
+ * @param helper - The helper object for formatting.
+ * @param options - The options available for the command.
+ * @returns The formatted help text.
+ */ function formatHelp(cmd, helper, options) {
+    let helpText = `MeoCord Copyright (C) 2025  Ukasyah Rahmatullah Zada
+    This program comes with ABSOLUTELY NO WARRANTY; for details type \`meocord show -w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type \`meocord show -c' for details.\n\n`;
+    helpText += `${helper.commandUsage(cmd)}\n\n`;
+    helpText += `${helper.commandDescription(cmd)}\n\n`;
+    if (cmd.registeredArguments.length > 0) {
+        helpText += generateArgumentsTable(cmd.registeredArguments);
+        helpText += '\n\n';
+    }
+    if (options.length > 0) {
+        helpText += 'Available Options:\n';
+        helpText += generateOptionsTable(options, helper);
+        helpText += '\n\n';
+    }
+    if (cmd.commands.length > 0) {
+        helpText += 'Available Commands:\n';
+        helpText += generateCommandsTable(cmd);
+        helpText += '\n';
+    }
+    return helpText;
+}
+/**
+ * Generates a table of commands with their aliases and descriptions.
+ *
+ * @param cmd - The command for which to generate the table.
+ * @returns The formatted table of commands.
+ */ function generateCommandsTable(cmd) {
+    const table = new CliTable3({
+        head: [
+            'Command',
+            'Alias',
+            'Description'
+        ]
+    });
+    cmd.commands.forEach((cmd)=>{
+        const alias = cmd.aliases().length > 0 ? cmd.aliases().join(', ') : '—';
+        const description = cmd.description() || 'No description provided';
+        table.push([
+            cmd.name(),
+            alias,
+            description
+        ]);
+    });
+    return table.toString();
+}
+/**
+ * Generates a table of commands with their aliases and descriptions.
+ *
+ * @param options
+ * @param helper
+ * @returns The formatted table of commands.
+ */ function generateOptionsTable(options, helper) {
+    const table = new CliTable3({
+        head: [
+            'Option',
+            'Description'
+        ]
+    });
+    options.forEach((option)=>table.push([
+            helper.optionTerm(option),
+            helper.optionDescription(option)
+        ]));
+    return table.toString();
+}
+/**
+ * Generates a formatted table of arguments for the specified command.
+ *
+ * This method creates two tables:
+ * 1. A table displaying argument names and their descriptions.
+ * 2. (If applicable) A table showing available choices for arguments with predefined choices.
+ *
+ * @param args - The list of arguments for the command.
+ * @returns A string representation of the formatted tables, including available arguments and their choices.
+ */ function generateArgumentsTable(args) {
+    const table = new CliTable3({
+        head: [
+            'Argument',
+            'Description'
+        ]
+    });
+    const choiceTable = new CliTable3({
+        head: [
+            'Choice'
+        ]
+    });
+    let hasChoices = false;
+    args.forEach((arg)=>{
+        if (arg.argChoices) {
+            hasChoices = true;
+            arg.argChoices.forEach((choice)=>{
+                choiceTable.push([
+                    choice
+                ]);
+            });
+        }
+        table.push([
+            arg.name(),
+            arg.description || 'No description provided'
+        ]);
+    });
+    let text = '';
+    if (hasChoices) {
+        text += 'Available Choices:\n';
+        text += choiceTable.toString();
+        text += '\n\n';
+    } else {
+        text += 'No available choices.\n\n';
+    }
+    text += 'Available Arguments:\n';
+    text += table.toString();
+    return text;
+}
+/**
+ * Ensures that the script is being run from the root directory of the project.
+ * Validates the existence of required files, dependencies, and configuration.
+ * If validation fails, it logs an error message and terminates the process.
+ */ async function ensureReady() {
+    const meocordPath = findModulePackageDir('meocord');
+    const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+    try {
+        // Ensure the root package.json exists
+        if (!fs__default.existsSync(packageJsonPath)) {
+            throw new Error('package.json not found. This script must be run from the root directory of the project.');
+        }
+        // Ensure the MeoCord package directory is found
+        if (!meocordPath) {
+            throw new Error('Cannot locate the "MeoCord" package directory.');
+        }
+        // Read and parse the root package.json
+        const { dependencies } = JSON.parse(fs__default.readFileSync(packageJsonPath, 'utf-8'));
+        // Read and parse the MeoCord package.json
+        const internalPackageJsonPath = path.join(meocordPath, 'package.json');
+        const { name: internalPackageName } = JSON.parse(fs__default.readFileSync(internalPackageJsonPath, 'utf-8'));
+        // Validate that MeoCord is listed as a dependency in the root package.json
+        if (!dependencies?.[internalPackageName]) {
+            throw new Error('The package.json does not list "MeoCord" as a dependency. Ensure you are in the root directory.');
+        }
+    } catch (error) {
+        // Log the error and exit the process
+        console.error(chalk.red(error instanceof Error ? error.message : 'An unknown error occurred during validation.'));
+        await wait(100);
+        process.exit(1);
+    }
+}
+
+export { configureCommandHelp, ensureReady, formatHelp, generateArgumentsTable, generateCommandsTable, generateOptionsTable };