chrxmaticc-framework 1.0.3 → 1.1.1

package/index.js

@@ -1,13 +1,13 @@
 /**
- * src/index.js
- * Main entry point — exports everything the user needs.
+ * index.js
+ * Main entry point — exports everything.
  */
 
-const { ChrxClient } = require("./core/Client");
-const Database = require("./core/Database");
-const XPSystem = require("./core/XPSystem");
-const AIWrapper = require("./core/AIWrapper");
-const MusicManager = require("./core/MusicManager");
+const { ChrxClient } = require("./Client");
+const Database = require("./Database");
+const XPSystem = require("./XPSystem");
+const AIWrapper = require("./AIWrapper");
+const MusicManager = require("./MusicManager");
 const {
   parseTime,
   formatTime,
@@ -17,7 +17,18 @@ const {
   applyStartMarker,
   startEndMarkerWatcher,
   stopEndMarkerWatcher,
-} = require("./core/songMarkers");
+} = require("./songMarkers");
+
+// ── Plugins ───────────────────────────────────────────────────────────────
+const Economy = require("./plugins/Economy");
+const Moderation = require("./plugins/Moderation");
+const Giveaways = require("./plugins/Giveaways");
+const Tickets = require("./plugins/Tickets");
+const Welcome = require("./plugins/Welcome");
+const Polls = require("./plugins/Polls");
+const Reminders = require("./plugins/Reminders");
+const Starboard = require("./plugins/Starboard");
+const AutoMod = require("./plugins/AutoMod");
 
 module.exports = {
   // Core
@@ -29,7 +40,7 @@ module.exports = {
   AIWrapper,
   MusicManager,
 
-  // Song marker utilities (for advanced users)
+  // Song marker utilities
   parseTime,
   formatTime,
   setMarker,
@@ -38,4 +49,15 @@ module.exports = {
   applyStartMarker,
   startEndMarkerWatcher,
   stopEndMarkerWatcher,
-};
+
+  // Plugins
+  Economy,
+  Moderation,
+  Giveaways,
+  Tickets,
+  Welcome,
+  Polls,
+  Reminders,
+  Starboard,
+  AutoMod,
+};

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "chrxmaticc-framework",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "description": "A batteries-included Discord bot framework with music, AI, XP and database support.",
   "main": "index.js",
   "files": [
-    "index.js",
-    "*.js",
-    "core/**/*"
+  "index.js",
+  "*.js",
+  "core/**/*",
+  "plugins/**/*" 
+  
   ],
   "keywords": [
     "discord",

package/plugins/autoMod.js

@@ -0,0 +1,144 @@
+/**
+ * plugins/AutoMod.js
+ * AutoMod — bad word filter, link blocker, caps spam detection.
+ */
+
+const { EmbedBuilder } = require("discord.js");
+
+class AutoMod {
+  constructor(client) {
+    this.client = client;
+    this.configs = new Map(); // guildId -> config
+    this.logChannels = new Map(); // guildId -> channelId
+    this._registerEvents();
+  }
+
+  /**
+   * Configure AutoMod for a guild.
+   * @param {string} guildId
+   * @param {object} options
+   * @param {string[]} [options.bannedWords]     Words to filter
+   * @param {boolean}  [options.blockLinks]      Block all links
+   * @param {string[]} [options.allowedDomains]  Domains to allow if blockLinks is true
+   * @param {number}   [options.capsThreshold]   % caps before flagging (0-100, default 70)
+   * @param {number}   [options.capsMinLength]   Min message length to check caps (default 10)
+   * @param {string}   [options.logChannelId]    Channel to log violations
+   */
+  setup(guildId, options) {
+    this.configs.set(guildId, {
+      bannedWords: [],
+      blockLinks: false,
+      allowedDomains: [],
+      capsThreshold: 70,
+      capsMinLength: 10,
+      ...options,
+    });
+    if (options.logChannelId) this.logChannels.set(guildId, options.logChannelId);
+  }
+
+  async _log(guildId, embed) {
+    const channelId = this.logChannels.get(guildId);
+    if (!channelId) return;
+    const channel = this.client.channels.cache.get(channelId);
+    if (channel) channel.send({ embeds: [embed] }).catch(() => {});
+  }
+
+  _registerEvents() {
+    this.client.on("messageCreate", async (message) => {
+      if (message.author.bot || !message.guild) return;
+
+      const cfg = this.configs.get(message.guild.id);
+      if (!cfg) return;
+
+      const content = message.content;
+
+      // ── Bad word filter ─────────────────────────────────────────────────
+      if (cfg.bannedWords.length > 0) {
+        const lower = content.toLowerCase();
+        const found = cfg.bannedWords.find((w) => lower.includes(w.toLowerCase()));
+        if (found) {
+          await message.delete().catch(() => {});
+          const warning = await message.channel.send(
+            `🚫 ${message.author}, that word is not allowed here.`
+          ).catch(() => {});
+          if (warning) setTimeout(() => warning.delete().catch(() => {}), 4000);
+
+          await this._log(message.guild.id, new EmbedBuilder()
+            .setColor("#ED4245")
+            .setTitle("🤖 AutoMod — Bad Word")
+            .addFields(
+              { name: "User", value: `${message.author} (${message.author.id})` },
+              { name: "Word matched", value: `\`${found}\`` }
+            )
+            .setTimestamp()
+          );
+          return;
+        }
+      }
+
+      // ── Link blocker ────────────────────────────────────────────────────
+      if (cfg.blockLinks) {
+        const urlRegex = /(https?:\/\/[^\s]+)/gi;
+        const links = content.match(urlRegex);
+        if (links) {
+          const blocked = links.filter((link) => {
+            try {
+              const host = new URL(link).hostname;
+              return !cfg.allowedDomains.some((d) => host.endsWith(d));
+            } catch {
+              return true;
+            }
+          });
+
+          if (blocked.length > 0) {
+            await message.delete().catch(() => {});
+            const warning = await message.channel.send(
+              `🔗 ${message.author}, links are not allowed here.`
+            ).catch(() => {});
+            if (warning) setTimeout(() => warning.delete().catch(() => {}), 4000);
+
+            await this._log(message.guild.id, new EmbedBuilder()
+              .setColor("#ED4245")
+              .setTitle("🤖 AutoMod — Link Blocked")
+              .addFields(
+                { name: "User", value: `${message.author} (${message.author.id})` },
+                { name: "Link", value: blocked[0].slice(0, 100) }
+              )
+              .setTimestamp()
+            );
+            return;
+          }
+        }
+      }
+
+      // ── Caps filter ─────────────────────────────────────────────────────
+      if (content.length >= cfg.capsMinLength) {
+        const letters = content.replace(/[^a-zA-Z]/g, "");
+        if (letters.length > 0) {
+          const capsCount = (letters.match(/[A-Z]/g) || []).length;
+          const capsPct = (capsCount / letters.length) * 100;
+
+          if (capsPct >= cfg.capsThreshold) {
+            await message.delete().catch(() => {});
+            const warning = await message.channel.send(
+              `🔠 ${message.author}, please don't use excessive caps.`
+            ).catch(() => {});
+            if (warning) setTimeout(() => warning.delete().catch(() => {}), 4000);
+
+            await this._log(message.guild.id, new EmbedBuilder()
+              .setColor("#FEE75C")
+              .setTitle("🤖 AutoMod — Caps Spam")
+              .addFields(
+                { name: "User", value: `${message.author} (${message.author.id})` },
+                { name: "Caps %", value: `${Math.round(capsPct)}%` }
+              )
+              .setTimestamp()
+            );
+          }
+        }
+      }
+    });
+  }
+}
+
+module.exports = AutoMod;

package/plugins/economy.js

@@ -0,0 +1,181 @@
+/**
+ * plugins/Economy.js
+ * Economy plugin — coins, daily, work, rob, balance, shop.
+ * Requires Database module to be enabled.
+ */
+
+class Economy {
+  constructor(client) {
+    this.client = client;
+    this.cooldowns = new Map();
+  }
+
+  // ── Internal DB helpers ───────────────────────────────────────────────
+
+  async _ensure(userId, guildId) {
+    await this.client.db.query(`
+      INSERT INTO chrx_economy (user_id, guild_id, balance, bank)
+      VALUES ($1, $2, 0, 0)
+      ON CONFLICT DO NOTHING
+    `, [BigInt(userId), BigInt(guildId)]);
+  }
+
+  async _get(userId, guildId) {
+    await this._ensure(userId, guildId);
+    const res = await this.client.db.query(
+      `SELECT balance, bank FROM chrx_economy WHERE user_id = $1 AND guild_id = $2`,
+      [BigInt(userId), BigInt(guildId)]
+    );
+    return res.rows[0];
+  }
+
+  // ── Cooldown helper ───────────────────────────────────────────────────
+
+  _checkCooldown(key, ms) {
+    const now = Date.now();
+    if (this.cooldowns.has(key)) {
+      const remaining = ms - (now - this.cooldowns.get(key));
+      if (remaining > 0) return remaining;
+    }
+    this.cooldowns.set(key, now);
+    return 0;
+  }
+
+  // ── Public API ────────────────────────────────────────────────────────
+
+  /**
+   * Get a user's balance.
+   */
+  async getBalance(userId, guildId) {
+    return this._get(userId, guildId);
+  }
+
+  /**
+   * Add coins to a user's wallet.
+   */
+  async addCoins(userId, guildId, amount) {
+    await this._ensure(userId, guildId);
+    await this.client.db.query(
+      `UPDATE chrx_economy SET balance = balance + $1 WHERE user_id = $2 AND guild_id = $3`,
+      [amount, BigInt(userId), BigInt(guildId)]
+    );
+  }
+
+  /**
+   * Remove coins from a user's wallet.
+   */
+  async removeCoins(userId, guildId, amount) {
+    await this._ensure(userId, guildId);
+    await this.client.db.query(
+      `UPDATE chrx_economy SET balance = GREATEST(balance - $1, 0) WHERE user_id = $2 AND guild_id = $3`,
+      [amount, BigInt(userId), BigInt(guildId)]
+    );
+  }
+
+  /**
+   * Daily reward — 24h cooldown.
+   * @returns {{ amount: number, cooldown: number }} cooldown in ms if on cooldown
+   */
+  async daily(userId, guildId) {
+    const key = `daily-${userId}-${guildId}`;
+    const remaining = this._checkCooldown(key, 86400000);
+    if (remaining > 0) return { amount: 0, cooldown: remaining };
+
+    const amount = Math.floor(Math.random() * 200) + 100; // 100-300 coins
+    await this.addCoins(userId, guildId, amount);
+    return { amount, cooldown: 0 };
+  }
+
+  /**
+   * Work command — 1h cooldown.
+   */
+  async work(userId, guildId) {
+    const key = `work-${userId}-${guildId}`;
+    const remaining = this._checkCooldown(key, 3600000);
+    if (remaining > 0) return { amount: 0, cooldown: remaining };
+
+    const amount = Math.floor(Math.random() * 50) + 20; // 20-70 coins
+    await this.addCoins(userId, guildId, amount);
+    return { amount, cooldown: 0 };
+  }
+
+  /**
+   * Rob a user — 30% success rate, 1h cooldown.
+   */
+  async rob(robberId, targetId, guildId) {
+    const key = `rob-${robberId}-${guildId}`;
+    const remaining = this._checkCooldown(key, 3600000);
+    if (remaining > 0) return { success: false, cooldown: remaining };
+
+    const target = await this._get(targetId, guildId);
+    if (target.balance < 50) return { success: false, broke: true };
+
+    const success = Math.random() < 0.3;
+    if (success) {
+      const stolen = Math.floor(target.balance * 0.25);
+      await this.removeCoins(targetId, guildId, stolen);
+      await this.addCoins(robberId, guildId, stolen);
+      return { success: true, amount: stolen, cooldown: 0 };
+    }
+
+    const fine = Math.floor(Math.random() * 100) + 50;
+    await this.removeCoins(robberId, guildId, fine);
+    return { success: false, fine, cooldown: 0 };
+  }
+
+  /**
+   * Deposit coins into bank.
+   */
+  async deposit(userId, guildId, amount) {
+    const data = await this._get(userId, guildId);
+    const depositAmount = amount === "all" ? data.balance : Math.min(amount, data.balance);
+    await this.client.db.query(
+      `UPDATE chrx_economy SET balance = balance - $1, bank = bank + $1 WHERE user_id = $2 AND guild_id = $3`,
+      [depositAmount, BigInt(userId), BigInt(guildId)]
+    );
+    return depositAmount;
+  }
+
+  /**
+   * Withdraw coins from bank.
+   */
+  async withdraw(userId, guildId, amount) {
+    const data = await this._get(userId, guildId);
+    const withdrawAmount = amount === "all" ? data.bank : Math.min(amount, data.bank);
+    await this.client.db.query(
+      `UPDATE chrx_economy SET bank = bank - $1, balance = balance + $1 WHERE user_id = $2 AND guild_id = $3`,
+      [withdrawAmount, BigInt(userId), BigInt(guildId)]
+    );
+    return withdrawAmount;
+  }
+
+  /**
+   * Leaderboard — top 10 richest users in a guild.
+   */
+  async leaderboard(guildId) {
+    const res = await this.client.db.query(
+      `SELECT user_id, balance + bank AS total FROM chrx_economy WHERE guild_id = $1 ORDER BY total DESC LIMIT 10`,
+      [BigInt(guildId)]
+    );
+    return res.rows;
+  }
+
+  /**
+   * Create the economy table if it doesn't exist.
+   * Called automatically by ChrxClient on ready.
+   */
+  async initTable() {
+    await this.client.db.query(`
+      CREATE TABLE IF NOT EXISTS chrx_economy (
+        user_id BIGINT NOT NULL,
+        guild_id BIGINT NOT NULL,
+        balance BIGINT DEFAULT 0,
+        bank BIGINT DEFAULT 0,
+        PRIMARY KEY (user_id, guild_id)
+      )
+    `);
+    console.log("[Economy] Table ready.");
+  }
+}
+
+module.exports = Economy;

package/plugins/giveaway.js

@@ -0,0 +1,108 @@
+/**
+ * plugins/Giveaways.js
+ * Giveaway plugin — timed giveaways, reaction entry, winner picking.
+ */
+
+const { EmbedBuilder } = require("discord.js");
+
+class Giveaways {
+  constructor(client) {
+    this.client = client;
+    this.active = new Map(); // messageId -> giveaway data
+  }
+
+  /**
+   * Start a giveaway.
+   * @param {object} options
+   * @param {string} options.channelId
+   * @param {string} options.guildId
+   * @param {number} options.durationMs
+   * @param {string} options.prize
+   * @param {number} [options.winners=1]
+   * @param {string} options.hostedBy  User ID
+   */
+  async start({ channelId, guildId, durationMs, prize, winners = 1, hostedBy }) {
+    const channel = this.client.channels.cache.get(channelId);
+    if (!channel) throw new Error("[Giveaways] Channel not found.");
+
+    const endsAt = new Date(Date.now() + durationMs);
+
+    const msg = await channel.send({
+      embeds: [
+        new EmbedBuilder()
+          .setColor("#5865F2")
+          .setTitle("🎉 Giveaway!")
+          .setDescription(`**Prize:** ${prize}\n\nReact with 🎉 to enter!\n\n**Ends:** <t:${Math.floor(endsAt.getTime() / 1000)}:R>\n**Winners:** ${winners}\n**Hosted by:** <@${hostedBy}>`)
+          .setTimestamp(endsAt),
+      ],
+    });
+
+    await msg.react("🎉");
+
+    const data = { channelId, guildId, prize, winners, hostedBy, endsAt, messageId: msg.id };
+    this.active.set(msg.id, data);
+
+    setTimeout(() => this._end(msg.id), durationMs);
+
+    return msg;
+  }
+
+  async _end(messageId) {
+    const data = this.active.get(messageId);
+    if (!data) return;
+
+    this.active.delete(messageId);
+    const channel = this.client.channels.cache.get(data.channelId);
+    if (!channel) return;
+
+    const msg = await channel.messages.fetch(messageId).catch(() => null);
+    if (!msg) return;
+
+    const reaction = msg.reactions.cache.get("🎉");
+    if (!reaction) return;
+
+    const users = await reaction.users.fetch();
+    const eligible = users.filter((u) => !u.bot);
+
+    if (eligible.size === 0) {
+      return channel.send("🎉 Giveaway ended — no valid entries.");
+    }
+
+    const shuffled = eligible.random(Math.min(data.winners, eligible.size));
+    const winnerMentions = (Array.isArray(shuffled) ? shuffled : [shuffled]).map((u) => `<@${u.id}>`).join(", ");
+
+    await msg.edit({
+      embeds: [
+        new EmbedBuilder()
+          .setColor("#57F287")
+          .setTitle("🎉 Giveaway Ended!")
+          .setDescription(`**Prize:** ${data.prize}\n**Winners:** ${winnerMentions}\n**Hosted by:** <@${data.hostedBy}>`)
+          .setTimestamp(),
+      ],
+    });
+
+    channel.send(`🎉 Congratulations ${winnerMentions}! You won **${data.prize}**!`);
+  }
+
+  /**
+   * Reroll winners for an ended giveaway.
+   */
+  async reroll(messageId, channelId, count = 1) {
+    const channel = this.client.channels.cache.get(channelId);
+    if (!channel) return;
+    const msg = await channel.messages.fetch(messageId).catch(() => null);
+    if (!msg) return;
+
+    const reaction = msg.reactions.cache.get("🎉");
+    if (!reaction) return;
+
+    const users = await reaction.users.fetch();
+    const eligible = users.filter((u) => !u.bot);
+    const winners = eligible.random(Math.min(count, eligible.size));
+    const mentions = (Array.isArray(winners) ? winners : [winners]).map((u) => `<@${u.id}>`).join(", ");
+
+    channel.send(`🎉 New winner(s): ${mentions}!`);
+  }
+}
+
+module.exports = Giveaways;

package/plugins/moderation.js

@@ -0,0 +1,208 @@
+/**
+ * plugins/Moderation.js
+ * Moderation plugin — warn, ban, kick, timeout, mod logs, anti-spam.
+ */
+
+class Moderation {
+  constructor(client) {
+    this.client = client;
+    this.spamTracker = new Map(); // userId -> { count, timer }
+    this.logChannels = new Map(); // guildId -> channelId
+  }
+
+  // ── Config ────────────────────────────────────────────────────────────
+
+  /**
+   * Set the mod log channel for a guild.
+   */
+  setLogChannel(guildId, channelId) {
+    this.logChannels.set(guildId, channelId);
+  }
+
+  // ── Logging ───────────────────────────────────────────────────────────
+
+  async _log(guild, embed) {
+    const channelId = this.logChannels.get(guild.id);
+    if (!channelId) return;
+    const channel = guild.channels.cache.get(channelId);
+    if (channel) channel.send({ embeds: [embed] }).catch(() => {});
+  }
+
+  // ── Actions ───────────────────────────────────────────────────────────
+
+  /**
+   * Warn a user. Stored in Postgres if database is enabled.
+   */
+  async warn(guild, target, moderator, reason = "No reason provided") {
+    if (this.client.db) {
+      await this.client.db.query(`
+        INSERT INTO chrx_warnings (user_id, guild_id, moderator_id, reason)
+        VALUES ($1, $2, $3, $4)
+      `, [BigInt(target.id), BigInt(guild.id), BigInt(moderator.id), reason]);
+    }
+
+    const { EmbedBuilder } = require("discord.js");
+    await this._log(guild, new EmbedBuilder()
+      .setColor("#FEE75C")
+      .setTitle("⚠️ Warning Issued")
+      .addFields(
+        { name: "User", value: `${target} (${target.id})`, inline: true },
+        { name: "Moderator", value: `${moderator}`, inline: true },
+        { name: "Reason", value: reason }
+      )
+      .setTimestamp()
+    );
+
+    return true;
+  }
+
+  /**
+   * Get all warnings for a user in a guild.
+   */
+  async getWarnings(userId, guildId) {
+    if (!this.client.db) return [];
+    const res = await this.client.db.query(
+      `SELECT * FROM chrx_warnings WHERE user_id = $1 AND guild_id = $2 ORDER BY created_at DESC`,
+      [BigInt(userId), BigInt(guildId)]
+    );
+    return res.rows;
+  }
+
+  /**
+   * Clear warnings for a user.
+   */
+  async clearWarnings(userId, guildId) {
+    if (!this.client.db) return;
+    await this.client.db.query(
+      `DELETE FROM chrx_warnings WHERE user_id = $1 AND guild_id = $2`,
+      [BigInt(userId), BigInt(guildId)]
+    );
+  }
+
+  /**
+   * Ban a user.
+   */
+  async ban(guild, target, moderator, reason = "No reason provided", deleteMessageDays = 0) {
+    await guild.members.ban(target, { reason, deleteMessageSeconds: deleteMessageDays * 86400 });
+
+    const { EmbedBuilder } = require("discord.js");
+    await this._log(guild, new EmbedBuilder()
+      .setColor("#ED4245")
+      .setTitle("🔨 User Banned")
+      .addFields(
+        { name: "User", value: `${target} (${target.id})`, inline: true },
+        { name: "Moderator", value: `${moderator}`, inline: true },
+        { name: "Reason", value: reason }
+      )
+      .setTimestamp()
+    );
+  }
+
+  /**
+   * Kick a user.
+   */
+  async kick(guild, target, moderator, reason = "No reason provided") {
+    const member = guild.members.cache.get(target.id);
+    if (member) await member.kick(reason);
+
+    const { EmbedBuilder } = require("discord.js");
+    await this._log(guild, new EmbedBuilder()
+      .setColor("#ED4245")
+      .setTitle("👢 User Kicked")
+      .addFields(
+        { name: "User", value: `${target} (${target.id})`, inline: true },
+        { name: "Moderator", value: `${moderator}`, inline: true },
+        { name: "Reason", value: reason }
+      )
+      .setTimestamp()
+    );
+  }
+
+  /**
+   * Timeout a user.
+   * @param {number} durationMs  Timeout duration in milliseconds
+   */
+  async timeout(guild, target, moderator, durationMs, reason = "No reason provided") {
+    const member = guild.members.cache.get(target.id);
+    if (member) await member.timeout(durationMs, reason);
+
+    const { EmbedBuilder } = require("discord.js");
+    await this._log(guild, new EmbedBuilder()
+      .setColor("#FEE75C")
+      .setTitle("🔇 User Timed Out")
+      .addFields(
+        { name: "User", value: `${target} (${target.id})`, inline: true },
+        { name: "Moderator", value: `${moderator}`, inline: true },
+        { name: "Duration", value: `${Math.floor(durationMs / 60000)} minutes`, inline: true },
+        { name: "Reason", value: reason }
+      )
+      .setTimestamp()
+    );
+  }
+
+  // ── Anti-spam ─────────────────────────────────────────────────────────
+
+  /**
+   * Enable anti-spam. Auto-times out users who send 5+ messages in 3 seconds.
+   * @param {number} [threshold=5]    Messages before action
+   * @param {number} [windowMs=3000]  Time window in ms
+   * @param {number} [timeoutMs=30000] Timeout duration in ms
+   */
+  enableAntiSpam(threshold = 5, windowMs = 3000, timeoutMs = 30000) {
+    this.client.on("messageCreate", async (message) => {
+      if (message.author.bot || !message.guild) return;
+
+      const key = `${message.author.id}-${message.guild.id}`;
+      const now = Date.now();
+      const tracker = this.spamTracker.get(key) || { count: 0, start: now };
+
+      if (now - tracker.start > windowMs) {
+        this.spamTracker.set(key, { count: 1, start: now });
+        return;
+      }
+
+      tracker.count++;
+      this.spamTracker.set(key, tracker);
+
+      if (tracker.count >= threshold) {
+        this.spamTracker.delete(key);
+        const member = message.guild.members.cache.get(message.author.id);
+        if (!member) return;
+
+        await member.timeout(timeoutMs, "Auto-mod: Spam detected").catch(() => {});
+        message.channel.send(`🔇 ${message.author} was timed out for spamming.`).catch(() => {});
+
+        const { EmbedBuilder } = require("discord.js");
+        await this._log(message.guild, new EmbedBuilder()
+          .setColor("#ED4245")
+          .setTitle("🤖 Auto-Mod: Spam")
+          .addFields(
+            { name: "User", value: `${message.author} (${message.author.id})` },
+            { name: "Action", value: `Timed out for ${timeoutMs / 1000}s` }
+          )
+          .setTimestamp()
+        );
+      }
+    });
+  }
+
+  /**
+   * Create required tables. Called automatically on ready if db is enabled.
+   */
+  async initTable() {
+    if (!this.client.db) return;
+    await this.client.db.query(`
+      CREATE TABLE IF NOT EXISTS chrx_warnings (
+        id SERIAL PRIMARY KEY,
+        user_id BIGINT NOT NULL,
+        guild_id BIGINT NOT NULL,
+        moderator_id BIGINT NOT NULL,
+        reason TEXT,
+        created_at TIMESTAMP DEFAULT NOW()
+      )
+    `);
+    console.log("[Moderation] Table ready.");
+  }
+}
+
+module.exports = Moderation;

package/plugins/polls.js

@@ -0,0 +1,104 @@
+/**
+ * plugins/Polls.js
+ * Timed polls with reaction voting and result embeds.
+ */
+
+const { EmbedBuilder } = require("discord.js");
+
+const EMOJI_MAP = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣", "6️⃣", "7️⃣", "8️⃣", "9️⃣", "🔟"];
+
+class Polls {
+  constructor(client) {
+    this.client = client;
+    this.active = new Map(); // messageId -> poll data
+  }
+
+  /**
+   * Create a poll.
+   * @param {object} options
+   * @param {string} options.channelId
+   * @param {string} options.question
+   * @param {string[]} options.choices       2-10 choices
+   * @param {number} [options.durationMs]    0 = no end time
+   */
+  async create({ channelId, question, choices, durationMs = 0 }) {
+    if (choices.length < 2 || choices.length > 10) {
+      throw new Error("[Polls] Must have between 2 and 10 choices.");
+    }
+
+    const channel = this.client.channels.cache.get(channelId);
+    if (!channel) throw new Error("[Polls] Channel not found.");
+
+    const desc = choices.map((c, i) => `${EMOJI_MAP[i]} ${c}`).join("\n");
+    const endsText = durationMs > 0 ? `\n\n⏱ Ends: <t:${Math.floor((Date.now() + durationMs) / 1000)}:R>` : "";
+
+    const msg = await channel.send({
+      embeds: [
+        new EmbedBuilder()
+          .setColor("#5865F2")
+          .setTitle(`📊 ${question}`)
+          .setDescription(desc + endsText)
+          .setTimestamp(),
+      ],
+    });
+
+    for (let i = 0; i < choices.length; i++) {
+      await msg.react(EMOJI_MAP[i]);
+    }
+
+    const data = { question, choices, channelId, messageId: msg.id };
+    this.active.set(msg.id, data);
+
+    if (durationMs > 0) {
+      setTimeout(() => this._end(msg.id), durationMs);
+    }
+
+    return msg;
+  }
+
+  async _end(messageId) {
+    const data = this.active.get(messageId);
+    if (!data) return;
+    this.active.delete(messageId);
+
+    const channel = this.client.channels.cache.get(data.channelId);
+    if (!channel) return;
+
+    const msg = await channel.messages.fetch(messageId).catch(() => null);
+    if (!msg) return;
+
+    const results = data.choices.map((choice, i) => {
+      const reaction = msg.reactions.cache.get(EMOJI_MAP[i]);
+      const count = (reaction?.count ?? 1) - 1; // subtract bot's own reaction
+      return { choice, count };
+    });
+
+    const total = results.reduce((sum, r) => sum + r.count, 0);
+    const winner = results.reduce((a, b) => (a.count > b.count ? a : b));
+
+    const desc = results.map((r, i) => {
+      const pct = total > 0 ? Math.round((r.count / total) * 100) : 0;
+      const bar = "█".repeat(Math.floor(pct / 10)) + "░".repeat(10 - Math.floor(pct / 10));
+      return `${EMOJI_MAP[i]} **${r.choice}**\n${bar} ${pct}% (${r.count} votes)`;
+    }).join("\n\n");
+
+    await msg.edit({
+      embeds: [
+        new EmbedBuilder()
+          .setColor("#57F287")
+          .setTitle(`📊 Poll Ended — ${data.question}`)
+          .setDescription(desc + `\n\n🏆 **Winner: ${winner.choice}**`)
+          .setTimestamp(),
+      ],
+    });
+  }
+
+  /**
+   * Manually end a poll by message ID.
+   */
+  async end(messageId) {
+    await this._end(messageId);
+  }
+}
+
+module.exports = Polls;

package/plugins/reminder.js

@@ -0,0 +1,91 @@
+/**
+ * plugins/Reminders.js
+ * DM reminders — persistent via Postgres if database is enabled.
+ */
+
+class Reminders {
+  constructor(client) {
+    this.client = client;
+    this.pending = new Map(); // reminderId -> timeout
+  }
+
+  /**
+   * Set a reminder for a user.
+   * @param {string} userId
+   * @param {string} channelId  Channel to ping them in
+   * @param {string} reminder   Reminder text
+   * @param {number} durationMs When to remind them
+   */
+  async set(userId, channelId, reminder, durationMs) {
+    let dbId = null;
+
+    if (this.client.db) {
+      const res = await this.client.db.query(`
+        INSERT INTO chrx_reminders (user_id, channel_id, reminder, remind_at)
+        VALUES ($1, $2, $3, $4)
+        RETURNING id
+      `, [BigInt(userId), BigInt(channelId), reminder, new Date(Date.now() + durationMs)]);
+      dbId = res.rows[0].id;
+    }
+
+    const timeout = setTimeout(async () => {
+      const channel = this.client.channels.cache.get(channelId);
+      if (channel) {
+        channel.send(`⏰ <@${userId}> — Reminder: **${reminder}**`).catch(() => {});
+      }
+      if (dbId && this.client.db) {
+        await this.client.db.query(`DELETE FROM chrx_reminders WHERE id = $1`, [dbId]);
+      }
+      this.pending.delete(dbId ?? `${userId}-${Date.now()}`);
+    }, durationMs);
+
+    this.pending.set(dbId ?? `${userId}-${Date.now()}`, timeout);
+    return { durationMs, reminder };
+  }
+
+  /**
+   * Restore reminders from DB on startup.
+   * Call this in your ready event.
+   */
+  async restore() {
+    if (!this.client.db) return;
+    const now = new Date();
+    const res = await this.client.db.query(
+      `SELECT * FROM chrx_reminders WHERE remind_at > $1`,
+      [now]
+    );
+
+    for (const row of res.rows) {
+      const remaining = new Date(row.remind_at).getTime() - Date.now();
+      if (remaining <= 0) continue;
+
+      const timeout = setTimeout(async () => {
+        const channel = this.client.channels.cache.get(row.channel_id.toString());
+        if (channel) channel.send(`⏰ <@${row.user_id}> — Reminder: **${row.reminder}**`).catch(() => {});
+        await this.client.db.query(`DELETE FROM chrx_reminders WHERE id = $1`, [row.id]);
+        this.pending.delete(row.id);
+      }, remaining);
+
+      this.pending.set(row.id, timeout);
+    }
+
+    console.log(`[Reminders] Restored ${res.rows.length} pending reminder(s).`);
+  }
+
+  async initTable() {
+    if (!this.client.db) return;
+    await this.client.db.query(`
+      CREATE TABLE IF NOT EXISTS chrx_reminders (
+        id SERIAL PRIMARY KEY,
+        user_id BIGINT NOT NULL,
+        channel_id BIGINT NOT NULL,
+        reminder TEXT NOT NULL,
+        remind_at TIMESTAMP NOT NULL,
+        created_at TIMESTAMP DEFAULT NOW()
+      )
+    `);
+    console.log("[Reminders] Table ready.");
+  }
+}
+
+module.exports = Reminders;

package/plugins/starboard.js

@@ -0,0 +1,68 @@
+/**
+ * plugins/Starboard.js
+ * React with ⭐ enough times → message gets pinned to a starboard channel.
+ */
+
+const { EmbedBuilder } = require("discord.js");
+
+class Starboard {
+  constructor(client) {
+    this.client = client;
+    this.configs = new Map(); // guildId -> { channelId, threshold, emoji }
+    this.posted = new Set(); // messageIds already on starboard
+    this._registerEvents();
+  }
+
+  /**
+   * Configure starboard for a guild.
+   * @param {string} guildId
+   * @param {object} options
+   * @param {string} options.channelId   Starboard channel
+   * @param {number} [options.threshold=3]  Stars needed
+   * @param {string} [options.emoji="⭐"]
+   */
+  setup(guildId, { channelId, threshold = 3, emoji = "⭐" }) {
+    this.configs.set(guildId, { channelId, threshold, emoji });
+  }
+
+  _registerEvents() {
+    this.client.on("messageReactionAdd", async (reaction, user) => {
+      if (user.bot) return;
+      if (reaction.partial) await reaction.fetch().catch(() => {});
+
+      const cfg = this.configs.get(reaction.message.guildId);
+      if (!cfg) return;
+      if (reaction.emoji.name !== cfg.emoji) return;
+      if (this.posted.has(reaction.message.id)) return;
+      if (reaction.count < cfg.threshold) return;
+
+      this.posted.add(reaction.message.id);
+
+      const msg = reaction.message.partial
+        ? await reaction.message.fetch().catch(() => null)
+        : reaction.message;
+      if (!msg) return;
+
+      const starChannel = this.client.channels.cache.get(cfg.channelId);
+      if (!starChannel) return;
+
+      const embed = new EmbedBuilder()
+        .setColor("#FEE75C")
+        .setAuthor({ name: msg.author.tag, iconURL: msg.author.displayAvatarURL() })
+        .setDescription(msg.content || "*No text content*")
+        .addFields({ name: "Source", value: `[Jump to message](${msg.url})` })
+        .setTimestamp(msg.createdAt);
+
+      if (msg.attachments.size > 0) {
+        embed.setImage(msg.attachments.first().url);
+      }
+
+      await starChannel.send({
+        content: `${cfg.emoji} **${reaction.count}** | <#${msg.channelId}>`,
+        embeds: [embed],
+      }).catch(() => {});
+    });
+  }
+}
+
+module.exports = Starboard;

package/plugins/tickets.js

@@ -0,0 +1,116 @@
+/**
+ * plugins/Tickets.js
+ * Support ticket system — open, close, log.
+ */
+
+const { EmbedBuilder, PermissionFlagsBits, ChannelType } = require("discord.js");
+
+class Tickets {
+  constructor(client) {
+    this.client = client;
+    this.config = new Map(); // guildId -> { categoryId, logChannelId, supportRoleId }
+  }
+
+  /**
+   * Configure the ticket system for a guild.
+   */
+  setup(guildId, { categoryId, logChannelId, supportRoleId }) {
+    this.config.set(guildId, { categoryId, logChannelId, supportRoleId });
+  }
+
+  /**
+   * Open a ticket for a user.
+   */
+  async open(guild, user, topic = "Support") {
+    const cfg = this.config.get(guild.id);
+    if (!cfg) throw new Error("[Tickets] Not configured for this guild.");
+
+    const existing = guild.channels.cache.find(
+      (c) => c.name === `ticket-${user.username.toLowerCase()}` && c.parentId === cfg.categoryId
+    );
+    if (existing) return { channel: existing, alreadyOpen: true };
+
+    const channel = await guild.channels.create({
+      name: `ticket-${user.username.toLowerCase()}`,
+      type: ChannelType.GuildText,
+      parent: cfg.categoryId,
+      permissionOverwrites: [
+        { id: guild.roles.everyone, deny: [PermissionFlagsBits.ViewChannel] },
+        { id: user.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages] },
+        ...(cfg.supportRoleId ? [{ id: cfg.supportRoleId, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.SendMessages] }] : []),
+      ],
+    });
+
+    await channel.send({
+      embeds: [
+        new EmbedBuilder()
+          .setColor("#5865F2")
+          .setTitle(`🎫 Ticket — ${topic}`)
+          .setDescription(`Welcome ${user}! Support will be with you shortly.\nUse \`/ticket close\` to close this ticket.`)
+          .setTimestamp(),
+      ],
+    });
+
+    if (this.client.db) {
+      await this.client.db.query(`
+        INSERT INTO chrx_tickets (user_id, guild_id, channel_id, topic)
+        VALUES ($1, $2, $3, $4)
+      `, [BigInt(user.id), BigInt(guild.id), BigInt(channel.id), topic]);
+    }
+
+    return { channel, alreadyOpen: false };
+  }
+
+  /**
+   * Close a ticket channel.
+   */
+  async close(guild, channel, closedBy) {
+    const cfg = this.config.get(guild.id);
+
+    if (cfg?.logChannelId) {
+      const logChannel = guild.channels.cache.get(cfg.logChannelId);
+      if (logChannel) {
+        await logChannel.send({
+          embeds: [
+            new EmbedBuilder()
+              .setColor("#ED4245")
+              .setTitle("🎫 Ticket Closed")
+              .addFields(
+                { name: "Channel", value: channel.name, inline: true },
+                { name: "Closed by", value: `${closedBy}`, inline: true }
+              )
+              .setTimestamp(),
+          ],
+        });
+      }
+    }
+
+    if (this.client.db) {
+      await this.client.db.query(
+        `UPDATE chrx_tickets SET closed_at = NOW() WHERE channel_id = $1`,
+        [BigInt(channel.id)]
+      );
+    }
+
+    await channel.send("🔒 Ticket closing in 5 seconds...").catch(() => {});
+    setTimeout(() => channel.delete().catch(() => {}), 5000);
+  }
+
+  async initTable() {
+    if (!this.client.db) return;
+    await this.client.db.query(`
+      CREATE TABLE IF NOT EXISTS chrx_tickets (
+        id SERIAL PRIMARY KEY,
+        user_id BIGINT NOT NULL,
+        guild_id BIGINT NOT NULL,
+        channel_id BIGINT NOT NULL,
+        topic TEXT,
+        closed_at TIMESTAMP,
+        created_at TIMESTAMP DEFAULT NOW()
+      )
+    `);
+    console.log("[Tickets] Table ready.");
+  }
+}
+
+module.exports = Tickets;

