djs-builder 0.5.0 → 0.5.2

package/lib/discord/events-handler/prefix-responder.ts

@@ -4,6 +4,7 @@ import { PrefixOptions } from '../types/utils';
 import { getSimilarCommands } from '../functions/utils';
 import { botData } from './login';
 import { logError } from '../functions/logger'; 
+
 const cooldowns: Collection<string, Collection<string, number>> = new Collection();
 
 export async function handleMessageCreate(message: Message, prefixOptions: PrefixOptions): Promise<void> {
@@ -17,88 +18,106 @@ export async function handleMessageCreate(message: Message, prefixOptions: Prefi
             botPrefix = customPrefixEntry.prefix;
         }
     }
-    if (message.guild?.members.me) {
+
+    if (message.guild && message.guild.members.me) {
         const user = message.author;
-        const botData = new Collection<string, string | string[]>();
-        const permissionsArray = botData.get('permissions') as string[] | undefined;
+        const botPermissions = message.guild.members.me.permissions;
 
-        if (!message.guild.members.me.permissions.has('SendMessages')) {
+        if (!botPermissions.has('SendMessages')) {
             try {
-                user.send({ content: "I'm sorry, but I don't have permission to send messages in this server." });
+                await user.send("I'm sorry, but I don't have permission to send messages in this server.");
             } catch (error: any) {
                 logError("Failed to send permission error message to user.", error);
                 return;
             }
         }
 
+        const permissionsArray = botData.get('permissions') as string[] | undefined;
         if (permissionsArray && permissionsArray.length > 0) {
-            const missingPermissions = permissionsArray.filter(permission => !message.guild?.members.me?.permissions.has(permission as PermissionResolvable));
+            const missingPermissions = permissionsArray.filter(permission => !botPermissions.has(permission as PermissionResolvable));
 
             if (missingPermissions.length > 0) {
                 try {
-                    user.send({ content: `I'm sorry, but I don't have permission(s): ${missingPermissions.join(', ')} in this server.` });
+                    await user.send(`I'm sorry, but I don't have permission(s): ${missingPermissions.join(', ')} in this server.`);
                 } catch (error: any) {
-                    logError("Failed to send missing permissions message to user.", error); // Log the error with details
+                    logError("Failed to send missing permissions message to user.", error);
                     return;
                 }
             }
         }
     }
 
-    if (!message.content.startsWith(botPrefix) || message.author.bot) return;
+    let args = [];
+    let commandName: string | undefined;
 
-    if (prefixOptions.global === false && prefixOptions.serverIds && prefixOptions.serverIds.length > 0) {
-        const guildId = message.guild?.id;
-        if (guildId && !prefixOptions.serverIds.includes(guildId)) return;
+    if (message.content.startsWith(botPrefix)) {
+        args = message.content.slice(botPrefix.length).trim().split(/ +/);
+        commandName = args.shift()?.toLowerCase();
     } else {
-        const args = message.content.slice(botPrefix.length).trim().split(/ +/);
-        const commandName = args.shift()?.toLowerCase();
+        commandName = message.content.split(/ +/)[0].toLowerCase();
+        args = message.content.split(/ +/).slice(1);
+    }
 
-        if (!commandName || (!commands.has(commandName) && !aliases.has(commandName))) return;
+    if (!commandName) return;
 
-        const command = commands.get(commandName) || commands.get(aliases.get(commandName) || '');
+    const command = commands.get(commandName) || commands.get(aliases.get(commandName) || '');
 
-        if (!command) {
-            const similarCommands = getSimilarCommands(commandName, commands);
-            if (similarCommands.length > 0) {
-                await message.reply(`Command not found. Did you mean: ${similarCommands.join(', ')}?`);
-            } else {
-                await message.reply(`Command '${commandName}' doesn't exist.`);
-            }
-            return;
+    if (!command) {
+        const similarCommands = getSimilarCommands(commandName, commands);
+        if (similarCommands.length > 0) {
+            await message.reply(`Command not found. Did you mean: ${similarCommands.join(', ')}?`);
+        } else {
+            await message.reply(`Command '${commandName}' doesn't exist.`);
         }
+        return;
+    }
+
+    if (command.owner && message.author.id !== ownerId) {
+        await message.reply(`Only the bot owner can use this command.`);
+        return;
+    }
 
-        if (command.owner && message.author.id !== ownerId) {
-            await message.reply(`Only the bot owner can use this command.`);
+    if (command.developer) {
+        if (developers && !developers.includes(message.author.id)) {
+            if (message.author.id === ownerId) return;
+            await message.reply("You are not authorized to use this command.");
             return;
         }
+    }
 
-        if (command.developer) {
-            if (developers && !developers.includes(message.author.id)) {
-                if (message.author.id === ownerId) return;
-                await message.reply("You are not authorized to use this command.");
+    if (message.guild) {
+        if (command.botPerms && command.botPerms.length > 0) {
+            const missingBotPerms = command.botPerms.filter(perm => !message.guild?.members.me?.permissions.has(perm as PermissionResolvable));
+            if (missingBotPerms.length > 0) {
+                await message.reply(`I'm missing the following permissions to execute this command: ${missingBotPerms.join(', ')}`);
                 return;
             }
         }
 
-        const now = Date.now();
-        const timestamps = cooldowns.get(command.name) || new Collection<string, number>();
-        const cooldownAmount = (command.cooldown || 3) * 1000;
-
-        if (timestamps.has(message.author.id)) {
-            const expirationTime = timestamps.get(message.author.id) || 0;
-            const timeLeft = (expirationTime - now) / 1000;
-
-            if (now < expirationTime) {
-                await message.reply(`Please wait ${timeLeft.toFixed(1)} more second(s) before reusing the \`${command.name}\` command.`);
-                return;
+        if (command.userPerms && command.userPerms.length > 0) {
+            const member = message.guild.members.cache.get(message.author.id);
+            if (member) {
+                const missingUserPerms = command.userPerms.filter(perm => !member.permissions.has(perm as PermissionResolvable));
+                if (missingUserPerms.length > 0) {
+                    await message.reply(`You are missing the following permissions to use this command: ${missingUserPerms.join(', ')}`);
+                    return;
+                }
             }
         }
 
-        timestamps.set(message.author.id, now);
-        setTimeout(() => timestamps.delete(message.author.id), cooldownAmount);
-        cooldowns.set(command.name, timestamps);
+        if (command.accessLevel) {
+            const member = message.guild.members.cache.get(message.author.id);
+            if (member) {
+                const highestRole = member.roles.highest;
+                if (highestRole.id !== command.accessLevel) {
+                    await message.reply("You do not have the required role to use this command.");
+                    return;
+                }
+            }
+        }
+    }
 
+    if (command.fastUse && !message.content.startsWith(botPrefix)) {
         try {
             if (command.run) {
                 await command.run(message.client, message, args);
@@ -106,34 +125,93 @@ export async function handleMessageCreate(message: Message, prefixOptions: Prefi
                 await command.execute(message.client, message, args);
             }
 
-            const channel = message.guild?.channels.cache.get(prefixOptions.logsId || '') as TextChannel | undefined;
-            const userName = message.author.username;
-            const userId = message.author.id;
-            const serverName = message.guild?.name || null;
-            const serverId = message.guild?.id || null;
-            const messageLink = `https://discord.com/channels/${serverId}/${message.channel.id}/${message.id}`;
-
-            const embedLog = new EmbedBuilder()
-                .setColor("Blue")
-                .setThumbnail(message.client.user?.displayAvatarURL())
-                .setTitle("Use Prefix Command")
-                .setTimestamp()
-                .addFields(
-                    { name: "📧 Cmd:", value: `- ${command.name}`, inline: true },
-                    { name: "🤪 User:", value: `- ${userName} (<@${userId}>)`, inline: true },
-                    { name: "\u200B", value: "\u200B", inline: true },
-                    { name: "🏠 Server:", value: `- ${serverName}.\n- [\`${serverId}\`].`, inline: true },
-                    { name: "📩 Message:", value: `- [Link](${messageLink})`, inline: true },
-                    { name: "\u200B", value: "\u200B", inline: true },
-                    { name: "⏳ Date:", value: `- <t:${Math.floor(Date.now() / 1000)}:R>`, inline: true }
-                );
-
-            if (prefixOptions.logsId && channel) {
-                await channel.send({ embeds: [embedLog] });
+            if (message.guild) {
+                const channel = message.guild.channels.cache.get(prefixOptions.logsId || '') as TextChannel | undefined;
+                const userName = message.author.username;
+                const userId = message.author.id;
+                const serverName = message.guild.name || null;
+                const serverId = message.guild.id || null;
+                const messageLink = `https://discord.com/channels/${serverId}/${message.channel.id}/${message.id}`;
+
+                const embedLog = new EmbedBuilder()
+                    .setColor("Blue")
+                    .setThumbnail(message.client.user?.displayAvatarURL())
+                    .setTitle("Use Prefix Command")
+                    .setTimestamp()
+                    .addFields(
+                        { name: "📧 Cmd:", value: `- ${command.name}`, inline: true },
+                        { name: "🤪 User:", value: `- ${userName} (<@${userId}>)`, inline: true },
+                        { name: "\u200B", value: "\u200B", inline: true },
+                        { name: "🏠 Server:", value: `- ${serverName}.\n- [\`${serverId}\`].`, inline: true },
+                        { name: "📩 Message:", value: `- [Link](${messageLink})`, inline: true },
+                        { name: "\u200B", value: "\u200B", inline: true },
+                        { name: "⏳ Date:", value: `- <t:${Math.floor(Date.now() / 1000)}:R>`, inline: true }
+                    );
+
+                if (prefixOptions.logsId && channel) {
+                    await channel.send({ embeds: [embedLog] });
+                }
             }
         } catch (error: any) {
             logError(`Error executing command ${command.name}`, error);
         }
+        return;
+    }
+
+    const now = Date.now();
+    const timestamps = cooldowns.get(command.name) || new Collection<string, number>();
+    const cooldownAmount = (command.cooldown || 3) * 1000;
+
+    if (timestamps.has(message.author.id)) {
+        const expirationTime = timestamps.get(message.author.id) || 0;
+        const timeLeft = (expirationTime - now) / 1000;
+
+        if (now < expirationTime) {
+            await message.reply(`Please wait ${timeLeft.toFixed(1)} more second(s) before reusing the \`${command.name}\` command.`);
+            return;
+        }
+    }
+
+    timestamps.set(message.author.id, now);
+    setTimeout(() => timestamps.delete(message.author.id), cooldownAmount);
+    cooldowns.set(command.name, timestamps);
+
+    try {
+        if (command.run) {
+            await command.run(message.client, message, args);
+        } else if (command.execute) {
+            await command.execute(message.client, message, args);
+        }
+
+        if (message.guild && prefixOptions.logsId) {
+            const channel = message.guild.channels.cache.get(prefixOptions.logsId as string) as TextChannel;
+            if (channel) {
+                const userName = message.author.username;
+                const userId = message.author.id;
+                const serverName = message.guild.name || null;
+                const serverId = message.guild.id || null;
+                const messageLink = `https://discord.com/channels/${serverId}/${message.channel.id}/${message.id}`;
+    
+                const embedLog = new EmbedBuilder()
+                    .setColor("Blue")
+                    .setThumbnail(message.client.user?.displayAvatarURL())
+                    .setTitle("Use Prefix Command")
+                    .setTimestamp()
+                    .addFields(
+                        { name: "📧 Cmd:", value: `- ${command.name}`, inline: true },
+                        { name: "🤪 User:", value: `- ${userName} (<@${userId}>)`, inline: true },
+                        { name: "\u200B", value: "\u200B", inline: true },
+                        { name: "🏠 Server:", value: `- ${serverName}.\n- [\`${serverId}\`].`, inline: true },
+                        { name: "📩 Message:", value: `- [Link](${messageLink})`, inline: true },
+                        { name: "\u200B", value: "\u200B", inline: true },
+                        { name: "⏳ Date:", value: `- <t:${Math.floor(Date.now() / 1000)}:R>`, inline: true }
+                    );
+    
+                await channel.send({ embeds: [embedLog] });
+            }
+        }
+    } catch (error: any) {
+        logError(`Error executing command ${command.name}`, error);
     }
 }
 

package/lib/discord/events-handler/prefixLoader.ts

@@ -47,7 +47,7 @@ export async function prefixLoader(client: any): Promise<{ commands: Collection<
         return { commands: commands, success: true };
     } catch (error: any) {
         logError('Error reloading commands:');
-        logError(error.message);
+        logError(error.message, error);
 
         return { commands: new Collection(), success: false };
     }

package/lib/discord/events-handler/slash-register.ts

@@ -30,6 +30,13 @@ export async function registerSlashCommands(client: any, token: string, slash: S
                             if (command.cooldown && !isNaN(command.cooldown)) {
                                 command.data.cooldown = command.cooldown || 0;
                             }
+                            command.data.botPerms = command.botPerms || [];
+                            command.data.userPerms = command.userPerms || [];
+                            command.data.owner = command.owner || false;
+                            command.data.developer = command.developer || false;
+                            command.data.category = command.category || 'Uncategorized';
+
+
                             slashCommands.set(command.data.name, command);
                         }
                     } catch (error: any) {
@@ -44,6 +51,13 @@ export async function registerSlashCommands(client: any, token: string, slash: S
                         if (command.cooldown && !isNaN(command.cooldown)) {
                             command.data.cooldown = command.cooldown || 0;
                         }
+                        command.data.botPerms = command.botPerms || [];
+                        command.data.userPerms = command.userPerms || [];
+                        command.data.owner = command.owner || false;
+                        command.data.developer = command.developer || false;
+                        command.data.category = command.category || 'Uncategorized';
+
+
                         slashCommands.set(command.data.name, command);
                     }
                 } catch (error: any) {

package/lib/discord/events-handler/slash-responder.ts

@@ -1,4 +1,4 @@
-import { Client, Collection, Interaction, EmbedBuilder, Snowflake, PermissionResolvable } from 'discord.js';
+import { Client, Collection, Interaction, EmbedBuilder, Snowflake, PermissionResolvable, TextChannel } from 'discord.js';
 import { registerSlashCommands } from './slash-register';
 import { SlashOptions } from '../types/starter';
 import { logWarning, logError, logInfo } from '../functions/logger';
@@ -79,36 +79,38 @@ export async function loadSlash(client: Client, token: string, options: SlashOpt
                 logWarning(`Command "${command.data.name}" has neither run nor execute method.`);
             }
 
-            const channel = interaction.guild.channels.cache.get(options.logsId || '') as any;
-            const userName = interaction.user.username;
-            const userId = interaction.user.id;
-            const serverName = interaction.guild.name || 'Unknown Server';
-            const serverId = interaction.guild.id || 'Unknown ID';
-            let messageLink = '';
-
-            if (interaction.channel) {
-                messageLink = `https://discord.com/channels/${serverId}/${interaction.channel.id}/${interaction.id}`;
-            } else {
-                messageLink = 'Unknown';
-            }
-
-            const embedLog = new EmbedBuilder()
-                .setColor("Blue")
-                .setThumbnail(interaction.client.user?.displayAvatarURL())
-                .setTitle("Use Slash Command")
-                .setTimestamp()
-                .addFields(
-                    { name: "📧 Cmd:", value: `- ${command.data.name}`, inline: true },
-                    { name: "🤪 User:", value: `- ${userName} (<@${userId}>)`, inline: true },
-                    { name: "\u200B", value: "\u200B", inline: true },
-                    { name: "🏠 Server:", value: `- ${serverName}.\n- [\`${serverId}\`].`, inline: true },
-                    { name: "📩 Message:", value: `- [Link](${messageLink})`, inline: true },
-                    { name: "\u200B", value: "\u200B", inline: true },
-                    { name: "⏳ Date:", value: `- <t:${Math.floor(Date.now() / 1000)}:R>`, inline: true }
-                );
-
-            if (options.logsId && channel) {
-                await channel.send({ embeds: [embedLog] });
+            if (options.logsId) {
+                const channel = interaction.guild.channels.cache.get(options.logsId as string) as TextChannel;
+                  if(channel) { 
+                    const userName = interaction.user.username;
+                    const userId = interaction.user.id;
+                    const serverName = interaction.guild.name || 'Unknown Server';
+                    const serverId = interaction.guild.id || 'Unknown ID';
+                    let messageLink = '';
+        
+                    if (interaction.channel) {
+                        messageLink = `https://discord.com/channels/${serverId}/${interaction.channel.id}/${interaction.id}`;
+                    } else {
+                        messageLink = 'Unknown';
+                    }
+        
+                    const embedLog = new EmbedBuilder()
+                        .setColor("Blue")
+                        .setThumbnail(interaction.client.user?.displayAvatarURL())
+                        .setTitle("Use Slash Command")
+                        .setTimestamp()
+                        .addFields(
+                            { name: "📧 Cmd:", value: `- ${command.data.name}`, inline: true },
+                            { name: "🤪 User:", value: `- ${userName} (<@${userId}>)`, inline: true },
+                            { name: "\u200B", value: "\u200B", inline: true },
+                            { name: "🏠 Server:", value: `- ${serverName}.\n- [\`${serverId}\`].`, inline: true },
+                            { name: "📩 Message:", value: `- [Link](${messageLink})`, inline: true },
+                            { name: "\u200B", value: "\u200B", inline: true },
+                            { name: "⏳ Date:", value: `- <t:${Math.floor(Date.now() / 1000)}:R>`, inline: true }
+                        );
+        
+                    await channel.send({ embeds: [embedLog] });    
+                  }
             }
 
             const executionTime = Date.now() - startExecutionTime;

package/lib/discord/events-handler/slashLoader.ts

@@ -46,6 +46,12 @@ export async function slashLoader(client: any): Promise<{ commands: Collection<s
             try {
                 const command = require(file);
                 if (command.data) {
+                    command.cooldown = command.cooldown || 0;
+                    command.owner = command.owner || false;
+                    command.developer = command.developer || false;
+                    command.botPerms = command.botPerms || [];
+                    command.userPerms = command.userPerms || [];
+                    
                     client.slashCommands.set(command.data.name, command);
                     newCommands.set(command.data.name, command);
                 }
@@ -64,8 +70,7 @@ export async function slashLoader(client: any): Promise<{ commands: Collection<s
         return { commands: newCommands, success: true };
     } catch (error: any) {
         logError('Error reloading slash commands:');
-        logError(error.message);
-        console.error(error);
+        logError(error.message, error);
         return { commands: new Collection<string, any>(), success: false };
     }
 }

package/lib/discord/functions/logger.ts

@@ -9,9 +9,6 @@ const cyan = '\x1b[36m';
 const reset = '\x1b[0m';
 const yellow = '\x1b[33m';
 
-import { inspect } from 'util';
-
-
 function getTimestamp(): string {
     const now = new Date();
     const year = now.getFullYear();
@@ -23,6 +20,19 @@ function getTimestamp(): string {
     return `[${year}-${month}-${day} ${hours}:${minutes}:${seconds}]`;
 }
 
+function extractErrorLocation(stack: string): string {
+    const lines = stack.split('\n');
+    const locationLine = lines[1] || lines[0];
+    
+    const match = locationLine.match(/\((.*):(\d+):(\d+)\)/);
+    if (match) {
+        const file = match[1];
+        const line = match[2];
+        return `File: ${file}, Line: ${line}`;
+    }
+    return 'Unknown location';
+}
+
 export function logSuccess(message: string) {
     console.log(`${getTimestamp()} ${green}${successEmoji}${reset} ${green}${message}${reset}`);
 }
@@ -32,18 +42,17 @@ export function logError(message: string, error?: Error) {
     const baseMessage = `${timestamp} ${red}${errorEmoji}${reset} ${red}${message}${reset}`;
 
     if (error && error.stack) {
-        console.error(`${baseMessage}\n${error.stack}`);
+        const location = extractErrorLocation(error.stack);
+        console.error(`${baseMessage}\n${location}\n${error.stack}`);
     } else {
         console.error(baseMessage);
     }
 }
 
-
 export function logInfo(message: string) {
     console.log(`${getTimestamp()} ${cyan}${infoEmoji}${reset} ${cyan}${message}${reset}`);
 }
 
-
 export function logWarning(message: string) {
     console.warn(`${getTimestamp()} ${yellow}${warningEmoji}${reset} ${yellow}${message}${reset}`);
 }

package/lib/discord/functions/similarity.ts

@@ -1,19 +1,32 @@
-import { Collection } from 'discord.js'
+import { Collection } from 'discord.js';
 import { Command } from '../types/starter';
+
 export function getSimilarCommands(commandName: string, commands: Collection<string, Command>): string[] {
-    const similarityThreshold = 0.6; 
+    const similarityThreshold = 0.6;
+    const partialMatches: string[] = [];
     const similarCommands: { name: string; similarity: number }[] = [];
 
     commands.forEach((_, cmdName) => {
+        if (cmdName.includes(commandName) || commandName.includes(cmdName)) {
+            partialMatches.push(cmdName);
+        }
+
         const similarity = calculateSimilarity(commandName, cmdName);
         if (similarity >= similarityThreshold) {
             similarCommands.push({ name: cmdName, similarity });
         }
     });
 
+    const combinedCommands = new Set([...partialMatches, ...similarCommands.map(cmd => cmd.name)]);
+    const uniqueCommands = Array.from(combinedCommands);
+
     similarCommands.sort((a, b) => b.similarity - a.similarity);
 
-    return similarCommands.map(cmd => cmd.name);
+    return uniqueCommands.sort((a, b) => {
+        const aIndex = similarCommands.findIndex(cmd => cmd.name === a);
+        const bIndex = similarCommands.findIndex(cmd => cmd.name === b);
+        return bIndex - aIndex;
+    });
 }
 
 function calculateSimilarity(str1: string, str2: string): number {
@@ -21,7 +34,6 @@ function calculateSimilarity(str1: string, str2: string): number {
     const len2 = str2.length;
     const matrix = [];
 
-    // Initialize the matrix
     for (let i = 0; i <= len1; i++) {
         matrix[i] = [i];
     }
@@ -35,7 +47,7 @@ function calculateSimilarity(str1: string, str2: string): number {
             matrix[i][j] = Math.min(
                 matrix[i - 1][j] + 1,
                 matrix[i][j - 1] + 1,
-                matrix[i - 1][j - 1] + cost 
+                matrix[i - 1][j - 1] + cost
             );
         }
     }

package/lib/discord/functions/terminal.ts

@@ -1,17 +1,25 @@
-import { blue, cyan, blueBright, magentaBright, red, yellow, cyanBright, gray, redBright, greenBright, yellowBright } from 'colorette';
-import { BotOptions } from '../types/starter';
+import { blue, cyanBright, greenBright, red, yellowBright, redBright, green, magentaBright, cyan, yellow, blueBright, gray } from 'colorette';
 import Table from 'cli-table';
 import fs from 'fs';
 import path from 'path';
+import figlet from 'figlet';
 
-interface Client {
-    user: { username: string };
-    prefixSize?: number;
-    slashSize?: number;
-    eventSize?: number;
+
+
+async function showLoadingBar(duration: number) {
+    const steps = [15, 30, 70, 85, 95, 100];
+    const interval = duration / steps.length;
+
+    for (const step of steps) {
+        process.stdout.write(`\r${cyanBright('Loading... ')}${'█'.repeat(step / 10)}${'░'.repeat(10 - step / 10)} ${step}%`);
+        await new Promise(resolve => setTimeout(resolve, interval));
+    }
+
+    process.stdout.write('\r'.padEnd(50) + '\r');
 }
 
-export async function terminalLogs(client: any, bot: BotOptions): Promise<void> {
+// Main function to show terminal logs
+export async function terminalLogs(client: any, bot: any): Promise<void> {
     const { user, prefixSize = 0, slashSize = 0, eventSize = 0 } = client;
 
     const totalCommands = slashSize + prefixSize;
@@ -45,9 +53,12 @@ export async function terminalLogs(client: any, bot: BotOptions): Promise<void>
     const projectPath = findProjectRoot();
     const projectSize = getProjectSize(projectPath);
 
+    await showLoadingBar(3000);
+
     const botStatesTable = new Table({
         head: [blue('# Bot States')],
-        colWidths: [30, 20]
+        colWidths: [30, 40],
+        style: { 'padding-left': 1, 'padding-right': 1 }
     });
     botStatesTable.push(
         [yellowBright('Bot Name'), user.username],
@@ -59,10 +70,11 @@ export async function terminalLogs(client: any, bot: BotOptions): Promise<void>
 
     const botInfoTable = new Table({
         head: [blue('# Bot Info')],
-        colWidths: [30, 25]
+        colWidths: [30, 50],
+        style: { 'padding-left': 1, 'padding-right': 1 }
     });
-    if (client.presence?.Status) {
-        botInfoTable.push([yellow('Status'), client.presence.Status]);
+    if (client.presence?.status) {
+        botInfoTable.push([yellowBright('Status'), client.presence.status]);
     }
     if (bot.Status?.activities && bot.Status.activities.length > 0) {
         botInfoTable.push([cyanBright('Activity'), bot.Status.activities[0]]);
@@ -90,6 +102,7 @@ export async function terminalLogs(client: any, bot: BotOptions): Promise<void>
         const loggedInAt = new Date(client.readyTimestamp).toLocaleString();
         botInfoTable.push([yellowBright('Logged In At'), loggedInAt]);
     }
-    console.log(botStatesTable.toString());
-    console.log(botInfoTable.toString());
+
+    console.log(`\n${blueBright('Bot States')}\n${botStatesTable.toString()}\n`);
+    console.log(`${blueBright('Bot Info')}\n${botInfoTable.toString()}\n`);
 }

package/lib/discord/types/starter.ts

@@ -106,9 +106,12 @@ export interface Command {
     cooldown?: number;
     usage?: string;
     developer?: boolean;
-    prefix?: boolean;
     category?: string;
+    fastUse?: boolean;
+    botPerms?: string[];
+    userPerms?: string[];
     owner?: boolean;
+    accessLevel?: string; 
 }
 
 export interface StarterOptions {

package/lib/discord/utils.ts

@@ -7,7 +7,8 @@ import { readCommands } from "./events-handler/prefix-register";
 import { loadPrefix, handleMessageCreate } from "./events-handler/prefix-responder";
 import { registerSlashCommands } from "./events-handler/slash-register";
 import { loadSlash } from "./events-handler/slash-responder";
+import { logError, logInfo, logSuccess, logWarning  } from "./functions/logger";
 import { loadEvents, withRetry, processEventFile, processDirectory, limitConcurrency, countEventFiles } from "./events-handler/events";
 export { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
     loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
-     processEventFile }
+     processEventFile, logError, logInfo, logSuccess, logWarning }

package/lib/index.ts

@@ -29,12 +29,12 @@ fetch("https://registry.npmjs.com/-/v1/search?text=djs-builder")
 
 import { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
     loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
-     processEventFile } from "./discord/utils";
+     processEventFile, logError, logInfo, logSuccess, logWarning } from "./discord/utils";
 
 export { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
     loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
-     processEventFile };
+     processEventFile , logError, logInfo, logSuccess, logWarning};
 export default { Starter, ButtonManager, MenuManager, PermissionChecker, slashLoader, prefixLoader, eventLoader, readCommands, loadEvents,
     loadSlash, loadPrefix, handleMessageCreate, processDirectory, countEventFiles, limitConcurrency, withRetry, registerSlashCommands,
-     processEventFile };
+     processEventFile, logError, logInfo, logSuccess, logWarning };
 export * from './discord/types/starter';