@futdevpro/nts-dynamo 1.10.76 → 1.11.1

package/src/_modules/discord-assistant/_services/dias.service-base.ts

@@ -0,0 +1,81 @@
+
+import { Client, Guild, Message, TextChannel } from 'discord.js';
+
+import { DyNTS_DiBo_Main_ControlService } from '../../discord-bot/_services/dibo-main.control-service';
+import { DyNTS_OAI_LLMChat_ServiceBase } from '../../open-ai/_services/oai-llm-chat.service-base';
+import { DyNTS_DiAs_global_settings } from '../_collections/dias-global-settings.const';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_OAI_GPT_Message } from '../../open-ai/_models/interfaces/oai-gpt-message.interface';
+import { DyNTS_OAI_GPT_Message_Role } from '../../open-ai/_enums/oai-gpt-message-role.enum';
+
+
+export abstract class DyNTS_DiAs_ServiceBase extends DyNTS_DiBo_Main_ControlService {
+
+  getLLMChatControlService(): DyNTS_OAI_LLMChat_ServiceBase {
+    return new DyNTS_OAI_LLMChat_ServiceBase();
+  }
+  readonly llmChat_CS: DyNTS_OAI_LLMChat_ServiceBase = this.getLLMChatControlService();
+
+  defaultSystemPrompt: string = DyNTS_DiAs_global_settings.defaultSystemPrompt;
+
+  protected constructor() {
+    super();
+
+    DyNTS_global_settings.dias_settings ??= DyNTS_DiAs_global_settings;
+
+    this.llmChat_CS.defaultSettings.systemPrompt = this.defaultSystemPrompt;
+  }
+
+  async gatherMessages(message: Message, limit: number = 100): Promise<Message[]> {
+    const channel = message.channel;
+    const userId = message.author.id;
+
+    const messages: Message[] = await channel.messages.fetch({ limit: limit }).then(
+      messages => messages.filter(
+        msg => !DyNTS_DiAs_global_settings.skipConversationMessagesFlags.some(
+          flag => msg.content.includes(flag)
+        )
+      ).map(msg => msg) // this last part creates simple array from Discord Collection
+    );
+
+    if (messages.some(msg => ![ this.botClientId, userId ].includes(msg.author.id))) {
+      messages.forEach(msg => {
+        msg.content = `**${msg.author.displayName}**: ${msg.content}`;
+      });
+    }
+
+    return messages;
+  }
+
+  async convertDiscordMessagesToOAIConversation(
+    messages: Message[]
+  ): Promise<DyNTS_OAI_GPT_Message[]> {
+    return messages.map(message => {
+      if (
+        (message?.author &&
+          (message.author.bot || 
+            message.author.id === this.botClientId ||
+            message.author.displayName === this.botDisplayName))
+      ) {
+        if (DyNTS_DiAs_global_settings.userTranslationFlags.some(
+          flag => message.content.includes(flag)
+        )) {
+          return {
+            role: DyNTS_OAI_GPT_Message_Role.user,
+            content: message.content,
+          };
+        } else {
+          return {
+            role: DyNTS_OAI_GPT_Message_Role.assistant,
+            content: message.content,
+          };
+        }
+      } else {
+        return {
+          role: DyNTS_OAI_GPT_Message_Role.user,
+          content: message.content,
+        };
+      }
+    })
+  }
+}

package/src/_modules/discord-assistant/index.ts

@@ -0,0 +1,36 @@
+
+
+
+
+//
+// Discord Assistant module (AI-based)
+//
+// This module is created to simplify the usage of Discord Assistant
+// It creates universal solutions for the most common use cases
+//
+
+
+// DEPENDENCIES
+export * from '../discord-bot';
+export * from '../open-ai';
+
+
+// COLLECTIONS
+export * from './_collections/dias-global-settings.const';
+
+// MODELS
+export * from './_models/dias-global-settings.interface';
+export * from './_models/dias-knowledge.data-model';
+
+// SERVICES
+export * from './_services/dias-chunk.data-service';
+export * from './_services/dias-io.control-service';
+export * from './_services/dias-main.control-service';
+export * from './_services/dias.service-base';
+
+
+
+
+
+
+

package/src/_modules/discord-assistant-voiced/_services/dias-discord-bot.control-service.ts

