refactor: rename mascot to chatbot across entire codebase

- Backend: mascot-chat module → chatbot, routes /mascot/chat → /chat
- Shared schema: pgMascotChatMessagesTable → pgChatbotMessagesTable
- Frontend: MascotProvider/useMascot → ChatbotProvider/useChatbot
- Gateway schema: update exports to match shared schema
- Docs: update all .md references (CLAUDE.md, README, specs, plans)
- All API routes, controller names, service classes, types renamed

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

services/backend/src/modules/chatbot/chatbot.controller.ts

@@ -0,0 +1,84 @@
+import { createChildLogger } from "@bete/shared/logger";
+import type { Request, Response } from "express";
+import { asyncHandler } from "../../shared/middlewares/index.js";
+import { chatbotService } from "./chatbot.service.js";
+
+const logger = createChildLogger("chatbot.controller");
+
+interface AuthenticatedRequest extends Request {
+  userId?: string;
+}
+
+export const handleChatbotChat = asyncHandler(
+  async (req: Request, res: Response) => {
+    const { message, context } = req.body as {
+      message: string;
+      context?: Record<string, unknown>;
+    };
+
+    // Validate required fields
+    if (!message || typeof message !== "string") {
+      return res.status(400).json({
+        error: "INVALID_INPUT",
+        message: "Message is required and must be a string",
+      });
+    }
+
+    // Get user ID from auth middleware (if available)
+    const userId = (req as AuthenticatedRequest).userId || "anonymous";
+
+    logger.debug(
+      { userId, messageLength: message.length, context },
+      "Received chatbot chat message",
+    );
+
+    // Process message & generate response
+    const response = await chatbotService.processMessage(
+      message,
+      context,
+      userId,
+    );
+
+    // Save conversation to database
+    await chatbotService.saveConversation({
+      userId,
+      userMessage: message,
+      botResponse: response,
+      context,
+      timestamp: new Date(),
+    });
+
+    logger.info({ userId }, "Chatbot chat processed successfully");
+
+    res.status(200).json({
+      response,
+      timestamp: new Date().toISOString(),
+    });
+  },
+);
+
+export const getChatbotHistory = asyncHandler(
+  async (req: Request, res: Response) => {
+    const userId = (req as AuthenticatedRequest).userId || "anonymous";
+    const limit = Math.min(parseInt(req.query.limit as string, 10) || 50, 100);
+
+    const history = await chatbotService.getChatHistory(userId, limit);
+
+    res.status(200).json({
+      history,
+      total: history.length,
+    });
+  },
+);
+
+export const clearChatbotHistory = asyncHandler(
+  async (req: Request, res: Response) => {
+    const userId = (req as AuthenticatedRequest).userId || "anonymous";
+
+    await chatbotService.clearChatHistory(userId);
+
+    res.status(200).json({
+      message: "Chat history cleared successfully",
+    });
+  },
+);

services/backend/src/modules/chatbot/chatbot.repository.ts

@@ -0,0 +1,138 @@
+import { pgChatbotMessagesTable, pgMessagesTable } from "@bete/shared";
+import { createChildLogger } from "@bete/shared/logger";
+import { and, desc, eq, type SQL, sql } from "drizzle-orm";
+import { getDatabase } from "../../shared/database/index.js";
+
+const logger = createChildLogger("chatbot.repository");
+
+export interface ChatbotContext {
+  messageCount?: number;
+  activeParticipants?: number;
+  lastActivity?: string;
+  topicsDiscussed?: string[];
+  guildId?: string;
+  channelId?: string;
+}
+
+export interface SaveConversationInput {
+  userId: string;
+  userMessage: string;
+  botResponse: string;
+  context?: ChatbotContext;
+  timestamp: Date;
+}
+
+export interface ChatbotHistoryRow {
+  id: string;
+  user_id: string;
+  user_message: string;
+  bot_response: string;
+  context: ChatbotContext | null;
+  created_at: string;
+}
+
+export interface ServerInsights {
+  total_messages: number;
+  active_users: number;
+  flagged: number;
+  warned: number;
+}
+
+export class ChatbotRepository {
+  async saveConversation(input: SaveConversationInput): Promise<void> {
+    const db = getDatabase();
+
+    await db.insert(pgChatbotMessagesTable).values({
+      user_id: input.userId,
+      user_message: input.userMessage,
+      bot_response: input.botResponse,
+      context: (input.context ?? {}) as Record<string, unknown>,
+      created_at: input.timestamp,
+    });
+
+    logger.debug({ userId: input.userId }, "Conversation saved");
+  }
+
+  async getChatHistory(
+    userId: string,
+    limit: number,
+  ): Promise<ChatbotHistoryRow[]> {
+    const db = getDatabase();
+
+    const rows = await db
+      .select()
+      .from(pgChatbotMessagesTable)
+      .where(eq(pgChatbotMessagesTable.user_id, userId))
+      .orderBy(desc(pgChatbotMessagesTable.created_at))
+      .limit(limit);
+
+    logger.debug({ userId, count: rows.length }, "Chat history fetched");
+    return rows.reverse() as unknown as ChatbotHistoryRow[];
+  }
+
+  async clearChatHistory(userId: string): Promise<void> {
+    const db = getDatabase();
+
+    const deleted = await db
+      .delete(pgChatbotMessagesTable)
+      .where(eq(pgChatbotMessagesTable.user_id, userId))
+      .returning({ id: pgChatbotMessagesTable.id });
+
+    logger.info(
+      { userId, deletedRows: deleted.length },
+      "Chat history cleared",
+    );
+  }
+
+  async getServerInsights(
+    guildId?: string,
+    channelId?: string,
+  ): Promise<ServerInsights> {
+    try {
+      const db = getDatabase();
+      const conditions: SQL[] = [];
+
+      if (guildId) {
+        conditions.push(eq(pgMessagesTable.guild_id, guildId));
+      }
+      if (channelId) {
+        conditions.push(eq(pgMessagesTable.channel_id, channelId));
+      }
+
+      const where = conditions.length > 0 ? and(...conditions) : undefined;
+
+      const [result] = await db
+        .select({
+          total_messages: sql<number>`COUNT(*)::int`,
+          active_users: sql<number>`COUNT(DISTINCT ${pgMessagesTable.user_id})::int`,
+          flagged: sql<number>`COUNT(*) FILTER (WHERE ${pgMessagesTable.ai_status} = 'flagged')::int`,
+          warned: sql<number>`COUNT(*) FILTER (WHERE ${pgMessagesTable.ai_status} = 'warn')::int`,
+        })
+        .from(pgMessagesTable)
+        .where(where);
+
+      const insights = result ?? {
+        total_messages: 0,
+        active_users: 0,
+        flagged: 0,
+        warned: 0,
+      };
+
+      logger.debug({ guildId, channelId, insights }, "Server insights fetched");
+      return insights;
+    } catch (error) {
+      logger.warn(
+        { error, guildId, channelId },
+        "Failed to load server insights",
+      );
+      return {
+        total_messages: 0,
+        active_users: 0,
+        flagged: 0,
+        warned: 0,
+      };
+    }
+  }
+}
+
+export const chatbotRepository = new ChatbotRepository();

