kythia-core 0.9.3-beta

package/src/managers/ShutdownManager.js

@@ -0,0 +1,197 @@
+/**
+ * 🛑 Shutdown Manager
+ *
+ * @file src/managers/ShutdownManager.js
+ * @copyright © 2025 kenndeclouv
+ * @assistant chaa & graa
+ * @version 0.9.3-beta
+ *
+ * @description
+ * Handles graceful shutdown procedures including interval tracking,
+ * component cleanup, and resource management.
+ */
+
+const exitHook = require('async-exit-hook');
+
+class ShutdownManager {
+    /**
+     * 🏗️ ShutdownManager Constructor
+     * @param {Object} client - Discord client instance
+     * @param {Object} container - Dependency container
+     */
+    constructor({ client, container }) {
+        this.client = client;
+        this.container = container;
+        this._activeIntervals = new Set();
+        this._messagesWithActiveCollectors = new Set();
+        this._collectorPatched = false;
+        this._cleanupAttached = false;
+
+        this.logger = this.container.logger;
+    }
+
+    /**
+     * 🕵️‍♂️ [GLOBAL PATCH] Overrides global interval functions to track all active intervals.
+     * This allows for a truly generic and scalable graceful shutdown of all timed tasks.
+     */
+    initializeGlobalIntervalTracker() {
+        if (!this._activeIntervals) this._activeIntervals = new Set();
+
+        const botInstance = this;
+        const originalSetInterval = global.setInterval;
+        const originalClearInterval = global.clearInterval;
+
+        global.setInterval = function (...args) {
+            const intervalId = originalSetInterval.apply(this, args);
+
+            botInstance._activeIntervals.add(intervalId);
+            return intervalId;
+        };
+
+        global.clearInterval = function (intervalId) {
+            originalClearInterval.apply(this, [intervalId]);
+
+            botInstance._activeIntervals.delete(intervalId);
+        };
+
+        this.logger.info('✅ Global setInterval/clearInterval has been patched for tracking.');
+    }
+
+    /**
+     * 🛑 [FINAL ARCHITECTURE v5] Manages ALL graceful shutdown procedures.
+     * This version patches the core message sending/editing methods to automatically
+     * track ANY message with components, regardless of how its interactions are handled.
+     */
+    initializeShutdownCollectors() {
+        if (!this._messagesWithActiveCollectors) this._messagesWithActiveCollectors = new Set();
+
+        if (!this._collectorPatched) {
+            const origCreateCollector = require('discord.js').Message.prototype.createMessageComponentCollector;
+            const botInstance = this;
+
+            require('discord.js').Message.prototype.createMessageComponentCollector = function (...args) {
+                const collector = origCreateCollector.apply(this, args);
+                const message = this;
+
+                if (botInstance._messagesWithActiveCollectors) {
+                    botInstance._messagesWithActiveCollectors.add(message);
+                }
+
+                collector.once('end', () => {
+                    if (botInstance._messagesWithActiveCollectors) {
+                        botInstance._messagesWithActiveCollectors.delete(message);
+                    }
+                });
+
+                return collector;
+            };
+            this._collectorPatched = true;
+            this.logger.info('✅ Corrected collector-based component tracking has been patched.');
+        }
+
+        if (!this._cleanupAttached) {
+            const cleanupAndFlush = async (callback) => {
+                this.logger.info('🛑 Graceful shutdown initiated...');
+
+                if (this._activeIntervals && this._activeIntervals.size > 0) {
+                    this.logger.info(`🛑 Halting ${this._activeIntervals.size} active global intervals...`);
+                    for (const intervalId of this._activeIntervals) {
+                        clearInterval(intervalId);
+                    }
+                }
+
+                const messagesToProcess = this._messagesWithActiveCollectors;
+
+                if (messagesToProcess && messagesToProcess.size > 0) {
+                    this.logger.info(`🛑 Disabling components on up to ${messagesToProcess.size} messages.`);
+                    const editPromises = [];
+
+                    function disableRecursively(components) {
+                        return components.map((comp) => {
+                            if (comp.components && Array.isArray(comp.components)) {
+                                comp.components = disableRecursively(comp.components);
+                            }
+
+                            if (comp.type === 2 || comp.type === 3 || comp.type >= 5) {
+                                return { ...comp, disabled: true };
+                            }
+                            return comp;
+                        });
+                    }
+
+                    for (const msg of messagesToProcess) {
+                        if (!msg.editable || !msg.components || msg.components.length === 0) continue;
+                        try {
+                            const rawComponents = msg.components.map((c) => c.toJSON());
+                            const disabledComponents = disableRecursively(rawComponents);
+                            editPromises.push(msg.edit({ components: disabledComponents }).catch(() => {}));
+                        } catch (e) {}
+                    }
+                    await Promise.allSettled(editPromises);
+                }
+                this.logger.info('✅ Component cleanup complete.');
+
+                this.logger.info('🚰 Flushing remaining logs...');
+                this.logger.on('finish', () => {
+                    console.log('⏳ Logger has flushed. Kythia is now safely shutting down.');
+                    if (callback) callback();
+                });
+                this.logger.end();
+                setTimeout(() => {
+                    console.log('⏳ Logger flush timeout. Forcing exit.');
+                    if (callback) callback();
+                }, 4000);
+            };
+
+            exitHook(cleanupAndFlush);
+            process.on('unhandledRejection', (error) => {
+                this.logger.error('‼️ UNHANDLED PROMISE REJECTION:', error);
+            });
+            process.on('uncaughtException', (error) => {
+                this.logger.error('‼️ UNCAUGHT EXCEPTION! Bot will shutdown.', error);
+                process.exit(1);
+            });
+
+            this._cleanupAttached = true;
+            this.logger.info('🛡️  Graceful shutdown and error handlers are now active.');
+        }
+    }
+
+    /**
+     * Initialize all shutdown procedures
+     */
+    initialize() {
+        this.initializeGlobalIntervalTracker();
+        this.initializeShutdownCollectors();
+    }
+
+    /**
+     * Get active intervals count
+     * @returns {number} Number of active intervals
+     */
+    getActiveIntervalsCount() {
+        return this._activeIntervals ? this._activeIntervals.size : 0;
+    }
+
+    /**
+     * Get messages with active collectors count
+     * @returns {number} Number of messages with active collectors
+     */
+    getActiveCollectorsCount() {
+        return this._messagesWithActiveCollectors ? this._messagesWithActiveCollectors.size : 0;
+    }
+
+    /**
+     * Force cleanup (for testing purposes)
+     */
+    forceCleanup() {
+        if (this._activeIntervals) {
+            for (const intervalId of this._activeIntervals) {
+                clearInterval(intervalId);
+            }
+            this._activeIntervals.clear();
+        }
+    }
+}
+
+module.exports = ShutdownManager;

