@spatulox/simplediscordbot 1.0.1

package/dist/cli/InteractionCLI.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionCLI = void 0;
+const BaseCLI_1 = require("./BaseCLI");
+const InteractionManager_1 = require("../manager/handlers/builder/interactions/InteractionManager");
+const BotEnv_1 = require("../bot/BotEnv");
+class InteractionCLI extends BaseCLI_1.BaseCLI {
+    constructor(parent) {
+        super(parent);
+        this.managers = {};
+        const { clientId, token } = BotEnv_1.BotEnv;
+        this.managers['CommandManager'] = new InteractionManager_1.CommandManager(clientId, token);
+        this.managers['ContextMenuManager'] = new InteractionManager_1.ContextMenuManager(clientId, token);
+    }
+    getTitle() {
+        return '🔄 Interaction Manager CLI';
+    }
+    async showMainMenu() {
+        console.clear();
+        console.log(this.getTitle());
+        console.log('═'.repeat(40));
+        console.log('1. CommandManager');
+        console.log('2. ContextMenuManager');
+        console.log('3. Back');
+        console.log('═'.repeat(40));
+        const choice = await this.prompt('Choose a manager: ');
+        switch (choice) {
+            case '1': return this.handleManager('CommandManager');
+            case '2': return this.handleManager('ContextMenuManager');
+            case '3': return this.goBack();
+            default: return this.showMainMenu();
+        }
+    }
+    async handleManager(key) {
+        const manager = this.managers[key];
+        if (!manager)
+            return;
+        console.clear();
+        console.log(`${key} - ${manager.folderPath}`);
+        console.log('═'.repeat(50));
+        console.log(`1. List remote ${manager.folderPath}`);
+        console.log(`2. Deploy local ${manager.folderPath}`);
+        console.log(`3. Update remote ${manager.folderPath}`);
+        console.log(`4. Delete remote ${manager.folderPath}`);
+        console.log('5. Back');
+        console.log('═'.repeat(50));
+        const choice = await this.prompt('Choose an action: ');
+        switch (choice) {
+            case '1':
+                await manager.list();
+                break;
+            case '2':
+                await this.handleDeploy(manager);
+                break;
+            case '3':
+                await this.handleUpdate(manager);
+                break;
+            case '4':
+                await this.handleDelete(manager);
+                break;
+            case '5':
+            case 'exit': return this.showMainMenu();
+        }
+        await this.prompt('Press Enter to continue...');
+        return this.handleManager(key);
+    }
+    async selectCommands(manager, remote = true) {
+        const handlerManagerType = `${manager.folderPath}(s)`;
+        const commandList = remote ? await manager.list() : await manager.listFromFile();
+        if (!commandList?.length) {
+            console.log(`No ${handlerManagerType} found`);
+            return [];
+        }
+        const input = await this.prompt('Enter numbers (ex: 1,3,5 or "all" or "exit"): ');
+        if (input.toLowerCase() === 'all') {
+            return commandList;
+        }
+        if (input.toLowerCase() === 'exit') {
+            return [];
+        }
+        const indices = input.split(',').map(i => parseInt(i.trim())).filter(i => !isNaN(i));
+        const selected = commandList.filter((cmd) => indices.includes(cmd.index));
+        if (selected.length === 0) {
+            console.log('Invalid number');
+            return [];
+        }
+        console.log(`${selected.length} selected ${handlerManagerType}`);
+        return selected;
+    }
+    async handleDeploy(manager) {
+        const selected = await this.selectCommands(manager, false);
+        if (selected.length === 0)
+            return;
+        await manager.deploy(selected);
+    }
+    async handleUpdate(manager) {
+        const selected = await this.selectCommands(manager);
+        if (selected.length === 0)
+            return;
+        await manager.update(selected);
+    }
+    async handleDelete(manager) {
+        const selected = await this.selectCommands(manager);
+        if (selected.length === 0)
+            return;
+        await manager.delete(selected);
+    }
+}
+exports.InteractionCLI = InteractionCLI;