@@ -0,0 +1,11 @@
+import { Client, GatewayIntentBits, Guild, Collection, GuildMember, Message, Partials } from 'discord.js'
+import * as dotenv from 'dotenv'
+import { DyNTS_SingletonService } from '../../../_services/base/singleton.service';
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+import { DyNTS_global_settings } from '../../../_collections/global-settings.const';
+import { DyNTS_DiAs_Main_ControlService } from '../../discord-assistant/_services/dias-main.control-service';
+
+
+export abstract class DyNTS_DiAV_Main_ControlService extends DyNTS_DiAs_Main_ControlService {
+
+}

package/src/_modules/discord-assistant-voiced/index.ts

@@ -0,0 +1,36 @@
+try {
+  require('@discordjs/opus');
+} catch (error) {
+  console.log(
+    '❌ @discordjs/opus package not found, please install it with: pnpm add @discordjs/opus'
+  );
+}
+
+try {
+  require('@discordjs/voice');
+} catch (error) {
+  console.log(
+    '❌ @discordjs/voice package not found, please install it with: pnpm add @discordjs/voice'
+  );
+}
+
+
+//
+// Discord Assistant Voiced module
+//
+// This module is created to simplify the usage of Discord Assistant Voiced
+// It creates universal solutions for the most common use cases
+//
+
+// DEPENDENCIES
+export * from '../discord-assistant';
+
+
+// SERVICES
+export * from './_services/dias-discord-bot.control-service';
+
+
+
+
+
+

package/src/_modules/discord-bot/_collections/dibo-default-commands.const.ts

@@ -0,0 +1,17 @@
+import { Message } from 'discord.js';
+import { DyNTS_DiBo_Command } from '../_models/dibo-command.interface';
+
+
+
+
+
+
+export const DyNTS_DiBo_defaultCommands: DyNTS_DiBo_Command[] = [
+  {
+    command: '!ping',
+    description: 'Ping the bot',
+    commandHandler: async (message: Message) => {
+      await message.reply('Pong!');
+    },
+  },
+]

package/src/_modules/discord-bot/_collections/dibo-global-settings.conts.ts

@@ -0,0 +1,56 @@
+import { GatewayIntentBits, Partials } from 'discord.js';
+import { DyNTS_DiBo_Global_Settings } from '../_models/global-bot-log-settings.interface';
+import { minute, week } from '@futdevpro/fsm-dynamo';
+import { DyNTS_DiBo_defaultCommands } from './dibo-default-commands.const';
+
+
+
+
+export const DyNTS_DiBo_global_settings: DyNTS_DiBo_Global_Settings = {
+  debugLevel: 3,
+
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMembers,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.MessageContent,
+    GatewayIntentBits.DirectMessages,
+    GatewayIntentBits.GuildVoiceStates,
+  ],
+  
+  partials: [
+    Partials.Channel,
+  ],
+
+  allowedUsers: 'all',
+
+  messageSettings: {
+    messageFetchTimeLimit: 3 * week,
+    messageFetchCountLimit: 1000,
+    messageSendDelay: minute / 3,
+
+    skipFlags: [
+      '[BOT-SKIP]',
+      '[SYSTEM|REFUSE|BOT]',
+    ],
+  },
+
+  channelSettings: {
+    reportChannelName: 'bot-report',
+
+    defaultChannels: [
+      'bot-help',
+    ],
+
+    allowedChannels: [],
+    dmIsAllowed: false,
+  },
+
+  commandSettings: {
+    commandOperator: '',
+
+    commands: DyNTS_DiBo_defaultCommands,
+  },
+
+  allowBotsInteractEachOther: false,
+}

package/src/_modules/discord-bot/_collections/dibo-operations.util.ts