services/backend/src/modules/chatbot/chatbot.routes.ts

@@ -0,0 +1,22 @@
+import express, { type Router } from "express";
+import { validateBody } from "../../shared/middlewares/index.js";
+import {
+  clearChatbotHistory,
+  getChatbotHistory,
+  handleChatbotChat,
+} from "./chatbot.controller.js";
+import { chatRequestSchema } from "./chatbot.schema.js";
+
+export function createChatbotRouter(): Router {
+  const router = express.Router();
+
+  router.post(
+    "/chat",
+    validateBody(chatRequestSchema),
+    handleChatbotChat,
+  );
+  router.get("/chat/history", getChatbotHistory);
+  router.delete("/chat/history", clearChatbotHistory);
+
+  return router;
+}

services/backend/src/modules/chatbot/chatbot.schema.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+
+export const contextSchema = z.object({
+  messageCount: z.number().int().nonnegative().optional(),
+  activeParticipants: z.number().int().nonnegative().optional(),
+  lastActivity: z.string().datetime().optional(),
+  topicsDiscussed: z.array(z.string()).optional(),
+  guildId: z.string().optional(),
+  channelId: z.string().optional(),
+});
+
+export const chatRequestSchema = z.object({
+  message: z.string().min(1, "Message is required"),
+  context: contextSchema.optional(),
+});
+
+export const chatResponseSchema = z.object({
+  response: z.string(),
+  timestamp: z.string(),
+});
+
+export const chatHistoryQuerySchema = z.object({
+  limit: z.coerce.number().int().positive().max(100).default(50),
+});
+
+export type ChatRequest = z.infer<typeof chatRequestSchema>;
+export type ChatResponse = z.infer<typeof chatResponseSchema>;
+export type ChatContext = z.infer<typeof contextSchema>;
+export type ChatHistoryQuery = z.infer<typeof chatHistoryQuerySchema>;

services/backend/src/modules/chatbot/chatbot.service.ts

