Initial commit for Hugging Face

.gitignore

@@ -0,0 +1,17 @@
+node_modules/
+venv/
+.env
+.env.example
+session/
+temp_files/
+*.log
+session_b64.txt
+session_small.zip
+session.zip
+b64.txt
+test_file_gen.js
+hf_upload.js
+package-lock.json
+.DS_Store
+.gemini/
+.gemini_security/

Dockerfile

@@ -0,0 +1,24 @@
+FROM node:20-bullseye
+
+# Install dependencies sistem (FFmpeg & LibreOffice)
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libreoffice \
+    unzip \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy package.json dan install dependencies
+COPY package*.json ./
+RUN npm install
+
+# Copy seluruh kode bot
+COPY . .
+
+# Port yang dibuka oleh HF
+EXPOSE 7860
+
+# Jalankan bot
+CMD ["npm", "start"]

README.md

@@ -0,0 +1,95 @@
+# 🤖 WhatsApp AI Bot (Baileys + Gemini + RAG + Local Tools)
+
+Bot WhatsApp canggih berbasis `Baileys` yang terintegrasi dengan berbagai provider AI (Multi-Modal) menggunakan sistem **Native Tool Calling** dan **RAG (Retrieval-Augmented Generation)**. Bot ini dirancang untuk performa tinggi, efisiensi token, dan kemampuan pengolahan file lokal yang kuat.
+
+---
+
+## 🚀 Fitur Utama
+
+### 1. Multi-Modal AI & Fallback
+*   **Engine Utama**: Gemini 2.5 Flash (Mendukung input Teks, Gambar, Video, dan Stiker).
+*   **Engine Cadangan (Auto-Fallback)**: Jika Gemini mengalami error atau limit, bot otomatis beralih ke **Groq (Llama-3.3-70b)** untuk memastikan layanan tetap online.
+*   **Konteks Cerdas**: AI mengingat riwayat percakapan secara terpisah antara Chat Pribadi dan Chat Grup.
+
+### 2. Sistem RAG (Retrieval-Augmented Generation)
+*   **Auto-Extraction**: Membaca otomatis file PDF, DOCX, TXT, dan PPTX yang dikirim user.
+*   **Intelligent Analysis**: Menggunakan Groq (Llama-3) untuk merangkum dan memahami isi dokumen secara instan saat file diterima.
+*   **Context Injection**: Hasil analisis dokumen disuntikkan langsung ke percakapan berikutnya agar AI memahami konteks file tanpa perlu memanggil tool manual.
+
+### 3. Tools Modular (Native Function Calling)
+*   **Web Search**: Mencari informasi terbaru secara real-time di Google.
+*   **Sticker Maker**: Konversi Gambar & Video (6 detik) menjadi stiker secara lokal menggunakan FFmpeg. (Gunakan perintah `.sticker` atau minta AI).
+*   **Universal File Converter**: Mengubah format file apapun secara lokal (PDF <-> Word, Image <-> PDF, Audio Extraction, dll) menggunakan **LibreOffice** & **Sharp**.
+*   **Image Generator**: Membuat gambar inovatif melalui OpenRouter (Flux.2 & Seedream).
+*   **Smart Reminder**: Penjadwalan pengingat otomatis yang tetap aktif meskipun bot restart.
+
+### 4. Aktivitas & UX
+*   **Status Indicator**: Menampilkan status seperti _"Mencari di Google..."_ atau _"Membuat stiker..."_ untuk feedback yang transparan.
+*   **Sticker Reactive**: AI akan bereaksi secara interaktif terhadap visual stiker yang dikirim oleh user.
+*   **Logging Detail**: Seluruh aktivitas pesan, penggunaan tool, dan error dicatat secara rinci di terminal menggunakan `pino-pretty`.
+
+---
+
+## 🛠️ Persyaratan Sistem
+
+Bot ini menggunakan engine lokal untuk konversi file agar tidak bergantung pada API berbayar:
+1.  **Node.js** v18 atau lebih tinggi.
+2.  **FFmpeg**: Untuk pembuatan stiker dan konversi media.
+3.  **LibreOffice**: Untuk konversi dokumen (PDF, Word, Excel).
+
+**Install di Ubuntu/Debian:**
+```bash
+sudo apt update
+sudo apt install ffmpeg libreoffice -y
+```
+
+---
+
+## ⚙️ Instalasi & Setup
+
+1.  **Clone / Download Project**
+2.  **Install Dependency:**
+    ```bash
+    npm install
+    ```
+3.  **Konfigurasi Environment:**
+    Salin `.env.example` menjadi `.env` dan isi API Key Anda:
+    ```env
+    GOOGLE_AI_API_KEY=your_key
+    GROQ_API_KEY=your_key
+    OPENROUTER_API_KEY=your_key
+    PHONE_NUMBER=6285607277006
+    ```
+4.  **Jalankan Bot:**
+    ```bash
+    npm start
+    ```
+5.  **Pairing:** Masukkan kode pairing yang muncul di terminal ke WhatsApp Anda (Linked Devices).
+
+---
+
+## 📂 Struktur Project
+
+```text
+├── index.js                # Entry point & Logika Orchestration
+├── config.js               # Konfigurasi API & Environment
+├── lib/
+│   ├── contextManager.js   # Pengelola memori percakapan
+│   ├── toolHandler.js      # Registry & Eksekutor Tool
+│   ├── ragHandler.js       # Ekstraksi teks dokumen cerdas (OCR support)
+│   ├── groqHandler.js      # Analisis dokumen cepat via Groq
+│   ├── reminderService.js  # Layanan pengingat latar belakang
+│   └── markdownParser.js   # Parser format pesan WhatsApp
+├── tools/                  # Implementasi fungsi tools lokal
+└── session/                # Penyimpanan sesi & data (reminders, doc_store)
+```
+
+---
+
+## 🛡️ Keamanan & Privasi
+*   **Offline Processing**: Konversi file dilakukan secara lokal di server Anda.
+*   **Channel Blocking**: Bot tidak akan merespons pesan dari WhatsApp Channels/Newsletter untuk menjaga kuota AI.
+*   **Auto-Cleanup**: File sementara otomatis dihapus setelah diproses untuk menjaga kerahasiaan data.
+
+---
+*Dibuat dengan ❤️ untuk sistem bot WhatsApp yang lebih cerdas dan responsif.*

TODO.md

@@ -0,0 +1,33 @@
+# Project To-Do List: WhatsApp Bot with Baileys + AI (RAG & Tools)
+
+- [x] **Project Setup**
+    - [x] Initialize `package.json`
+    - [x] Install dependencies (`@whiskeysockets/baileys`, `@google/generative-ai`, `dotenv`, `pino`, etc.)
+    - [x] Create directory structure (`session`, `tools`, `tools/schemas`, `lib`)
+    - [x] Create `.env.example` and `config.js`
+
+- [x] **Core Architecture (Baileys)**
+    - [x] Implement `index.js` connection logic
+    - [x] Add Pairing Code authentication (+62 856-0727-7006 default)
+    - [x] Implement Session handling
+    - [x] Implement Message Handler (Basic)
+
+- [x] **AI Integration & Logic**
+    - [x] Create `lib/contextManager.js` (Memory per chat/group)
+    - [x] Create `lib/toolHandler.js` (Dynamic Registry & Execution)
+    - [x] Implement Native Tool Calling integration with Gemini SDK
+    - [x] Implement `lib/markdownParser.js` (AI MD -> WA MD)
+
+- [x] **RAG System**
+    - [x] Create `lib/ragHandler.js` (Document extraction & Chunking)
+    - [x] Implement file support (PDF, DOCX, TXT)
+    - [x] Implement retrieval logic (`tools/documentSearch.js`)
+
+- [x] **Tools Implementation**
+    - [x] Create `tools/schemas/webSearch.json` & `tools/webSearch.js`
+    - [x] Create `tools/schemas/fileGenerator.json` & `tools/fileGenerator.js`
+    - [x] Implement UX Status Indicators (e.g., "> Mengecek di google")
+
+- [x] **Final Polish**
+    - [x] Verify structure against requirements
+    - [x] Test build/lint (Project structure created and ready to run)

config.js

@@ -0,0 +1,35 @@
+require('dotenv').config();
+
+const config = {
+    ai: {
+        groq: {
+            apiKey: process.env.GROQ_API_KEY,
+            fastModel: process.env.GROQ_FAST_MODEL || 'llama-3.1-8b-instant',
+            powerfulModel: process.env.GROQ_POWERFUL_MODEL || 'llama-3.3-70b-versatile'
+        },
+        openRouter: {
+            apiKey: process.env.OPENROUTER_API_KEY,
+            model: process.env.OPENROUTER_MODEL || 'openai/gpt-oss-120b:free'
+        },
+        google: {
+            apiKey: process.env.GOOGLE_AI_API_KEY,
+            model: process.env.GOOGLE_AI_MODEL || 'gemini-2.5-flash'
+        },
+        huggingFace: {
+            apiKey: process.env.HUGGINGFACE_API_KEY,
+            model: process.env.HUGGINGFACE_MODEL || 'google/gemma-3-27b-it'
+        }
+    },
+    search: {
+        apiKey: process.env.GOOGLE_SEARCH_API_KEY,
+        cseId: process.env.GOOGLE_CSE_ID
+    },
+    cloudConvertApiKey: process.env.CLOUDCONVERT_API_KEY,
+    whatsapp: {
+        phoneNumber: process.env.PHONE_NUMBER || process.env.DEFAULT_NUMBER || '6285607277006',
+        sessionPath: './session',
+        authType: 'pairing' // 'qr' or 'pairing'
+    }
+};
+
+module.exports = config;

