chrxmaticc-framework 1.3.0 → 1.4.0

package/core/ChrxCommandBuilder.js

@@ -52,7 +52,6 @@ class ChrxCommandBuilder {
       });
     }
 
-    // ── Critical: expose data and execute so CommandLoader + deploy-commands picks it up ──
     this.data    = builder;
     this.execute = this._execute.bind(this);
   }
@@ -61,20 +60,24 @@ class ChrxCommandBuilder {
     const client = interaction.client;
     const opts   = this._options;
 
+    // ── Guild only ────────────────────────────────────────────────────────
     if (opts.guildOnly !== false && !interaction.guild) {
       return interaction.reply({ content: "❌ This command can only be used in a server.", ephemeral: true });
     }
 
+    // ── Owner only ────────────────────────────────────────────────────────
     if (opts.ownerOnly && interaction.user.id !== process.env.OWNER_ID) {
       return interaction.reply({ content: "❌ This command is restricted to the bot owner.", ephemeral: true });
     }
 
+    // ── Permission check ──────────────────────────────────────────────────
     if (opts.permission) {
       if (!interaction.member?.permissions.has(PermissionFlagsBits[opts.permission])) {
         return interaction.reply({ content: `❌ You need the **${opts.permission}** permission to use this.`, ephemeral: true });
       }
     }
 
+    // ── Cooldown ──────────────────────────────────────────────────────────
     if (opts.cooldown) {
       const key = `${interaction.user.id}-${opts.name}`;
       const now = Date.now();
@@ -91,6 +94,18 @@ class ChrxCommandBuilder {
       setTimeout(() => this._cooldowns.delete(key), opts.cooldown * 1000);
     }
 
+    // ── TimedReply — auto defer if timedReply option is set ───────────────
+    if (opts.timedReply) {
+      const minutes = opts.timedReply.minutes ?? 1;
+      const ms      = Math.min(minutes * 60 * 1000, 15 * 60 * 1000); // Discord hard cap is 15min
+      if (ms > 2500) {
+        // Only defer if we expect the command to take longer than ~2.5s
+        await interaction.deferReply({ ephemeral: opts.timedReply.ephemeral ?? false });
+      }
+      console.log(`[ChrxCommand] /${opts.name} timedReply active — ${minutes}min window`);
+    }
+
+    // ── Plugin injection ──────────────────────────────────────────────────
     const plugins = {
       economy:    client.chrx?.economy,
       moderation: client.chrx?.moderation,
@@ -106,6 +121,7 @@ class ChrxCommandBuilder {
       db:         client.db,
     };
 
+    // ── Run ───────────────────────────────────────────────────────────────
     try {
       await opts.run(interaction, plugins);
     } catch (err) {

package/core/ChrxReply.js

@@ -0,0 +1,236 @@
+/**
+ * core/ChrxReply.js
+ * Unified reply system — every Discord reply type simplified into clean triggers.
+ *
+ * Includes:
+ * - ChrxReply        → interaction.reply()
+ * - ChrxDeferReply   → interaction.deferReply()
+ * - ChrxEditReply    → interaction.editReply()
+ * - ChrxFollowUp     → interaction.followUp()
+ * - ChrxFetchReply   → interaction.fetchReply()
+ * - ChrxSilentReply  → ephemeral reply shortcut
+ * - ChrxAutoReply    → smart reply (detects state automatically)
+ * - ChrxThinkReply   → defer + slow handler + editReply
+ */
+
+// ── Helpers ───────────────────────────────────────────────────────────────
+
+/**
+ * Normalize input into a Discord reply payload.
+ * Accepts: string, EmbedBuilder, or plain payload object.
+ */
+function normalize(input, extra = {}) {
+  if (!input) return extra;
+
+  if (typeof input === "string") {
+    return { content: input, ...extra };
+  }
+
+  // EmbedBuilder instance
+  if (input?.data || input?.setTitle) {
+    return { embeds: [input], ...extra };
+  }
+
+  // Array of embeds
+  if (Array.isArray(input)) {
+    return { embeds: input, ...extra };
+  }
+
+  // Plain object payload — merge with extra
+  return { ...input, ...extra };
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxReply — normal reply
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {string|object|import("discord.js").EmbedBuilder} content
+ * @param {object} [options]
+ * @param {boolean} [options.ephemeral]
+ * @param {object[]} [options.components]
+ * @param {object[]} [options.files]
+ */
+async function ChrxReply(interaction, content, options = {}) {
+  try {
+    return await interaction.reply(normalize(content, options));
+  } catch (err) {
+    console.error("[ChrxReply] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxDeferReply — defer the interaction
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {object} [options]
+ * @param {boolean} [options.ephemeral]
+ */
+async function ChrxDeferReply(interaction, options = {}) {
+  try {
+    if (interaction.deferred || interaction.replied) return;
+    return await interaction.deferReply({ ephemeral: options.ephemeral ?? false });
+  } catch (err) {
+    console.error("[ChrxDeferReply] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxEditReply — edit an existing reply
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {string|object|import("discord.js").EmbedBuilder} content
+ * @param {object} [options]
+ */
+async function ChrxEditReply(interaction, content, options = {}) {
+  try {
+    // Auto defer if not already deferred or replied
+    if (!interaction.deferred && !interaction.replied) {
+      await interaction.deferReply({ ephemeral: options.ephemeral ?? false });
+    }
+    return await interaction.editReply(normalize(content, options));
+  } catch (err) {
+    console.error("[ChrxEditReply] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxFollowUp — follow up message
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {string|object|import("discord.js").EmbedBuilder} content
+ * @param {object} [options]
+ * @param {boolean} [options.ephemeral]
+ */
+async function ChrxFollowUp(interaction, content, options = {}) {
+  try {
+    return await interaction.followUp(normalize(content, options));
+  } catch (err) {
+    console.error("[ChrxFollowUp] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxFetchReply — fetch the reply message object
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @returns {Promise<import("discord.js").Message>}
+ */
+async function ChrxFetchReply(interaction) {
+  try {
+    return await interaction.fetchReply();
+  } catch (err) {
+    console.error("[ChrxFetchReply] Error:", err.message);
+    return null;
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxSilentReply — ephemeral reply shortcut
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * Always sends as ephemeral. No options needed.
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {string|object|import("discord.js").EmbedBuilder} content
+ */
+async function ChrxSilentReply(interaction, content) {
+  try {
+    if (interaction.deferred || interaction.replied) {
+      return await interaction.followUp({ ...normalize(content), ephemeral: true });
+    }
+    return await interaction.reply({ ...normalize(content), ephemeral: true });
+  } catch (err) {
+    console.error("[ChrxSilentReply] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxAutoReply — smart reply, detects state automatically
+// Never throws "interaction already replied" — picks the right method every time
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {string|object|import("discord.js").EmbedBuilder} content
+ * @param {object} [options]
+ * @param {boolean} [options.ephemeral]
+ */
+async function ChrxAutoReply(interaction, content, options = {}) {
+  try {
+    const payload = normalize(content, options);
+
+    if (interaction.replied) {
+      return await interaction.followUp(payload);
+    }
+
+    if (interaction.deferred) {
+      return await interaction.editReply(payload);
+    }
+
+    return await interaction.reply(payload);
+  } catch (err) {
+    console.error("[ChrxAutoReply] Error:", err.message);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// ChrxThinkReply — defer + slow async handler + auto editReply
+// Perfect for AI commands, database queries, anything slow
+// ═════════════════════════════════════════════════════════════════════════════
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {Function} handler   Async function that returns the reply content
+ * @param {object}  [options]
+ * @param {boolean} [options.ephemeral]
+ * @param {string}  [options.errorMessage]  Custom error message on failure
+ *
+ * @example
+ * await ChrxThinkReply(interaction, async () => {
+ *   const result = await someSlowDatabaseCall();
+ *   return `Result: ${result}`;
+ * });
+ */
+async function ChrxThinkReply(interaction, handler, options = {}) {
+  try {
+    if (!interaction.deferred && !interaction.replied) {
+      await interaction.deferReply({ ephemeral: options.ephemeral ?? false });
+    }
+
+    const result = await handler();
+
+    if (!result) return;
+
+    return await interaction.editReply(normalize(result));
+  } catch (err) {
+    console.error("[ChrxThinkReply] Error:", err.message);
+    await interaction.editReply({
+      content: options.errorMessage || err.message || "❌ Something went wrong.",
+    }).catch(() => {});
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+// Exports
+// ═════════════════════════════════════════════════════════════════════════════
+
+module.exports = {
+  ChrxReply,
+  ChrxDeferReply,
+  ChrxEditReply,
+  ChrxFollowUp,
+  ChrxFetchReply,
+  ChrxSilentReply,
+  ChrxAutoReply,
+  ChrxThinkReply,
+};

package/core/ChrxRouter.js

@@ -0,0 +1,233 @@
+/**
+ * core/ChrxRouter.js
+ * Global interaction router — register handlers once, auto-routes everything.
+ *
+ * Supports:
+ * - Buttons
+ * - Select menus
+ * - Modal submits
+ * - Context menus
+ *
+ * Usage:
+ * ChrxRouter.init(client);
+ * ChrxRouter.button("ban_confirm", async (i) => i.reply("✅ Banned!"));
+ * ChrxRouter.select("role_select", async (i, values) => i.reply(`Picked: ${values[0]}`));
+ * ChrxRouter.modal("feedback_modal", async (i, values) => i.reply(`Got: ${values.feedback}`));
+ * ChrxRouter.context("Get Avatar", async (i) => i.reply(i.targetUser.displayAvatarURL()));
+ */
+
+const { ComponentType } = require("discord.js");
+
+// ── Route registries ──────────────────────────────────────────────────────
+const buttonRoutes  = new Map(); // customId -> handler
+const selectRoutes  = new Map(); // customId -> handler
+const modalRoutes   = new Map(); // customId -> handler
+const contextRoutes = new Map(); // name     -> handler
+
+// ── Middleware ────────────────────────────────────────────────────────────
+const middlewares = [];
+
+// ── Cooldowns ─────────────────────────────────────────────────────────────
+const cooldowns = new Map(); // `${userId}-${id}` -> timestamp
+
+let _initialized = false;
+
+const ChrxRouter = {
+
+  /**
+   * Initialize the router — call this once after bot is ready.
+   * @param {import("discord.js").Client} client
+   */
+  init(client) {
+    if (_initialized) return;
+    _initialized = true;
+
+    client.on("interactionCreate", async (interaction) => {
+      try {
+        // ── Run middleware ────────────────────────────────────────────────
+        for (const mw of middlewares) {
+          const pass = await mw(interaction);
+          if (pass === false) return; // middleware blocked it
+        }
+
+        // ── Button ────────────────────────────────────────────────────────
+        if (interaction.isButton()) {
+          const handler = ChrxRouter._resolve(buttonRoutes, interaction.customId);
+          if (handler) await handler(interaction);
+          return;
+        }
+
+        // ── Select menu ───────────────────────────────────────────────────
+        if (interaction.isStringSelectMenu()) {
+          const handler = ChrxRouter._resolve(selectRoutes, interaction.customId);
+          if (handler) await handler(interaction, interaction.values);
+          return;
+        }
+
+        // ── Modal submit ──────────────────────────────────────────────────
+        if (interaction.isModalSubmit()) {
+          const handler = ChrxRouter._resolve(modalRoutes, interaction.customId);
+          if (handler) {
+            // Build values object keyed by field customId
+            const values = {};
+            for (const [key, field] of interaction.fields.fields) {
+              values[key] = field.value;
+            }
+            await handler(interaction, values);
+          }
+          return;
+        }
+
+        // ── Context menu ──────────────────────────────────────────────────
+        if (interaction.isContextMenuCommand()) {
+          const handler = contextRoutes.get(interaction.commandName);
+          if (handler) await handler(interaction);
+          return;
+        }
+
+      } catch (err) {
+        console.error("[ChrxRouter] Unhandled error:", err.message);
+        const msg = { content: err.message || "❌ Something went wrong.", ephemeral: true };
+        try {
+          if (interaction.replied || interaction.deferred) {
+            await interaction.followUp(msg);
+          } else {
+            await interaction.reply(msg);
+          }
+        } catch {}
+      }
+    });
+
+    console.log("[ChrxRouter] Initialized — routing all interactions globally.");
+  },
+
+  // ── Internal resolver — supports wildcards ────────────────────────────
+  // e.g. "ban_confirm_*" matches "ban_confirm_123456"
+  _resolve(registry, id) {
+    // Exact match first
+    if (registry.has(id)) return registry.get(id);
+
+    // Wildcard match
+    for (const [pattern, handler] of registry) {
+      if (pattern.endsWith("*") && id.startsWith(pattern.slice(0, -1))) {
+        return handler;
+      }
+    }
+
+    return null;
+  },
+
+  // ═══════════════════════════════════════════════════════════════════════
+  // Registration methods
+  // ═══════════════════════════════════════════════════════════════════════
+
+  /**
+   * Register a button handler.
+   * @param {string}   id       Button customId (supports wildcard e.g. "confirm_*")
+   * @param {Function} handler  async (interaction) => void
+   * @param {object}   [options]
+   * @param {number}   [options.cooldown]   Cooldown in seconds per user
+   * @param {boolean}  [options.ownerOnly]  Restrict to OWNER_ID
+   */
+  button(id, handler, options = {}) {
+    buttonRoutes.set(id, ChrxRouter._wrap(handler, id, options));
+    return ChrxRouter; // chainable
+  },
+
+  /**
+   * Register a select menu handler.
+   * @param {string}   id       Select menu customId
+   * @param {Function} handler  async (interaction, values) => void
+   * @param {object}   [options]
+   */
+  select(id, handler, options = {}) {
+    selectRoutes.set(id, ChrxRouter._wrap(handler, id, options));
+    return ChrxRouter;
+  },
+
+  /**
+   * Register a modal submit handler.
+   * @param {string}   id       Modal customId
+   * @param {Function} handler  async (interaction, values) => void
+   *                            values = { inputId: "user typed value", ... }
+   * @param {object}   [options]
+   */
+  modal(id, handler, options = {}) {
+    modalRoutes.set(id, ChrxRouter._wrap(handler, id, options));
+    return ChrxRouter;
+  },
+
+  /**
+   * Register a context menu handler.
+   * @param {string}   name     Context menu command name
+   * @param {Function} handler  async (interaction) => void
+   */
+  context(name, handler) {
+    contextRoutes.set(name, handler);
+    return ChrxRouter;
+  },
+
+  /**
+   * Remove a registered route.
+   * @param {"button"|"select"|"modal"|"context"} type
+   * @param {string} id
+   */
+  remove(type, id) {
+    const map = { button: buttonRoutes, select: selectRoutes, modal: modalRoutes, context: contextRoutes }[type];
+    if (map) map.delete(id);
+    return ChrxRouter;
+  },
+
+  /**
+   * Add global middleware — runs before every routed interaction.
+   * Return false to block the interaction.
+   * @param {Function} fn  async (interaction) => boolean | void
+   */
+  use(fn) {
+    middlewares.push(fn);
+    return ChrxRouter;
+  },
+
+  /**
+   * List all registered routes (useful for debugging).
+   */
+  list() {
+    return {
+      buttons:  [...buttonRoutes.keys()],
+      selects:  [...selectRoutes.keys()],
+      modals:   [...modalRoutes.keys()],
+      contexts: [...contextRoutes.keys()],
+    };
+  },
+
+  // ── Internal: wrap handler with cooldown + ownerOnly ──────────────────
+  _wrap(handler, id, options = {}) {
+    return async (interaction, ...args) => {
+      // Owner only
+      if (options.ownerOnly && interaction.user.id !== process.env.OWNER_ID) {
+        return interaction.reply({ content: "❌ This is restricted to the bot owner.", ephemeral: true });
+      }
+
+      // Cooldown
+      if (options.cooldown) {
+        const key = `${interaction.user.id}-${id}`;
+        const now = Date.now();
+        if (cooldowns.has(key)) {
+          const remaining = (options.cooldown * 1000) - (now - cooldowns.get(key));
+          if (remaining > 0) {
+            return interaction.reply({
+              content: `⏱ Wait **${(remaining / 1000).toFixed(1)}s** before doing that again.`,
+              ephemeral: true,
+            });
+          }
+        }
+        cooldowns.set(key, now);
+        setTimeout(() => cooldowns.delete(key), options.cooldown * 1000);
+      }
+
+      await handler(interaction, ...args);
+    };
+  },
+};
+
+module.exports = ChrxRouter;

package/core/ChrxTimedReply.js

@@ -0,0 +1,50 @@
+/**
+ * core/ChrxTimedReply.js
+ * Extended deferReply — keeps the interaction alive for a custom duration
+ * and handles the reply automatically when your function resolves.
+ *
+ * Usage:
+ * await ChrxTimedReply(interaction, async () => "Pong!");
+ * await ChrxTimedReply(interaction, async () => ({ content: "Pong!", ephemeral: true }));
+ * await ChrxTimedReply(interaction, async () => ({ embeds: [myEmbed] }));
+ */
+
+/**
+ * @param {import("discord.js").CommandInteraction} interaction
+ * @param {Function} handler  Async function that returns a string, object, or EmbedBuilder
+ * @param {object}  [options]
+ * @param {boolean} [options.ephemeral]  Defer as ephemeral (default: false)
+ */
+async function ChrxTimedReply(interaction, handler, options = {}) {
+  // Defer immediately to keep the interaction token alive
+  await interaction.deferReply({ ephemeral: options.ephemeral ?? false });
+
+  try {
+    const result = await handler();
+
+    if (!result) return;
+
+    // ── Normalize result into a payload ───────────────────────────────────
+    let payload = {};
+
+    if (typeof result === "string") {
+      payload.content = result;
+    } else if (result?.setTitle || result?.data?.title) {
+      // EmbedBuilder instance
+      payload.embeds = [result];
+    } else {
+      // Plain object — pass through as-is
+      payload = result;
+    }
+
+    await interaction.editReply(payload);
+
+  } catch (err) {
+    console.error("[ChrxTimedReply] Handler error:", err);
+    await interaction.editReply({
+      content: err.message || "❌ Something went wrong.",
+    }).catch(() => {});
+  }
+}
+
+module.exports = ChrxTimedReply;

package/index.js

@@ -9,26 +9,22 @@ const XPSystem               = require("./core/XPSystem");
 const AIWrapper              = require("./core/AIWrapper");
 const MusicManager           = require("./core/MusicManager");
 const ChrxCommandBuilder     = require("./core/ChrxCommandBuilder");
-const { ChrxEmbedBuilder, EmbedTrigger } = require("./core/ChrxEmbedBuilder");
+const ChrxTimedReply         = require("./core/ChrxTimedReply");
+const ChrxRouter             = require("./core/ChrxRouter");
+const { ChrxEmbedBuilder, EmbedTrigger }                = require("./core/ChrxEmbedBuilder");
 const { ChrxModalBuilder, ModalTrigger, onModalSubmit } = require("./core/ChrxModalBuilder");
 const {
-  ChrxButton,
-  ChrxSelectMenu,
-  ChrxPagination,
-  ChrxContextMenu,
-  ChrxMenu,
-  ChrxForm,
-  ChrxConfirm,
+  ChrxButton, ChrxSelectMenu, ChrxPagination,
+  ChrxContextMenu, ChrxMenu, ChrxForm, ChrxConfirm,
 } = require("./core/ChrxComponentsV3");
 const {
-  parseTime,
-  formatTime,
-  setMarker,
-  getMarkers,
-  clearMarker,
-  applyStartMarker,
-  startEndMarkerWatcher,
-  stopEndMarkerWatcher,
+  ChrxReply, ChrxDeferReply, ChrxEditReply,
+  ChrxFollowUp, ChrxFetchReply, ChrxSilentReply,
+  ChrxAutoReply, ChrxThinkReply,
+} = require("./core/ChrxReply");
+const {
+  parseTime, formatTime, setMarker, getMarkers,
+  clearMarker, applyStartMarker, startEndMarkerWatcher, stopEndMarkerWatcher,
 } = require("./core/songMarkers");
 
 // ── Plugins ───────────────────────────────────────────────────────────────
@@ -46,6 +42,18 @@ module.exports = {
   // Core
   ChrxClient,
   ChrxCommandBuilder,
+  ChrxRouter,
+
+  // Reply system
+  ChrxReply,
+  ChrxDeferReply,
+  ChrxEditReply,
+  ChrxFollowUp,
+  ChrxFetchReply,
+  ChrxSilentReply,
+  ChrxAutoReply,
+  ChrxThinkReply,
+  ChrxTimedReply,
 
   // Embed & Modal
   ChrxEmbedBuilder,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrxmaticc-framework",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "A batteries-included Discord bot framework with music, AI, XP and database support.",
   "main": "index.js",
   "files": [