@@ -0,0 +1,372 @@
+import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import { 
+  Client, Guild, GuildChannelManager, GuildBasedChannel, Message, TextBasedChannel, GuildMember, 
+  TextChannel,
+  VoiceChannel
+} from 'discord.js';
+import { Collection } from 'discord.js';
+import { DyNTS_DiBo_global_settings } from './dibo-global-settings.conts';
+import { DyNTS_DiBo_LastMessageDate } from '../_models/dibo-last-message-date.interface';
+import { DyNTS_DiBo_LastMentionDate } from '../_models/dibo-last-mention-date.inteface';
+
+export class DyNTS_DiBo_Operations_Util {
+
+  static findChannelByName(channels: GuildChannelManager, name: string): GuildBasedChannel {
+    const channel = channels.cache.find(
+      (ch) => ch.name === name && ch.isTextBased()
+    )
+
+    if (!channel) {
+      DyFM_Log.error('No text channel found')
+      return
+    }
+
+    return channel
+  }
+
+  static findTextChannelByName(channels: GuildChannelManager, name: string): TextChannel {
+    const channel = this.findChannelByName(channels, name)
+    
+    if (!channel.isTextBased()) {
+      throw new Error('Channel is not text based')
+    }
+
+    return channel as TextChannel
+  }
+
+  static findVoiceChannelByName(channels: GuildChannelManager, name: string): VoiceChannel {
+    const channel = this.findChannelByName(channels, name)
+    
+    if (!channel.isVoiceBased()) {
+      throw new Error('Channel is not voice based')
+    }
+
+    return channel as VoiceChannel
+  }
+
+  static async reportIn(guild: Guild, client: Client): Promise<void> {
+    try {
+      const lastReportMessage = await this.getLastMessageInChannel(
+        guild,
+        DyNTS_DiBo_global_settings.channelSettings.reportChannelName
+      )
+      const reportMessage = `${client.user?.username} report for duty!`
+
+      if (lastReportMessage.content === reportMessage) {
+        await this.deleteMessage(lastReportMessage).catch((error) => {
+          DyFM_Log.error('Failed to delete message', error);
+        });
+      }
+
+      this.sendMessageToChannelByName(
+        guild, 
+        DyNTS_DiBo_global_settings.channelSettings.reportChannelName, 
+        reportMessage
+      )
+    } catch (error) {
+      DyFM_Log.error('Failed to report in', error);
+    }
+  }
+
+  static sendMessageToChannelByName(guild: Guild, channelName: string, message: string) {
+    const channel = this.findChannelByName(guild.channels, channelName)
+
+    if (channel?.isTextBased()) {
+      channel.send(message)
+      DyFM_Log.success('Message sent to channel', channel.name)
+    } else {
+      DyFM_Log.error('Channel is not text based')
+    }
+  }
+
+  static async readMembersInChannel(
+    guild: Guild, 
+    channelName: string
+  ): Promise<Collection<string, GuildMember>> {
+    const channel = this.findChannelByName(guild.channels, channelName)
+        
+    const members = await guild?.members.fetch()
+
+    const allowedMembers = members?.filter((member) =>
+      channel.permissionsFor(member)?.has('ViewChannel')
+    )
+
+    return allowedMembers
+  }
+
+  static async readMemberNamesInChannel(guild: Guild, channelName: string): Promise<string[]> {
+    const members = await this.readMembersInChannel(guild, channelName)
+
+    const memberNames = members?.map((member) => member.user.username)
+
+    return memberNames
+  }
+
+  static async fetchAllMessagesWithPaging(
+    channel: TextBasedChannel,
+    maxFetch = 1000
+  ): Promise<Collection<string, Message<true>>> {
+    let lastId: string | undefined = undefined;
+    let fetched = 0;
+    const allMessages = new Collection<string, Message<true>>();
+
+    while (fetched < maxFetch) {
+      const options: any = { limit: 100 };
+      if (lastId) options.before = lastId;
+
+      const messages = await channel.messages.fetch(options) as unknown as Collection<string, Message<true>>;
+      if (messages.size === 0) break;
+
+      messages.forEach((msg: Message<true>) => {
+        allMessages.set(msg.id, msg);
+      });
+
+      lastId = messages.last()?.id;
+      fetched += messages.size;
+    }
+
+    DyFM_Log.success('Fetched messages with paging', allMessages.size);
+    return allMessages;
+  }
+
+  static async readLastMessageDatesByMembers(
+    guild: Guild, 
+    channelName: string,
+    memberNames: string[]
+  ): Promise<DyNTS_DiBo_LastMessageDate[]> {
+    const channel = this.findChannelByName(guild.channels, channelName)
+
+    if (!channel?.isTextBased()) {
+      DyFM_Log.error('Channel is not text based')
+      return
+    }
+
+    // Prepare tracking for each member
+    const memberStatus: Record<string, { lastMessageDate: Date | null, allMessages: number }> = {};
+    memberNames.forEach(name => {
+      memberStatus[name] = { lastMessageDate: null, allMessages: 0 };
+    });
+
+    let lastId: string | undefined = undefined;
+    let done = false;
+    const cutoffTime = Date.now() - DyNTS_DiBo_global_settings.messageSettings.messageFetchTimeLimit;
+    let totalFetched = 0;
+
+    while (
+      !done && 
+      totalFetched < DyNTS_DiBo_global_settings.messageSettings.messageFetchCountLimit
+    ) {
+      const options: any = { limit: 100 };
+      if (lastId) options.before = lastId;
+      const messages = await channel.messages.fetch(options) as unknown as Collection<string, Message<true>>;
+      if (messages.size === 0) break;
+
+      let shouldStop = false;
+      messages.forEach((message) => {
+        // Check if message is too old
+        if (message.createdTimestamp < cutoffTime) {
+          shouldStop = true;
+
+          return;
+        }
+
+        const author = message.author.username;
+        if (memberStatus[author] !== undefined) {
+          memberStatus[author].allMessages++;
+
+          // Only set lastMessageDate if not already set (since we fetch newest first)
+          if (!memberStatus[author].lastMessageDate) {
+            memberStatus[author].lastMessageDate = message.createdAt;
+          }
+        }
+      });
+
+      if (shouldStop) {
+        DyFM_Log.warn('Reached time limit cutoff');
+        break;
+      }
+
+      // Check if all members have a lastMessageDate
+      done = memberNames.every(name => memberStatus[name].lastMessageDate !== null);
+      lastId = messages.last()?.id;
+      totalFetched += messages.size;
+    }
+
+    if (totalFetched >= DyNTS_DiBo_global_settings.messageSettings.messageFetchCountLimit) {
+      DyFM_Log.warn(
+        'Reached maximum fetch count limit', 
+        DyNTS_DiBo_global_settings.messageSettings.messageFetchCountLimit
+      );
+    }
+
+    const lastMessageDatesByMembers: DyNTS_DiBo_LastMessageDate[] = memberNames.map((memberName) => {
+      const status = memberStatus[memberName];
+      if (!status.lastMessageDate) {
+        DyFM_Log.warn('No last message date found for member', memberName);
+
+        return {
+          memberName: memberName,
+          allMessages: status.allMessages,
+          lastMessageDate: null/* new Date(0) */
+        }
+      }
+
+      return ({ 
+        memberName: memberName, 
+        allMessages: status.allMessages,
+        lastMessageDate: new Date(status.lastMessageDate)
+      })
+    });
+
+    return lastMessageDatesByMembers;
+  }
+
+  static async readLastMessageWithMemberNamePingInIt(
+    guild: Guild,
+    channelName: string,
+    members: Collection<string, GuildMember>
+  ): Promise<DyNTS_DiBo_LastMentionDate[]> {
+    const channel = this.findChannelByName(guild.channels, channelName)
+
+    if (!channel?.isTextBased()) {
+      DyFM_Log.error('Channel is not text based')
+      return []
+    }
+
+    // Prepare tracking for each member
+    const memberStatus: Record<string, { lastMentionDate: Date | null, allMentions: number }> = {};
+    members.forEach(member => {
+      memberStatus[member.user.username] = { lastMentionDate: null, allMentions: 0 };
+    });
+
+    let lastId: string | undefined = undefined;
+    let done = false;
+    const cutoffTime = Date.now() - DyNTS_DiBo_global_settings.messageSettings.messageFetchTimeLimit;
+    let totalFetched = 0;
+
+    while (
+      !done && 
+      totalFetched < DyNTS_DiBo_global_settings.messageSettings.messageFetchCountLimit
+    ) {
+      const options: any = { limit: 100 };
+      if (lastId) options.before = lastId;
+      const messages = await channel.messages.fetch(options) as unknown as Collection<string, Message<true>>;
+      if (messages.size === 0) break;
+
+      let shouldStop = false;
+      messages.forEach((message) => {
+        // Check if message is too old
+        if (message.createdTimestamp < cutoffTime) {
+          shouldStop = true;
+          return;
+        }
+
+        // Check if message content contains "@Username" for any member
+        members.forEach(member => {
+          if (
+            message.content.includes(`@${member.user.id}`) && 
+            !memberStatus[member.user.username].lastMentionDate
+          ) {
+            memberStatus[member.user.username].lastMentionDate = message.createdAt;
+            memberStatus[member.user.username].allMentions++;
+            DyFM_Log.success(
+              'Found message with member ping', 
+              { 
+                memberName: member.user.username, 
+                messageId: message.id 
+              }
+            );
+          }
+        });
+      });
+
+      if (shouldStop) {
+        DyFM_Log.warn('Reached time limit cutoff while searching for member pings');
+        break;
+      }
+
+      // Check if all members have a lastMessageDate
+      done = members.every(member => memberStatus[member.user.username].lastMentionDate !== null);
+      lastId = messages.last()?.id;
+      totalFetched += messages.size;
+    }
+
+    if (totalFetched >= DyNTS_DiBo_global_settings.messageSettings.messageFetchCountLimit) {
+      DyFM_Log.warn(
+        'Reached maximum fetch count limit while searching for member pings', 
+        DyNTS_DiBo_global_settings.messageSettings.messageFetchCountLimit
+      );
+    }
+
+    const lastMentionDatesByMembers: DyNTS_DiBo_LastMentionDate[] = members.map((member) => {
+      const status = memberStatus[member.user.username];
+      if (!status.lastMentionDate) {
+        DyFM_Log.warn('No message found with member ping', member.user.username);
+        return {
+          memberId: member.user.id,
+          memberName: member.user.username,
+          allMentions: status.allMentions,
+          lastMentionDate: null/* new Date(0) */
+        }
+      }
+      return ({ 
+        memberId: member.user.id,
+        memberName: member.user.username, 
+        allMentions: status.allMentions,
+        lastMentionDate: new Date(status.lastMentionDate)
+      })
+    });
+
+    return lastMentionDatesByMembers;
+  }
+  static readMentionsInChannel = this.readLastMessageWithMemberNamePingInIt
+
+  static async readLastMessagesInChannel(
+    guild: Guild,
+    channelName: string,
+  ): Promise<Collection<string, Message<true>>> {
+    const channel = this.findChannelByName(guild.channels, channelName)
+
+    if (!channel?.isTextBased()) {
+      DyFM_Log.error('Channel is not text based')
+      return
+    }
+
+    const messages = await channel.messages.fetch({ limit: 100 })
+
+    return messages
+  }
+  
+  static async getLastMessageInChannel(
+    guild: Guild,
+    channelName: string
+  ): Promise<Message<true>> {
+    const channel = this.findChannelByName(guild.channels, channelName)
+
+    if (!channel?.isTextBased()) {
+      DyFM_Log.error('Channel is not text based')
+      return
+    }
+    
+    const messages = await channel.messages.fetch({ limit: 1 })
+
+    return messages.first()
+  }
+
+  static getMemberIdByName(
+    members: Collection<string, GuildMember>, 
+    username: string
+  ): string | undefined {
+    const member = members.find(m => m.user.username === username);
+    return member ? member.user.id : undefined;
+  }
+
+  static async deleteMessage(message: Message): Promise<void> {
+    await message.delete().catch((error) => {
+      DyFM_Log.error('Failed to delete message', error);
+    });
+
+    DyFM_Log.success('Message deleted', message.id);
+  }
+}

package/src/_modules/discord-bot/_models/dibo-command.interface.ts

@@ -0,0 +1,12 @@
+import { Message } from 'discord.js';
+
+
+
+
+export interface DyNTS_DiBo_Command {
+  command: string;
+  description: string;
+  commandHandler: (message: Message) => Promise<void>;
+  permissionNeeded?: (message: Message) => Promise<boolean>;
+}
+

package/src/_modules/discord-bot/_models/dibo-last-mention-date.inteface.ts

@@ -0,0 +1,8 @@
+
+
+export interface DyNTS_DiBo_LastMentionDate {
+  memberId: string
+  memberName: string
+  allMentions: number
+  lastMentionDate: Date
+}

package/src/_modules/discord-bot/_models/dibo-last-message-date.interface.ts

@@ -0,0 +1,6 @@
+
+export interface DyNTS_DiBo_LastMessageDate {
+  memberName: string
+  allMessages: number
+  lastMessageDate: Date
+}