waengine 1.0.8 → 1.0.9

package/plugins/education-plugin/index.js

@@ -0,0 +1,275 @@
+// 📚 Education Plugin
+export default class EducationPlugin {
+    constructor(client) {
+        this.client = client;
+        this.name = 'education-plugin';
+        this.version = '1.0.0';
+        this.description = 'Bildungs-System mit Wikipedia, Wörterbuch, Mathe und Code-Hilfe';
+        
+        this.mathOperators = {
+            '+': (a, b) => a + b,
+            '-': (a, b) => a - b,
+            '*': (a, b) => a * b,
+            '/': (a, b) => a / b,
+            '^': (a, b) => Math.pow(a, b),
+            'sqrt': (a) => Math.sqrt(a),
+            'sin': (a) => Math.sin(a),
+            'cos': (a) => Math.cos(a),
+            'tan': (a) => Math.tan(a)
+        };
+    }
+
+    async searchWikipedia(query) {
+        try {
+            // Verwende HTTP Client für Wikipedia API
+            const response = await this.client.http.get(`https://de.wikipedia.org/api/rest_v1/page/summary/${encodeURIComponent(query)}`);
+            
+            return {
+                title: response.title,
+                extract: response.extract,
+                url: response.content_urls?.desktop?.page,
+                thumbnail: response.thumbnail?.source
+            };
+        } catch (error) {
+            return {
+                title: query,
+                extract: `Artikel über "${query}" nicht gefunden. Versuche einen anderen Suchbegriff.`,
+                url: `https://de.wikipedia.org/wiki/${encodeURIComponent(query)}`,
+                thumbnail: null
+            };
+        }
+    }
+
+    async defineWord(word) {
+        // Simuliertes Wörterbuch
+        const definitions = {
+            'javascript': 'Eine Programmiersprache für Web-Entwicklung',
+            'node': 'JavaScript-Laufzeitumgebung für Server-Anwendungen',
+            'api': 'Application Programming Interface - Schnittstelle zwischen Anwendungen',
+            'bot': 'Automatisiertes Programm das Aufgaben ausführt',
+            'whatsapp': 'Messaging-Dienst für Smartphones und Computer'
+        };
+        
+        return definitions[word.toLowerCase()] || `Definition für "${word}" nicht gefunden. Versuche !wiki ${word} für mehr Informationen.`;
+    }
+
+    solveMath(expression) {
+        try {
+            // Einfacher Mathe-Parser (sicherheitshalber begrenzt)
+            const sanitized = expression.replace(/[^0-9+\-*/.() ]/g, '');
+            
+            // Verwende Function constructor für sichere Evaluation
+            const result = Function(`"use strict"; return (${sanitized})`)();
+            
+            return {
+                expression: expression,
+                result: result,
+                success: true
+            };
+        } catch (error) {
+            return {
+                expression: expression,
+                result: 'Ungültiger mathematischer Ausdruck',
+                success: false
+            };
+        }
+    }
+
+    explainCode(code, language = 'javascript') {
+        const explanations = {
+            'console.log': 'Gibt Text in der Konsole aus',
+            'function': 'Definiert eine wiederverwendbare Funktion',
+            'const': 'Deklariert eine Konstante (unveränderliche Variable)',
+            'let': 'Deklariert eine Variable mit Block-Scope',
+            'var': 'Deklariert eine Variable mit Function-Scope',
+            'if': 'Bedingte Anweisung - führt Code nur aus wenn Bedingung wahr ist',
+            'for': 'Schleife - wiederholt Code eine bestimmte Anzahl mal',
+            'while': 'Schleife - wiederholt Code solange Bedingung wahr ist',
+            'return': 'Gibt einen Wert aus einer Funktion zurück',
+            'async': 'Markiert eine Funktion als asynchron',
+            'await': 'Wartet auf das Ergebnis einer asynchronen Operation'
+        };
+        
+        let explanation = `💻 **Code-Erklärung (${language}):**\n\n`;
+        explanation += `\`\`\`${language}\n${code}\n\`\`\`\n\n`;
+        
+        // Suche nach bekannten Keywords
+        const foundKeywords = [];
+        Object.keys(explanations).forEach(keyword => {
+            if (code.includes(keyword)) {
+                foundKeywords.push(`• **${keyword}**: ${explanations[keyword]}`);
+            }
+        });
+        
+        if (foundKeywords.length > 0) {
+            explanation += '📝 **Erklärungen:**\n' + foundKeywords.join('\n');
+        } else {
+            explanation += '💡 Sende kleinere Code-Snippets für detailliertere Erklärungen.';
+        }
+        
+        return explanation;
+    }
+
+    getRandomFact() {
+        const facts = [
+            'Der erste Computer-Bug war tatsächlich ein echter Käfer, der 1947 in einem Computer gefunden wurde.',
+            'Das Internet wiegt etwa 50 Gramm - das Gewicht aller Elektronen in Bewegung.',
+            'JavaScript wurde in nur 10 Tagen entwickelt.',
+            'Das erste YouTube-Video wurde am 23. April 2005 hochgeladen.',
+            'Es gibt mehr mögliche Schachspiele als Atome im beobachtbaren Universum.',
+            'Der Begriff "Spam" für unerwünschte E-Mails kommt von Monty Python.',
+            'Das @-Symbol wird in verschiedenen Sprachen unterschiedlich genannt: Klammeraffe (Deutsch), Snabel-a (Dänisch), oder Elefantenohr (Tschechisch).'
+        ];
+        
+        return facts[Math.floor(Math.random() * facts.length)];
+    }
+
+    getCommands() {
+        return {
+            'wiki': this.handleWiki.bind(this),
+            'define': this.handleDefine.bind(this),
+            'math': this.handleMath.bind(this),
+            'code': this.handleCode.bind(this),
+            'learn': this.handleLearn.bind(this),
+            'fact': this.handleFact.bind(this),
+            'study': this.handleStudy.bind(this)
+        };
+    }
+
+    async handleWiki(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !wiki <suchbegriff>\n\n📚 Beispiel: !wiki JavaScript');
+        }
+
+        const query = args.join(' ');
+        await msg.reply(`📚 Suche Wikipedia-Artikel über "${query}"...`);
+        
+        const article = await this.searchWikipedia(query);
+        
+        let wikiText = `📚 **Wikipedia: ${article.title}**\n\n`;
+        wikiText += `${article.extract}\n\n`;
+        wikiText += `🔗 Mehr lesen: ${article.url}`;
+        
+        await msg.reply(wikiText);
+    }
+
+    async handleDefine(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !define <wort>\n\n📖 Beispiel: !define API');
+        }
+
+        const word = args.join(' ');
+        const definition = await this.defineWord(word);
+        
+        let defineText = `📖 **Definition: ${word}**\n\n`;
+        defineText += definition;
+        
+        await msg.reply(defineText);
+    }
+
+    async handleMath(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !math <ausdruck>\n\n🧮 Beispiele:\n• !math 2 + 2\n• !math 15 * 8\n• !math (10 + 5) / 3');
+        }
+
+        const expression = args.join(' ');
+        const result = this.solveMath(expression);
+        
+        let mathText = `🧮 **Mathe-Rechner:**\n\n`;
+        mathText += `📝 Ausdruck: ${result.expression}\n`;
+        
+        if (result.success) {
+            mathText += `✅ Ergebnis: ${result.result}`;
+        } else {
+            mathText += `❌ Fehler: ${result.result}`;
+        }
+        
+        await msg.reply(mathText);
+    }
+
+    async handleCode(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !code <code>\n\n💻 Beispiel: !code console.log("Hello World")');
+        }
+
+        const code = args.join(' ');
+        const explanation = this.explainCode(code);
+        
+        await msg.reply(explanation);
+    }
+
+    async handleLearn(msg, args) {
+        if (args.length === 0) {
+            const topics = [
+                '🌐 **Web Development**: HTML, CSS, JavaScript',
+                '🐍 **Python**: Programmierung für Anfänger',
+                '⚛️ **React**: Frontend Framework',
+                '🟢 **Node.js**: Backend JavaScript',
+                '🗄️ **Datenbanken**: SQL, MongoDB',
+                '🔧 **Git**: Versionskontrolle',
+                '☁️ **Cloud**: AWS, Azure, Google Cloud'
+            ];
+            
+            let learnText = `📚 **Lernthemen:**\n\n`;
+            learnText += topics.join('\n') + '\n\n';
+            learnText += '💡 Verwende: !learn <thema> für Details';
+            
+            return msg.reply(learnText);
+        }
+
+        const topic = args.join(' ').toLowerCase();
+        const resources = {
+            'javascript': '📚 **JavaScript lernen:**\n\n• MDN Web Docs\n• JavaScript.info\n• FreeCodeCamp\n• Codecademy\n\n💡 Starte mit Variablen, Funktionen und DOM-Manipulation!',
+            'python': '🐍 **Python lernen:**\n\n• Python.org Tutorial\n• Automate the Boring Stuff\n• Python Crash Course\n• Codecademy Python\n\n💡 Perfekt für Anfänger und Automatisierung!',
+            'react': '⚛️ **React lernen:**\n\n• React Docs\n• React Tutorial\n• Scrimba React Course\n• Full Stack Open\n\n💡 Lerne erst JavaScript, dann React!',
+            'node': '🟢 **Node.js lernen:**\n\n• Node.js Docs\n• The Node.js Handbook\n• Express.js Guide\n• NPM Packages\n\n💡 Ideal für Backend-Entwicklung!'
+        };
+        
+        const resource = resources[topic] || `📚 Ressourcen für "${topic}" nicht gefunden. Versuche: !learn ohne Parameter für verfügbare Themen.`;
+        
+        await msg.reply(resource);
+    }
+
+    async handleFact(msg, args) {
+        const fact = this.getRandomFact();
+        
+        await msg.reply(`💡 **Wusstest du schon?**\n\n${fact}`);
+    }
+
+    async handleStudy(msg, args) {
+        const userId = msg.getSender();
+        
+        if (args.length === 0) {
+            const studyTime = this.client.storage.read.from('education').get(`${userId}.studyTime`) || 0;
+            const studyDays = this.client.storage.read.from('education').get(`${userId}.studyDays`) || 0;
+            
+            let studyText = `📊 **Deine Lernstatistiken:**\n\n`;
+            studyText += `⏱️ Gesamte Lernzeit: ${Math.floor(studyTime / 60)} Minuten\n`;
+            studyText += `📅 Lerntage: ${studyDays}\n\n`;
+            studyText += `💡 Verwende !study start um eine Lernsession zu beginnen`;
+            
+            return msg.reply(studyText);
+        }
+
+        const action = args[0].toLowerCase();
+        
+        if (action === 'start') {
+            this.client.storage.write.in('education').set(`${userId}.sessionStart`, Date.now());
+            await msg.reply('📚 **Lernsession gestartet!**\n\n⏱️ Viel Erfolg beim Lernen!\n💡 Verwende !study stop um die Session zu beenden');
+        } else if (action === 'stop') {
+            const sessionStart = this.client.storage.read.from('education').get(`${userId}.sessionStart`);
+            
+            if (!sessionStart) {
+                return msg.reply('❌ Keine aktive Lernsession gefunden!');
+            }
+            
+            const sessionTime = Math.floor((Date.now() - sessionStart) / 1000 / 60); // Minuten
+            
+            this.client.storage.write.in('education').increment(`${userId}.studyTime`, sessionTime);
+            this.client.storage.write.in('education').increment(`${userId}.studyDays`, 1);
+            this.client.storage.delete.from('education').key(`${userId}.sessionStart`);
+            
+            await msg.reply(`✅ **Lernsession beendet!**\n\n⏱️ Dauer: ${sessionTime} Minuten\n🎉 Gut gemacht!`);
+        }
+    }
+}