package/src/structures/BaseCommand.js

@@ -0,0 +1,49 @@
+/**
+ * Base Command Structure
+ * @class BaseCommand
+ * @description Base class for all command types (slash commands, context menus, etc.)
+ */
+class BaseCommand {
+    /**
+     * @param {Object} container - Dependency injection container
+     */
+    constructor(container) {
+        if (!container) {
+            throw new Error('Container is required for BaseCommand');
+        }
+
+        this.container = container;
+        this.client = container.client;
+        this.logger = container.logger;
+        this.t = container.t;
+        this.models = container.models;
+        this.kythiaConfig = container.kythiaConfig;
+        this.helpers = container.helpers;
+
+        this.data = {
+            name: 'base-command',
+            description: 'Base command description',
+            cooldown: 10,
+            permissions: [],
+            ownerOnly: false,
+            teamOnly: false,
+            guildOnly: false,
+        };
+    }
+
+    /**
+     * Main command execution method (must be implemented by child classes)
+     * @param {import('discord.js').CommandInteraction} interaction - The interaction object
+     * @returns {Promise<void>}
+     */
+    async execute(interaction) {
+        if (interaction.options?.getSubcommand?.(false)) {
+            this.logger.warn(`Command group ${this.constructor.name} execute called - this should be handled by subcommand`);
+            return;
+        }
+
+        throw new Error(`Execute method not implemented for ${this.constructor.name}`);
+    }
+}
+
+module.exports = BaseCommand;

package/src/utils/color.js