index.js

@@ -0,0 +1,450 @@
+const {
+    default: makeWASocket,
+    useMultiFileAuthState,
+    DisconnectReason,
+    fetchLatestBaileysVersion,
+    makeCacheableSignalKeyStore,
+    downloadMediaMessage,
+    proto
+} = require('@whiskeysockets/baileys');
+const pino = require('pino');
+const { Boom } = require('@hapi/boom');
+const fs = require('fs-extra');
+const path = require('path');
+const { GoogleGenerativeAI } = require('@google/generative-ai');
+const axios = require('axios');
+const Groq = require('groq-sdk');
+const mime = require('mime-types');
+const express = require('express');
+
+const config = require('./config');
+const app = express();
+const PORT = process.env.PORT || 7860; // Port default Hugging Face
+
+app.get('/', (req, res) => {
+    res.send('Bot WhatsApp is running perfectly!');
+});
+
+app.listen(PORT, () => {
+    logger.info(`HTTP Server is active on port ${PORT}`);
+});
+
+const toolHandler = require('./lib/toolHandler');
+const contextManager = require('./lib/contextManager');
+const ragHandler = require('./lib/ragHandler');
+const groqHandler = require('./lib/groqHandler');
+const reminderService = require('./lib/reminderService');
+const statsTracker = require('./lib/statsTracker');
+const recapManager = require('./lib/recapManager');
+const { parseMarkdownToWhatsApp } = require('./lib/markdownParser');
+
+// --- INITIALIZATION ---
+const TEMP_DIR = path.join(__dirname, 'temp_files');
+const SESSION_DIR = path.join(__dirname, 'session');
+const DOC_STORE_DIR = path.join(__dirname, 'session/doc_store');
+
+fs.ensureDirSync(TEMP_DIR);
+fs.ensureDirSync(SESSION_DIR);
+fs.ensureDirSync(DOC_STORE_DIR);
+
+// Clear temp files on startup
+fs.emptyDirSync(TEMP_DIR);
+
+// Enhanced Logger
+const logger = pino({
+    level: 'info',
+    transport: {
+        target: 'pino-pretty',
+        options: { colorize: true, translateTime: 'SYS:standard', ignore: 'pid,hostname' }
+    }
+});
+
+// AI Setup
+const genAI = new GoogleGenerativeAI(config.ai.google.apiKey);
+const groq = new Groq({ apiKey: config.ai.groq.apiKey });
+
+const pendingDocumentContexts = new Map();
+const model = genAI.getGenerativeModel({
+    model: config.ai.google.model,
+    tools: toolHandler.getTools()
+});
+
+async function startBot() {
+    const { state, saveCreds } = await useMultiFileAuthState(SESSION_DIR);
+    const { version, isLatest } = await fetchLatestBaileysVersion();
+    
+    logger.info(`Starting WhatsApp Bot v${version.join('.')} (Production Mode)`);
+
+    const sock = makeWASocket({
+        version,
+        logger: pino({ level: 'silent' }),
+        printQRInTerminal: config.whatsapp.authType !== 'pairing',
+        auth: {
+            creds: state.creds,
+            keys: makeCacheableSignalKeyStore(state.keys, pino({ level: 'silent' })),
+        },
+        browser: ['Ubuntu', 'Chrome', '20.0.04'],
+        generateHighQualityLinkPreview: true,
+        getMessage: async (key) => {
+            // This helps with downloading quoted media
+            return proto.Message.fromObject({});
+        }
+    });
+
+    // Pairing Code logic
+    if (config.whatsapp.authType === 'pairing' && !sock.authState.creds.me) {
+        setTimeout(async () => {
+            try {
+                const phoneNumber = config.whatsapp.phoneNumber.replace(/[^0-9]/g, '');
+                if (!phoneNumber) {
+                    logger.error('Phone number missing in .env for pairing!');
+                    return;
+                }
+                const code = await sock.requestPairingCode(phoneNumber);
+                console.log(`\n\n[PAIRING CODE]: ${code}\n\n`);
+            } catch (err) {
+                logger.error(`Failed to request pairing code: ${err.message}`);
+            }
+        }, 5000);
+    }
+
+    sock.ev.on('creds.update', saveCreds);
+
+    sock.ev.on('connection.update', (update) => {
+        const { connection, lastDisconnect } = update;
+        if (connection === 'close') {
+            const shouldReconnect = (lastDisconnect.error instanceof Boom)
+                ? lastDisconnect.error.output.statusCode !== DisconnectReason.loggedOut
+                : true;
+            
+            logger.error(`Connection lost: ${lastDisconnect.error?.message}. Reconnecting: ${shouldReconnect}`);
+            
+            if (shouldReconnect) {
+                setTimeout(startBot, 5000); // 5s delay before reconnect
+            } else {
+                logger.fatal('Logged out. Please delete session folder and restart.');
+                process.exit(1);
+            }
+        } else if (connection === 'open') {
+            logger.info('SUCCESS: Bot is now online and connected.');
+            reminderService.init(sock);
+        }
+    });
+
+    sock.ev.on('messages.upsert', async ({ messages, type }) => {
+        if (type !== 'notify') return;
+
+        for (const msg of messages) {
+            try {
+                if (!msg.message || msg.key.fromMe) continue;
+
+                const remoteJid = msg.key.remoteJid;
+                
+                // Ignore Channels
+                if (remoteJid?.endsWith('@newsletter')) continue;
+
+                const pushName = msg.pushName || 'User';
+                const isGroup = remoteJid.endsWith('@g.us');
+                
+                const text = msg.message.conversation || msg.message.extendedTextMessage?.text || msg.message.imageMessage?.caption || msg.message.videoMessage?.caption || '';
+                const isImage = !!msg.message.imageMessage;
+                const isVideo = !!msg.message.videoMessage;
+                const isSticker = !!msg.message.stickerMessage;
+                const documentMessage = msg.message.documentMessage;
+
+                            logger.info({ event: 'INCOMING', from: pushName, chat: remoteJid, text: text.slice(0, 50) });
+                
+                            // --- TRACK STATISTICS ---
+                            statsTracker.addActivity(remoteJid, 'user', text);
+                
+                            // --- INTERACTIVE RECAP FLOW ---
+                            if (recapManager.isInRecap(remoteJid)) {
+                                await sock.sendPresenceUpdate('composing', remoteJid);
+                                const nextStepText = await recapManager.getNextStep(remoteJid, text);
+                                if (nextStepText) {
+                                    return await sock.sendMessage(remoteJid, { text: parseMarkdownToWhatsApp(nextStepText) });
+                                }
+                            }
+                
+                            // Trigger Recap (Manual for test or auto check)
+                            if (text.toLowerCase() === '.recap') {
+                                const intro = await recapManager.initiateRecap(remoteJid, 'monthly');
+                                if (intro) {
+                                    return await sock.sendMessage(remoteJid, { text: parseMarkdownToWhatsApp(intro) });
+                                } else {
+                                    return await sock.sendMessage(remoteJid, { text: "_Belum ada data yang cukup untuk membuat recap bulan lalu._" });
+                                }
+                            }
+                
+                            if (documentMessage) {                    await handleDocument(sock, msg, documentMessage);
+                    continue;
+                }
+
+            if (text.startsWith('.sticker') || text.startsWith('.stiker')) {
+                logger.info(`Manual sticker command from ${pushName} (${remoteJid})`);
+                await handleStickerCommand(sock, msg);
+                continue;
+            }
+
+            if (text.toLowerCase() === '.newchat') {
+                contextManager.clearHistory(remoteJid);
+                logger.info(`Context cleared for ${remoteJid} by ${pushName}`);
+                return await sock.sendMessage(remoteJid, { text: "_Konteks percakapan telah dihapus. Mari mulai obrolan baru!_" });
+            }
+
+            if (!text && !isImage && !isVideo && !isSticker) continue;
+
+                // --- CONTEXT PREPARATION ---
+                let finalUserText = text;
+                if (pendingDocumentContexts.has(remoteJid)) {
+                    const docContext = pendingDocumentContexts.get(remoteJid);
+                    finalUserText = `Ini adalah isi dokumen yang saya miliki:\n'${docContext}'\n${text || "Apa isi dokumen ini?"}`;
+                    pendingDocumentContexts.delete(remoteJid);
+                }
+
+                if (isSticker) {
+                    finalUserText = `[Sticker Received] ${text || "React to this sticker visually."}`;
+                }
+
+                let mediaParts = [];
+                let currentMediaPath = null;
+                let currentMimeType = null;
+
+                if (isImage || isVideo || isSticker) {
+                    const buffer = await downloadMediaMessage(msg, 'buffer', {}, { logger: pino({ level: 'silent' }), reuploadRequest: sock.updateMediaMessage });
+                    const mimeType = isImage ? 'image/jpeg' : (isVideo ? 'video/mp4' : 'image/webp');
+                    mediaParts.push({ inlineData: { data: buffer.toString('base64'), mimeType } });
+                    
+                    currentMimeType = mimeType;
+                    currentMediaPath = path.join(TEMP_DIR, `in_${Date.now()}.${mimeType.split('/')[1]}`);
+                    fs.writeFileSync(currentMediaPath, buffer);
+                }
+
+                contextManager.addMessage(remoteJid, finalUserText, 'user');
+                await sock.sendPresenceUpdate('composing', remoteJid);
+
+                // --- AI CORE LOGIC ---
+                try {
+                    let textResponse = await processWithGemini(sock, msg, remoteJid, text, mediaParts, currentMediaPath, currentMimeType);
+                    
+                    if (textResponse) {
+                        contextManager.addMessage(remoteJid, textResponse, 'model');
+                        await sock.sendMessage(remoteJid, { text: parseMarkdownToWhatsApp(textResponse) });
+                    }
+
+                } catch (geminiError) {
+                    logger.warn(`Gemini Error: ${geminiError.message}. Attempting Groq Fallback...`);
+                    
+                    try {
+                        let fallbackResponse = await processWithGroq(sock, msg, remoteJid, finalUserText);
+                        if (fallbackResponse) {
+                            contextManager.addMessage(remoteJid, fallbackResponse, 'model');
+                            await sock.sendMessage(remoteJid, { text: parseMarkdownToWhatsApp(fallbackResponse) });
+                        }
+                    } catch (groqError) {
+                        logger.error(`Critical AI Failure: ${groqError.message}`);
+                        await sock.sendMessage(remoteJid, { text: '_Maaf, sistem AI sedang tidak responsif. Mohon coba lagi nanti._' });
+                    }
+                } finally {
+                    if (currentMediaPath && fs.existsSync(currentMediaPath)) fs.unlinkSync(currentMediaPath);
+                }
+
+            } catch (loopError) {
+                logger.error(`Message Processing Error: ${loopError.message}`);
+            }
+        }
+    });
+}
+
+// --- AI HANDLERS ---
+
+async function processWithGemini(sock, msg, remoteJid, text, mediaParts, currentMediaPath, currentMimeType) {
+    const history = contextManager.getHistory(remoteJid);
+    const chatHistory = history.length > 0 ? history.slice(0, -1) : [];
+    
+    const chat = model.startChat({
+        history: chatHistory,
+        generationConfig: { maxOutputTokens: 2048, temperature: 0.7 },
+    });
+
+    const messageParts = [];
+    if (text) messageParts.push(text);
+    messageParts.push(...mediaParts);
+
+    let result = await chat.sendMessage(messageParts.length > 0 ? messageParts : "Analyze this.");
+    let response = await result.response;
+    let textResponse = response.text();
+    let functionCalls = response.functionCalls();
+    
+    let loopCount = 0;
+    while (functionCalls && functionCalls.length > 0 && loopCount < 5) {
+        loopCount++;
+        const functionResponses = [];
+
+        for (const call of functionCalls) {
+            const { name, args } = call;
+            
+            if (name === 'webSearch') await sock.sendMessage(remoteJid, { text: `> _Mencari di Google..._` });
+            if (name === 'stickerMaker') await sock.sendMessage(remoteJid, { text: `> _Membuat stiker..._` });
+            if (name === 'imageGenerator') await sock.sendMessage(remoteJid, { text: `> _Membuat gambar..._` });
+            if (['fileGenerator', 'fileConverter'].includes(name)) await sock.sendMessage(remoteJid, { text: `> _Membuat file..._` });
+
+            let toolContext = { remoteJid, filePath: currentMediaPath, mimeType: currentMimeType };
+            if (!toolContext.filePath && ['stickerMaker', 'fileConverter', 'imageGenerator'].includes(name)) {
+                const media = await downloadMediaForTool(sock, msg);
+                if (media) {
+                    toolContext.filePath = media.filePath;
+                    toolContext.mimeType = media.mimeType;
+                }
+            }
+
+            const toolResult = await toolHandler.executeTool(name, args, toolContext);
+            
+            // Handle Side Effects
+            if (name === 'imageGenerator' && toolResult.success) {
+                await sock.sendMessage(remoteJid, { image: { url: toolResult.imageUrl }, caption: `_Generated via Gemini_` });
+            } else if (['fileGenerator', 'fileConverter'].includes(name) && toolResult.success) {
+                const fileName = path.basename(toolResult.filePath);
+                await sock.sendMessage(remoteJid, { 
+                    document: { url: toolResult.filePath }, 
+                    mimetype: mime.lookup(fileName) || 'application/octet-stream',
+                    fileName: fileName
+                });
+            } else if (name === 'stickerMaker' && toolResult.success) {
+                await sock.sendMessage(remoteJid, { sticker: { url: toolResult.stickerPath } });
+            }
+
+            functionResponses.push({ functionResponse: { name, response: { content: toolResult } } });
+            if (toolContext.filePath && fs.existsSync(toolContext.filePath)) fs.unlinkSync(toolContext.filePath);
+        }
+
+        result = await chat.sendMessage(functionResponses);
+        response = await result.response;
+        textResponse = response.text();
+        functionCalls = response.functionCalls();
+    }
+    return textResponse;
+}
+
+async function processWithGroq(sock, msg, remoteJid, text) {
+    const history = contextManager.getHistory(remoteJid);
+    const groqMessages = [{ role: "system", content: "Anda adalah asisten WhatsApp cerdas dengan akses ke berbagai tools. Jawab dalam Bahasa Indonesia." }];
+
+    for (const m of history) {
+        groqMessages.push({
+            role: m.role === 'model' ? 'assistant' : 'user',
+            content: m.parts[0].text
+        });
+    }
+
+    const tools = toolHandler.getOpenAITools();
+    let loopCount = 0;
+
+    while (loopCount < 5) {
+        loopCount++;
+        const completion = await groq.chat.completions.create({
+            messages: groqMessages,
+            model: config.ai.groq.powerfulModel || "llama-3.3-70b-versatile",
+            tools: tools,
+            tool_choice: "auto"
+        });
+
+        const responseMessage = completion.choices[0].message;
+        groqMessages.push(responseMessage);
+
+        if (responseMessage.tool_calls) {
+            for (const toolCall of responseMessage.tool_calls) {
+                const { name, arguments: argStr } = toolCall.function;
+                const args = JSON.parse(argStr);
+                
+                if (name === 'webSearch') await sock.sendMessage(remoteJid, { text: `> _Mencari di Google..._` });
+                if (name === 'stickerMaker') await sock.sendMessage(remoteJid, { text: `> _Membuat stiker..._` });
+                if (name === 'imageGenerator') await sock.sendMessage(remoteJid, { text: `> _Membuat gambar..._` });
+                if (['fileGenerator', 'fileConverter'].includes(name)) await sock.sendMessage(remoteJid, { text: `> _Membuat file..._` });
+
+                let toolContext = { remoteJid };
+                if (['stickerMaker', 'fileConverter', 'imageGenerator'].includes(name)) {
+                    const media = await downloadMediaForTool(sock, msg);
+                    if (media) {
+                        toolContext.filePath = media.filePath;
+                        toolContext.mimeType = media.mimeType;
+                    }
+                }
+
+                const toolResult = await toolHandler.executeTool(name, args, toolContext);
+                
+                if (name === 'imageGenerator' && toolResult.success) {
+                    await sock.sendMessage(remoteJid, { image: { url: toolResult.imageUrl }, caption: `_Generated via Groq_` });
+                } else if (['fileGenerator', 'fileConverter'].includes(name) && toolResult.success) {
+                    const fileName = path.basename(toolResult.filePath);
+                    await sock.sendMessage(remoteJid, { 
+                        document: { url: toolResult.filePath }, 
+                        mimetype: mime.lookup(fileName) || 'application/octet-stream',
+                        fileName: fileName
+                    });
+                } else if (name === 'stickerMaker' && toolResult.success) {
+                    await sock.sendMessage(remoteJid, { sticker: { url: toolResult.stickerPath } });
+                }
+
+                groqMessages.push({ tool_call_id: toolCall.id, role: "tool", name, content: JSON.stringify(toolResult) });
+                if (toolContext.filePath && fs.existsSync(toolContext.filePath)) fs.unlinkSync(toolContext.filePath);
+            }
+        } else {
+            return responseMessage.content;
+        }
+    }
+    return "Gagal memproses permintaan.";
+}
+
+// --- UTILITIES ---
+
+async function downloadMediaForTool(sock, msg) {
+    const quoted = msg.message.extendedTextMessage?.contextInfo?.quotedMessage;
+    const message = quoted || msg.message;
+    const mediaMsg = message.imageMessage || message.videoMessage || message.documentMessage || message.audioMessage || message.stickerMessage;
+    if (!mediaMsg) return null;
+
+    const buffer = await downloadMediaMessage({ message: message }, 'buffer', {}, { logger: pino({ level: 'silent' }), reuploadRequest: sock.updateMediaMessage });
+    const ext = mediaMsg.mimetype?.split('/')[1]?.split(';')[0] || 'bin';
+    const tempPath = path.join(TEMP_DIR, `tool_${Date.now()}.${ext}`);
+    fs.writeFileSync(tempPath, buffer);
+    return { filePath: tempPath, mimeType: mediaMsg.mimetype };
+}
+
+async function handleStickerCommand(sock, msg) {
+
+    const remoteJid = msg.key.remoteJid;
+
+    await sock.sendMessage(remoteJid, { text: '> _Membuat stiker..._' });
+
+    const media = await downloadMediaForTool(sock, msg);
+    if (!media) return sock.sendMessage(remoteJid, { text: '_Kirim/balas media dengan .sticker_'});
+
+    const result = await toolHandler.executeTool('stickerMaker', { target: 'auto' }, media);
+    if (result.success) await sock.sendMessage(remoteJid, { sticker: { url: result.stickerPath } });
+    if (fs.existsSync(media.filePath)) fs.unlinkSync(media.filePath);
+}
+
+async function handleDocument(sock, msg, docMsg) {
+    const remoteJid = msg.key.remoteJid;
+    const fileName = docMsg.fileName;
+    const tempPath = path.join(TEMP_DIR, fileName);
+    
+    await sock.sendMessage(remoteJid, { text: '> _Membaca dokumen..._'});
+    try {
+        const buffer = await downloadMediaMessage(msg, 'buffer', {}, { logger: pino({ level: 'silent' }), reuploadRequest: sock.updateMediaMessage });
+        fs.writeFileSync(tempPath, buffer);
+        const text = await ragHandler.extractText(tempPath, docMsg.mimetype);
+        if (text?.trim().length > 0) {
+            const analysis = await groqHandler.analyzeDocument(text, "Buat rangkuman detail.");
+            pendingDocumentContexts.set(remoteJid, analysis);
+            await sock.sendMessage(remoteJid, { text: `> _Dokumen "${fileName}" selesai dibaca. Dokumennya mau di apain?_` });
+        }
+        fs.unlinkSync(tempPath);
+    } catch (err) {
+        logger.error(`RAG Error: ${err.message}`);
+    }
+}
+
+// --- START ---
+startBot().catch(err => logger.fatal(`Startup Crash: ${err.message}`));

