@futdevpro/nts-dynamo 1.14.28 → 1.14.31

package/src/_modules/bot/_models/bot-channel.interface.ts

@@ -1,7 +0,0 @@
-export interface DyNTS_Bot_Channel<T_MessagingPlatformChannel = any> {
-  id: string;
-  name: string;
-  isTextBased: boolean;
-  isDM: boolean;
-  rawPlatformChannel: T_MessagingPlatformChannel;
-}

package/src/_modules/bot/_models/bot-message.interface.ts

@@ -1,14 +0,0 @@
-export interface DyNTS_Bot_Message<T_MessagingPlatformMessage = any> {
-  id: string;
-  content: string;
-  authorId: string;
-  authorName: string;
-  authorDisplayName: string;
-  channelId: string;
-  channelName: string;
-  timestamp: number;
-  isBot: boolean;
-  replyToMessageId?: string;
-  mentions: string[]; // user IDs
-  rawPlatformMessage: T_MessagingPlatformMessage; // Original platform message for platform-specific operations
-}

package/src/_modules/bot/_models/bot-messaging-provider.interface.ts

@@ -1,88 +0,0 @@
-import { DyNTS_Bot_Message } from './bot-message.interface';
-import { DyNTS_Bot_Channel } from './bot-channel.interface';
-import { DyNTS_Bot_User } from './bot-user.interface';
-import { DyNTS_Bot_LastMessageDate } from './bot-last-message-date.interface';
-import { DyNTS_Bot_LastMentionDate } from './bot-last-mention-date.interface';
-import { DyNTS_Bot_MessagingProvider_Type } from '../_enums/bot-message-provider.enum';
-import { DyNTS_Bot_Global_Settings } from './bot-global-settings.interface';
-
-export interface DyNTS_Bot_MessagingProvider_Config extends DyNTS_Bot_Global_Settings {
-  /** Unique identifier for this provider instance (required when using multiple providers) */
-  providerId?: string;
-  messageProvider: DyNTS_Bot_MessagingProvider_Type;
-  messageProviderInstance?: DyNTS_Bot_MessagingProvider;
-  discord?: {
-    token: string;
-    guildId: string;
-    clientId: string;
-    oauth2Url: string;
-  };
-  slack?: {
-    token: string;
-    workspace: string;
-  };
-  teams?: {
-    appId: string;
-    appPassword: string;
-    tenantId: string;
-  };
-  dynamo?: {
-    defaultConversationId?: string; // Optional default conversation
-    botUserId?: string; // Bot user ID in messaging system
-    botDisplayName?: string; // Bot display name
-  };
-}
-
-export interface DyNTS_Bot_MessagingProvider<
-  T_MessagingPlatformChannel extends DyNTS_Bot_Channel<any> = DyNTS_Bot_Channel<any>,
-  T_MessagingPlatformMessage extends DyNTS_Bot_Message<any> = DyNTS_Bot_Message<any>,
-  T_MessagingPlatformUser extends DyNTS_Bot_User<any> = DyNTS_Bot_User<any>
-> {
-  // Initialization
-  initialize(config: DyNTS_Bot_MessagingProvider_Config): Promise<void>;
-  login(token: string): Promise<void>;
-  
-  // Channel operations
-  getChannelByName(name: string): Promise<T_MessagingPlatformChannel>;
-  sendMessageToChannelByName(channelName: string, message: string): Promise<T_MessagingPlatformMessage>;
-  getMessagesFromChannelByChannelName(channelName: string, limit?: number): Promise<T_MessagingPlatformMessage[]>;
-  getLastMessageInChannel(channelName: string): Promise<T_MessagingPlatformMessage>;
-  clearChannel(channelId: string): Promise<void>;
-  
-  // Message operations
-  sendMessage(channelId: string, content: string): Promise<T_MessagingPlatformMessage>;
-  replyToMessage(messageId: string, channelId: string, content: string): Promise<T_MessagingPlatformMessage>;
-  sendTyping(channelId: string): Promise<void>;
-  fetchMessages(channelId: string, limit: number): Promise<T_MessagingPlatformMessage[]>;
-  fetchAllMessagesWithPaging(channelId: string, maxFetch?: number): Promise<T_MessagingPlatformMessage[]>;
-  deleteMessage(messageId: string, channelId: string): Promise<void>;
-  
-  // User operations
-  getUserByName(username: string): Promise<T_MessagingPlatformUser>;
-  getUserMention(userId: string): string;
-  readMembersInChannel(channelName: string): Promise<T_MessagingPlatformUser[]>;
-  readMemberNamesInChannel(channelName: string): Promise<string[]>;
-  
-  // Advanced message queries
-  getLastMessageSentBy(channelName: string, username: string): Promise<T_MessagingPlatformMessage>;
-  getLastMentionOf(channelName: string, username: string): Promise<T_MessagingPlatformMessage>;
-  readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]>;
-  readLastMessageWithMemberNamePingInIt(channelName: string, users: T_MessagingPlatformUser[]): Promise<DyNTS_Bot_LastMentionDate[]>;
-  
-  // Platform-specific features (optional, may return null/undefined for unsupported platforms)
-  getRoleByName?(roleName: string): any;
-  getRolePingByName?(roleName: string): Promise<string>;
-  getRolePingsByName?(roleNames: string[]): Promise<string>;
-  
-  // Event binding
-  onMessage(handler: (message: T_MessagingPlatformMessage, issuer: string, providerId?: string) => void): void;
-  onReady(handler: () => void): void;
-  onError(handler: (error: Error) => void): void;
-  
-  // Metadata
-  getBotId(): string;
-  getBotDisplayName(): string;
-  getProviderName(): string;
-  getProviderId(): string;
-  isReady(): boolean;
-}