@@ -0,0 +1,181 @@
+import { createChildLogger } from "@bete/shared/logger";
+import { config } from "../../shared/config/index.js";
+import type {
+  ChatbotContext,
+  ChatbotHistoryRow,
+  SaveConversationInput,
+} from "./chatbot.repository.js";
+import { chatbotRepository } from "./chatbot.repository.js";
+
+const logger = createChildLogger("chatbot.service");
+
+class ChatbotService {
+  async processMessage(
+    message: string,
+    context: ChatbotContext | undefined,
+    userId: string,
+  ): Promise<string> {
+    logger.info(
+      { userId, messageLength: message.length },
+      "processMessage called",
+    );
+    const recentContext = await this.getRecentConversationContext(userId);
+    const serverInsights = await chatbotRepository.getServerInsights(
+      context?.guildId,
+      context?.channelId,
+    );
+
+    // Build LLM messages
+    const systemPrompt = this.buildSystemPrompt(serverInsights);
+    const conversationHistory = this.buildHistoryMessages(recentContext);
+    const llmResponse = await this.callLLM(
+      systemPrompt,
+      conversationHistory,
+      message,
+    );
+
+    return llmResponse;
+  }
+
+  async saveConversation(input: SaveConversationInput): Promise<void> {
+    logger.info({ userId: input.userId }, "saveConversation called");
+    await chatbotRepository.saveConversation(input);
+  }
+
+  async getChatHistory(
+    userId: string,
+    limit: number,
+  ): Promise<ChatbotHistoryRow[]> {
+    logger.debug({ userId, limit }, "getChatHistory called");
+    return chatbotRepository.getChatHistory(userId, limit);
+  }
+
+  async clearChatHistory(userId: string): Promise<void> {
+    logger.info({ userId }, "clearChatHistory called");
+    await chatbotRepository.clearChatHistory(userId);
+  }
+
+  private async getRecentConversationContext(
+    userId: string,
+  ): Promise<string[]> {
+    const history = await chatbotRepository.getChatHistory(userId, 3);
+    return history.flatMap((row) => [
+      `User: ${row.user_message}`,
+      `Bot: ${row.bot_response}`,
+    ]);
+  }
+
+  private buildSystemPrompt(insights: {
+    total_messages: number;
+    active_users: number;
+    flagged: number;
+    warned: number;
+  }): string {
+    return `Kamu lagi ngobrol sama chatbot Discord Watcher — temen ngobrol yang tau keadaan server.
+
+Data server saat ini:
+- Pesan: ${insights.total_messages}
+- User aktif: ${insights.active_users}
+- Flagged: ${insights.flagged}
+- Warning: ${insights.warned}
+
+Gaya ngobrol:
+- Santai, hangat, kayak ngobrol sama temen
+- Pake Bahasa Indonesia sehari-hari, ga perlu kaku
+- Sesekali pake emoji wajar aja, ga berlebihan
+- Kalo ditanya sesuatu yang kamu tau dari data server, jawab pake data itu
+- Kalo ga tau atau ga nyambung, bilang aja terus tanya balik biar ngobrolnya jalan
+- Jangan sebut "rule", "instruksi", "prompt" atau apapun soal cara kamu berpikir
+- Biasa aja, ga usaha lucu-lucu amat — natural`;
+  }
+
+  private buildHistoryMessages(
+    recentContext: string[],
+  ): Array<{ role: "user" | "assistant"; content: string }> {
+    // recentContext is alternating User/Bot messages
+    return recentContext.map((text) => {
+      if (text.startsWith("User: ")) {
+        return { role: "user" as const, content: text.slice(6) };
+      }
+      return { role: "assistant" as const, content: text.slice(7) };
+    });
+  }
+
+  private async callLLM(
+    systemPrompt: string,
+    history: Array<{ role: "user" | "assistant"; content: string }>,
+    userMessage: string,
+  ): Promise<string> {
+    const apiKey = config.AI_LLM_API_KEY;
+    const baseUrl = config.AI_LLM_BASE_URL;
+    const model = config.AI_LLM_MODEL;
+
+    if (!apiKey) {
+      logger.warn("AI_LLM_API_KEY not configured, using fallback response");
+      return this.fallbackResponse(userMessage);
+    }
+
+    try {
+      const { default: axios } = await import("axios");
+
+      // Gateway tidak handle role system — gabung konteks ke user message
+      const contextPrefixed = `${systemPrompt}\n\nPertanyaan user: ${userMessage}`;
+
+      const messages: Array<{ role: "user" | "assistant"; content: string }> = [
+        ...history,
+        { role: "user", content: contextPrefixed },
+      ];
+
+      const response = await axios.post(
+        `${baseUrl}/chat/completions`,
+        {
+          model,
+          messages,
+          max_tokens: 500,
+          temperature: 0.4,
+        },
+        {
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+          },
+          timeout: 30_000,
+        },
+      );
+
+      const result = response.data as {
+        choices?: Array<{ message?: { content?: string } }>;
+      };
+      const content = result?.choices?.[0]?.message?.content?.trim();
+
+      if (content) {
+        return content;
+      }
+
+      logger.warn({ response: result }, "LLM returned empty response");
+      return this.fallbackResponse(userMessage);
+    } catch (error) {
+      logger.warn({ error }, "LLM call failed, using fallback response");
+      return this.fallbackResponse(userMessage);
+    }
+  }
+
+  private fallbackResponse(input: string): string {
+    const lower = input.toLowerCase();
+
+    if (
+      lower.includes("halo") ||
+      lower.includes("hai") ||
+      lower.includes("hi") ||
+      lower.includes("pagi") ||
+      lower.includes("siang") ||
+      lower.includes("malam")
+    ) {
+      return "Halo! 👋 Lagi offline bentar, coba chat lagi nanti ya.";
+    }
+
+    return "Maaf, lagi ada masalah koneksi. Coba tanya lagi nanti!";
+  }
+}
+
+export const chatbotService = new ChatbotService();

services/backend/src/modules/chatbot/index.ts

@@ -0,0 +1 @@
+export { createChatbotRouter } from "./chatbot.routes.js";