package/plugins/games-plugin/config.json

@@ -0,0 +1,35 @@
+{
+  "name": "Games Plugin",
+  "version": "1.0.0", 
+  "description": "Spiele-System mit Quiz, Würfel, RPS und mehr",
+  "author": "WAEngine",
+  "commands": [
+    "dice",
+    "flip",
+    "rps", 
+    "quiz",
+    "answer",
+    "number",
+    "gamestats",
+    "gameleaderboard"
+  ],
+  "permissions": {
+    "dice": "all",
+    "flip": "all",
+    "rps": "all",
+    "quiz": "all", 
+    "answer": "all",
+    "number": "all",
+    "gamestats": "all",
+    "gameleaderboard": "all"
+  },
+  "settings": {
+    "maxDiceSides": 100,
+    "quizTimeout": 60000,
+    "numberGuessRange": {
+      "min": 1,
+      "max": 100
+    },
+    "leaderboardLimit": 10
+  }
+}

package/plugins/games-plugin/index.js

@@ -0,0 +1,300 @@
+// 🎲 Games Plugin
+export default class GamesPlugin {
+    constructor(client) {
+        this.client = client;
+        this.name = 'games-plugin';
+        this.version = '1.0.0';
+        this.description = 'Spiele-System mit Quiz, Würfel, RPS und mehr';
+        
+        this.quizQuestions = [
+            { question: 'Was ist die Hauptstadt von Deutschland?', answers: ['Berlin', 'München', 'Hamburg', 'Köln'], correct: 0 },
+            { question: 'Welches Jahr war die erste Mondlandung?', answers: ['1967', '1969', '1971', '1973'], correct: 1 },
+            { question: 'Wer hat JavaScript erfunden?', answers: ['Bill Gates', 'Steve Jobs', 'Brendan Eich', 'Mark Zuckerberg'], correct: 2 },
+            { question: 'Was ist 15 × 8?', answers: ['110', '120', '130', '140'], correct: 1 },
+            { question: 'Welcher Planet ist der größte?', answers: ['Saturn', 'Jupiter', 'Neptun', 'Uranus'], correct: 1 }
+        ];
+    }
+
+    rollDice(sides = 6) {
+        return Math.floor(Math.random() * sides) + 1;
+    }
+
+    flipCoin() {
+        return Math.random() < 0.5 ? 'Kopf' : 'Zahl';
+    }
+
+    playRPS(playerChoice) {
+        const choices = ['rock', 'paper', 'scissors'];
+        const botChoice = choices[Math.floor(Math.random() * 3)];
+        
+        const wins = {
+            rock: 'scissors',
+            paper: 'rock', 
+            scissors: 'paper'
+        };
+        
+        let result;
+        if (playerChoice === botChoice) {
+            result = 'tie';
+        } else if (wins[playerChoice] === botChoice) {
+            result = 'win';
+        } else {
+            result = 'lose';
+        }
+        
+        return { playerChoice, botChoice, result };
+    }
+
+    getRandomQuestion() {
+        return this.quizQuestions[Math.floor(Math.random() * this.quizQuestions.length)];
+    }
+
+    async startQuiz(userId, groupId) {
+        const question = this.getRandomQuestion();
+        const quizId = Date.now().toString();
+        
+        this.client.storage.write.in('games').set(`quiz.${quizId}`, {
+            question: question.question,
+            answers: question.answers,
+            correct: question.correct,
+            userId,
+            groupId,
+            startTime: Date.now(),
+            answered: false
+        });
+        
+        return { quizId, question };
+    }
+
+    async answerQuiz(quizId, answerIndex, userId) {
+        const quiz = this.client.storage.read.from('games').get(`quiz.${quizId}`);
+        
+        if (!quiz || quiz.answered) {
+            return { success: false, error: 'Quiz nicht gefunden oder bereits beantwortet' };
+        }
+        
+        if (userId !== quiz.userId) {
+            return { success: false, error: 'Das ist nicht dein Quiz!' };
+        }
+        
+        const isCorrect = answerIndex === quiz.correct;
+        const timeTaken = Date.now() - quiz.startTime;
+        
+        this.client.storage.write.in('games').set(`quiz.${quizId}.answered`, true);
+        
+        this.client.storage.write.in('games').increment(`stats.${userId}.quizzes`, 1);
+        if (isCorrect) {
+            this.client.storage.write.in('games').increment(`stats.${userId}.correct`, 1);
+        }
+        
+        return {
+            success: true,
+            correct: isCorrect,
+            correctAnswer: quiz.answers[quiz.correct],
+            timeTaken: Math.round(timeTaken / 1000)
+        };
+    }
+
+    async getLeaderboard(game = 'quiz') {
+        const stats = this.client.storage.read.from('games').get('stats') || {};
+        const leaderboard = [];
+        
+        Object.entries(stats).forEach(([userId, userStats]) => {
+            if (userStats[game]) {
+                leaderboard.push({
+                    userId,
+                    score: userStats.correct || 0,
+                    total: userStats.quizzes || 0,
+                    percentage: userStats.quizzes ? Math.round((userStats.correct / userStats.quizzes) * 100) : 0
+                });
+            }
+        });
+        
+        leaderboard.sort((a, b) => b.score - a.score);
+        return leaderboard.slice(0, 10);
+    }
+    getCommands() {
+        return {
+            'dice': this.handleDice.bind(this),
+            'flip': this.handleFlip.bind(this),
+            'rps': this.handleRPS.bind(this),
+            'quiz': this.handleQuiz.bind(this),
+            'answer': this.handleAnswer.bind(this),
+            'gamestats': this.handleGameStats.bind(this),
+            'gameleaderboard': this.handleGameLeaderboard.bind(this),
+            'number': this.handleNumberGuess.bind(this)
+        };
+    }
+
+    async handleDice(msg, args) {
+        const sides = parseInt(args[0]) || 6;
+        if (sides < 2 || sides > 100) {
+            return msg.reply('❌ Würfel muss zwischen 2 und 100 Seiten haben!');
+        }
+        
+        const result = this.rollDice(sides);
+        await msg.reply(`🎲 **Würfel Ergebnis:**\n\n🎯 ${result} (von ${sides})`);
+    }
+
+    async handleFlip(msg, args) {
+        const result = this.flipCoin();
+        const emoji = result === 'Kopf' ? '🪙' : '💰';
+        
+        await msg.reply(`${emoji} **Münzwurf:**\n\n🎯 ${result}!`);
+    }
+
+    async handleRPS(msg, args) {
+        if (args.length === 0) {
+            return msg.reply('❌ Verwendung: !rps <rock/paper/scissors>\n\n🪨 Rock\n📄 Paper\n✂️ Scissors');
+        }
+        
+        const playerChoice = args[0].toLowerCase();
+        const validChoices = ['rock', 'paper', 'scissors'];
+        
+        if (!validChoices.includes(playerChoice)) {
+            return msg.reply('❌ Ungültige Wahl! Verwende: rock, paper oder scissors');
+        }
+        
+        const game = this.playRPS(playerChoice);
+        const emojis = { rock: '🪨', paper: '📄', scissors: '✂️' };
+        
+        let resultText = `🎮 **Schere-Stein-Papier**\n\n`;
+        resultText += `👤 Du: ${emojis[game.playerChoice]}\n`;
+        resultText += `🤖 Bot: ${emojis[game.botChoice]}\n\n`;
+        
+        if (game.result === 'win') {
+            resultText += '🎉 **Du gewinnst!**';
+        } else if (game.result === 'lose') {
+            resultText += '😔 **Du verlierst!**';
+        } else {
+            resultText += '🤝 **Unentschieden!**';
+        }
+        
+        await msg.reply(resultText);
+    }
+
+    async handleQuiz(msg, args) {
+        const userId = msg.getSender();
+        const groupId = msg.from;
+        
+        const { quizId, question } = await this.startQuiz(userId, groupId);
+        
+        let quizText = `🧠 **Quiz Zeit!**\n\n`;
+        quizText += `❓ ${question.question}\n\n`;
+        
+        question.answers.forEach((answer, index) => {
+            quizText += `${index + 1}. ${answer}\n`;
+        });
+        
+        quizText += `\n💡 Antworte mit: !answer ${quizId} <1-4>`;
+        
+        await msg.reply(quizText);
+    }
+
+    async handleAnswer(msg, args) {
+        if (args.length < 2) {
+            return msg.reply('❌ Verwendung: !answer <quiz-id> <antwort-nummer>');
+        }
+        
+        const quizId = args[0];
+        const answerIndex = parseInt(args[1]) - 1;
+        const userId = msg.getSender();
+        
+        if (isNaN(answerIndex) || answerIndex < 0 || answerIndex > 3) {
+            return msg.reply('❌ Antwort muss zwischen 1 und 4 sein!');
+        }
+        
+        const result = await this.answerQuiz(quizId, answerIndex, userId);
+        
+        if (!result.success) {
+            return msg.reply(`❌ ${result.error}`);
+        }
+        
+        let resultText = `📊 **Quiz Ergebnis:**\n\n`;
+        
+        if (result.correct) {
+            resultText += `✅ **Richtig!**\n`;
+        } else {
+            resultText += `❌ **Falsch!**\n`;
+            resultText += `💡 Richtige Antwort: ${result.correctAnswer}\n`;
+        }
+        
+        resultText += `⏱️ Zeit: ${result.timeTaken}s`;
+        
+        await msg.reply(resultText);
+    }
+
+    async handleGameStats(msg, args) {
+        const userId = msg.getSender();
+        const stats = this.client.storage.read.from('games').get(`stats.${userId}`) || {};
+        
+        const quizzes = stats.quizzes || 0;
+        const correct = stats.correct || 0;
+        const percentage = quizzes ? Math.round((correct / quizzes) * 100) : 0;
+        
+        let statsText = `📊 **Deine Game Stats:**\n\n`;
+        statsText += `🧠 Quiz gespielt: ${quizzes}\n`;
+        statsText += `✅ Richtige Antworten: ${correct}\n`;
+        statsText += `📈 Erfolgsquote: ${percentage}%`;
+        
+        await msg.reply(statsText);
+    }
+
+    async handleGameLeaderboard(msg, args) {
+        const leaderboard = await this.getLeaderboard('quiz');
+        
+        if (leaderboard.length === 0) {
+            return msg.reply('📊 **Leaderboard ist leer!**\n\n🎮 Spiele !quiz um auf die Liste zu kommen');
+        }
+        
+        let lbText = '🏆 **Quiz Leaderboard**\n\n';
+        
+        leaderboard.forEach((entry, index) => {
+            const medal = index === 0 ? '🥇' : index === 1 ? '🥈' : index === 2 ? '🥉' : `${index + 1}.`;
+            lbText += `${medal} @${entry.userId.split('@')[0]}\n`;
+            lbText += `✅ ${entry.score}/${entry.total} (${entry.percentage}%)\n\n`;
+        });
+        
+        await msg.reply(lbText);
+    }
+
+    async handleNumberGuess(msg, args) {
+        const userId = msg.getSender();
+        const activeGame = this.client.storage.read.from('games').get(`number.${userId}`);
+        
+        if (!activeGame) {
+            // Neues Spiel starten
+            const number = Math.floor(Math.random() * 100) + 1;
+            this.client.storage.write.in('games').set(`number.${userId}`, {
+                number,
+                attempts: 0,
+                startTime: Date.now()
+            });
+            
+            return msg.reply('🔢 **Zahlenraten gestartet!**\n\n🎯 Ich denke an eine Zahl zwischen 1 und 100\n💡 Rate mit: !number <zahl>');
+        }
+        
+        if (args.length === 0) {
+            return msg.reply('❌ Gib eine Zahl zwischen 1 und 100 ein!');
+        }
+        
+        const guess = parseInt(args[0]);
+        if (isNaN(guess) || guess < 1 || guess > 100) {
+            return msg.reply('❌ Zahl muss zwischen 1 und 100 sein!');
+        }
+        
+        activeGame.attempts++;
+        this.client.storage.write.in('games').set(`number.${userId}.attempts`, activeGame.attempts);
+        
+        if (guess === activeGame.number) {
+            const timeTaken = Math.round((Date.now() - activeGame.startTime) / 1000);
+            this.client.storage.delete.from('games').key(`number.${userId}`);
+            
+            await msg.reply(`🎉 **Richtig geraten!**\n\n🎯 Die Zahl war: ${activeGame.number}\n🔢 Versuche: ${activeGame.attempts}\n⏱️ Zeit: ${timeTaken}s`);
+        } else if (guess < activeGame.number) {
+            await msg.reply(`📈 **Zu niedrig!**\n\n🔢 Versuch ${activeGame.attempts}: ${guess}\n💡 Die Zahl ist höher`);
+        } else {
+            await msg.reply(`📉 **Zu hoch!**\n\n🔢 Versuch ${activeGame.attempts}: ${guess}\n💡 Die Zahl ist niedriger`);
+        }
+    }
+}