package/src/_modules/bot/_models/bot-user.interface.ts

@@ -1,7 +0,0 @@
-export interface DyNTS_Bot_User<T_PlatformUser = any> {
-  id: string;
-  username: string;
-  displayName: string;
-  isBot: boolean;
-  rawPlatformUser: T_PlatformUser;
-}

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

@@ -1,18 +0,0 @@
-import { DyNTS_Bot_Operations_Util } from '../../../_collections/bot-operations.util';
-import { DyNTS_DiB_Message, DyNTS_DiB_Channel, DyNTS_DiB_User } from '../_models/dib-platform.types';
-import { DyNTS_DiB_MessagingProvider } from '../_services/dib-messaging-provider.service';
-
-/**
- * Discord Bot Operations Utility
- * 
- * Platform-specific implementation of bot operations for Discord
- */
-export class DyNTS_DiB_Operations_Util extends DyNTS_Bot_Operations_Util<
-  DyNTS_DiB_Channel,
-  DyNTS_DiB_Message,
-  DyNTS_DiB_User,
-  DyNTS_DiB_MessagingProvider
-> {
-  // Discord-specific operations can be added here
-  // All base operations are inherited from the generic class
-}

package/src/_modules/bot/_modules/discord-bot/_collections/dib.util.ts

@@ -1,20 +0,0 @@
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
-import { DyNTS_DiB_MessagingProvider } from '../_services/dib-messaging-provider.service';
-import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
-
-export class DyNTS_DiB_Util {
-
-  static async reportIn(provider: DyNTS_DiB_MessagingProvider): Promise<void> {
-    try {
-      const reportMessage = `${provider.getBotDisplayName()} report for duty! ` +
-        `(v${DyNTS_global_settings.systemVersion} ${DyNTS_global_settings.env_settings?.environment})`;
-
-      await provider.sendMessageToChannelByName(
-        DyNTS_global_settings.bot_settings?.channelSettings?.reportChannelName || 'bot-reports', 
-        reportMessage
-      );
-    } catch (error) {
-      DyFM_Error.logSimple('Failed to report in', error);
-    }
-  }
-}

package/src/_modules/bot/_modules/discord-bot/_services/dib-messaging-provider.service.ts