package/dist/cli/MainCLI.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MainCLI = void 0;
+const BaseCLI_1 = require("./BaseCLI");
+const InteractionCLI_1 = require("./InteractionCLI/InteractionCLI");
+const GenerationCLI_1 = require("./GenerationCLI/GenerationCLI");
+/**
+ * --- MainCLI ---
+ * Main controller for sub menu
+ */
+class MainCLI extends BaseCLI_1.BaseCLI {
+    getTitle() {
+        return "💠 SimpleDiscordBot CLI";
+    }
+    constructor() {
+        super();
+        this.menuSelection = [
+            { label: "Manage Interactions", action: () => new InteractionCLI_1.InteractionCLI(this) },
+            { label: "Generate Files", action: () => new GenerationCLI_1.GenerationCLI(this) },
+            { label: "Help", action: () => this.showHelp() },
+            { label: "Exit", action: () => this },
+        ];
+        this.showMainMenu();
+    }
+    execute() {
+        console.log("👋 Bye !");
+        process.exit();
+    }
+}
+exports.MainCLI = MainCLI;
+new MainCLI();

package/dist/cli/type/ContextMenuConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli/type/InteractionType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionContextType = exports.InteractionIntegrationType = void 0;
+var InteractionIntegrationType;
+(function (InteractionIntegrationType) {
+    InteractionIntegrationType[InteractionIntegrationType["GUILD_INSTALL"] = 0] = "GUILD_INSTALL";
+    InteractionIntegrationType[InteractionIntegrationType["USER_INSTALL"] = 1] = "USER_INSTALL";
+})(InteractionIntegrationType || (exports.InteractionIntegrationType = InteractionIntegrationType = {}));
+var InteractionContextType;
+(function (InteractionContextType) {
+    InteractionContextType[InteractionContextType["SERVER_CHANNEL"] = 0] = "SERVER_CHANNEL";
+    InteractionContextType[InteractionContextType["BOT_DM"] = 1] = "BOT_DM";
+    InteractionContextType[InteractionContextType["GROUP_DM"] = 2] = "GROUP_DM";
+})(InteractionContextType || (exports.InteractionContextType = InteractionContextType = {}));

package/dist/cli/type/SlashCommandConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordRegex = exports.SimpleMutex = exports.Log = exports.Time = exports.ModalManager = exports.UserManager = exports.GuildManager = exports.ReactionManager = exports.WebhookManager = exports.EmbedColor = exports.EmbedManager = exports.FileManager = exports.Bot = void 0;
+var Bot_1 = require("./bot/Bot");
+Object.defineProperty(exports, "Bot", { enumerable: true, get: function () { return Bot_1.Bot; } });
+// Manager
+var FileManager_1 = require("./manager/FileManager");
+Object.defineProperty(exports, "FileManager", { enumerable: true, get: function () { return FileManager_1.FileManager; } });
+var EmbedManager_1 = require("./manager/messages/EmbedManager");
+Object.defineProperty(exports, "EmbedManager", { enumerable: true, get: function () { return EmbedManager_1.EmbedManager; } });
+Object.defineProperty(exports, "EmbedColor", { enumerable: true, get: function () { return EmbedManager_1.EmbedColor; } });
+var WebhookManager_1 = require("./manager/messages/WebhookManager");
+Object.defineProperty(exports, "WebhookManager", { enumerable: true, get: function () { return WebhookManager_1.WebhookManager; } });
+var ReactionManager_1 = require("./manager/messages/ReactionManager");
+Object.defineProperty(exports, "ReactionManager", { enumerable: true, get: function () { return ReactionManager_1.ReactionManager; } });
+var GuildManager_1 = require("./manager/guild/GuildManager");
+Object.defineProperty(exports, "GuildManager", { enumerable: true, get: function () { return GuildManager_1.GuildManager; } });
+var UserManager_1 = require("./manager/direct/UserManager");
+Object.defineProperty(exports, "UserManager", { enumerable: true, get: function () { return UserManager_1.UserManager; } });
+// Handlers
+var ModalManager_1 = require("./manager/handlers/builder/ModalManager");
+Object.defineProperty(exports, "ModalManager", { enumerable: true, get: function () { return ModalManager_1.ModalManager; } });
+// Utils
+var UnitTime_1 = require("./utils/times/UnitTime");
+Object.defineProperty(exports, "Time", { enumerable: true, get: function () { return UnitTime_1.Time; } });
+var Log_1 = require("./utils/Log");
+Object.defineProperty(exports, "Log", { enumerable: true, get: function () { return Log_1.Log; } });
+var SimpleMutex_1 = require("./utils/SimpleMutex");
+Object.defineProperty(exports, "SimpleMutex", { enumerable: true, get: function () { return SimpleMutex_1.SimpleMutex; } });
+var DiscordRegex_1 = require("./utils/DiscordRegex");
+Object.defineProperty(exports, "DiscordRegex", { enumerable: true, get: function () { return DiscordRegex_1.DiscordRegex; } });