package/plugins/moderation-plugin/config.json

@@ -0,0 +1,86 @@
+{
+  "name": "moderation-plugin",
+  "displayName": "Moderation Plugin",
+  "version": "1.0.0",
+  "description": "Erweiterte Moderation mit Auto-Mod, Spam-Schutz und Admin-Tools",
+  "author": "WAEngine",
+  "category": "moderation",
+  "permissions": [
+    "admin_only",
+    "group_management",
+    "message_deletion"
+  ],
+  "commands": [
+    {
+      "name": "warn",
+      "description": "Warnung an User vergeben",
+      "usage": "!warn @user [grund]",
+      "adminOnly": true
+    },
+    {
+      "name": "unwarn",
+      "description": "Warnung von User entfernen",
+      "usage": "!unwarn @user",
+      "adminOnly": true
+    },
+    {
+      "name": "warnings",
+      "description": "Warnungen anzeigen",
+      "usage": "!warnings [@user]",
+      "adminOnly": false
+    },
+    {
+      "name": "kick",
+      "description": "User aus Gruppe entfernen",
+      "usage": "!kick @user [grund]",
+      "adminOnly": true
+    },
+    {
+      "name": "automod",
+      "description": "Auto-Moderation verwalten",
+      "usage": "!automod [on/off]",
+      "adminOnly": true
+    },
+    {
+      "name": "modstats",
+      "description": "Moderations-Statistiken",
+      "usage": "!modstats",
+      "adminOnly": false
+    },
+    {
+      "name": "rules",
+      "description": "Gruppenregeln anzeigen",
+      "usage": "!rules",
+      "adminOnly": false
+    },
+    {
+      "name": "setrules",
+      "description": "Gruppenregeln festlegen",
+      "usage": "!setrules <regel1> | <regel2>",
+      "adminOnly": true
+    },
+    {
+      "name": "purge",
+      "description": "Nachrichten löschen",
+      "usage": "!purge <anzahl>",
+      "adminOnly": true
+    }
+  ],
+  "settings": {
+    "autoMod": {
+      "maxMessages": 5,
+      "timeWindow": 10000,
+      "banWords": ["spam", "werbung", "fake", "scam"],
+      "maxCapsPercent": 70,
+      "maxEmojis": 10
+    }
+  },
+  "dependencies": [],
+  "storage": [
+    "warnings",
+    "autoMod",
+    "rules",
+    "bans",
+    "mutes"
+  ]
+}