lib/contextManager.js

@@ -0,0 +1,75 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class ContextManager {
+    constructor(limit = 20) {
+        this.history = new Map(); // Key: remoteJid, Value: Array of messages
+        this.limit = limit;
+    }
+
+    /**
+     * Get chat history for a specific JID
+     * @param {string} jid - The Chat ID (user or group)
+     * @returns {Array} - Array of message objects { role, parts: [{ text }] }
+     */
+    getHistory(jid) {
+        if (!this.history.has(jid)) {
+            this.history.set(jid, []);
+        }
+        return this.history.get(jid);
+    }
+
+    /**
+     * Add a message to the history
+     * @param {string} jid 
+     * @param {string} text 
+     * @param {string} role - 'user' | 'model' | 'system'
+     */
+    addMessage(jid, text, role = 'user') {
+        const history = this.getHistory(jid);
+        
+        let finalRole = role;
+        let finalText = text;
+
+        // Gemini only accepts 'user' and 'model'. Handle 'system' or 'ai'.
+        if (role === 'ai') {
+            finalRole = 'model';
+        } else if (role === 'system') {
+            finalRole = 'user';
+            finalText = `[System Notice]: ${text}`;
+        }
+        
+        const message = {
+            role: finalRole,
+            parts: [{ text: finalText }]
+        };
+
+        history.push(message);
+
+        // Prune if exceeds limit (keep system prompt if we had one, but we are using native tools so maybe less reliance on system prompt in history)
+        if (history.length > this.limit) {
+            // Remove the oldest message (index 0)
+            history.shift();
+        }
+    }
+
+    /**
+     * Clear history for a JID
+     * @param {string} jid 
+     */
+    clearHistory(jid) {
+        this.history.delete(jid);
+    }
+
+    /**
+     * Get formatted history for Gemini API
+     * @param {string} jid 
+     */
+    getFormattedHistory(jid) {
+        return this.getHistory(jid);
+    }
+}
+
+// Singleton instance
+const contextManager = new ContextManager();
+module.exports = contextManager;