@@ -0,0 +1,176 @@
+const discordColors = {
+    Default: 0x000000,
+    White: 0xffffff,
+    Aqua: 0x1abc9c,
+    Green: 0x57f287,
+    Blue: 0x3498db,
+    Yellow: 0xfee75c,
+    Purple: 0x9b59b6,
+    LuminousVividPink: 0xe91e63,
+    Fuchsia: 0xeb459e,
+    Gold: 0xf1c40f,
+    Orange: 0xe67e22,
+    Red: 0xed4245,
+    Grey: 0x95a5a6,
+    Navy: 0x34495e,
+    DarkAqua: 0x11806a,
+    DarkGreen: 0x1f8b4c,
+    DarkBlue: 0x206694,
+    DarkPurple: 0x71368a,
+    DarkVividPink: 0xad1457,
+    DarkGold: 0xc27c0e,
+    DarkOrange: 0xa84300,
+    DarkRed: 0x992d22,
+    DarkGrey: 0x979c9f,
+    DarkerGrey: 0x7f8c8d,
+    LightGrey: 0xbcc0c0,
+    DarkNavy: 0x2c3e50,
+    Blurple: 0x5865f2,
+    Greyple: 0x99aab5,
+    DarkButNotBlack: 0x2c2f33,
+    NotQuiteBlack: 0x23272a,
+};
+
+/**
+ * Converts a color between multiple representations.
+ *
+ * @param {string|number|{r:number,g:number,b:number}} input - The input color value.
+ * @param {{from:'hex'|'rgb'|'decimal'|'discord', to:'hex'|'rgb'|'decimal'}} options - Conversion options.
+ * @returns {string|number|{r:number,g:number,b:number}} The converted color.
+ */
+function convertColor(input, { from, to }) {
+    function hexToRgb(hex) {
+        let h = hex.replace(/^#/, '');
+        if (h.length === 3) {
+            h = h
+                .split('')
+                .map((x) => x + x)
+                .join('');
+        }
+        if (!/^[0-9a-fA-F]{6}$/.test(h)) throw new Error('Invalid hex color');
+        return {
+            r: parseInt(h.slice(0, 2), 16),
+            g: parseInt(h.slice(2, 4), 16),
+            b: parseInt(h.slice(4, 6), 16),
+        };
+    }
+
+    function rgbToHex({ r, g, b }) {
+        if (
+            typeof r !== 'number' ||
+            typeof g !== 'number' ||
+            typeof b !== 'number' ||
+            r < 0 ||
+            r > 255 ||
+            g < 0 ||
+            g > 255 ||
+            b < 0 ||
+            b > 255
+        )
+            throw new Error('Invalid RGB color');
+        return (
+            '#' +
+            [r, g, b]
+                .map((x) => {
+                    const hex = x.toString(16);
+                    return hex.length === 1 ? '0' + hex : hex;
+                })
+                .join('')
+                .toUpperCase()
+        );
+    }
+
+    function hexToDecimal(hex) {
+        let h = hex.replace(/^#/, '');
+        if (h.length === 3) {
+            h = h
+                .split('')
+                .map((x) => x + x)
+                .join('');
+        }
+        if (!/^[0-9a-fA-F]{6}$/.test(h)) throw new Error('Invalid hex color');
+        return Number('0x' + h.toUpperCase());
+    }
+
+    function decimalToHex(decimal) {
+        if (typeof decimal !== 'number' || decimal < 0 || decimal > 0xffffff) throw new Error('Invalid decimal color');
+        let hex = decimal.toString(16).toUpperCase();
+        while (hex.length < 6) hex = '0' + hex;
+        return '#' + hex;
+    }
+
+    function rgbToDecimal({ r, g, b }) {
+        if (
+            typeof r !== 'number' ||
+            typeof g !== 'number' ||
+            typeof b !== 'number' ||
+            r < 0 ||
+            r > 255 ||
+            g < 0 ||
+            g > 255 ||
+            b < 0 ||
+            b > 255
+        )
+            throw new Error('Invalid RGB color');
+        return (r << 16) + (g << 8) + b;
+    }
+
+    function decimalToRgb(decimal) {
+        if (typeof decimal !== 'number' || decimal < 0 || decimal > 0xffffff) throw new Error('Invalid decimal color');
+        return {
+            r: (decimal >> 16) & 0xff,
+            g: (decimal >> 8) & 0xff,
+            b: decimal & 0xff,
+        };
+    }
+
+    if (from === to) return input;
+
+    let rgb, hex, decimal;
+
+    switch (from) {
+        case 'hex':
+            hex = input;
+            rgb = hexToRgb(hex);
+            decimal = hexToDecimal(hex);
+            break;
+        case 'rgb':
+            rgb = input;
+            hex = rgbToHex(rgb);
+            decimal = rgbToDecimal(rgb);
+            break;
+        case 'decimal':
+            decimal = input;
+            hex = decimalToHex(decimal);
+            rgb = decimalToRgb(decimal);
+            break;
+        case 'discord':
+            if (typeof input === 'string') {
+                const key = Object.keys(discordColors).find((k) => k.toLowerCase() === input.toLowerCase());
+                if (!key) throw new Error(`Invalid Discord color name: ${input}`);
+                decimal = discordColors[key];
+            } else if (typeof input === 'number') {
+                decimal = input;
+            } else {
+                throw new Error('Invalid input type for Discord color');
+            }
+            hex = decimalToHex(decimal);
+            rgb = decimalToRgb(decimal);
+            break;
+        default:
+            throw new Error(`Invalid "from" color type: ${from}`);
+    }
+
+    switch (to) {
+        case 'hex':
+            return hex;
+        case 'rgb':
+            return rgb;
+        case 'decimal':
+            return decimal;
+        default:
+            throw new Error(`Invalid "to" color type: ${to}`);
+    }
+}
+
+module.exports = convertColor;

package/src/utils/formatter.js

@@ -0,0 +1,99 @@
+/**
+ * Converts a string to a small-caps-like Unicode alphabet variant.
+ * @param {string} text - Input text.
+ * @returns {string} Converted text using tiny letters.
+ */
+function toTinyText(text) {
+    const normal = 'abcdefghijklmnopqrstuvwxyz';
+    const tiny = [
+        'ᴀ',
+        'ʙ',
+        'ᴄ',
+        'ᴅ',
+        'ᴇ',
+        'ғ',
+        'ɢ',
+        'ʜ',
+        'ɪ',
+        'ᴊ',
+        'ᴋ',
+        'ʟ',
+        'ᴍ',
+        'ɴ',
+        'ᴏ',
+        'ᴘ',
+        'ǫ',
+        'ʀ',
+        's',
+        'ᴛ',
+        'ᴜ',
+        'ᴠ',
+        'ᴡ',
+        'x',
+        'ʏ',
+        'ᴢ',
+    ];
+
+    return text
+        .split('')
+        .map((char) => {
+            const lowerChar = char.toLowerCase();
+            const index = normal.indexOf(lowerChar);
+            if (index !== -1) {
+                return tiny[index];
+            }
+            return char;
+        })
+        .join('');
+}
+
+/**
+ * Converts a string to a bold Unicode alphabet variant approximating "tiny" bold.
+ * @param {string} text - Input text.
+ * @returns {string} Converted text using bold tiny letters.
+ */
+function toTinyBoldText(text) {
+    const normal = 'abcdefghijklmnopqrstuvwxyz';
+    const tinyBold = [
+        '𝗮',
+        '𝗯',
+        '𝗰',
+        '𝗱',
+        '𝗲',
+        '𝗳',
+        '𝗴',
+        '𝗵',
+        '𝗶',
+        '𝗷',
+        '𝗸',
+        '𝗹',
+        '𝗺',
+        '𝗻',
+        '𝗼',
+        '𝗽',
+        '𝗾',
+        '𝗿',
+        '𝘀',
+        '𝘁',
+        '𝘂',
+        '𝘃',
+        '𝘄',
+        '𝘅',
+        '𝘆',
+        '𝘇',
+    ];
+
+    return text
+        .split('')
+        .map((char) => {
+            const lowerChar = char.toLowerCase();
+            const index = normal.indexOf(lowerChar);
+            if (index !== -1) {
+                return tinyBold[index];
+            }
+            return char;
+        })
+        .join('');
+}
+
+module.export = { toTinyText, toTinyBoldText };

package/src/utils/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    color: require('./color.js'),
+    formatter: require('./formatter.js'),
+};