@@ -1,475 +0,0 @@
-import { Client, GatewayIntentBits, Guild, Collection, GuildMember, Message, Partials, Role, TextChannel } from 'discord.js';
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
-import { DyNTS_Bot_MessagingProvider, DyNTS_Bot_MessagingProvider_Config } from '../../../_models/bot-messaging-provider.interface';
-import { DyNTS_Bot_LastMessageDate } from '../../../_models/bot-last-message-date.interface';
-import { DyNTS_Bot_LastMentionDate } from '../../../_models/bot-last-mention-date.interface';
-import { DyNTS_Bot_MessagingProvider_Type } from '../../../_enums/bot-message-provider.enum';
-import { DyNTS_DiB_Message, DyNTS_DiB_Channel, DyNTS_DiB_User } from '../_models/dib-platform.types';
-import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
-
-export class DyNTS_DiB_MessagingProvider implements DyNTS_Bot_MessagingProvider<
-  DyNTS_DiB_Channel,
-  DyNTS_DiB_Message,
-  DyNTS_DiB_User
-> {
-  private client: Client;
-  private guild: Guild;
-  private channelCache: Map<string, TextChannel>;
-  private roleCache: Map<string, Role>;
-  private isInitialized: boolean = false;
-  private config: DyNTS_Bot_MessagingProvider_Config;
-  
-  // Event handlers
-  private messageHandlers: Array<(message: DyNTS_DiB_Message, issuer: string) => void> = [];
-  private readyHandlers: Array<() => void> = [];
-  private errorHandlers: Array<(error: Error) => void> = [];
-
-  constructor() {
-    this.channelCache = new Map();
-    this.roleCache = new Map();
-  }
-
-  // Public accessors for Discord-specific objects (for backward compatibility with CCAP)
-  get discordClient(): Client {
-    return this.client;
-  }
-
-  get discordGuild(): Guild {
-    return this.guild;
-  }
-
-  async initialize(config: DyNTS_Bot_MessagingProvider_Config): Promise<void> {
-    this.config = config;
-    
-    if (config.messageProvider !== DyNTS_Bot_MessagingProvider_Type.discord) {
-      throw new Error(`Invalid provider type: ${config.messageProvider}. Expected 'discord'`);
-    }
-
-    if (!config.discord) {
-      throw new Error('Discord configuration is required');
-    }
-
-    this.client = new Client({
-      intents: [
-        GatewayIntentBits.Guilds,
-        GatewayIntentBits.GuildMembers,
-        GatewayIntentBits.GuildMessages,
-        GatewayIntentBits.MessageContent,
-        GatewayIntentBits.DirectMessages,
-        GatewayIntentBits.GuildVoiceStates,
-      ],
-      partials: [
-        Partials.Channel,
-      ],
-    });
-
-    this.isInitialized = true;
-    DyFM_Log.success('Discord provider initialized');
-  }
-
-  async login(token: string): Promise<void> {
-    if (!this.isInitialized) {
-      throw new Error('Provider not initialized. Call initialize() first.');
-    }
-
-    return new Promise((resolve, reject) => {
-      this.client.on('ready', async () => {
-        if (DyNTS_global_settings.bot_settings?.debugLevel >= 1) {
-          DyFM_Log.success(`Discord bot logged in as ${this.client.user?.tag}`);
-        }
-
-        // Get guild
-        this.guild = this.client.guilds.cache.get(this.config.discord.guildId);
-        if (!this.guild) {
-          reject(new Error(`Discord server not found with ID: ${this.config.discord.guildId}`));
-          return;
-        }
-
-        // Set up event listeners
-        this.setupEventListeners();
-
-        // Trigger ready handlers
-        this.readyHandlers.forEach(handler => handler());
-
-        resolve();
-      });
-
-      this.client.on('error', (error) => {
-        this.errorHandlers.forEach(handler => handler(error));
-        reject(error);
-      });
-
-      this.client.login(token).catch(reject);
-    });
-  }
-
-  private setupEventListeners(): void {
-    this.client.on('messageCreate', (message: Message) => {
-      if (message.author.bot) return; // Ignore bot messages
-      
-      const botMessage = this.translateMessage(message);
-      this.messageHandlers.forEach(handler => handler(botMessage, 'discord-message'));
-    });
-  }
-
-  // Channel operations
-  async getChannelByName(name: string): Promise<DyNTS_DiB_Channel> {
-    if (this.channelCache.has(name)) {
-      return this.translateChannel(this.channelCache.get(name));
-    }
-
-    const channel = this.guild.channels.cache.find(
-      (ch) => ch.name === name && ch.isTextBased()
-    ) as TextChannel;
-
-    if (!channel) {
-      throw new Error(`No text channel found with name "${name}"`);
-    }
-
-    this.channelCache.set(name, channel);
-    return this.translateChannel(channel);
-  }
-
-  async sendMessageToChannelByName(channelName: string, message: string): Promise<DyNTS_DiB_Message> {
-    const channel = await this.getChannelByName(channelName);
-    const discordChannel = this.channelCache.get(channelName);
-    const sentMessage = await discordChannel.send(message);
-    return this.translateMessage(sentMessage);
-  }
-
-  async getMessagesFromChannelByChannelName(channelName: string, limit: number = 100): Promise<DyNTS_DiB_Message[]> {
-    const channel = await this.getChannelByName(channelName);
-    const discordChannel = this.channelCache.get(channelName);
-    const messages = await discordChannel.messages.fetch({ limit });
-    return Array.from(messages.values()).map(msg => this.translateMessage(msg));
-  }
-
-  async getLastMessageInChannel(channelName: string): Promise<DyNTS_DiB_Message> {
-    const channel = await this.getChannelByName(channelName);
-    const discordChannel = this.channelCache.get(channelName);
-    const messages = await discordChannel.messages.fetch({ limit: 1 });
-    const lastMessage = messages.first();
-    return lastMessage ? this.translateMessage(lastMessage) : null;
-  }
-
-  async clearChannel(channelId: string): Promise<void> {
-    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
-    if (!channel) {
-      throw new Error(`Channel not found with ID: ${channelId}`);
-    }
-
-    let lastId: string | undefined = undefined;
-    let fetched = 0;
-    const maxFetch = 1000;
-
-    while (fetched < maxFetch) {
-      const options: { limit: number; before?: string } = { limit: 100 };
-      if (lastId) options.before = lastId;
-
-      const messageCollection: Collection<string, Message> = await channel.messages.fetch(options);
-      if (messageCollection.size === 0) break;
-
-      const deletePromises = Array.from(messageCollection.values()).map(message => 
-        message.delete().catch((error) => {
-          DyFM_Error.logSimple('Failed to delete message', error);
-        })
-      );
-
-      await Promise.all(deletePromises);
-      lastId = Array.from(messageCollection.values()).pop()?.id;
-      fetched += messageCollection.size;
-    }
-  }
-
-  // Message operations
-  async sendMessage(channelId: string, content: string): Promise<DyNTS_DiB_Message> {
-    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
-    if (!channel) {
-      throw new Error(`Channel not found with ID: ${channelId}`);
-    }
-    const message = await channel.send(content);
-    return this.translateMessage(message);
-  }
-
-  async replyToMessage(messageId: string, channelId: string, content: string): Promise<DyNTS_DiB_Message> {
-    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
-    if (!channel) {
-      throw new Error(`Channel not found with ID: ${channelId}`);
-    }
-    const message = await channel.messages.fetch(messageId);
-    const reply = await message.reply(content);
-    return this.translateMessage(reply);
-  }
-
-  async sendTyping(channelId: string): Promise<void> {
-    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
-    if (!channel) {
-      throw new Error(`Channel not found with ID: ${channelId}`);
-    }
-    await channel.sendTyping();
-  }
-
-  async fetchMessages(channelId: string, limit: number): Promise<DyNTS_DiB_Message[]> {
-    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
-    if (!channel) {
-      throw new Error(`Channel not found with ID: ${channelId}`);
-    }
-    const messages = await channel.messages.fetch({ limit });
-    return Array.from(messages.values()).map(msg => this.translateMessage(msg));
-  }
-
-  async fetchAllMessagesWithPaging(channelId: string, maxFetch: number = 1000): Promise<DyNTS_DiB_Message[]> {
-    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
-    if (!channel) {
-      throw new Error(`Channel not found with ID: ${channelId}`);
-    }
-
-    let lastId: string | undefined = undefined;
-    let fetched = 0;
-    const allMessages: DyNTS_DiB_Message[] = [];
-
-    while (fetched < maxFetch) {
-      const options: { limit: number; before?: string } = { limit: 100 };
-      if (lastId) options.before = lastId;
-
-      const messageCollection: Collection<string, Message> = await channel.messages.fetch(options);
-      if (messageCollection.size === 0) break;
-
-      Array.from(messageCollection.values()).forEach((msg: Message) => {
-        allMessages.push(this.translateMessage(msg));
-      });
-
-      lastId = Array.from(messageCollection.values()).pop()?.id;
-      fetched += messageCollection.size;
-    }
-
-    return allMessages;
-  }
-
-  async deleteMessage(messageId: string, channelId: string): Promise<void> {
-    const channel = this.guild.channels.cache.get(channelId) as TextChannel;
-    if (!channel) {
-      throw new Error(`Channel not found with ID: ${channelId}`);
-    }
-    const message = await channel.messages.fetch(messageId);
-    await message.delete();
-  }
-
-  // User operations
-  async getUserByName(username: string): Promise<DyNTS_DiB_User> {
-    const member = this.guild.members.cache.find(m => m.user.username === username);
-    if (!member) {
-      throw new Error(`User not found with username: ${username}`);
-    }
-    return this.translateUser(member);
-  }
-
-  getUserMention(userId: string): string {
-    return `<@${userId}>`;
-  }
-
-  async readMembersInChannel(channelName: string): Promise<DyNTS_DiB_User[]> {
-    const channel = await this.getChannelByName(channelName);
-    const discordChannel = this.channelCache.get(channelName);
-    const members = await this.guild.members.fetch();
-    
-    const allowedMembers = members.filter((member) =>
-      discordChannel.permissionsFor(member)?.has('ViewChannel')
-    );
-
-    return Array.from(allowedMembers.values()).map(member => this.translateUser(member));
-  }
-
-  async readMemberNamesInChannel(channelName: string): Promise<string[]> {
-    const members = await this.readMembersInChannel(channelName);
-    return members.map(member => member.username);
-  }
-
-  // Advanced message queries
-  async getLastMessageSentBy(channelName: string, username: string): Promise<DyNTS_DiB_Message> {
-    const messages = await this.fetchAllMessagesWithPaging(
-      (await this.getChannelByName(channelName)).id,
-      1000
-    );
-    
-    return messages.find(msg => msg.authorName === username) || null;
-  }
-
-  async getLastMentionOf(channelName: string, username: string): Promise<DyNTS_DiB_Message> {
-    const messages = await this.fetchAllMessagesWithPaging(
-      (await this.getChannelByName(channelName)).id,
-      1000
-    );
-    
-    return messages.find(msg => 
-      msg.content.includes(`@${username}`) || 
-      msg.content.includes(`<@${username}>`)
-    ) || null;
-  }
-
-  async readLastMessageDatesByMembers(channelName: string, memberNames: string[]): Promise<DyNTS_Bot_LastMessageDate[]> {
-    const channel = await this.getChannelByName(channelName);
-    const messages = await this.fetchAllMessagesWithPaging(channel.id, 1000);
-    
-    const memberStatus: Record<string, { lastMessageDate: Date | null, allMessages: number }> = {};
-    memberNames.forEach(name => {
-      memberStatus[name] = { lastMessageDate: null, allMessages: 0 };
-    });
-
-    const cutoffTime = Date.now() - (3 * 7 * 24 * 60 * 60 * 1000); // 3 weeks
-
-    messages.forEach((message) => {
-      if (message.timestamp < cutoffTime) return;
-
-      const author = message.authorName;
-      if (memberStatus[author] !== undefined) {
-        memberStatus[author].allMessages++;
-        if (!memberStatus[author].lastMessageDate) {
-          memberStatus[author].lastMessageDate = new Date(message.timestamp);
-        }
-      }
-    });
-
-    return memberNames.map((memberName) => {
-      const status = memberStatus[memberName];
-      return {
-        memberName: memberName,
-        allMessages: status.allMessages,
-        lastMessageDate: status.lastMessageDate
-      };
-    });
-  }
-
-  async readLastMessageWithMemberNamePingInIt(channelName: string, users: DyNTS_DiB_User[]): Promise<DyNTS_Bot_LastMentionDate[]> {
-    const channel = await this.getChannelByName(channelName);
-    const messages = await this.fetchAllMessagesWithPaging(channel.id, 1000);
-    
-    const memberStatus: Record<string, { lastMentionDate: Date | null, allMentions: number }> = {};
-    users.forEach(user => {
-      memberStatus[user.username] = { lastMentionDate: null, allMentions: 0 };
-    });
-
-    const cutoffTime = Date.now() - (3 * 7 * 24 * 60 * 60 * 1000); // 3 weeks
-
-    messages.forEach((message) => {
-      if (message.timestamp < cutoffTime) return;
-
-      users.forEach(user => {
-        if (
-          message.content.includes(`@${user.id}`) && 
-          !memberStatus[user.username].lastMentionDate
-        ) {
-          memberStatus[user.username].lastMentionDate = new Date(message.timestamp);
-          memberStatus[user.username].allMentions++;
-        }
-      });
-    });
-
-    return users.map((user) => {
-      const status = memberStatus[user.username];
-      return {
-        memberId: user.id,
-        memberName: user.username,
-        allMentions: status.allMentions,
-        lastMentionDate: status.lastMentionDate
-      };
-    });
-  }
-
-  // Discord-specific features
-  getRoleByName(roleName: string): Role {
-    if (this.roleCache.has(roleName)) {
-      return this.roleCache.get(roleName);
-    }
-
-    const role = this.guild.roles.cache.find(r => r.name === roleName);
-    if (role) {
-      this.roleCache.set(roleName, role);
-    }
-    return role;
-  }
-
-  async getRolePingByName(roleName: string): Promise<string> {
-    const role = this.getRoleByName(roleName);
-    return role ? `<@&${role.id}>` : '';
-  }
-
-  async getRolePingsByName(roleNames: string[]): Promise<string> {
-    const pings: string[] = await Promise.all(
-      roleNames.map(roleName => this.getRolePingByName(roleName))
-    );
-    return pings.join(' ');
-  }
-
-  // Event binding
-  onMessage(handler: (message: DyNTS_DiB_Message, issuer: string) => void): void {
-    this.messageHandlers.push(handler);
-  }
-
-  onReady(handler: () => void): void {
-    this.readyHandlers.push(handler);
-  }
-
-  onError(handler: (error: Error) => void): void {
-    this.errorHandlers.push(handler);
-  }
-
-  // Metadata
-  getBotId(): string {
-    return this.client?.user?.id;
-  }
-
-  getBotDisplayName(): string {
-    return this.client?.user?.displayName;
-  }
-
-  getProviderName(): string {
-    return 'discord';
-  }
-
-  getProviderId(): string {
-    return this.config?.providerId || this.getProviderName();
-  }
-
-  isReady(): boolean {
-    return this.isInitialized && this.client?.readyAt !== null;
-  }
-
-  // Translation methods
-  private translateMessage(discordMessage: Message): DyNTS_DiB_Message {
-    return {
-      id: discordMessage.id,
-      content: discordMessage.content,
-      authorId: discordMessage.author.id,
-      authorName: discordMessage.author.username,
-      authorDisplayName: discordMessage.author.displayName,
-      channelId: discordMessage.channelId,
-      channelName: (discordMessage.channel as TextChannel)?.name || 'unknown',
-      timestamp: discordMessage.createdTimestamp,
-      isBot: discordMessage.author.bot,
-      replyToMessageId: discordMessage.reference?.messageId,
-      mentions: Array.from(discordMessage.mentions.users.keys()),
-      rawPlatformMessage: discordMessage
-    };
-  }
-
-  private translateChannel(discordChannel: TextChannel): DyNTS_DiB_Channel {
-    return {
-      id: discordChannel.id,
-      name: discordChannel.name,
-      isTextBased: discordChannel.isTextBased(),
-      isDM: discordChannel.isDMBased(),
-      rawPlatformChannel: discordChannel
-    };
-  }
-
-  private translateUser(discordMember: GuildMember): DyNTS_DiB_User {
-    return {
-      id: discordMember.user.id,
-      username: discordMember.user.username,
-      displayName: discordMember.displayName,
-      isBot: discordMember.user.bot,
-      rawPlatformUser: discordMember
-    };
-  }
-}

package/src/_modules/bot/_modules/dynamo-bot/_collections/dyb.util.ts

@@ -1,26 +0,0 @@
-import { DyFM_Error, DyFM_Log } from '@futdevpro/fsm-dynamo';
-import { DyNTS_DyB_MessagingProvider } from '../_services/dyb-messaging-provider.service';
-import { DyNTS_global_settings } from '../../../../../_collections/global-settings.const';
-
-export class DyNTS_DyB_Util {
-
-  static async reportIn(provider: DyNTS_DyB_MessagingProvider): Promise<void> {
-    try {
-      const reportMessage = `${provider.getBotDisplayName()} report for duty! ` +
-        `(v${DyNTS_global_settings.systemVersion} ${DyNTS_global_settings.env_settings?.environment})`;
-
-      // Try to send to default conversation if configured
-      const config = provider.getConfig();
-      if (config?.dynamo?.defaultConversationId) {
-        await provider.sendMessage(
-          config.dynamo.defaultConversationId,
-          reportMessage
-        );
-      } else {
-        DyFM_Log.info('Dynamo bot initialized - no default conversation configured for report');
-      }
-    } catch (error) {
-      DyFM_Error.logSimple('Failed to report in', error);
-    }
-  }
-}