package/plugins/welcome.js

@@ -0,0 +1,81 @@
+/**
+ * plugins/Welcome.js
+ * Welcome/goodbye messages + auto role on join.
+ */
+
+const { EmbedBuilder } = require("discord.js");
+
+class Welcome {
+  constructor(client) {
+    this.client = client;
+    this.configs = new Map(); // guildId -> config
+    this._registerEvents();
+  }
+
+  /**
+   * Configure welcome for a guild.
+   * @param {string} guildId
+   * @param {object} options
+   * @param {string} [options.channelId]      Welcome channel
+   * @param {string} [options.message]        Custom message. Use {user} and {server} as placeholders.
+   * @param {string} [options.goodbyeChannelId]
+   * @param {string} [options.goodbyeMessage]
+   * @param {string} [options.autoRoleId]     Role to give on join
+   */
+  setup(guildId, options) {
+    this.configs.set(guildId, options);
+  }
+
+  _registerEvents() {
+    this.client.on("guildMemberAdd", async (member) => {
+      const cfg = this.configs.get(member.guild.id);
+      if (!cfg) return;
+
+      if (cfg.autoRoleId) {
+        const role = member.guild.roles.cache.get(cfg.autoRoleId);
+        if (role) await member.roles.add(role).catch(() => {});
+      }
+
+      if (cfg.channelId) {
+        const channel = this.client.channels.cache.get(cfg.channelId);
+        if (!channel) return;
+        const msg = (cfg.message || "Welcome {user} to **{server}**!")
+          .replace("{user}", member.toString())
+          .replace("{server}", member.guild.name);
+
+        await channel.send({
+          embeds: [
+            new EmbedBuilder()
+              .setColor("#57F287")
+              .setDescription(msg)
+              .setThumbnail(member.user.displayAvatarURL())
+              .setTimestamp(),
+          ],
+        }).catch(() => {});
+      }
+    });
+
+    this.client.on("guildMemberRemove", async (member) => {
+      const cfg = this.configs.get(member.guild.id);
+      if (!cfg?.goodbyeChannelId) return;
+
+      const channel = this.client.channels.cache.get(cfg.goodbyeChannelId);
+      if (!channel) return;
+
+      const msg = (cfg.goodbyeMessage || "**{user}** has left **{server}**. Goodbye!")
+        .replace("{user}", member.user.tag)
+        .replace("{server}", member.guild.name);
+
+      await channel.send({
+        embeds: [
+          new EmbedBuilder()
+            .setColor("#ED4245")
+            .setDescription(msg)
+            .setTimestamp(),
+        ],
+      }).catch(() => {});
+    });
+  }
+}
+
+module.exports = Welcome;