lib/groqHandler.js

@@ -0,0 +1,52 @@
+const Groq = require('groq-sdk');
+const config = require('../config');
+const pino = require('pino');
+
+const logger = pino({
+    level: 'info',
+    transport: {
+        target: 'pino-pretty',
+        options: { colorize: true, translateTime: 'SYS:standard', ignore: 'pid,hostname' }
+    }
+});
+
+const groq = new Groq({
+    apiKey: config.ai.groq.apiKey
+});
+
+class GroqHandler {
+    async analyzeDocument(docText, query) {
+        try {
+            logger.info(`Groq Analysis Started: Text length ${docText.length}, Query: "${query}"`);
+            
+            const safeText = docText.slice(0, 25000); 
+            
+            const completion = await groq.chat.completions.create({
+                messages: [
+                    {
+                        role: "system",
+                        content: "Anda adalah asisten analisis dokumen yang cerdas. Tugas anda adalah membaca konteks teks yang diberikan dan menjawab pertanyaan pengguna berdasarkan teks tersebut. Jawablah dalam Bahasa Indonesia yang jelas dan ringkas. Jika diminta merangkum, buatlah rangkuman poin-poin."
+                    },
+                    {
+                        role: "user",
+                        content: `KONTEKS DOKUMEN:\n${safeText}\n\nPERTANYAAN USER:\n${query}`
+                    }
+                ],
+                model: config.ai.groq.fastModel || "llama-3.1-8b-instant",
+                temperature: 0.5,
+                max_tokens: 4096,
+            });
+
+            const result = completion.choices[0]?.message?.content || "Gagal mendapatkan analisis dari Groq.";
+            logger.info(`Groq Analysis Finished. Output length: ${result.length}`);
+            
+            return result;
+        } catch (error) {
+            logger.error(`Groq Error: ${error.message}`);
+            return "Terjadi kesalahan saat model kedua mencoba membaca dokumen.";
+        }
+    }
+}
+
+const groqHandler = new GroqHandler();
+module.exports = groqHandler;

lib/markdownParser.js

