waengine 1.0.6 → 1.0.8

package/README.md

@@ -496,20 +496,52 @@ const messageTypes = await msg.stats.getMessagesByType()
 
 ### **Prefix Setup**
 ```javascript
-// Set prefix
+// Global Prefix (Fallback)
 const prefix = "!"
 client.setPrefix(prefix)
 
-// Register commands
+// Chat-spezifische Prefixes (NEU in v1.0.7!)
+client.setChatPrefix(chatId, "#")  // Für spezifischen Chat
+client.getChatPrefix(chatId)       // Prefix abrufen
+client.removeChatPrefix(chatId)    // Prefix entfernen
+
+// Commands registrieren
 client.addCommand('help', async (msg, args) => {
     await msg.reply('Help text')
 })
+```
 
-client.addCommand('ping', async (msg, args) => {
-    await msg.reply('Pong! 🏓')
-})
+### **Chat-spezifische Prefixes (v1.0.7)**
+Jeder Chat/Gruppe kann einen eigenen Prefix haben:
+
+```javascript
+// Setprefix Command (Admin only)
+client.addCommand('setprefix', async (msg, args) => {
+    if (msg.isGroup && !(await msg.isAdmin())) {
+        return msg.reply('❌ Nur Admins können den Prefix ändern!');
+    }
+    
+    const newPrefix = args[0];
+    client.setChatPrefix(msg.from, newPrefix);
+    await msg.reply(`✅ Prefix geändert zu: "${newPrefix}"`);
+});
+
+// Prefix Info Command
+client.addCommand('prefixinfo', async (msg) => {
+    const chatPrefix = client.getChatPrefix(msg.from);
+    const stats = client.getPrefixStats();
+    
+    await msg.reply(`🎯 Aktueller Prefix: "${chatPrefix}"\n📊 Gesamt Chats: ${stats.totalChats}`);
+});
 ```
 
