djs-next 0.0.1 → 1.0.0-dev.2

package/src/cli.ts

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { input, select, password } from '@inquirer/prompts';
+import { spawnSync } from 'child_process';
+import { tsTemplates } from './templates/ts.js';
+import { esmTemplates } from './templates/esm.js';
+import { cjsTemplates } from './templates/cjs.js';
+import pc from 'picocolors';
+import { execSync } from 'child_process';
+
+async function main() {
+  console.log(pc.bold(pc.blue('\n🚀 Welcome to djs-next!\n')));
+
+  const userAgent = process.env.npm_config_user_agent || '';
+  let pm = 'npm';
+  if (userAgent.startsWith('yarn')) pm = 'yarn';
+  else if (userAgent.startsWith('pnpm')) pm = 'pnpm';
+  else if (userAgent.startsWith('bun')) pm = 'bun';
+
+  const args = process.argv.slice(2);
+  let projectName = args[0] || '';
+
+  if (!projectName || projectName === 'init') {
+    projectName = await input({
+      message: 'What is your project named?',
+      default: 'my-bot',
+      validate: (value) => value.trim().length > 0 || 'Project name is required'
+    });
+  }
+
+  const language = await select({
+    message: 'Would you like to use TypeScript or JavaScript?',
+    choices: [
+      { name: 'TypeScript', value: 'ts' },
+      { name: 'JavaScript', value: 'js' }
+    ],
+    default: 'ts'
+  });
+
+  const moduleSystem = await select({
+    message: 'Would you like to use ES Modules or CommonJS?',
+    choices: [
+      { name: 'ES Modules (import/export)', value: 'esm' },
+      { name: 'CommonJS (require/module.exports)', value: 'cjs' }
+    ],
+    default: 'esm'
+  });
+
+  const botToken = await password({
+    message: 'What is your Discord Bot Token? (Leave empty to skip)',
+    mask: true
+  });
+
+  const clientId = await input({
+    message: 'What is your Discord Client ID? (Leave empty to skip)'
+  });
+
+  const targetPath = path.resolve(process.cwd(), projectName);
+
+  if (fs.existsSync(targetPath)) {
+    console.error(pc.red(`\nDirectory "${projectName}" already exists.`));
+    process.exit(1);
+  }
+
+  console.log(pc.cyan(`\nScaffolding project in ${targetPath}...`));
+  fs.mkdirSync(targetPath, { recursive: true });
+
+  const isTS = language === 'ts';
+  const isESM = moduleSystem === 'esm';
+  const ext = isTS ? 'ts' : 'js';
+
+  let devScript = isTS ? "tsx watch src/index.ts" : "node --watch src/index.js";
+  let startScript = isTS ? "node dist/index.js" : "node src/index.js";
+  
+  if (pm === 'bun') {
+    devScript = `bun run --watch src/index.${ext}`;
+    startScript = `bun src/index.${ext}`;
+  }
+
+  const packageJson: any = {
+    name: projectName.toLowerCase().replace(/\\s+/g, '-'),
+    version: "1.0.0",
+    main: isTS ? "dist/index.js" : "src/index.js",
+    type: isESM ? "module" : "commonjs",
+    scripts: {
+      "dev": devScript,
+      "start": startScript
+    },
+    dependencies: {
+      "discord.js": "latest",
+      "djs-next": "latest",
+      "dotenv": "latest"
+    },
+    devDependencies: {}
+  };
+
+  if (isTS) {
+    packageJson.scripts.build = "tsc";
+    packageJson.devDependencies = {
+      "typescript": "latest",
+      "@types/node": "latest",
+      "tsx": "latest"
+    };
+  }
+
+  fs.writeFileSync(path.join(targetPath, 'package.json'), JSON.stringify(packageJson, null, 2));
+
+  if (isTS) {
+    const tsconfig = {
+      compilerOptions: {
+        target: "ES2022",
+        module: isESM ? "NodeNext" : "CommonJS",
+        moduleResolution: isESM ? "NodeNext" : "Node",
+        strict: true,
+        esModuleInterop: true,
+        outDir: "./dist",
+        types: ["node"],
+        ignoreDeprecations: "5.0"
+      },
+      include: ["src/**/*"]
+    };
+    fs.writeFileSync(path.join(targetPath, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
+  }
+
+  fs.writeFileSync(path.join(targetPath, '.env'), `DISCORD_TOKEN=${botToken || 'your_token_here'}
+CLIENT_ID=${clientId || 'your_client_id_here'}
+`);
+  fs.writeFileSync(path.join(targetPath, '.gitignore'), `node_modules/
+dist/
+.env
+.DS_Store
+`);
+
+  const srcDir = path.join(targetPath, 'src');
+  fs.mkdirSync(srcDir, { recursive: true });
+  fs.mkdirSync(path.join(srcDir, 'commands'), { recursive: true });
+  fs.mkdirSync(path.join(srcDir, 'events'), { recursive: true });
+  fs.mkdirSync(path.join(srcDir, 'components', 'buttons'), { recursive: true });
+  fs.mkdirSync(path.join(srcDir, 'tasks'), { recursive: true });
+
+  // Index File
+  if (isTS) {
+    fs.writeFileSync(path.join(srcDir, `index.${ext}`), tsTemplates.index);
+  } else if (isESM) {
+    fs.writeFileSync(path.join(srcDir, `index.${ext}`), esmTemplates.index);
+  } else {
+    fs.writeFileSync(path.join(srcDir, 'index.js'), cjsTemplates.index);
+  }
+
+  // Ping Command
+  if (isTS) {
+    fs.writeFileSync(path.join(srcDir, 'commands', 'ping.ts'), tsTemplates.ping);
+  } else if (isESM) {
+    fs.writeFileSync(path.join(srcDir, 'commands', 'ping.js'), esmTemplates.ping);
+  } else {
+    fs.writeFileSync(path.join(srcDir, 'commands', 'ping.js'), cjsTemplates.ping);
+  }
+
+  // Ready Event
+  if (isTS) {
+    fs.writeFileSync(path.join(srcDir, 'events', 'ready.ts'), tsTemplates.ready);
+  } else if (isESM) {
+    fs.writeFileSync(path.join(srcDir, 'events', 'ready.js'), esmTemplates.ready);
+  } else {
+    fs.writeFileSync(path.join(srcDir, 'events', 'ready.js'), cjsTemplates.ready);
+  }
+
+  // Healthcheck Task
+  if (isTS) {
+    fs.writeFileSync(path.join(srcDir, 'tasks', 'healthcheck.ts'), tsTemplates.healthcheck);
+  } else if (isESM) {
+    fs.writeFileSync(path.join(srcDir, 'tasks', 'healthcheck.js'), esmTemplates.healthcheck);
+  } else {
+    fs.writeFileSync(path.join(srcDir, 'tasks', 'healthcheck.js'), cjsTemplates.healthcheck);
+  }
+
+  console.log(pc.cyan(`\nInstalling dependencies with ${pm}...`));
+  try {
+    execSync(`${pm} install`, { cwd: targetPath, stdio: 'inherit' });
+  } catch (error) {
+    console.error(pc.red(`\nFailed to install dependencies. Please run '${pm} install' manually.`));
+  }
+
+  console.log(pc.green(pc.bold(`\nSuccess! Created ${projectName} at ${targetPath}`)));
+  console.log(`\nInside that directory, you can run several commands:`);
+  console.log(pc.cyan(`\n  ${pm} run dev`));
+  console.log(`    Starts the development server with hot-reloading.`);
+  if (isTS) {
+    console.log(pc.cyan(`\n  ${pm} run build`));
+    console.log(`    Compiles the TypeScript app into JavaScript.`);
+  }
+  console.log(pc.cyan(`\n  ${pm} start`));
+  console.log(`    Starts the production server.`);
+  console.log(`\nWe suggest that you begin by typing:\n`);
+  console.log(pc.cyan(`  cd ${projectName}`));
+  console.log(pc.cyan(`  ${pm} run dev\n`));
+}
+
+main().catch((err) => {
+  console.error(pc.red('An unexpected error occurred:'), err);
+  process.exit(1);
+});

package/src/client.ts

@@ -30,10 +30,7 @@ export class DJSNextClient<DB = any> extends Client {
   private _developers: string[];
   private _middleware?: (interaction: Interaction | Message, client: Client) => Promise<boolean> | boolean;
   private _prefixes: string[];
-  private _enableSlashCommands: boolean;
-  private _enableTextCommands: boolean;
-  private _enableMentionPrefix: boolean | string[];
-  private _enableNoPrefix: boolean | string[];
+  private _enableMentionPrefix: boolean;
 
   constructor(options: DJSNextClientOptions) {
     super(options);
@@ -52,13 +49,7 @@ export class DJSNextClient<DB = any> extends Client {
     
     const prefs = options.prefixes || [];
     this._prefixes = Array.isArray(prefs) ? prefs : [prefs];
-    this._prefixes = this._prefixes.filter(p => p !== ''); // Remove empty strings, handle explicitly via enableNoPrefix
-
-    this._enableSlashCommands = options.enableSlashCommands ?? true;
-    this._enableTextCommands = options.enableTextCommands ?? true;
     this._enableMentionPrefix = options.enableMentionPrefix ?? true;
-    this._enableNoPrefix = options.enableNoPrefix ?? false;
-    if (options.db) this.db = options.db as any;
 
     this.attachCoreListeners();
   }
@@ -78,8 +69,6 @@ export class DJSNextClient<DB = any> extends Client {
 
       // 2. Chat Input Commands Execution
       if (interaction.isChatInputCommand()) {
-        if (!this._enableSlashCommands) return;
-        
         let commandKey = interaction.commandName;
         const group = interaction.options.getSubcommandGroup(false);
         const sub = interaction.options.getSubcommand(false);
@@ -90,12 +79,56 @@ export class DJSNextClient<DB = any> extends Client {
         const command = this.commands.get(commandKey);
         if (!command || !command.execute) return;
 
-        if (!(await this.handlePreconditions(command, interaction, commandKey))) return;
+        // --- Permissions & Validation Checks ---
+        if (command.developerOnly && !this._developers.includes(interaction.user.id)) {
+          return interaction.reply({ content: 'Only developers can use this command.', ephemeral: true }) as never;
+        }
+
+        if (command.guildOnly && !interaction.inGuild()) {
+          return interaction.reply({ content: 'This command can only be used in a server.', ephemeral: true }) as never;
+        }
+
+        if (command.userPermissions && interaction.memberPermissions) {
+          const missing = interaction.memberPermissions.missing(command.userPermissions);
+          if (missing.length > 0) {
+            return interaction.reply({ content: `You are missing permissions: \`${missing.join(', ')}\``, ephemeral: true }) as never;
+          }
+        }
+
+        if (command.botPermissions && interaction.guild?.members.me?.permissions) {
+          const missing = interaction.guild.members.me.permissions.missing(command.botPermissions);
+          if (missing.length > 0) {
+            return interaction.reply({ content: `I am missing permissions to run this: \`${missing.join(', ')}\``, ephemeral: true }) as never;
+          }
+        }
+
+        // --- Built-in Cooldowns ---
+        if (command.cooldown) {
+          if (!this.cooldowns.has(commandKey)) this.cooldowns.set(commandKey, new Collection());
+          const now = Date.now();
+          const timestamps = this.cooldowns.get(commandKey)!;
+          const cooldownAmount = command.cooldown * 1000;
+
+          if (timestamps.has(interaction.user.id)) {
+            const expirationTime = timestamps.get(interaction.user.id)! + cooldownAmount;
+            if (now < expirationTime) {
+              return interaction.reply({ 
+                content: `Please wait, you are on a cooldown. You can use it again <t:${Math.round(expirationTime / 1000)}:R>.`, 
+                ephemeral: true 
+              }) as never;
+            }
+          }
+          timestamps.set(interaction.user.id, now);
+          setTimeout(() => timestamps.delete(interaction.user.id), cooldownAmount);
+        }
 
         try {
           await command.execute(interaction, this);
         } catch (error) {
-          await this.handleCommandError(error, commandKey, interaction);
+          console.error(`[djs-next] Error executing command: "${commandKey}"`, error);
+          const msg = { content: 'We ran into an internal error executing this command. The developers have been notified.', ephemeral: true };
+          if (interaction.replied || interaction.deferred) await interaction.followUp(msg).catch(()=>null);
+          else await interaction.reply(msg).catch(()=>null);
         }
       }
 
@@ -142,12 +175,13 @@ export class DJSNextClient<DB = any> extends Client {
           }
         }
         if (component) {
-          if (!(await this.handlePreconditions(component, interaction, interaction.customId))) return;
-
           try {
             await component.execute(interaction, this, params);
           } catch (error) {
-            await this.handleCommandError(error, interaction.customId, interaction);
+            console.error(`[djs-next] Error executing component: "${interaction.customId}"`, error);
+            const msg = { content: 'We ran into an internal error executing this component.', ephemeral: true };
+            if (interaction.replied || interaction.deferred) await interaction.followUp(msg).catch(()=>null);
+            else await interaction.reply(msg).catch(()=>null);
           }
         }
       }
@@ -155,7 +189,6 @@ export class DJSNextClient<DB = any> extends Client {
 
     this.on('messageCreate', async (message: Message) => {
       if (message.author.bot) return;
-      if (!this._enableTextCommands) return;
 
       // Global Middleware execution for Messages
       if (this._middleware) {
@@ -174,29 +207,26 @@ export class DJSNextClient<DB = any> extends Client {
 
       // 1. Check Mention Prefix
       const mentionRegex = new RegExp(`^<@!?${this.user?.id}>\\s*`);
-      const canUseMention = this._enableMentionPrefix === true || (Array.isArray(this._enableMentionPrefix) && this._enableMentionPrefix.includes(message.author.id));
-      
-      if (canUseMention && mentionRegex.test(content)) {
+      if (this._enableMentionPrefix && mentionRegex.test(content)) {
         matchedPrefix = content.match(mentionRegex)![0];
         isCommand = true;
       } else {
-        // 2. Check Standard Prefixes
+        // 2. Check Standard/No Prefixes
+        // Sort by length descending so longer prefixes match first
         const sortedPrefs = [...this._prefixes].sort((a, b) => b.length - a.length);
         
+        // If prefixes array is empty or contains an empty string, it means "no prefix" is supported!
+        if (sortedPrefs.includes('')) {
+          isCommand = true; 
+        }
+
         for (const p of sortedPrefs) {
-          if (content.startsWith(p)) {
+          if (p !== '' && content.startsWith(p)) {
             matchedPrefix = p;
             isCommand = true;
             break;
           }
         }
-
-        // 3. Check No Prefix
-        const canUseNoPrefix = this._enableNoPrefix === true || (Array.isArray(this._enableNoPrefix) && this._enableNoPrefix.includes(message.author.id));
-        if (!isCommand && canUseNoPrefix) {
-          isCommand = true;
-          matchedPrefix = '';
-        }
       }
 
       if (!isCommand) return;
@@ -214,13 +244,42 @@ export class DJSNextClient<DB = any> extends Client {
 
       if (!command || !command.executeText) return;
 
-      if (!(await this.handlePreconditions(command, message, commandName))) return;
+      // Validation Checks (Developers/GuildOnly)
+      if (command.developerOnly && !this._developers.includes(message.author.id)) return;
+      if (command.guildOnly && !message.guild) return;
+
+      if (command.userPermissions && message.member?.permissions) {
+        const missing = message.member.permissions.missing(command.userPermissions);
+        if (missing.length > 0) return;
+      }
+      if (command.botPermissions && message.guild?.members.me?.permissions) {
+        const missing = message.guild.members.me.permissions.missing(command.botPermissions);
+        if (missing.length > 0) return;
+      }
+
+      // Cooldowns
+      if (command.cooldown) {
+        if (!this.cooldowns.has(commandName)) this.cooldowns.set(commandName, new Collection());
+        const now = Date.now();
+        const timestamps = this.cooldowns.get(commandName)!;
+        const cooldownAmount = command.cooldown * 1000;
+
+        if (timestamps.has(message.author.id)) {
+          const expirationTime = timestamps.get(message.author.id)! + cooldownAmount;
+          if (now < expirationTime) {
+            return void await message.reply(`Please wait, you are on a cooldown. You can use it again <t:${Math.round(expirationTime / 1000)}:R>.`);
+          }
+        }
+        timestamps.set(message.author.id, now);
+        setTimeout(() => timestamps.delete(message.author.id), cooldownAmount);
+      }
 
       // Execute Text Command
       try {
         await command.executeText(message, args, this);
       } catch (error) {
-        await this.handleCommandError(error, commandName, message);
+        console.error(`[djs-next] Error executing text command: "${commandName}"`, error);
+        await message.reply('We ran into an internal error executing this command.').catch(() => null);
       }
     });
   }
@@ -230,17 +289,15 @@ export class DJSNextClient<DB = any> extends Client {
 
     this.config = await loadConfig();
 
-    // Fallback options to config, then to default 'src' folders
+    // Fallback options to config
     this._guildId = this._guildId || this.config.devGuildId;
-    
-    if (!this._commandsDir) this._commandsDir = path.resolve(process.cwd(), this.config.directories?.commands || 'src/commands');
-    if (!this._eventsDir) this._eventsDir = path.resolve(process.cwd(), this.config.directories?.events || 'src/events');
-    if (!this._componentsDir) this._componentsDir = path.resolve(process.cwd(), this.config.directories?.components || 'src/components');
-    if (!this._tasksDir) this._tasksDir = path.resolve(process.cwd(), this.config.directories?.tasks || 'src/tasks');
-    if (!this._localesDir) this._localesDir = path.resolve(process.cwd(), this.config.directories?.locales || 'src/locales');
+    if (!this._commandsDir && this.config.directories?.commands) this._commandsDir = path.resolve(process.cwd(), this.config.directories.commands);
+    if (!this._eventsDir && this.config.directories?.events) this._eventsDir = path.resolve(process.cwd(), this.config.directories.events);
+    if (!this._componentsDir && this.config.directories?.components) this._componentsDir = path.resolve(process.cwd(), this.config.directories.components);
+    if (!this._tasksDir && this.config.directories?.tasks) this._tasksDir = path.resolve(process.cwd(), this.config.directories.tasks);
+    if (!this._localesDir && this.config.directories?.locales) this._localesDir = path.resolve(process.cwd(), this.config.directories.locales);
 
-    // Only load if the directories actually exist
-    if (fs.existsSync(this._localesDir)) loadLocales(this._localesDir, this.config.defaultLocale);
+    if (this._localesDir) loadLocales(this._localesDir, this.config.defaultLocale);
 
     // Load middleware from root
     if (!this._middleware) {
@@ -263,18 +320,17 @@ export class DJSNextClient<DB = any> extends Client {
       }
     }
 
-    if (fs.existsSync(this._eventsDir)) await loadEvents(this, this._eventsDir);
-    if (fs.existsSync(this._componentsDir)) this.components = await loadComponents(this._componentsDir);
-    if (fs.existsSync(this._tasksDir)) await loadTasks(this, this._tasksDir);
+    if (this._eventsDir) await loadEvents(this, this._eventsDir);
+    if (this._componentsDir) this.components = await loadComponents(this._componentsDir);
+    if (this._tasksDir) await loadTasks(this, this._tasksDir);
 
-    await this.login(token);
-    console.log(`[djs-next] Bot is ready and logged in as ${this.user?.tag}!`);
-
-    // Load and deploy commands AFTER login so we can automatically use this.user.id
-    if (fs.existsSync(this._commandsDir)) {
-      this._clientId = this._clientId || this.user!.id;
+    if (this._commandsDir) {
+      if (!this._clientId) throw new Error("[djs-next] You must provide a clientId to deploy commands.");
       this.commands = await loadAndDeployCommands(this._commandsDir, token, this._clientId, this._guildId);
     }
+
+    await this.login(token);
+    console.log(`[djs-next] Bot is ready and logged in as ${this.user?.tag}!`);
   }
 
   public enableDevTools(prefix: 'dnxt' | 'nxt' = 'dnxt'): void {
@@ -326,167 +382,4 @@ export class DJSNextClient<DB = any> extends Client {
       console.warn(`[djs-next] chokidar not installed. HMR is disabled. Please run "npm install chokidar" to use this feature.`);
     }
   }
-
-  private async handleCommandError(error: any, commandKey: string, context: Interaction | Message) {
-    console.error(`[djs-next] Error executing command/component: "${commandKey}"`, error);
-    const djs = require('discord.js');
-    if (this.config.responses?.errorBoundary === null) {
-      // Developer explicitly opted out of error boundary user messages
-    } else {
-      try {
-        const errorContent = this.config.responses?.errorBoundary || `### ⚠️ Execution Error\n> The framework encountered a fatal error while executing \`${commandKey}\`.`;
-        const codeBlock = `\`\`\`js\n${String(error.stack || error.message).substring(0, 1500)}\n\`\`\``;
-
-        if ('commandName' in context || 'customId' in context) {
-          const container = new djs.ContainerBuilder()
-            .setAccentColor(0xED4245)
-            .addTextDisplayComponents(new djs.TextDisplayBuilder().setContent(errorContent))
-            .addSeparatorComponents(new djs.SeparatorBuilder())
-            .addTextDisplayComponents(new djs.TextDisplayBuilder().setContent(codeBlock));
-            
-          const payload = { components: [container], flags: 32768, ephemeral: true };
-          const i = context as Interaction;
-          if (i.isRepliable()) {
-            if (i.replied || i.deferred) await i.followUp(payload);
-            else await i.reply(payload);
-          }
-        } else {
-          const embed = new djs.EmbedBuilder()
-            .setColor(0xED4245)
-            .setDescription(`${errorContent}\n\n${codeBlock}`);
-            
-          const m = context as Message;
-          await m.reply({ embeds: [embed] });
-        }
-      } catch (e) {
-        // Fallback ignore if channel is dead
-      }
-    }
-
-    if (this.config.errorLogChannelId) {
-      try {
-        const channel = await this.channels.fetch(this.config.errorLogChannelId);
-        if (channel && channel.isTextBased()) {
-          const userId = 'user' in context ? context.user.id : context.author.id;
-          await (channel as any).send(`🚨 **Global Error Boundary Caught Exception**\n**Context:** \`${commandKey}\`\n**User:** <@${userId}>\n\`\`\`js\n${String(error.stack || error.message).substring(0, 1900)}\n\`\`\``);
-        }
-      } catch (e) {
-        console.error(`[djs-next] Failed to send error to log channel:`, e);
-      }
-    }
-  }
-
-  private async handlePreconditions(command: FileCommand | FileComponent, context: Interaction | Message, commandKey: string): Promise<boolean> {
-    const userId = 'user' in context ? context.user.id : context.author.id;
-    const isGuild = 'guild' in context && context.guild !== null;
-    const member = context.member as any;
-
-    const sendErr = async (msg: string | null) => {
-      if (msg === null) return;
-      if ('reply' in context && typeof context.reply === 'function') {
-        try {
-          if ('replied' in context && (context as any).isRepliable() && ((context as any).replied || (context as any).deferred)) {
-            await (context as any).followUp({ content: msg, ephemeral: true });
-          } else {
-            await (context as any).reply({ content: msg, ephemeral: true, allowedMentions: { repliedUser: false } });
-          }
-        } catch(e) {}
-      }
-    };
-
-    if ('developerOnly' in command && command.developerOnly && !this._developers.includes(userId)) {
-      await sendErr(this.config.responses?.developerOnly !== undefined ? this.config.responses.developerOnly : 'Only developers can use this command.');
-      return false;
-    }
-    if ('guildOnly' in command && command.guildOnly && !isGuild) {
-      await sendErr(this.config.responses?.guildOnly !== undefined ? this.config.responses.guildOnly : 'This command can only be used in a server.');
-      return false;
-    }
-    if ('userPermissions' in command && command.userPermissions && member?.permissions) {
-      const missing = member.permissions.missing(command.userPermissions);
-      if (missing.length > 0) {
-        await sendErr(this.config.responses?.missingPerms !== undefined ? (this.config.responses.missingPerms === null ? null : this.config.responses.missingPerms.replace('{perms}', missing.join(', '))) : `You are missing permissions: \`${missing.join(', ')}\``);
-        return false;
-      }
-    }
-    if ('botPermissions' in command && command.botPermissions && context.guild?.members.me?.permissions) {
-      const missing = context.guild.members.me.permissions.missing(command.botPermissions);
-      if (missing.length > 0) {
-        await sendErr(this.config.responses?.missingPerms !== undefined ? (this.config.responses.missingPerms === null ? null : this.config.responses.missingPerms.replace('{perms}', missing.join(', '))) : `I am missing permissions to run this: \`${missing.join(', ')}\``);
-        return false;
-      }
-    }
-
-    let totalCooldown = 'cooldown' in command && command.cooldown ? command.cooldown * 1000 : 0;
-
-    if (command.preconditions) {
-      for (const pre of command.preconditions) {
-        const parts = pre.split(':');
-        const type = parts[0].toLowerCase();
-        const val = parts.slice(1).join(':');
-
-        if (type === 'owneronly' || type === 'developeronly') {
-          if (!this._developers.includes(userId)) {
-            await sendErr(this.config.responses?.developerOnly !== undefined ? this.config.responses.developerOnly : 'Only developers can use this command.');
-            return false;
-          }
-        } else if (type === 'guildonly') {
-          if (!isGuild) {
-            await sendErr(this.config.responses?.guildOnly !== undefined ? this.config.responses.guildOnly : 'This command can only be used in a server.');
-            return false;
-          }
-        } else if (type === 'requireperms') {
-          const perms = val.split(',').map(p => p.trim());
-          if (member?.permissions) {
-            const missing = member.permissions.missing(perms);
-            if (missing.length > 0) {
-              await sendErr(this.config.responses?.missingPerms !== undefined ? (this.config.responses.missingPerms === null ? null : this.config.responses.missingPerms.replace('{perms}', missing.join(', '))) : `You are missing permissions: \`${missing.join(', ')}\``);
-              return false;
-            }
-          }
-        } else if (type === 'cooldown') {
-          const match = val.match(/(\d+)(s|m|h)/);
-          if (match) {
-            let amount = parseInt(match[1]) * 1000;
-            if (match[2] === 'm') amount *= 60;
-            if (match[2] === 'h') amount *= 3600;
-            totalCooldown = Math.max(totalCooldown, amount);
-          }
-        }
-      }
-    }
-
-    if (totalCooldown > 0) {
-      const now = Date.now();
-      
-      if (this.config.cooldownAdapter) {
-        const lastUsed = await this.config.cooldownAdapter.get(commandKey, userId);
-        if (lastUsed) {
-          const expirationTime = lastUsed + totalCooldown;
-          if (now < expirationTime) {
-            const timeStr = `<t:${Math.round(expirationTime / 1000)}:R>`;
-            await sendErr(this.config.responses?.cooldown !== undefined ? (this.config.responses.cooldown === null ? null : this.config.responses.cooldown.replace('{time}', timeStr)) : `Please wait, you are on a cooldown. You can use it again ${timeStr}.`);
-            return false;
-          }
-        }
-        await this.config.cooldownAdapter.set(commandKey, userId, now);
-      } else {
-        if (!this.cooldowns.has(commandKey)) this.cooldowns.set(commandKey, new Collection());
-        const timestamps = this.cooldowns.get(commandKey)!;
-
-        if (timestamps.has(userId)) {
-          const expirationTime = timestamps.get(userId)! + totalCooldown;
-          if (now < expirationTime) {
-            const timeStr = `<t:${Math.round(expirationTime / 1000)}:R>`;
-            await sendErr(this.config.responses?.cooldown !== undefined ? (this.config.responses.cooldown === null ? null : this.config.responses.cooldown.replace('{time}', timeStr)) : `Please wait, you are on a cooldown. You can use it again ${timeStr}.`);
-            return false;
-          }
-        }
-        timestamps.set(userId, now);
-        setTimeout(() => timestamps.delete(userId), totalCooldown);
-      }
-    }
-
-    return true;
-  }
 }

package/src/index.ts

@@ -1,10 +1,7 @@
-import 'dotenv/config';
 export * from './client.js';
-export { DJSNextClientOptions, FileCommand, FileComponent, FileTask, Event as DJSNextEvent, DJSNextConfig, CooldownAdapter } from './types.js';
+export { DJSNextClientOptions, FileCommand, FileComponent, FileTask, Event as DJSNextEvent, DJSNextConfig } from './types.js';
 export * from './utils/paginate.js';
-export * from './utils/prompts.js';
 export * from './utils/configLoader.js';
 export * from './utils/i18n.js';
-export * from './utils/PaginationBuilder.js';
 // Re-export everything from discord.js so users don't need to install it explicitly
 export * from 'discord.js';