package/dist/manager/FileManager.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileManager = void 0;
+// src/filesystem/FileManager.ts
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const Log_1 = require("../utils/Log");
+const Bot_1 = require("../bot/Bot");
+const EmbedManager_1 = require("./messages/EmbedManager");
+class FileManager {
+    /**
+     * Reads a JSON file synchronously.
+     * @param filePath Full path to the JSON file
+     * @returns Parsed JSON object or 'Error' string on failure
+     */
+    static async readJsonFile(filePath) {
+        try {
+            const data = await promises_1.default.readFile(filePath, 'utf8');
+            return JSON.parse(data);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to read JSON file ${filePath}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Lists all directories in a given path.
+     * @param directoryPath Path to scan for directories
+     * @returns Array of directory names or false on error
+     */
+    static async listDirectories(directoryPath) {
+        try {
+            const files = await promises_1.default.readdir(directoryPath, { withFileTypes: true });
+            const directories = files
+                .filter(file => file.isDirectory())
+                .map(dir => dir.name);
+            return directories;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to read directory ${directoryPath}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Lists all JSON files in a directory.
+     * @param directoryPath Path to scan for JSON files
+     * @returns Array of JSON filenames or false on error
+     */
+    static async listJsonFiles(directoryPath) {
+        try {
+            const files = await promises_1.default.readdir(directoryPath);
+            return files.filter(file => path_1.default.extname(file) === '.json');
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to read directory ${directoryPath}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Lists files with specific extension in a directory.
+     * @param directoryPath Path to scan
+     * @param extension File extension (with or without dot)
+     * @returns Array of matching filenames or 'Error' string on failure
+     */
+    static async listFiles(directoryPath, extension) {
+        if (typeof directoryPath !== 'string' || typeof extension !== 'string') {
+            Log_1.Log.error('Directory path and extension must be strings');
+            return false;
+        }
+        try {
+            let ext = extension;
+            if (ext.startsWith('.')) {
+                ext = ext.slice(1);
+            }
+            const files = await promises_1.default.readdir(directoryPath);
+            return files.filter(file => path_1.default.extname(file) === `.${ext}`);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to read directory ${directoryPath}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Creates directory structure and writes JSON data to file.
+     * @param directoryPath Full directory path (creates if missing)
+     * @param filename Filename without extension
+     * @param data Data to write (JSON serializable)
+     * @param sendErrorToErrorChannel Send error to the error channel
+     * @returns true on success, false on failure
+     */
+    static async writeJsonFile(directoryPath, filename, data, sendErrorToErrorChannel = true) {
+        // Skip if data is an Error array
+        if (Array.isArray(data) && data.length === 1 && data[0] === 'Error') {
+            Log_1.Log.error(`Cannot save data for ${filename}: data contains 'Error'`);
+            return false;
+        }
+        try {
+            // Create directory structure recursively
+            const directories = directoryPath.split(path_1.default.sep).filter(Boolean);
+            let currentPath = '';
+            for (const dir of directories) {
+                currentPath = path_1.default.join(currentPath, dir);
+                try {
+                    await promises_1.default.access(currentPath);
+                }
+                catch {
+                    await promises_1.default.mkdir(currentPath, { recursive: true });
+                }
+            }
+            if (!filename || filename.trim() === '') {
+                Log_1.Log.error('Cannot write JSON file: empty filename');
+                return false;
+            }
+            const cleanFilename = filename.replace(/\.json$/i, '');
+            const filePath = path_1.default.join(directoryPath, `${cleanFilename}.json`);
+            const jsonContent = JSON.stringify(data, null, 2);
+            await promises_1.default.writeFile(filePath, jsonContent);
+            Log_1.Log.info(`Successfully wrote data to ${filePath}`);
+            return true;
+        }
+        catch (error) {
+            const cleanFilename = filename.replace(/\.json$/i, '') || 'unknown';
+            if (sendErrorToErrorChannel) {
+                await Bot_1.Bot.log.sendError(EmbedManager_1.EmbedManager.error(`Failed to write file ${directoryPath}/${cleanFilename}.json: ${error}`));
+            }
+            else {
+                Log_1.Log.error(`Failed to write file ${directoryPath}/${cleanFilename}.json: ${error}`);
+            }
+            return false;
+        }
+    }
+}
+exports.FileManager = FileManager;

package/dist/manager/direct/UserManager.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserManager = void 0;
+const Bot_1 = require("../../bot/Bot");
+const Log_1 = require("../../utils/Log");
+class UserManager {
+    /**
+     * Find a member
+     */
+    static async find(userId) {
+        try {
+            return await Bot_1.Bot.client.users.fetch(userId);
+        }
+        catch (error) {
+            Log_1.Log.error(`UserManager: Member ${userId} not found`);
+            return null;
+        }
+    }
+    /**
+     * Find member in specific guild
+     */
+    static async findInGuild(guildId, memberId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                throw new Error(`Guild ${guildId} not found`);
+            const member = await guild.members.fetch({ user: memberId, force: true });
+            return member ?? null;
+        }
+        catch (error) {
+            Log_1.Log.error(`UserManager: Member ${memberId} not found in ${guildId}`);
+            return null;
+        }
+    }
+    /**
+     * Check if user is still in guild
+     */
+    static async isInGuild(guildId, userId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                return false;
+            await guild.members.fetch({ user: userId, force: true });
+            return true;
+        }
+        catch (error) {
+            return error.code !== 10007; // Unknown Member
+        }
+    }
+    /**
+     * Impl
+     */
+    static async send(user_id_or_user, content_or_options) {
+        try {
+            let user;
+            if (typeof user_id_or_user === 'string') {
+                user = await Bot_1.Bot.client.users.fetch(user_id_or_user);
+            }
+            else {
+                user = user_id_or_user;
+            }
+            const dmChannel = await user.createDM();
+            const payload = typeof content_or_options === 'string'
+                ? { content: content_or_options }
+                : content_or_options;
+            const message = await dmChannel.send(payload);
+            Log_1.Log.info(`Sent DM to ${user.id} (${user.username}): "${(payload.content || 'Embed').substring(0, 50)}..."`);
+            return message;
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to send DM to ${user_id_or_user}: ${error}`);
+            throw new Error(`Cannot send DM to ${user_id_or_user}`);
+        }
+    }
+}
+exports.UserManager = UserManager;

package/dist/manager/discord/ChannelManager.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelManager = void 0;
+const Bot_1 = require("../../bot/Bot");
+const Log_1 = require("../../utils/Log");
+class ChannelManager {
+    /**
+     * Search text-based channel by ID (cache or fetch)
+     */
+    static async find(channelId) {
+        try {
+            const channel = Bot_1.Bot.client.channels.cache.get(channelId) || await Bot_1.Bot.client.channels.fetch(channelId);
+            return channel?.isTextBased() ? channel : null;
+        }
+        catch (error) {
+            Log_1.Log.error(`ChannelManager: Failed to fetch ${channelId}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Find channel in specific guild
+     */
+    static async findInGuild(guildId, channelId) {
+        try {
+            const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+            if (!guild)
+                return null;
+            const channel = guild.channels.cache.get(channelId);
+            return channel?.isTextBased() ? channel : null;
+        }
+        catch (error) {
+            Log_1.Log.error(`ChannelManager: Failed guild channel ${guildId}/${channelId}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Get all text channels in guild
+     */
+    static getTextChannelsInGuild(guildId) {
+        const guild = Bot_1.Bot.client.guilds.cache.get(guildId);
+        if (!guild)
+            return [];
+        return guild.channels.cache
+            .filter(channel => channel.isTextBased() && channel.type !== 11) // Exclude threads
+            .map(channel => channel);
+    }
+}
+exports.ChannelManager = ChannelManager;

package/dist/manager/discord/DiscordRegex.js

@@ -0,0 +1,114 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscordRegex = void 0;
+/**
+ * Classe utilitaire pour valider tous les formats Discord avec regex
+ */
+class DiscordRegex {
+    /**
+     * Validate Discord ID Discord (18)
+     */
+    static isDiscordId(id) {
+        return this.DISCORD_ID.test(id);
+    }
+    /**
+     * Validate a bot ID (19)
+     */
+    static isBotMention(mention) {
+        return this.BOT_REGEX.test(mention);
+    }
+    /**
+     * Validate a User ping
+     */
+    static isUserMention(mention) {
+        return this.USER_REGEX.test(mention);
+    }
+    /**
+     * Validate a Discord username
+     */
+    static isUsername(username) {
+        return this.USERNAME.test(username);
+    }
+    /**
+     * Type guard for Discord ID
+     */
+    static isDiscordIdType(id) {
+        return this.isDiscordId(id);
+    }
+    /**
+     * Any Discord URL
+     */
+    static isDiscordUrl(url) {
+        return this.URL_REGEX.test(url) || this.INVITE.test(url);
+    }
+    /**
+     * Any discord mention
+     */
+    static isAnyMention(text) {
+        return this.DISCORD_MENTION_REGEX.test(text);
+    }
+    /**
+     * List all regex
+     */
+    static listAll() {
+        return {
+            SPACE: this.SPACE,
+            URL_REGEX: this.URL_REGEX,
+            USER_REGEX: this.USER_REGEX,
+            BOT_REGEX: this.BOT_REGEX,
+            CHANNEL_REGEX: this.CHANNEL_REGEX,
+            ROLE_REGEX: this.ROLE_REGEX,
+            DISCORD_PING_REGEX: this.DISCORD_PING_REGEX,
+            DISCORD_MENTION_REGEX: this.DISCORD_MENTION_REGEX,
+            DISCORD_ID: this.DISCORD_ID,
+            USERNAME: this.USERNAME,
+            USERNAME_DISCRIM: this.USERNAME_DISCRIM,
+            CHANNEL_MENTION: this.CHANNEL_MENTION,
+            USER_MENTION: this.USER_MENTION,
+            ROLE_MENTION: this.ROLE_MENTION,
+            INVITE: this.INVITE,
+            EMOJI: this.EMOJI
+        };
+    }
+}
+exports.DiscordRegex = DiscordRegex;
+_a = DiscordRegex;
+// Caractères spéciaux
+DiscordRegex.SPACE = "\u200B";
+// URLs basiques
+DiscordRegex.URL_REGEX = /(https?:\/\/[^s]+)/;
+/* DISCORD REGEX */
+DiscordRegex.USER_REGEX = /<@\d{18}>/;
+DiscordRegex.BOT_REGEX = /<@\d{19}>/;
+DiscordRegex.CHANNEL_REGEX = /(<#\d{19}>)|(<id:(browse|customize|guide)>)/;
+DiscordRegex.ROLE_REGEX = /<@&\d{19}>/;
+/**
+ * Mention a User
+ * Mention a Role
+ */
+DiscordRegex.DISCORD_PING_REGEX = new RegExp(`(${_a.USER_REGEX.source})|(${_a.BOT_REGEX.source})|(${_a.ROLE_REGEX.source})`);
+/**
+ * Mention a User
+ * Mention a Role
+ * Mention a Channel
+ */
+DiscordRegex.DISCORD_MENTION_REGEX = new RegExp(`(${_a.DISCORD_PING_REGEX.source})|(${_a.CHANNEL_REGEX.source})`);
+// ID Discord (18 chiffres exactement)
+DiscordRegex.DISCORD_ID = /^[0-9]{18}$/;
+// ID utilisateur/guild/channel (18 chiffres)
+DiscordRegex.SNOWFLAKE = /^[0-9]{18}$/;
+// Username Discord (2-32 caractères alphanumériques + _ .)
+DiscordRegex.USERNAME = /^[a-zA-Z0-9_]{2,32}$/;
+// Username + discrim (ancien format)
+DiscordRegex.USERNAME_DISCRIM = /^[a-zA-Z0-9_]{2,32}#\d{4}$/;
+// Channel mention <#123456789012345678>
+DiscordRegex.CHANNEL_MENTION = /^<#([0-9]{18})>$/;
+// User mention <@123456789012345678> ou <@!123456789012345678>
+DiscordRegex.USER_MENTION = /^<@!?([0-9]{18})>$/;
+// Role mention <@&123456789012345678>
+DiscordRegex.ROLE_MENTION = /^<@&([0-9]{18})>$/;
+// URL Invite Discord
+DiscordRegex.INVITE = /^discord(?:app\.com\/invite|gg)\/[a-zA-Z0-9]+$/;
+// Emoji Discord (custom or unicode)
+DiscordRegex.EMOJI = /^<a?:[a-zA-Z0-9_]{2,32}:[0-9]{18}>$|^[\u{1F300}-\u{1F5FF}\u{1F600}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{2600}-\u{26FF}\u{2700}-\u{27BF}]+$/u;

package/dist/manager/discord/GuildManager.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildManager = void 0;
+const Log_1 = require("../../utils/Log");
+const UnitTime_1 = require("../../utils/times/UnitTime");
+const ChannelManager_1 = require("./ChannelManager");
+const UserManager_1 = require("./UserManager");
+class GuildManager {
+    /**
+     * Search channel by ID (TextChannel, DMChannel, ThreadChannel)
+     */
+    static async searchChannel(guildId, channelId) {
+        try {
+            return await ChannelManager_1.ChannelManager.findInGuild(guildId, channelId);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to fetch channel ${channelId}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Search guild member by ID
+     */
+    static async searchMember(memberId, guildId) {
+        try {
+            return await UserManager_1.UserManager.findInGuild(guildId, guildId);
+        }
+        catch (error) {
+            Log_1.Log.error(`Failed to fetch member ${memberId} in guild ${guildId}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Check if member is still in guild
+     */
+    static async isMemberInGuild(memberId, guildId) {
+        try {
+            return await UserManager_1.UserManager.isInGuild(memberId, guildId);
+        }
+        catch (error) {
+            return error.code !== 10007; // Unknown Member
+        }
+    }
+    /**
+     * Fetch all members with retry logic
+     */
+    static async fetchAllMembers(guild) {
+        const MAX_ATTEMPTS = 3;
+        const RETRY_DELAY = UnitTime_1.Time.minute.MIN_05.toMilliseconds();
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+            try {
+                Log_1.Log.info(`Fetching members for ${guild.name} (attempt ${attempt})`);
+                const members = await guild.members.fetch();
+                Log_1.Log.info(`${guild.name}: ${members.size} members fetched`);
+                return members;
+            }
+            catch (error) {
+                Log_1.Log.error(`Guild ${guild.name} fetch failed (attempt ${attempt}): ${error}`);
+                if (attempt < MAX_ATTEMPTS) {
+                    await new Promise(r => setTimeout(r, RETRY_DELAY));
+                }
+            }
+        }
+        throw new Error(`Failed to fetch members for ${guild.id} after ${MAX_ATTEMPTS} attempts`);
+    }
+}
+exports.GuildManager = GuildManager;