vantuz 3.0.1 → 3.1.0

package/core/ai-provider.js

@@ -0,0 +1,252 @@
+/**
+ * 🤖 AI Provider Integration v3.1
+ * Gerçek AI API çağrıları + Context desteği
+ */
+
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const LOG_FILE = path.join(os.homedir(), '.vantuz', 'vantuz.log');
+
+// ═══════════════════════════════════════════════════════════════════════════
+// LOGGING
+// ═══════════════════════════════════════════════════════════════════════════
+
+export function log(level, message, data = null) {
+    const timestamp = new Date().toISOString();
+    const logLine = `[${timestamp}] [${level}] ${message}${data ? ' | ' + JSON.stringify(data) : ''}\n`;
+
+    try {
+        fs.appendFileSync(LOG_FILE, logLine);
+    } catch (e) { }
+}
+
+export function getLogs(lines = 50) {
+    try {
+        if (!fs.existsSync(LOG_FILE)) {
+            return 'Log dosyası bulunamadı.';
+        }
+        const content = fs.readFileSync(LOG_FILE, 'utf-8');
+        const allLines = content.split('\n').filter(l => l.trim());
+        return allLines.slice(-lines).join('\n');
+    } catch (e) {
+        return `Log okuma hatası: ${e.message}`;
+    }
+}
+
+export function clearLogs() {
+    try {
+        fs.writeFileSync(LOG_FILE, '');
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SYSTEM PROMPT
+// ═══════════════════════════════════════════════════════════════════════════
+
+const VANTUZ_SYSTEM_PROMPT = `Sen Vantuz AI, e-ticaret operasyonlarını yöneten yapay zeka asistanısın.
+
+## Kimliğin
+- İsim: Vantuz AI
+- Uzmanlık: E-ticaret yönetimi, pazaryeri entegrasyonları, fiyatlandırma stratejileri
+- Dil: Türkçe
+- Kişilik: Profesyonel, çözüm odaklı, verimli
+
+## Desteklenen Pazaryerleri
+1. 🟠 Trendyol - Tam entegrasyon
+2. 🟣 Hepsiburada - Tam entegrasyon
+3. 🔵 N11 - Tam entegrasyon
+4. 🟡 Amazon - FBA destekli
+5. 🌸 Çiçeksepeti - Entegre
+6. 📮 PTTavm - Entegre
+7. 🛒 Pazarama - Entegre
+
+## Yeteneklerin
+- Stok kontrolü ve güncelleme
+- Fiyat analizi ve güncelleme
+- Sipariş yönetimi
+- Rakip analizi
+- Satış raporları
+
+## Önemli Kurallar
+1. Kar marjının altına fiyat düşürme önerme
+2. Stokta olmayan ürünü satışa açma
+3. Kritik işlemlerden önce onay iste
+4. Kısa ve öz yanıt ver
+5. Sayısal verileri düzgün formatla
+
+## Yanıt Formatı
+- Kısa ve öz ol
+- Emoji kullan ama abartma
+- Sayısal verileri tablo formatında göster
+- Hata durumunda çözüm öner`;
+
+// ═══════════════════════════════════════════════════════════════════════════
+// AI CHAT
+// ═══════════════════════════════════════════════════════════════════════════
+
+export async function chat(message, config, env) {
+    const provider = config.aiProvider || 'gemini';
+
+    // Context bilgisi ekle
+    const contextInfo = config.systemContext || '';
+    const fullSystemPrompt = VANTUZ_SYSTEM_PROMPT + contextInfo;
+
+    log('INFO', `AI isteği: ${provider}`, { message: message.slice(0, 100) });
+
+    try {
+        switch (provider) {
+            case 'gemini':
+                return await chatGemini(message, env.GEMINI_API_KEY, fullSystemPrompt);
+            case 'groq':
+                return await chatGroq(message, env.GROQ_API_KEY, fullSystemPrompt);
+            case 'openai':
+                return await chatOpenAI(message, env.OPENAI_API_KEY, fullSystemPrompt);
+            case 'anthropic':
+                return await chatAnthropic(message, env.ANTHROPIC_API_KEY, fullSystemPrompt);
+            case 'deepseek':
+                return await chatDeepSeek(message, env.DEEPSEEK_API_KEY, fullSystemPrompt);
+            default:
+                return 'Desteklenmeyen AI sağlayıcı: ' + provider;
+        }
+    } catch (error) {
+        log('ERROR', `AI hatası: ${error.message}`, { provider });
+        return `AI hatası: ${error.message}. /logs komutu ile detay görün.`;
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PROVIDER IMPLEMENTATIONS
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function chatGemini(message, apiKey, systemPrompt) {
+    if (!apiKey) throw new Error('GEMINI_API_KEY ayarlanmamış');
+
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=${apiKey}`;
+
+    const response = await axios.post(url, {
+        contents: [{
+            parts: [{
+                text: `${systemPrompt}\n\nKullanıcı: ${message}`
+            }]
+        }]
+    }, {
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 30000
+    });
+
+    const text = response.data?.candidates?.[0]?.content?.parts?.[0]?.text;
+    if (!text) throw new Error('Gemini yanıt vermedi');
+
+    log('INFO', 'Gemini yanıtı alındı', { chars: text.length });
+    return text;
+}
+
+async function chatGroq(message, apiKey, systemPrompt) {
+    if (!apiKey) throw new Error('GROQ_API_KEY ayarlanmamış');
+
+    const response = await axios.post('https://api.groq.com/openai/v1/chat/completions', {
+        model: 'llama-3.3-70b-versatile',
+        messages: [
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: message }
+        ],
+        max_tokens: 1000,
+        temperature: 0.7
+    }, {
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json'
+        },
+        timeout: 30000
+    });
+
+    const text = response.data?.choices?.[0]?.message?.content;
+    if (!text) throw new Error('Groq yanıt vermedi');
+
+    log('INFO', 'Groq yanıtı alındı', { chars: text.length });
+    return text;
+}
+
+async function chatOpenAI(message, apiKey, systemPrompt) {
+    if (!apiKey) throw new Error('OPENAI_API_KEY ayarlanmamış');
+
+    const response = await axios.post('https://api.openai.com/v1/chat/completions', {
+        model: 'gpt-4o-mini',
+        messages: [
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: message }
+        ],
+        max_tokens: 1000
+    }, {
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json'
+        },
+        timeout: 30000
+    });
+
+    const text = response.data?.choices?.[0]?.message?.content;
+    if (!text) throw new Error('OpenAI yanıt vermedi');
+
+    log('INFO', 'OpenAI yanıtı alındı', { chars: text.length });
+    return text;
+}
+
+async function chatAnthropic(message, apiKey, systemPrompt) {
+    if (!apiKey) throw new Error('ANTHROPIC_API_KEY ayarlanmamış');
+
+    const response = await axios.post('https://api.anthropic.com/v1/messages', {
+        model: 'claude-3-haiku-20240307',
+        max_tokens: 1000,
+        messages: [
+            { role: 'user', content: message }
+        ],
+        system: systemPrompt
+    }, {
+        headers: {
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+            'Content-Type': 'application/json'
+        },
+        timeout: 30000
+    });
+
+    const text = response.data?.content?.[0]?.text;
+    if (!text) throw new Error('Anthropic yanıt vermedi');
+
+    log('INFO', 'Anthropic yanıtı alındı', { chars: text.length });
+    return text;
+}
+
+async function chatDeepSeek(message, apiKey, systemPrompt) {
+    if (!apiKey) throw new Error('DEEPSEEK_API_KEY ayarlanmamış');
+
+    const response = await axios.post('https://api.deepseek.com/v1/chat/completions', {
+        model: 'deepseek-chat',
+        messages: [
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: message }
+        ],
+        max_tokens: 1000
+    }, {
+        headers: {
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json'
+        },
+        timeout: 30000
+    });
+
+    const text = response.data?.choices?.[0]?.message?.content;
+    if (!text) throw new Error('DeepSeek yanıt vermedi');
+
+    log('INFO', 'DeepSeek yanıtı alındı', { chars: text.length });
+    return text;
+}
+
+export default { chat, log, getLogs, clearLogs };

package/core/channels.js

@@ -0,0 +1,334 @@
+/**
+ * 📱 CHANNEL MANAGER
+ * WhatsApp ve Telegram entegrasyonu
+ * 
+ * OpenClaw altyapısı üzerine kurulu
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import axios from 'axios';
+import { log } from './ai-provider.js';
+
+const VANTUZ_HOME = path.join(os.homedir(), '.vantuz');
+const CONFIG_PATH = path.join(VANTUZ_HOME, '.env');
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CHANNEL BASE CLASS
+// ═══════════════════════════════════════════════════════════════════════════
+
+class Channel {
+    constructor(name, config) {
+        this.name = name;
+        this.config = config;
+        this.connected = false;
+    }
+
+    async connect() {
+        throw new Error('connect() must be implemented');
+    }
+
+    async send(to, message) {
+        throw new Error('send() must be implemented');
+    }
+
+    async startListening(onMessage) {
+        throw new Error('startListening() must be implemented');
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// WHATSAPP (via WhatsApp Business API / Twilio / Meta Cloud API)
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class WhatsAppChannel extends Channel {
+    constructor(config) {
+        super('whatsapp', config);
+        this.apiUrl = config.apiUrl || 'https://graph.facebook.com/v17.0';
+        this.phoneNumberId = config.phoneNumberId;
+        this.accessToken = config.accessToken;
+    }
+
+    async connect() {
+        if (!this.phoneNumberId || !this.accessToken) {
+            log('ERROR', 'WhatsApp: phoneNumberId veya accessToken eksik');
+            return false;
+        }
+
+        try {
+            // Verify connection
+            const response = await axios.get(
+                `${this.apiUrl}/${this.phoneNumberId}`,
+                {
+                    headers: { 'Authorization': `Bearer ${this.accessToken}` }
+                }
+            );
+            this.connected = response.status === 200;
+            log('INFO', 'WhatsApp bağlantısı kuruldu', { phoneNumberId: this.phoneNumberId });
+            return true;
+        } catch (e) {
+            log('ERROR', 'WhatsApp bağlantı hatası', { error: e.message });
+            return false;
+        }
+    }
+
+    async send(to, message) {
+        if (!this.connected) {
+            await this.connect();
+        }
+
+        try {
+            const response = await axios.post(
+                `${this.apiUrl}/${this.phoneNumberId}/messages`,
+                {
+                    messaging_product: 'whatsapp',
+                    recipient_type: 'individual',
+                    to: to,
+                    type: 'text',
+                    text: { body: message }
+                },
+                {
+                    headers: {
+                        'Authorization': `Bearer ${this.accessToken}`,
+                        'Content-Type': 'application/json'
+                    }
+                }
+            );
+
+            log('INFO', 'WhatsApp mesaj gönderildi', { to, messageId: response.data?.messages?.[0]?.id });
+            return { success: true, messageId: response.data?.messages?.[0]?.id };
+        } catch (e) {
+            log('ERROR', 'WhatsApp gönderme hatası', { error: e.message });
+            return { success: false, error: e.message };
+        }
+    }
+
+    // Webhook handler için
+    handleWebhook(body) {
+        const entry = body.entry?.[0];
+        const changes = entry?.changes?.[0];
+        const value = changes?.value;
+        const message = value?.messages?.[0];
+
+        if (message) {
+            return {
+                from: message.from,
+                text: message.text?.body || '',
+                timestamp: message.timestamp,
+                messageId: message.id
+            };
+        }
+        return null;
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// TELEGRAM (via Telegram Bot API)
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class TelegramChannel extends Channel {
+    constructor(config) {
+        super('telegram', config);
+        this.botToken = config.botToken;
+        this.apiUrl = `https://api.telegram.org/bot${this.botToken}`;
+    }
+
+    async connect() {
+        if (!this.botToken) {
+            log('ERROR', 'Telegram: botToken eksik');
+            return false;
+        }
+
+        try {
+            const response = await axios.get(`${this.apiUrl}/getMe`);
+            if (response.data.ok) {
+                this.botInfo = response.data.result;
+                this.connected = true;
+                log('INFO', 'Telegram bağlantısı kuruldu', { username: this.botInfo.username });
+                return true;
+            }
+            return false;
+        } catch (e) {
+            log('ERROR', 'Telegram bağlantı hatası', { error: e.message });
+            return false;
+        }
+    }
+
+    async send(chatId, message, options = {}) {
+        if (!this.connected) {
+            await this.connect();
+        }
+
+        try {
+            const response = await axios.post(`${this.apiUrl}/sendMessage`, {
+                chat_id: chatId,
+                text: message,
+                parse_mode: options.parseMode || 'HTML',
+                ...options
+            });
+
+            log('INFO', 'Telegram mesaj gönderildi', { chatId, messageId: response.data?.result?.message_id });
+            return { success: true, messageId: response.data?.result?.message_id };
+        } catch (e) {
+            log('ERROR', 'Telegram gönderme hatası', { error: e.message });
+            return { success: false, error: e.message };
+        }
+    }
+
+    async setWebhook(url) {
+        try {
+            const response = await axios.post(`${this.apiUrl}/setWebhook`, {
+                url: url,
+                allowed_updates: ['message', 'callback_query']
+            });
+            log('INFO', 'Telegram webhook ayarlandı', { url });
+            return response.data.ok;
+        } catch (e) {
+            log('ERROR', 'Telegram webhook hatası', { error: e.message });
+            return false;
+        }
+    }
+
+    async getUpdates(offset = 0) {
+        try {
+            const response = await axios.post(`${this.apiUrl}/getUpdates`, {
+                offset,
+                timeout: 30
+            });
+            return response.data.result || [];
+        } catch (e) {
+            log('ERROR', 'Telegram getUpdates hatası', { error: e.message });
+            return [];
+        }
+    }
+
+    // Long polling mode
+    async startPolling(onMessage) {
+        let offset = 0;
+        log('INFO', 'Telegram polling başlatıldı');
+
+        while (true) {
+            try {
+                const updates = await this.getUpdates(offset);
+
+                for (const update of updates) {
+                    offset = update.update_id + 1;
+
+                    if (update.message?.text) {
+                        const msg = {
+                            chatId: update.message.chat.id,
+                            from: update.message.from,
+                            text: update.message.text,
+                            messageId: update.message.message_id
+                        };
+
+                        // Callback
+                        if (onMessage) {
+                            const response = await onMessage(msg);
+                            if (response) {
+                                await this.send(msg.chatId, response);
+                            }
+                        }
+                    }
+                }
+            } catch (e) {
+                log('ERROR', 'Polling hatası', { error: e.message });
+                await new Promise(r => setTimeout(r, 5000));
+            }
+        }
+    }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CHANNEL MANAGER
+// ═══════════════════════════════════════════════════════════════════════════
+
+export class ChannelManager {
+    constructor() {
+        this.channels = {};
+    }
+
+    loadEnv() {
+        const env = {};
+        try {
+            if (fs.existsSync(CONFIG_PATH)) {
+                const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
+                content.split('\n').forEach(line => {
+                    const match = line.match(/^([^=]+)=(.*)$/);
+                    if (match) {
+                        env[match[1].trim()] = match[2].trim();
+                    }
+                });
+            }
+        } catch (e) { }
+        return env;
+    }
+
+    async initAll() {
+        const env = this.loadEnv();
+        const results = {};
+
+        // WhatsApp
+        if (env.WHATSAPP_PHONE_NUMBER_ID && env.WHATSAPP_ACCESS_TOKEN) {
+            const wa = new WhatsAppChannel({
+                phoneNumberId: env.WHATSAPP_PHONE_NUMBER_ID,
+                accessToken: env.WHATSAPP_ACCESS_TOKEN
+            });
+            if (await wa.connect()) {
+                this.channels.whatsapp = wa;
+                results.whatsapp = true;
+            }
+        }
+
+        // Telegram
+        if (env.TELEGRAM_BOT_TOKEN) {
+            const tg = new TelegramChannel({
+                botToken: env.TELEGRAM_BOT_TOKEN
+            });
+            if (await tg.connect()) {
+                this.channels.telegram = tg;
+                results.telegram = true;
+            }
+        }
+
+        return results;
+    }
+
+    getChannel(name) {
+        return this.channels[name];
+    }
+
+    getConnected() {
+        return Object.keys(this.channels);
+    }
+
+    async broadcast(message, channels = 'all') {
+        const targets = channels === 'all'
+            ? Object.keys(this.channels)
+            : channels.split(',');
+
+        const results = {};
+        for (const ch of targets) {
+            if (this.channels[ch]) {
+                // Not: WhatsApp ve Telegram için farklı recipient gerekir
+                // Bu örnek bir demonstration, gerçek kullanımda recipient listesi lazım
+                results[ch] = 'Channel ready';
+            }
+        }
+        return results;
+    }
+}
+
+// Singleton
+let managerInstance = null;
+
+export async function getChannelManager() {
+    if (!managerInstance) {
+        managerInstance = new ChannelManager();
+        await managerInstance.initAll();
+    }
+    return managerInstance;
+}
+
+export default ChannelManager;