+**Features:**
+- ✅ **Persistent Storage** - Prefixes werden automatisch gespeichert
+- ✅ **Admin-only** - Nur Admins können Prefixes in Gruppen ändern
+- ✅ **Validierung** - Max 5 Zeichen, keine Leerzeichen
+- ✅ **Statistics** - Übersicht über alle verwendeten Prefixes
+- ✅ **Fallback** - Global Prefix als Standard
+
 ### **Command Properties**
 ```javascript
 // In message events

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waengine",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "🚀 WAEngine - The most powerful WhatsApp Bot Library with Multi-Device Support & EasyBot API",
   "main": "src/index.js",
   "type": "module",
@@ -24,6 +24,9 @@
     "messaging",
     "multi-account",
     "load-balancing",
+    "prefix-system",
+    "chat-specific",
+    "group-management",
     "typescript",
     "javascript",
     "nodejs"
@@ -47,6 +50,8 @@
   },
   "dependencies": {
     "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "axios": "^1.13.4",
+    "node-cron": "^3.0.3",
     "pino": "^8.0.0",
     "playwright": "^1.58.1",
     "qrcode": "^1.5.4",

package/src/ai-integration.js

@@ -0,0 +1,185 @@
+// AI Integration für WAEngine
+import axios from 'axios';
+
+export class AIIntegration {
+    constructor(options = {}) {
+        this.apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+        this.baseURL = options.baseURL || 'https://api.openai.com/v1';
+        this.model = options.model || 'gpt-3.5-turbo';
+        this.enabled = !!this.apiKey;
+        
+        if (!this.enabled) {
+            console.log('⚠️ AI Integration deaktiviert - Kein API Key gefunden');
+        } else {
+            console.log('🤖 AI Integration aktiviert');
+        }
+    }
+
+    // ===== CHAT COMPLETION =====
+    
+    async chat(prompt, options = {}) {
+        if (!this.enabled) {
+            throw new Error('❌ AI Integration nicht konfiguriert! Setze OPENAI_API_KEY');
+        }
+
+        try {
+            const response = await axios.post(`${this.baseURL}/chat/completions`, {
+                model: options.model || this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: options.systemPrompt || 'Du bist ein hilfreicher WhatsApp Bot Assistent. Antworte kurz und freundlich auf Deutsch.'
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                max_tokens: options.maxTokens || 500,
+                temperature: options.temperature || 0.7
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            return response.data.choices[0].message.content.trim();
+        } catch (error) {
+            console.error('❌ AI Chat Fehler:', error.response?.data || error.message);
+            throw new Error(`AI Fehler: ${error.response?.data?.error?.message || error.message}`);
+        }
+    }
+
+    // ===== SMART RESPONSES =====
+    
+    async smartReply(message, context = {}) {
+        const prompt = `
+Kontext: WhatsApp Bot Nachricht
+User schrieb: "${message}"
+Chat-Type: ${context.isGroup ? 'Gruppe' : 'Privat'}
+${context.userName ? `User: ${context.userName}` : ''}
+
+Antworte natürlich und hilfreich. Maximal 2 Sätze.
+        `.trim();
+
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein freundlicher WhatsApp Bot. Antworte natürlich und kurz.',
+            maxTokens: 200
+        });
+    }
+
+    // ===== TEXT ANALYSIS =====
+    
+    async analyzeMessage(text) {
+        const prompt = `
+Analysiere diese Nachricht:
+"${text}"
+
+Gib zurück als JSON:
+{
+  "sentiment": "positive/negative/neutral",
+  "language": "de/en/es/fr/etc",
+  "category": "question/command/greeting/complaint/other",
+  "toxicity": "low/medium/high",
+  "confidence": 0.0-1.0
+}
+        `.trim();
+
+        try {
+            const response = await this.chat(prompt, {
+                systemPrompt: 'Du bist ein Text-Analyse-Experte. Antworte nur mit gültigem JSON.',
+                maxTokens: 150
+            });
+            
+            return JSON.parse(response);
+        } catch (error) {
+            return {
+                sentiment: 'neutral',
+                language: 'unknown',
+                category: 'other',
+                toxicity: 'low',
+                confidence: 0.5
+            };
+        }
+    }
+
+    // ===== MODERATION =====
+    
+    async moderateContent(text) {
+        try {
+            const response = await axios.post(`${this.baseURL}/moderations`, {
+                input: text
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            const result = response.data.results[0];
+            
+            return {
+                flagged: result.flagged,
+                categories: result.categories,
+                scores: result.category_scores,
+                safe: !result.flagged
+            };
+        } catch (error) {
+            console.error('❌ Moderation Fehler:', error.message);
+            return { flagged: false, safe: true };
+        }
+    }
+
+    // ===== TRANSLATION =====
+    
+    async translate(text, targetLang = 'de') {
+        const prompt = `Übersetze folgenden Text nach ${targetLang}. Antworte nur mit der Übersetzung:\n\n"${text}"`;
+        
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein professioneller Übersetzer. Antworte nur mit der Übersetzung.',
+            maxTokens: 300
+        });
+    }
+
+    // ===== SUMMARIZATION =====
+    
+    async summarize(text, maxLength = 100) {
+        const prompt = `Fasse folgenden Text in maximal ${maxLength} Zeichen zusammen:\n\n"${text}"`;
+        
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein Experte für Textzusammenfassungen. Sei präzise und kurz.',
+            maxTokens: Math.ceil(maxLength / 2)
+        });
+    }
+
+    // ===== QUESTION ANSWERING =====
+    
+    async answerQuestion(question, context = '') {
+        const prompt = context ? 
+            `Kontext: ${context}\n\nFrage: ${question}` : 
+            question;
+            
+        return await this.chat(prompt, {
+            systemPrompt: 'Du bist ein hilfreicher Assistent. Beantworte Fragen präzise und verständlich.',
+            maxTokens: 400
+        });
+    }
+
+    // ===== CREATIVE WRITING =====
+    
+    async generateText(prompt, style = 'normal') {
+        const stylePrompts = {
+            funny: 'Schreibe lustig und humorvoll',
+            formal: 'Schreibe formal und professionell',
+            casual: 'Schreibe locker und umgangssprachlich',
+            creative: 'Schreibe kreativ und fantasievoll',
+            normal: 'Schreibe natürlich und verständlich'
+        };
+
+        return await this.chat(prompt, {
+            systemPrompt: `Du bist ein kreativer Schreiber. ${stylePrompts[style] || stylePrompts.normal}.`,
+            maxTokens: 600
+        });
+    }
+}

package/src/client.js

@@ -3,6 +3,11 @@ import pino from "pino";
 import { generateQRCode, closeBrowser } from "./qr.js";
 import { Message } from "./message.js";
 import { SessionManager } from "./session-manager.js";
+import { PrefixManager } from "./prefix-manager.js";
+import { getStorage } from "./storage.js";
+import { AIIntegration } from "./ai-integration.js";
+import { HTTPClient } from "./http-client.js";
+import { Scheduler } from "./scheduler.js";
 
 export class WhatsAppClient {
     constructor(options = {}) {
@@ -24,10 +29,26 @@ export class WhatsAppClient {
         // Session Manager
         this.sessionManager = new SessionManager(this.options.authDir);
         
-        // Prefix System
-        this.prefix = null;
+        // Prefix System (erweitert für gruppen-spezifische Prefixes)
+        this.prefix = null; // Global fallback
+        this.prefixManager = new PrefixManager('./data');
         this.commands = new Map();
         
+        // Storage System
+        this.storage = getStorage();
+        
+        // AI Integration
+        this.ai = new AIIntegration(options.ai || {});
+        
+        // HTTP Client
+        this.http = new HTTPClient(options.http || {});
+        
+        // Scheduler System
+        this.scheduler = new Scheduler(this);
+        
+        // Waiting System für Messages
+        this.waiting = this.scheduler.createWaiting();
+        
         // Deine eigenen API-Objekte
         this.get = new GetAPI(this);
         this.add = new AddAPI(this);
@@ -308,28 +329,32 @@ export class WhatsAppClient {
                 
                 const messageObj = new Message(this, messageData);
                 
-                // Prefix System - Command Check
-                if (this.prefix && messageData.text && messageData.text.startsWith(this.prefix)) {
-                    const commandText = messageData.text.slice(this.prefix.length).trim();
-                    const [command, ...args] = commandText.split(' ');
-                    
-                    console.log(`⚡ Command: ${this.prefix}${command}`);
-                    
-                    messageObj.isCommand = true;
-                    messageObj.command = command.toLowerCase();
-                    messageObj.args = args;
-                    messageObj.commandText = commandText;
-                    
-                    // Command Event emittieren
-                    this.emit('command', messageObj);
+                // Prefix System - Command Check (erweitert für Chat-spezifische Prefixes)
+                const chatPrefix = this.prefixManager.getPrefix(messageData.from);
+                
+                if (messageData.text && messageData.text.startsWith(chatPrefix)) {
+                    const commandData = this.prefixManager.parseCommand(messageData.text, messageData.from);
                     
-                    // Spezifischen Command Handler aufrufen falls vorhanden
-                    if (this.commands.has(command.toLowerCase())) {
-                        const handler = this.commands.get(command.toLowerCase());
-                        try {
-                            handler(messageObj, args);
-                        } catch (error) {
-                            console.error(`❌ Fehler in Command '${command}':`, error);
+                    if (commandData) {
+                        console.log(`⚡ Command in ${messageData.from}: ${commandData.prefix}${commandData.command}`);
+                        
+                        messageObj.isCommand = true;
+                        messageObj.command = commandData.command;
+                        messageObj.args = commandData.args;
+                        messageObj.commandText = commandData.commandText;
+                        messageObj.prefix = commandData.prefix;
+                        
+                        // Command Event emittieren
+                        this.emit('command', messageObj);
+                        
+                        // Spezifischen Command Handler aufrufen falls vorhanden
+                        if (this.commands.has(commandData.command)) {
+                            const handler = this.commands.get(commandData.command);
+                            try {
+                                handler(messageObj, commandData.args);
+                            } catch (error) {
+                                console.error(`❌ Fehler in Command '${commandData.command}':`, error);
+                            }
                         }
                     }
                 } else {
@@ -424,15 +449,43 @@ export class WhatsAppClient {
         };
     }
 
-    // ===== PREFIX SYSTEM =====
+    // ===== PREFIX SYSTEM (ERWEITERT) =====
     
+    // Global Prefix (Fallback)
     setPrefix(prefix) {
         this.prefix = prefix;
+        this.prefixManager.defaultPrefix = prefix;
+        console.log(`🌐 Global Prefix gesetzt: "${prefix}"`);
         return this;
     }
 
-    getPrefix() {
-        return this.prefix;
+    getPrefix(chatId = null) {
+        if (chatId) {
+            return this.prefixManager.getPrefix(chatId);
+        }
+        return this.prefix || this.prefixManager.defaultPrefix;
+    }
+
+    // Chat-spezifische Prefixes
+    setChatPrefix(chatId, prefix) {
+        return this.prefixManager.setPrefix(chatId, prefix);
+    }
+
+    getChatPrefix(chatId) {
+        return this.prefixManager.getPrefix(chatId);
+    }
+
+    removeChatPrefix(chatId) {
+        return this.prefixManager.removePrefix(chatId);
+    }
+
+    // Prefix Statistics
+    getPrefixStats() {
+        return this.prefixManager.getStats();
+    }
+
+    getAllPrefixes() {
+        return this.prefixManager.getAllPrefixes();
     }
 
     addCommand(command, handler) {

package/src/http-client.js

@@ -0,0 +1,276 @@
+// HTTP Client für WAEngine
+import axios from 'axios';
+
+export class HTTPClient {
+    constructor(options = {}) {
+        this.timeout = options.timeout || 10000;
+        this.retries = options.retries || 3;
+        this.baseHeaders = options.headers || {};
+        
+        // Axios Instance erstellen
+        this.axios = axios.create({
+            timeout: this.timeout,
+            headers: this.baseHeaders
+        });
+        
+        console.log('🌐 HTTP Client initialisiert');
+    }
+
+    // ===== BASIC HTTP METHODS =====
+    
+    async get(url, options = {}) {
+        return await this.request('GET', url, null, options);
+    }
+
+    async post(url, data = null, options = {}) {
+        return await this.request('POST', url, data, options);
+    }
+
+    async put(url, data = null, options = {}) {
+        return await this.request('PUT', url, data, options);
+    }
+
+    async delete(url, options = {}) {
+        return await this.request('DELETE', url, null, options);
+    }
+
+    // ===== CORE REQUEST METHOD =====
+    
+    async request(method, url, data = null, options = {}) {
+        let lastError;
+        
+        for (let attempt = 1; attempt <= this.retries; attempt++) {
+            try {
+                const config = {
+                    method,
+                    url,
+                    ...options
+                };
+                
+                if (data) {
+                    config.data = data;
+                }
+                
+                const response = await this.axios(config);
+                return response.data;
+                
+            } catch (error) {
+                lastError = error;
+                
+                if (attempt < this.retries && this.shouldRetry(error)) {
+                    console.log(`🔄 HTTP Retry ${attempt}/${this.retries} für ${url}`);
+                    await this.delay(1000 * attempt); // Exponential backoff
+                } else {
+                    break;
+                }
+            }
+        }
+        
+        throw new Error(`HTTP Request failed: ${lastError.message}`);
+    }
+
+    shouldRetry(error) {
+        // Retry bei Netzwerk-Fehlern oder 5xx Status Codes
+        return !error.response || error.response.status >= 500;
+    }
+
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    // ===== API WRAPPERS =====
+    
+    // Weather API
+    async getWeather(city, apiKey = process.env.WEATHER_API_KEY) {
+        if (!apiKey) {
+            throw new Error('❌ Weather API Key fehlt! Setze WEATHER_API_KEY');
+        }
+        
+        try {
+            const data = await this.get(`https://api.openweathermap.org/data/2.5/weather`, {
+                params: {
+                    q: city,
+                    appid: apiKey,
+                    units: 'metric',
+                    lang: 'de'
+                }
+            });
+            
+            return {
+                city: data.name,
+                country: data.sys.country,
+                temperature: Math.round(data.main.temp),
+                description: data.weather[0].description,
+                humidity: data.main.humidity,
+                windSpeed: data.wind.speed,
+                icon: data.weather[0].icon
+            };
+        } catch (error) {
+            throw new Error(`Wetter-Fehler: ${error.message}`);
+        }
+    }
+
+    // News API
+    async getNews(category = 'general', apiKey = process.env.NEWS_API_KEY) {
+        if (!apiKey) {
+            throw new Error('❌ News API Key fehlt! Setze NEWS_API_KEY');
+        }
+        
+        try {
+            const data = await this.get(`https://newsapi.org/v2/top-headlines`, {
+                params: {
+                    country: 'de',
+                    category: category,
+                    apiKey: apiKey,
+                    pageSize: 5
+                }
+            });
+            
+            return data.articles.map(article => ({
+                title: article.title,
+                description: article.description,
+                url: article.url,
+                source: article.source.name,
+                publishedAt: new Date(article.publishedAt).toLocaleDateString('de-DE')
+            }));
+        } catch (error) {
+            throw new Error(`News-Fehler: ${error.message}`);
+        }
+    }
+
+    // Crypto Prices
+    async getCryptoPrice(symbol = 'bitcoin') {
+        try {
+            const data = await this.get(`https://api.coingecko.com/api/v3/simple/price`, {
+                params: {
+                    ids: symbol,
+                    vs_currencies: 'eur,usd',
+                    include_24hr_change: true
+                }
+            });
+            
+            const coin = data[symbol];
+            return {
+                symbol: symbol,
+                priceEUR: coin.eur,
+                priceUSD: coin.usd,
+                change24h: coin.eur_24h_change?.toFixed(2) || 0
+            };
+        } catch (error) {
+            throw new Error(`Crypto-Fehler: ${error.message}`);
+        }
+    }
+
+    // QR Code Generator
+    async generateQRCode(text, size = 200) {
+        try {
+            const url = `https://api.qrserver.com/v1/create-qr-code/?size=${size}x${size}&data=${encodeURIComponent(text)}`;
+            
+            // Return URL instead of downloading
+            return {
+                url: url,
+                text: text,
+                size: size
+            };
+        } catch (error) {
+            throw new Error(`QR-Code-Fehler: ${error.message}`);
+        }
+    }
+
+    // URL Shortener
+    async shortenUrl(longUrl, apiKey = process.env.BITLY_API_KEY) {
+        if (!apiKey) {
+            // Fallback zu kostenlosem Service
+            try {
+                const data = await this.post('https://is.gd/create.php', null, {
+                    params: {
+                        format: 'json',
+                        url: longUrl
+                    }
+                });
+                
+                return {
+                    shortUrl: data.shorturl,
+                    longUrl: longUrl,
+                    service: 'is.gd'
+                };
+            } catch (error) {
+                throw new Error(`URL-Shortener-Fehler: ${error.message}`);
+            }
+        }
+        
+        // Bitly API
+        try {
+            const data = await this.post('https://api-ssl.bitly.com/v4/shorten', {
+                long_url: longUrl
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            
+            return {
+                shortUrl: data.link,
+                longUrl: longUrl,
+                service: 'bitly'
+            };
+        } catch (error) {
+            throw new Error(`Bitly-Fehler: ${error.message}`);
+        }
+    }
+
+    // Random Facts
+    async getRandomFact() {
+        try {
+            const data = await this.get('https://uselessfacts.jsph.pl/random.json?language=en');
+            return data.text;
+        } catch (error) {
+            throw new Error(`Random-Fact-Fehler: ${error.message}`);
+        }
+    }
+
+    // Random Joke
+    async getRandomJoke() {
+        try {
+            const data = await this.get('https://official-joke-api.appspot.com/random_joke');
+            return `${data.setup}\n\n${data.punchline}`;
+        } catch (error) {
+            throw new Error(`Joke-Fehler: ${error.message}`);
+        }
+    }
+
+    // IP Info
+    async getIPInfo(ip = '') {
+        try {
+            const url = ip ? `http://ip-api.com/json/${ip}` : 'http://ip-api.com/json/';
+            const data = await this.get(url);
+            
+            return {
+                ip: data.query,
+                country: data.country,
+                city: data.city,
+                region: data.regionName,
+                timezone: data.timezone,
+                isp: data.isp
+            };
+        } catch (error) {
+            throw new Error(`IP-Info-Fehler: ${error.message}`);
+        }
+    }
+
+    // Website Screenshot (via API)
+    async getWebsiteScreenshot(url, width = 1280, height = 720) {
+        try {
+            const screenshotUrl = `https://api.screenshotmachine.com/?key=${process.env.SCREENSHOT_API_KEY}&url=${encodeURIComponent(url)}&dimension=${width}x${height}`;
+            
+            return {
+                screenshotUrl: screenshotUrl,
+                originalUrl: url,
+                dimensions: `${width}x${height}`
+            };
+        } catch (error) {
+            throw new Error(`Screenshot-Fehler: ${error.message}`);
+        }
+    }
+}