@@ -0,0 +1,36 @@
+/**
+ * Parses Markdown from AI response to WhatsApp compatible format.
+ * WhatsApp supports: *bold*, _italic_, ~strikethrough~, ```monospace```
+ */
+
+function parseMarkdownToWhatsApp(text) {
+    if (!text) return '';
+
+    let formattedText = text;
+
+    // Bold: **text** or __text__ -> *text*
+    formattedText = formattedText.replace(/\*\*(.*?)\*\*/g, '*$1*');
+    formattedText = formattedText.replace(/__(.*?)__/g, '*$1*');
+
+    // Italic: *text* (if not matched by bold) or _text_ -> _text_
+    // Note: This is tricky because * is also used for lists. 
+    // We try to match pairs of * that are not part of a list or bold.
+    // A simple approximation:
+    formattedText = formattedText.replace(/(?<!\*)\*(?![*\s])(.*?)(?<!\s)\*(?!\*)/g, '_$1_');
+
+    // Headers: # Header -> *Header*
+    formattedText = formattedText.replace(/^#{1,6}\s+(.*)$/gm, '*$1*');
+
+    // Strikethrough: ~~text~~ -> ~text~
+    formattedText = formattedText.replace(/~~(.*?)~~/g, '~$1~');
+
+    // Links: [text](url) -> text (url)
+    formattedText = formattedText.replace(/\[(.*?)\]\((.*?)\)/g, '$1 ($2)');
+
+    // Lists: - item or * item -> • item (WhatsApp renders bullet points better with •)
+    // formattedText = formattedText.replace(/^[\*\-]\s+(.*)$/gm, '• $1');
+
+    return formattedText;
+}
+
+module.exports = { parseMarkdownToWhatsApp };

lib/ragHandler.js

@@ -0,0 +1,121 @@
+const fs = require('fs-extra');
+const path = require('path');
+const pdf = require('pdf-parse');
+const mammoth = require('mammoth');
+const officeParser = require('officeparser');
+const XLSX = require('xlsx');
+const Tesseract = require('tesseract.js');
+const mime = require('mime-types');
+
+class RagHandler {
+    constructor() {
+        this.storePath = path.join(__dirname, '../session/doc_store');
+        fs.ensureDirSync(this.storePath);
+    }
+
+    /**
+     * Membersihkan teks hasil ekstraksi dari whitespace berlebih dan karakter aneh.
+     */
+    cleanText(text) {
+        if (!text) return "";
+        return text
+            .replace(/\r\n/g, '\n') // Normalize newlines
+            .replace(/\t/g, ' ')    // Tabs to spaces
+            .replace(/ +/g, ' ')    // Multiple spaces to single space
+            .replace(/\n\s*\n/g, '\n\n') // Max 2 newlines
+            .trim();
+    }
+
+    /**
+     * Smart Extraction Router
+     */
+    async extractText(filePath, mimeType) {
+        try {
+            let extractedText = "";
+            const ext = path.extname(filePath).toLowerCase();
+
+            // 1. PDF Handling
+            if (mimeType === 'application/pdf' || ext === '.pdf') {
+                const dataBuffer = fs.readFileSync(filePath);
+                const data = await pdf(dataBuffer);
+                extractedText = data.text;
+                
+                // Jika PDF kosong (mungkin scanned), fallback ke OCR (Optional logic could go here, 
+                // but pdf-parse is usually fast. OCR on PDF pages requires splitting which is heavy).
+                if (extractedText.trim().length < 50) {
+                    extractedText += "\n[Catatan Sistem: Teks sangat sedikit. Dokumen ini mungkin berisi gambar scan yang sulit dibaca secara langsung.]";
+                }
+            } 
+            // 2. Word (DOCX)
+            else if (mimeType === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' || ext === '.docx') {
+                const result = await mammoth.extractRawText({ path: filePath });
+                extractedText = result.value;
+            } 
+            // 3. Excel / CSV (XLSX, XLS, CSV)
+            else if (
+                mimeType.includes('spreadsheet') || 
+                mimeType.includes('excel') || 
+                ext === '.xlsx' || ext === '.xls' || ext === '.csv'
+            ) {
+                const workbook = XLSX.readFile(filePath);
+                const sheetNames = workbook.SheetNames;
+                let excelData = [];
+                
+                sheetNames.forEach(name => {
+                    const sheet = workbook.Sheets[name];
+                    const csv = XLSX.utils.sheet_to_csv(sheet);
+                    if (csv && csv.trim().length > 0) {
+                        excelData.push(`--- Sheet: ${name} ---
+${csv}`);
+                    }
+                });
+                extractedText = excelData.join('\n\n');
+            }
+            // 4. PowerPoint (PPTX, PPT)
+            else if (mimeType.includes('presentation') || mimeType.includes('powerpoint') || ext === '.pptx' || ext === '.ppt') {
+                extractedText = await new Promise((resolve, reject) => {
+                    officeParser.parseOffice(filePath, (data, err) => {
+                        if (err) resolve(""); // Fail gracefully
+                        else resolve(data);
+                    });
+                });
+            }
+            // 5. Images (OCR)
+            else if (mimeType.startsWith('image/') || ['.jpg', '.jpeg', '.png', '.bmp'].includes(ext)) {
+                console.log(`Starting OCR for ${filePath}...`);
+                const { data: { text } } = await Tesseract.recognize(filePath, 'ind', { // 'ind' for Indonesian
+                    logger: m => {} // Silent logger
+                });
+                extractedText = text;
+            }
+            // 6. Plain Text / Code
+            else {
+                // Fallback for .txt, .js, .py, .json, etc.
+                extractedText = fs.readFileSync(filePath, 'utf8');
+            }
+
+            return this.cleanText(extractedText);
+
+        } catch (error) {
+            console.error('Smart Extraction Error:', error);
+            return `[Error: Gagal mengekstrak teks dari file ini. Format mungkin rusak atau tidak didukung.]`;
+        }
+    }
+
+    async saveDocumentContext(jid, text) {
+        const filePath = path.join(this.storePath, `${jid.replace(/\D/g, '')}.txt`);
+        await fs.writeFile(filePath, text, 'utf8');
+        return filePath;
+    }
+
+    async getDocumentContext(jid) {
+        const filePath = path.join(this.storePath, `${jid.replace(/\D/g, '')}.txt`);
+        if (fs.existsSync(filePath)) {
+            return await fs.readFile(filePath, 'utf8');
+        }
+        return null;
+    }
+}
+
+const ragHandler = new RagHandler();
+module.exports = ragHandler;

lib/recapManager.js

@@ -0,0 +1,84 @@
+const groqHandler = require('./groqHandler');
+const statsTracker = require('./statsTracker');
+
+class RecapManager {
+    constructor() {
+        this.activeRecaps = new Map(); // jid -> { type, step, data }
+    }
+
+    /**
+     * Memulai proses recap
+     */
+    async initiateRecap(jid, type = 'monthly') {
+        const now = new Date();
+        const lastMonth = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+        const year = lastMonth.getFullYear().toString();
+        const month = (lastMonth.getMonth() + 1).toString().padStart(2, '0');
+        
+        const stats = statsTracker.getUserStats(jid, year, month);
+        if (!stats || stats.total_messages < 5) return null;
+
+        const monthName = lastMonth.toLocaleString('id-ID', { month: 'long' });
+        
+        // State awal
+        this.activeRecaps.set(jid, {
+            type,
+            step: 0,
+            monthName,
+            stats,
+            history: [] // Untuk menjaga konsistensi narasi AI
+        });
+
+        return this.getNextStep(jid);
+    }
+
+    async getNextStep(jid, userReply = '') {
+        const session = this.activeRecaps.get(jid);
+        if (!session) return null;
+
+        session.step++;
+        
+        const { stats, monthName, step, type } = session;
+        
+        // Prompt dasar untuk AI agar gaya bicaranya "Deep & Trendy"
+        const systemPrompt = `Anda adalah asisten yang sedang memberikan kilas balik (recap) ${type} kepada user. 
+        Gunakan gaya bahasa anak muda zaman sekarang yang puitis tapi santai, gunakan plesetan atau tren terkait bulan ${monthName}. 
+        Urutan ini harus terasa personal (psychologically moving). 
+        Jangan berikan semua info sekaligus. HANYA berikan bagian untuk STEP ${step}.
+        Gunakan Bahasa Indonesia yang sangat akrab.`;
+
+        let prompt = "";
+        
+        if (type === 'monthly') {
+            switch(step) {
+                case 1: // Hook & Intro
+                    prompt = "Berikan kalimat pembuka yang sangat menarik tentang perjalanan kita di bulan ${monthName}. Mention bahwa kita sudah melewati banyak hal bersama.";
+                    break;
+                case 2: // Stats Dasar
+                    prompt = "Berikan data: Kita ngobrol selama ${stats.days_active.length} hari dengan total ${stats.total_messages} pesan. Berikan komentar unik tentang angka ini.";
+                    break;
+                case 3: // Puncak & Kebiasaan
+                    const peakHour = Object.entries(stats.hourly_activity).sort((a,b) => b[1]-a[1])[0][0];
+                    prompt = `Bahas tentang puncak aktivitas kita yang biasanya jam ${peakHour}.00. Juga bahas pola/kebiasaan baru yang kamu tangkap dari topik ini: ${stats.topics_summary.join(", ")}. Tanya pendapat user tentang kebiasaan ini untuk mengakhiri recap.`;
+                    break;
+                default:
+                    this.activeRecaps.delete(jid);
+                    return null;
+            }
+        }
+
+        const response = await groqHandler.analyzeDocument(JSON.stringify(stats), `${systemPrompt}\n\n${prompt}`);
+        
+        // Jika step terakhir, hapus sesi
+        if (step >= 3) this.activeRecaps.delete(jid);
+        
+        return response;
+    }
+
+    isInRecap(jid) {
+        return this.activeRecaps.has(jid);
+    }
+}
+
+const recapManager = new RecapManager();
+module.exports = recapManager;

lib/reminderService.js

@@ -0,0 +1,106 @@
+const schedule = require('node-schedule');
+const fs = require('fs-extra');
+const path = require('path');
+const pino = require('pino');
+
+const logger = pino({
+    level: 'info',
+    transport: {
+        target: 'pino-pretty',
+        options: { colorize: true, translateTime: 'SYS:standard', ignore: 'pid,hostname' }
+    }
+});
+
+const REMINDERS_FILE = path.join(__dirname, '../session/reminders.json');
+
+class ReminderService {
+    constructor() {
+        this.jobs = new Map(); // id -> job
+        this.sock = null;
+    }
+
+    init(sock) {
+        this.sock = sock;
+        
+        // Ensure file exists to prevent watch error
+        if (!fs.existsSync(REMINDERS_FILE)) {
+            fs.writeJSONSync(REMINDERS_FILE, [], { spaces: 2 });
+        }
+
+        this.loadAndScheduleAll();
+        
+        // Use watchFile for better cross-platform stability in production
+        fs.watchFile(REMINDERS_FILE, { interval: 5000 }, (curr, prev) => {
+            if (curr.mtime !== prev.mtime) {
+                logger.info('Reminders file changed, reloading...');
+                this.loadAndScheduleAll();
+            }
+        });
+    }
+
+    loadAndScheduleAll() {
+        try {
+            if (!fs.existsSync(REMINDERS_FILE)) return;
+            const reminders = fs.readJSONSync(REMINDERS_FILE);
+            
+            reminders.forEach(r => {
+                if (r.status === 'pending' && !this.jobs.has(r.id)) {
+                    const scheduledDate = new Date(r.time);
+                    const now = new Date();
+
+                    if (scheduledDate > now) {
+                        this.scheduleJob(r);
+                    } else {
+                        // Mark missed reminders as done or notify immediately
+                        logger.warn(`Missed reminder found for [${r.id}] scheduled at ${r.time}. Marking as done.`);
+                        this.markAsDone(r.id);
+                    }
+                }
+            });
+        } catch (e) {
+            logger.error(`Error loading reminders: ${e.message}`);
+        }
+    }
+
+    scheduleJob(reminder) {
+        // Prevent duplicate jobs
+        if (this.jobs.has(reminder.id)) return;
+
+        const job = schedule.scheduleJob(new Date(reminder.time), async () => {
+            try {
+                if (this.sock) {
+                    logger.info({ event: 'REMINDER_FIRED', to: reminder.jid, task: reminder.task });
+                    await this.sock.sendMessage(reminder.jid, { 
+                        text: `⏰ *REMINDER CERDAS*\n\nHalo! Saya diingatkan untuk memberitahu Anda:\n\n> "${reminder.task}" ` 
+                    });
+                    this.markAsDone(reminder.id);
+                    this.jobs.delete(reminder.id);
+                }
+            } catch (err) {
+                logger.error(`Failed to send reminder [${reminder.id}]: ${err.message}`);
+            }
+        });
+        
+        if (job) {
+            this.jobs.set(reminder.id, job);
+            logger.info(`Scheduled reminder [${reminder.id}] for ${reminder.time}`);
+        }
+    }
+
+    markAsDone(id) {
+        try {
+            // Read fresh data to avoid overwriting changes from other processes
+            const reminders = fs.readJSONSync(REMINDERS_FILE);
+            const index = reminders.findIndex(r => r.id === id);
+            if (index !== -1) {
+                reminders[index].status = 'done';
+                fs.writeJSONSync(REMINDERS_FILE, reminders, { spaces: 2 });
+            }
+        } catch (e) {
+            logger.error(`Error marking reminder as done: ${e.message}`);
+        }
+    }
+}
+
+const reminderService = new ReminderService();
+module.exports = reminderService;

lib/statsTracker.js

@@ -0,0 +1,72 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const STATS_FILE = path.join(__dirname, '../session/stats.json');
+
+class StatsTracker {
+    constructor() {
+        fs.ensureFileSync(STATS_FILE);
+        this.data = this.loadData();
+    }
+
+    loadData() {
+        try {
+            return fs.readJSONSync(STATS_FILE);
+        } catch (e) {
+            return {};
+        }
+    }
+
+    saveData() {
+        fs.writeJSONSync(STATS_FILE, this.data, { spaces: 2 });
+    }
+
+    /**
+     * Mencatat setiap pesan masuk
+     */
+    addActivity(jid, role = 'user', text = '') {
+        const now = new Date();
+        const year = now.getFullYear().toString();
+        const month = (now.getMonth() + 1).toString().padStart(2, '0');
+        const day = now.getDate().toString().padStart(2, '0');
+
+        if (!this.data[jid]) this.data[jid] = {};
+        if (!this.data[jid][year]) this.data[jid][year] = {};
+        if (!this.data[jid][year][month]) this.data[jid][year][month] = {
+            total_messages: 0,
+            days_active: [],
+            hourly_activity: {},
+            topics_summary: [] // Cuplikan singkat untuk bahan AI
+        };
+
+        const monthData = this.data[jid][year][month];
+        monthData.total_messages++;
+
+        if (!monthData.days_active.includes(day)) {
+            monthData.days_active.push(day);
+        }
+
+        const hour = now.getHours().toString();
+        monthData.hourly_activity[hour] = (monthData.hourly_activity[hour] || 0) + 1;
+
+        // Simpan sedikit sampel teks (maks 10 sampel per bulan untuk privasi & efisiensi)
+        if (role === 'user' && text.length > 10 && monthData.topics_summary.length < 30) {
+            if (Math.random() > 0.7) { // Random sampling
+                monthData.topics_summary.push(text.slice(0, 100));
+            }
+        }
+
+        this.saveData();
+    }
+
+    getUserStats(jid, year, month) {
+        return this.data[jid]?.[year]?.[month] || null;
+    }
+
+    getYearlyStats(jid, year) {
+        return this.data[jid]?.[year] || null;
+    }
+}
+
+const statsTracker = new StatsTracker();
+module.exports = statsTracker;

lib/toolHandler.js

@@ -0,0 +1,138 @@
+const fs = require('fs-extra');
+const path = require('path');
+const pino = require('pino');
+
+const logger = pino({
+    level: 'info',
+    transport: {
+        target: 'pino-pretty',
+        options: { colorize: true, translateTime: 'SYS:standard', ignore: 'pid,hostname' }
+    }
+});
+
+class ToolHandler {
+    constructor() {
+        this.toolsPath = path.join(__dirname, '../tools');
+        this.schemasPath = path.join(__dirname, '../tools/schemas');
+        this.registry = new Map();
+        this._initRegistry();
+    }
+
+    _initRegistry() {
+        if (!fs.existsSync(this.schemasPath)) return;
+
+        const schemas = fs.readdirSync(this.schemasPath).filter(f => f.endsWith('.json'));
+        
+        for (const schemaFile of schemas) {
+            const toolName = path.basename(schemaFile, '.json');
+            const implFile = path.join(this.toolsPath, `${toolName}.js`);
+
+            if (fs.existsSync(implFile)) {
+                this.registry.set(toolName, {
+                    schemaPath: path.join(this.schemasPath, schemaFile),
+                    implPath: implFile
+                });
+            } else {
+                logger.warn(`Tool schema found for "${toolName}" but implementation file is missing.`);
+            }
+        }
+    }
+
+    getTools() {
+        const tools = [];
+        for (const [name, paths] of this.registry) {
+            try {
+                const schema = fs.readJSONSync(paths.schemaPath);
+                schema.name = name; 
+                tools.push(schema);
+            } catch (err) {
+                logger.error(`Error reading schema for ${name}: ${err.message}`);
+            }
+        }
+        return [{ function_declarations: tools }];
+    }
+
+    /**
+     * Get tools in OpenAI/Groq format
+     */
+    getOpenAITools() {
+        const tools = [];
+        for (const [name, paths] of this.registry) {
+            try {
+                const schema = fs.readJSONSync(paths.schemaPath);
+                
+                // Convert Gemini-style schema to OpenAI-style
+                const convertSchema = (obj) => {
+                    if (typeof obj !== 'object' || obj === null) return obj;
+                    
+                    const newObj = Array.isArray(obj) ? [] : {};
+                    for (const key in obj) {
+                        if (key === 'type' && typeof obj[key] === 'string') {
+                            // Map Gemini types to JSON Schema types
+                            const typeMap = {
+                                'STRING': 'string',
+                                'NUMBER': 'number',
+                                'INTEGER': 'integer',
+                                'BOOLEAN': 'boolean',
+                                'ARRAY': 'array',
+                                'OBJECT': 'object'
+                            };
+                            newObj[key] = typeMap[obj[key]] || obj[key].toLowerCase();
+                        } else {
+                            newObj[key] = convertSchema(obj[key]);
+                        }
+                    }
+                    return newObj;
+                };
+
+                const openAISchema = {
+                    type: "function",
+                    function: {
+                        name: name,
+                        description: schema.description,
+                        parameters: convertSchema(schema.parameters)
+                    }
+                };
+                tools.push(openAISchema);
+            } catch (err) {
+                logger.error(`Error formatting OpenAI schema for ${name}: ${err.message}`);
+            }
+        }
+        return tools.length > 0 ? tools : undefined;
+    }
+
+    async executeTool(name, args, context = {}) {
+        if (!this.registry.has(name)) {
+            logger.error(`Execution failed: Tool "${name}" not found in registry.`);
+            throw new Error(`Tool ${name} not found`);
+        }
+
+        const { implPath } = this.registry.get(name);
+        
+        try {
+            logger.info({ event: 'TOOL_EXEC_START', tool: name, args });
+            
+            const toolModule = require(implPath);
+            if (typeof toolModule.execute !== 'function') {
+                throw new Error(`Tool ${name} does not export an 'execute' function.`);
+            }
+
+            const result = await toolModule.execute(args, context);
+            
+            logger.info({ 
+                event: 'TOOL_EXEC_END', 
+                tool: name, 
+                success: !!(result && !result.error),
+                output: typeof result === 'object' ? JSON.stringify(result).slice(0, 500) : result 
+            });
+
+            return result;
+        } catch (error) {
+            logger.error({ event: 'TOOL_EXEC_ERROR', tool: name, error: error.message });
+            return { error: error.message };
+        }
+    }
+}
+
+const toolHandler = new ToolHandler();
+module.exports = toolHandler;

package.json

@@ -0,0 +1,39 @@
+{
+  "name": "whatsapp2",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node syncSession.js && node index.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
+    "@google/generative-ai": "^0.24.1",
+    "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "axios": "^1.13.4",
+    "canvas": "^3.2.1",
+    "cloudconvert": "^3.0.0",
+    "docx": "^9.5.1",
+    "dotenv": "^17.2.3",
+    "fluent-ffmpeg": "^2.1.3",
+    "fs-extra": "^11.3.3",
+    "groq-sdk": "^0.37.0",
+    "mammoth": "^1.11.0",
+    "mime-types": "^3.0.2",
+    "node-schedule": "^2.1.1",
+    "officeparser": "^6.0.4",
+    "pdf-parse": "^2.4.5",
+    "pdfkit": "^0.17.2",
+    "pino": "^10.3.0",
+    "pino-pretty": "^13.1.3",
+    "puppeteer": "^24.36.1",
+    "puppeteer-extra": "^3.3.6",
+    "puppeteer-extra-plugin-stealth": "^2.11.2",
+    "qrcode-terminal": "^0.12.0",
+    "sharp": "^0.34.5",
+    "tesseract.js": "^7.0.0",
+    "xlsx": "^0.18.5"
+  }
+}

