Discord Bot

import {
  Client,
  GatewayIntentBits,
  Message,
  ChannelType,
} from "discord.js";
import {
  AgentRuntime,
  createMessageMemory,
  stringToUuid,
  type UUID,
} from "@elizaos/core";
import { openaiPlugin } from "@elizaos/plugin-openai";
import { plugin as sqlPlugin } from "@elizaos/plugin-sql";
import { v4 as uuidv4 } from "uuid";

// Character definition
const character = {
  name: "Eliza",
  username: "eliza_bot",
  bio: "A helpful AI assistant for your Discord server.",
  system: `You are Eliza, a friendly AI assistant in a Discord server.

Behavior:
- Be helpful, friendly, and engaging
- Keep responses concise (under 2000 characters for Discord)
- Use Discord markdown formatting when appropriate
- Reference the conversation context
- Be aware you're in a group chat (unless in DM)

When responding:
- If someone asks about your capabilities, explain what you can do
- If you see @mentions of other users, acknowledge the conversation context
- Adapt your tone to match the server's vibe`,
};

console.log("🚀 Initializing Eliza Discord Bot...");

// Initialize elizaOS runtime
const runtime = new AgentRuntime({
  character,
  plugins: [sqlPlugin, openaiPlugin],
});

await runtime.initialize();
console.log("✅ Runtime initialized");

// Initialize Discord client
const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
    GatewayIntentBits.DirectMessages,
  ],
});

// Track typing indicators
const typingChannels = new Set<string>();

// Handle messages
client.on("messageCreate", async (message: Message) => {
  // Ignore bot's own messages
  if (message.author.bot) return;

  // Only respond to mentions or DMs
  const isMentioned = message.mentions.has(client.user!.id);
  const isDM = message.channel.type === ChannelType.DM;

  if (!isMentioned && !isDM) return;

  try {
    // Show typing indicator
    if (!typingChannels.has(message.channelId)) {
      typingChannels.add(message.channelId);
      await message.channel.sendTyping();
    }

    // Extract message content (remove bot mention)
    let content = message.content;
    if (isMentioned) {
      content = content.replace(new RegExp(`<@!?${client.user!.id}>`), "").trim();
    }

    // Build context
    const context = await buildContext(message);

    // Create message for elizaOS
    const fullMessage = context
      ? `Context: ${context}\n\nUser message: ${content}`
      : content;

    const messageMemory = createMessageMemory({
      id: uuidv4() as UUID,
      entityId: stringToUuid(message.author.id),
      roomId: stringToUuid(message.channelId),
      content: { text: fullMessage },
    });

    // Get response from elizaOS
    let response = "";
    await runtime.messageService!.handleMessage(
      runtime,
      messageMemory,
      async (responseContent) => {
        if (responseContent?.text) {
          response += responseContent.text;
        }
        return [];
      }
    );

    // Split long messages (Discord limit: 2000 chars)
    const chunks = splitMessage(response, 2000);

    // Send response
    for (const chunk of chunks) {
      await message.reply(chunk);
    }
  } catch (error) {
    console.error("Error handling message:", error);
    await message.reply(
      "Sorry, I encountered an error processing your message."
    );
  } finally {
    typingChannels.delete(message.channelId);
  }
});

// Build conversation context
async function buildContext(message: Message): Promise<string> {
  const context: string[] = [];

  // Add server context
  if (message.guild) {
    context.push(`Server: ${message.guild.name}`);
    context.push(`Channel: #${(message.channel as any).name}`);
  }

  // Add recent messages for context
  try {
    const messages = await message.channel.messages.fetch({ limit: 5 });
    const recentMessages = Array.from(messages.values())
      .reverse()
      .slice(0, 4)
      .filter((m) => m.id !== message.id && !m.author.bot)
      .map((m) => `${m.author.username}: ${m.content}`);

    if (recentMessages.length > 0) {
      context.push(`Recent messages:\n${recentMessages.join("\n")}`);
    }
  } catch (error) {
    // Ignore if we can't fetch messages
  }

  return context.join("\n");
}

// Split message into chunks
function splitMessage(text: string, maxLength: number): string[] {
  if (text.length <= maxLength) return [text];

  const chunks: string[] = [];
  let currentChunk = "";

  const paragraphs = text.split("\n");

  for (const paragraph of paragraphs) {
    if (currentChunk.length + paragraph.length + 1 > maxLength) {
      if (currentChunk) chunks.push(currentChunk.trim());
      currentChunk = paragraph;
    } else {
      currentChunk += (currentChunk ? "\n" : "") + paragraph;
    }
  }

  if (currentChunk) chunks.push(currentChunk.trim());

  return chunks;
}

// Bot ready event
client.on("ready", () => {
  console.log(`✅ Bot logged in as ${client.user?.tag}`);
  console.log(`👥 Active in ${client.guilds.cache.size} servers`);
  console.log("\n💬 Bot is ready to respond to mentions and DMs!\n");
});

// Error handling
client.on("error", (error) => {
  console.error("Discord client error:", error);
});

process.on("SIGINT", async () => {
  console.log("\n🚦 Shutting down...");
  client.destroy();
  await runtime.stop();
  process.exit(0);
});

// Login
const token = process.env.DISCORD_BOT_TOKEN;
if (!token) {
  console.error("❌ DISCORD_BOT_TOKEN environment variable is required");
  process.exit(1);
}

client.login(token);