syncSession.js

@@ -0,0 +1,34 @@
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Script ini mendeteksi jika ada data sesi di Environment Variable
+ * dan mengembalikannya ke folder ./session sebelum bot dijalankan.
+ */
+async function syncSession() {
+    const sessionB64 = process.env.SESSION_DATA;
+    const sessionPath = path.join(__dirname, 'session');
+
+    if (sessionB64 && sessionB64.length > 100) {
+        console.log("Mendeteksi SESSION_DATA dari Secret... Mengekstrak...");
+        
+        try {
+            const zipPath = path.join(__dirname, 'session.zip');
+            fs.writeFileSync(zipPath, Buffer.from(sessionB64, 'base64'));
+            
+            // Ekstrak menggunakan unzip (tersedia di Linux HF)
+            fs.ensureDirSync(sessionPath);
+            execSync(`unzip -o ${zipPath} -d .`);
+            fs.unlinkSync(zipPath);
+            
+            console.log("Sesi berhasil dipulihkan!");
+        } catch (error) {
+            console.error("Gagal mengekstrak sesi:", error.message);
+        }
+    } else {
+        console.log("Tidak ada SESSION_DATA ditemukan. Memulai sesi baru.");
+    }
+}
+
+syncSession();

tools/fileConverter.js

@@ -0,0 +1,86 @@
+const path = require('path');
+const fs = require('fs-extra');
+const { exec } = require('child_process');
+const ffmpeg = require('fluent-ffmpeg');
+const ffmpegInstaller = require('@ffmpeg-installer/ffmpeg');
+const sharp = require('sharp');
+
+ffmpeg.setFfmpegPath(ffmpegInstaller.path);
+
+module.exports = {
+    /**
+     * Konverter File Lokal yang Kuat (FFmpeg + Sharp + LibreOffice)
+     */
+    execute: async (args, context) => {
+        const { outputFormat } = args;
+        const { filePath, mimeType } = context;
+
+        if (!outputFormat) return { error: 'Format output tidak ditentukan.' };
+        if (!filePath || !fs.existsSync(filePath)) return { error: 'File sumber tidak ditemukan.' };
+
+        const inputExt = path.extname(filePath).toLowerCase().replace('.', '');
+        const targetFormat = outputFormat.toLowerCase().replace('.', '');
+        const outputFileName = `${path.parse(filePath).name}_converted.${targetFormat}`;
+        const outputPath = path.join(__dirname, '../temp_files', outputFileName);
+        
+        fs.ensureDirSync(path.join(__dirname, '../temp_files'));
+
+        try {
+            // --- KATEGORI 1: GAMBAR (PNG, JPG, WEBP, TIFF, dll) ---
+            if (mimeType.startsWith('image/') && !mimeType.includes('photoshop')) {
+                await sharp(filePath)
+                    .toFormat(targetFormat)
+                    .toFile(outputPath);
+                return { success: true, filePath: outputPath };
+            }
+
+            // --- KATEGORI 2: AUDIO & VIDEO (MP4, MP3, MKV, WAV, dll) ---
+            if (mimeType.startsWith('video/') || mimeType.startsWith('audio/') || ['mp4', 'mkv', 'avi', 'mov', 'mp3', 'wav', 'flac', 'opus'].includes(inputExt)) {
+                return new Promise((resolve) => {
+                    let command = ffmpeg(filePath).toFormat(targetFormat);
+                    
+                    if (targetFormat === 'mp3') {
+                        command.audioBitrate('192k').noVideo();
+                    }
+
+                    command
+                        .on('end', () => resolve({ success: true, filePath: outputPath }))
+                        .on('error', (err) => resolve({ error: `FFmpeg Error: ${err.message}` }))
+                        .save(outputPath);
+                });
+            }
+
+            // --- KATEGORI 3: DOKUMEN (DOCX, PDF, XLSX, PPTX) ---
+            // Menggunakan LibreOffice Headless (Harus terinstall di OS)
+            const docFormats = ['pdf', 'docx', 'doc', 'xlsx', 'xls', 'pptx', 'ppt', 'txt', 'rtf', 'html'];
+            if (docFormats.includes(inputExt) || docFormats.includes(targetFormat)) {
+                return new Promise((resolve) => {
+                    // LibreOffice command: libreoffice --headless --convert-to [format] [file] --outdir [dir]
+                    const cmd = `libreoffice --headless --convert-to ${targetFormat} "${filePath}" --outdir "${path.join(__dirname, '../temp_files')}"`;
+                    
+                    exec(cmd, (error, stdout, stderr) => {
+                        if (error) {
+                            return resolve({ error: `LibreOffice Error: ${error.message}. Pastikan LibreOffice terinstall di server.` });
+                        }
+                        
+                        // LibreOffice terkadang menggunakan nama file asli, kita perlu mendeteksinya
+                        const expectedPath = path.join(__dirname, '../temp_files', `${path.parse(filePath).name}.${targetFormat}`);
+                        if (fs.existsSync(expectedPath)) {
+                            // Rename agar sesuai dengan outputFileName kita (opsional)
+                            fs.renameSync(expectedPath, outputPath);
+                            resolve({ success: true, filePath: outputPath });
+                        } else {
+                            resolve({ error: "Gagal menemukan file hasil konversi LibreOffice." });
+                        }
+                    });
+                });
+            }
+
+            return { error: `Format konversi dari ${inputExt} ke ${targetFormat} belum didukung oleh engine lokal.` };
+
+        } catch (error) {
+            console.error('Local Conversion Error:', error);
+            return { error: `Konversi gagal: ${error.message}` };
+        }
+    }
+};

tools/fileGenerator.js

@@ -0,0 +1,51 @@
+const fs = require('fs-extra');
+const path = require('path');
+const PDFDocument = require('pdfkit');
+const { Document, Packer, Paragraph, TextRun } = require('docx');
+
+const TEMP_DIR = path.join(__dirname, '../temp_files');
+fs.ensureDirSync(TEMP_DIR);
+
+module.exports = {
+    execute: async ({ filename, content, format }) => {
+        const filePath = path.join(TEMP_DIR, filename);
+        
+        try {
+            if (format === 'pdf' || filename.endsWith('.pdf')) {
+                const doc = new PDFDocument();
+                const stream = fs.createWriteStream(filePath);
+                doc.pipe(stream);
+                doc.fontSize(12).text(content, 100, 100);
+                doc.end();
+                
+                await new Promise((resolve) => stream.on('finish', resolve));
+            } else if (format === 'docx' || filename.endsWith('.docx')) {
+                const doc = new Document({
+                    sections: [{
+                        properties: {},
+                        children: content.split('\n').map(line => 
+                            new Paragraph({
+                                children: [new TextRun(line)],
+                            })
+                        ),
+                    }],
+                });
+                
+                const buffer = await Packer.toBuffer(doc);
+                fs.writeFileSync(filePath, buffer);
+            } else {
+                // txt, code (py, js, html)
+                fs.writeFileSync(filePath, content);
+            }
+
+            return { 
+                success: true, 
+                filePath: filePath, 
+                message: `File ${filename} created successfully.` 
+            };
+        } catch (error) {
+            console.error('File Generation Error:', error);
+            return { error: 'Failed to generate file.' };
+        }
+    }
+};

tools/imageGenerator.js

@@ -0,0 +1,70 @@
+const axios = require('axios');
+const config = require('../config');
+const fs = require('fs-extra');
+const path = require('path');
+
+const MODELS = [
+    "black-forest-labs/flux.2-klein-4b",
+    "bytedance-seed/seedream-4.5",
+    "black-forest-labs/flux.2-max"
+];
+
+module.exports = {
+    /**
+     * @param {object} args - { prompt }
+     * @param {object} context - { filePath, mimeType } for Image-to-Image
+     */
+    execute: async (args, context) => {
+        const { prompt } = args;
+        const { filePath, mimeType } = context;
+        
+        if (!config.ai.openRouter.apiKey) {
+            return { error: "OpenRouter API Key is missing." };
+        }
+
+        // Prepare image data if exists (Image-to-Image / Reference)
+        let imageData = null;
+        if (filePath && fs.existsSync(filePath) && mimeType.startsWith('image/')) {
+            imageData = fs.readFileSync(filePath).toString('base64');
+        }
+
+        for (const model of MODELS) {
+            try {
+                console.log(`Attempting image generation with model: ${model}...`);
+                
+                const payload = {
+                    model: model,
+                    prompt: prompt,
+                };
+
+                // Add reference image for multimodal models if available
+                if (imageData) {
+                    payload.images = [imageData];
+                }
+
+                const response = await axios.post('https://openrouter.ai/api/v1/images/generations', payload, {
+                    headers: {
+                        'Authorization': `Bearer ${config.ai.openRouter.apiKey}`,
+                        'Content-Type': 'application/json'
+                    },
+                    timeout: 60000 // Image gen can be slow
+                });
+
+                if (response.data && response.data.data && response.data.data[0]) {
+                    const imageUrl = response.data.data[0].url;
+                    return { 
+                        success: true, 
+                        imageUrl: imageUrl, 
+                        modelUsed: model,
+                        message: `Image generated using ${model}` 
+                    };
+                }
+            } catch (error) {
+                console.warn(`Model ${model} failed:`, error.response?.data || error.message);
+                continue; // Try next model
+            }
+        }
+
+        return { error: "All image generation models failed. Please try again later." };
+    }
+};

tools/manageReminder.js

@@ -0,0 +1,52 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const REMINDERS_FILE = path.join(__dirname, '../session/reminders.json');
+
+module.exports = {
+    /**
+     * @param {object} args - { task, scheduledTime, action }
+     * @param {object} context - { remoteJid }
+     */
+    execute: async (args, context) => {
+        const { task, scheduledTime, action } = args;
+        const { remoteJid } = context;
+
+        if (!remoteJid) return { error: "Context missing remoteJid" };
+
+        try {
+            fs.ensureFileSync(REMINDERS_FILE);
+            let reminders = [];
+            try {
+                reminders = fs.readJSONSync(REMINDERS_FILE);
+            } catch (e) { reminders = []; }
+
+            if (action === 'add') {
+                const newReminder = {
+                    id: Date.now().toString(),
+                    jid: remoteJid,
+                    task,
+                    time: scheduledTime,
+                    status: 'pending'
+                };
+                reminders.push(newReminder);
+                fs.writeJSONSync(REMINDERS_FILE, reminders, { spaces: 2 });
+                
+                // Note: The actual scheduling happens in the background service 
+                // which should watch this file or be notified.
+                return { success: true, message: `Reminder terdaftar untuk ${newReminder.time}: "${task}"` };
+            } 
+            
+            if (action === 'list') {
+                const userReminders = reminders.filter(r => r.jid === remoteJid && r.status === 'pending');
+                return { success: true, reminders: userReminders };
+            }
+
+            return { error: "Action not supported yet." };
+
+        } catch (error) {
+            console.error("Reminder Tool Error:", error);
+            return { error: error.message };
+        }
+    }
+};

tools/schemas/fileConverter.json

@@ -0,0 +1,14 @@
+{
+  "name": "fileConverter",
+  "description": "Converts any file format to another format (e.g., PDF to DOCX, JPG to PNG, MP4 to MP3, etc.). Use this when the user asks to change the format of a file they sent or quoted.",
+  "parameters": {
+    "type": "OBJECT",
+    "properties": {
+      "outputFormat": {
+        "type": "STRING",
+        "description": "The target format extension (e.g., 'pdf', 'docx', 'mp3', 'png')."
+      }
+    },
+    "required": ["outputFormat"]
+  }
+}

tools/schemas/fileGenerator.json

@@ -0,0 +1,23 @@
+{
+  "name": "fileGenerator",
+  "description": "Generates a file (PDF, DOCX, TXT, Python, JS, HTML) with the provided content. Use this when the user asks to create a file or download code.",
+  "parameters": {
+    "type": "OBJECT",
+    "properties": {
+      "filename": {
+        "type": "STRING",
+        "description": "The name of the file to create (e.g., 'report.pdf', 'script.py')."
+      },
+      "content": {
+        "type": "STRING",
+        "description": "The text content or code to put inside the file."
+      },
+      "format": {
+        "type": "STRING",
+        "enum": ["pdf", "docx", "txt", "code"],
+        "description": "The format of the file."
+      }
+    },
+    "required": ["filename", "content", "format"]
+  }
+}

tools/schemas/imageGenerator.json

@@ -0,0 +1,14 @@
+{
+  "name": "imageGenerator",
+  "description": "Generates or edits an image based on a prompt. Can use an existing image as reference if provided. Use this when the user wants to create, visualize, or edit something visually.",
+  "parameters": {
+    "type": "OBJECT",
+    "properties": {
+      "prompt": {
+        "type": "STRING",
+        "description": "The creative and detailed visual description of the image to generate, expanded from the user's request."
+      }
+    },
+    "required": ["prompt"]
+  }
+}

tools/schemas/manageReminder.json

@@ -0,0 +1,23 @@
+{
+  "name": "manageReminder",
+  "description": "Registers a new reminder or to-do list item for the user. AI should determine the specific date and time based on user input. For 'malam', assume 18:00 or 19:00 unless specified otherwise.",
+  "parameters": {
+    "type": "OBJECT",
+    "properties": {
+      "task": {
+        "type": "STRING",
+        "description": "The description of the task or note to be reminded of."
+      },
+      "scheduledTime": {
+        "type": "STRING",
+        "description": "The ISO 8601 formatted date and time for the reminder (e.g., '2026-02-02T18:00:00Z'). AI must calculate this relative to the current time."
+      },
+      "action": {
+        "type": "STRING",
+        "enum": ["add", "list", "delete"],
+        "description": "The action to perform."
+      }
+    },
+    "required": ["task", "scheduledTime", "action"]
+  }
+}

tools/schemas/stickerMaker.json

@@ -0,0 +1,15 @@
+{
+  "name": "stickerMaker",
+  "description": "Converts an image or video into a WhatsApp sticker. Use this when the user explicitly asks to create a sticker from media they sent or quoted.",
+  "parameters": {
+    "type": "OBJECT",
+    "properties": {
+      "target": {
+        "type": "STRING",
+        "description": "Set to 'auto' to indicate using the attached or quoted media.",
+        "enum": ["auto"]
+      }
+    },
+    "required": ["target"]
+  }
+}

tools/schemas/webSearch.json

@@ -0,0 +1,14 @@
+{
+  "name": "webSearch",
+  "description": "Tools untuk mencari informasi realtime atau terbaru",
+  "parameters": {
+    "type": "OBJECT",
+    "properties": {
+      "query": {
+        "type": "STRING",
+        "description": "The search query."
+      }
+    },
+    "required": ["query"]
+  }
+}

tools/stickerMaker.js

@@ -0,0 +1,56 @@
+const ffmpeg = require('fluent-ffmpeg');
+const ffmpegInstaller = require('@ffmpeg-installer/ffmpeg');
+const path = require('path');
+const fs = require('fs-extra');
+
+ffmpeg.setFfmpegPath(ffmpegInstaller.path);
+
+module.exports = {
+    /**
+     * @param {object} args
+     * @param {object} context - Contains filePath and mimeType of the media
+     */
+    execute: async (args, context) => {
+        const { filePath, mimeType } = context;
+        if (!filePath) return { error: 'No media found to convert.' };
+
+        const outputName = `sticker_${Date.now()}.webp`;
+        const outputPath = path.join(__dirname, '../temp_files', outputName);
+        fs.ensureDirSync(path.join(__dirname, '../temp_files'));
+
+        return new Promise((resolve, reject) => {
+            let command = ffmpeg(filePath);
+
+            if (mimeType.includes('video')) {
+                // Video to Animated Sticker (max 6 seconds)
+                command
+                    .setStartTime(0)
+                    .setDuration(6)
+                    .on('error', (err) => resolve({ error: `FFMPEG Error: ${err.message}` }))
+                    .on('end', () => resolve({ success: true, stickerPath: outputPath }))
+                    .addOutputOptions([
+                        '-vcodec', 'libwebp',
+                        '-vf', 'scale=512:512:force_original_aspect_ratio=increase,fps=15,crop=512:512',
+                        '-loop', '0',
+                        '-preset', 'default',
+                        '-an',
+                        '-vsync', '0',
+                        '-s', '512:512'
+                    ])
+                    .toFormat('webp')
+                    .save(outputPath);
+            } else {
+                // Image to Static Sticker
+                command
+                    .on('error', (err) => resolve({ error: `FFMPEG Error: ${err.message}` }))
+                    .on('end', () => resolve({ success: true, stickerPath: outputPath }))
+                    .addOutputOptions([
+                        '-vcodec', 'libwebp',
+                        '-vf', 'scale=512:512:force_original_aspect_ratio=increase,fps=15,crop=512:512'
+                    ])
+                    .toFormat('webp')
+                    .save(outputPath);
+            }
+        });
+    }
+};

tools/webSearch.js

@@ -0,0 +1,69 @@
+const config = require('../config');
+const axios = require('axios');
+// Lazy load puppeteer to save RAM on startup
+// const puppeteer = require('puppeteer-extra'); 
+
+async function searchWithApi(query) {
+    if (!config.search.apiKey || !config.search.cseId) return null;
+    
+    try {
+        const url = `https://www.googleapis.com/customsearch/v1?key=${config.search.apiKey}&cx=${config.search.cseId}&q=${encodeURIComponent(query)}`;
+        const response = await axios.get(url);
+        const items = response.data.items || [];
+        return items.map(item => `Title: ${item.title}\nLink: ${item.link}\nSnippet: ${item.snippet}`).join('\n\n');
+    } catch (error) {
+        console.error('API Search Error:', error.message);
+        return null;
+    }
+}
+
+async function searchWithPuppeteer(query) {
+    const puppeteer = require('puppeteer-extra');
+    const StealthPlugin = require('puppeteer-extra-plugin-stealth');
+    puppeteer.use(StealthPlugin());
+
+    let browser;
+    try {
+        browser = await puppeteer.launch({
+            headless: 'new',
+            args: ['--no-sandbox', '--disable-setuid-sandbox'] 
+        });
+        const page = await browser.newPage();
+        await page.goto(`https://www.google.com/search?q=${encodeURIComponent(query)}`);
+        
+        // Wait for results
+        await page.waitForSelector('#search');
+        
+        const results = await page.evaluate(() => {
+            const items = document.querySelectorAll('.tF2Cxc'); // Common selector for Google results
+            let data = [];
+            items.forEach(item => {
+                const title = item.querySelector('h3')?.innerText;
+                const link = item.querySelector('a')?.href;
+                const snippet = item.querySelector('.VwiC3b')?.innerText;
+                if (title && link) {
+                    data.push(`Title: ${title}\nLink: ${link}\nSnippet: ${snippet || ''}`);
+                }
+            });
+            return data.slice(0, 5).join('\n\n');
+        });
+        
+        return results;
+    } catch (error) {
+        console.error('Puppeteer Search Error:', error.message);
+        return 'Failed to perform search.';
+    } finally {
+        if (browser) await browser.close();
+    }
+}
+
+module.exports = {
+    execute: async ({ query }) => {
+        let results = await searchWithApi(query);
+        if (!results) {
+            console.log('Falling back to Puppeteer search...');
+            results = await searchWithPuppeteer(query);
+        }
+        return { result: results || 'No results found.' };
+    }
+};