vantuz 3.2.7 → 3.3.0

package/core/ai-provider.js

@@ -10,6 +10,75 @@ import os from 'os';
 
 const LOG_FILE = path.join(os.homedir(), '.vantuz', 'vantuz.log');
 
+const PROVIDER_CONFIG = {
+    gemini: {
+        url: (apiKey) => `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=${apiKey}`,
+        body: (systemPrompt, message) => ({
+            contents: [{ parts: [{ text: `${systemPrompt}\n\nKullanıcı: ${message}` }] }]
+        }),
+        headers: { 'Content-Type': 'application/json' },
+        parseResponse: (data) => data?.candidates?.[0]?.content?.parts?.[0]?.text,
+        errorMsg: 'Gemini yanıt vermedi'
+    },
+    groq: {
+        url: 'https://api.groq.com/openai/v1/chat/completions',
+        body: (systemPrompt, message) => ({
+            model: 'llama-3.3-70b-versatile',
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: message }
+            ],
+            max_tokens: 1000,
+            temperature: 0.7
+        }),
+        headers: (apiKey) => ({ 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' }),
+        parseResponse: (data) => data?.choices?.[0]?.message?.content,
+        errorMsg: 'Groq yanıt vermedi'
+    },
+    openai: {
+        url: 'https://api.openai.com/v1/chat/completions',
+        body: (systemPrompt, message) => ({
+            model: 'gpt-4o-mini',
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: message }
+            ],
+            max_tokens: 1000
+        }),
+        headers: (apiKey) => ({ 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' }),
+        parseResponse: (data) => data?.choices?.[0]?.message?.content,
+        errorMsg: 'OpenAI yanıt vermedi'
+    },
+    anthropic: {
+        url: 'https://api.anthropic.com/v1/messages',
+        body: (systemPrompt, message) => ({
+            model: 'claude-3-haiku-20240307',
+            max_tokens: 1000,
+            messages: [
+                { role: 'user', content: message }
+            ],
+            system: systemPrompt
+        }),
+        headers: (apiKey) => ({ 'x-api-key': apiKey, 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json' }),
+        parseResponse: (data) => data?.content?.[0]?.text,
+        errorMsg: 'Anthropic yanıt vermedi'
+    },
+    deepseek: {
+        url: 'https://api.deepseek.com/v1/chat/completions',
+        body: (systemPrompt, message) => ({
+            model: 'deepseek-chat',
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: message }
+            ],
+            max_tokens: 1000
+        }),
+        headers: (apiKey) => ({ 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' }),
+        parseResponse: (data) => data?.choices?.[0]?.message?.content,
+        errorMsg: 'DeepSeek yanıt vermedi'
+    }
+};
+
 // ═══════════════════════════════════════════════════════════════════════════
 // LOGGING
 // ═══════════════════════════════════════════════════════════════════════════
@@ -91,8 +160,28 @@ const VANTUZ_SYSTEM_PROMPT = `Sen Vantuz AI, e-ticaret operasyonlarını yönete
 // AI CHAT
 // ═══════════════════════════════════════════════════════════════════════════
 
+async function _makeApiRequest(providerName, providerConfig, message, apiKey, systemPrompt) {
+    if (!apiKey) throw new Error(`${providerName.toUpperCase()}_API_KEY ayarlanmamış`);
+
+    const url = typeof providerConfig.url === 'function' ? providerConfig.url(apiKey) : providerConfig.url;
+    const headers = typeof providerConfig.headers === 'function' ? providerConfig.headers(apiKey) : providerConfig.headers;
+    const body = providerConfig.body(systemPrompt, message);
+
+    const response = await axios.post(url, body, {
+        headers,
+        timeout: 30000
+    });
+
+    const text = providerConfig.parseResponse(response.data);
+    if (!text) throw new Error(providerConfig.errorMsg);
+
+    log('INFO', `${providerName} yanıtı alındı`, { chars: text.length });
+    return text;
+}
+
 export async function chat(message, config, env) {
     const provider = config.aiProvider || 'gemini';
+    const providerConfig = PROVIDER_CONFIG[provider];
 
     // Context bilgisi ekle
     const contextInfo = config.systemContext || '';
@@ -100,154 +189,19 @@ export async function chat(message, config, env) {
 
     log('INFO', `AI isteği: ${provider}`, { message: message.slice(0, 100) });
 
+    if (!providerConfig) {
+        return 'Desteklenmeyen AI sağlayıcı: ' + provider;
+    }
+
     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;
-        }
+        const apiKey = env[`${provider.toUpperCase()}_API_KEY`];
+        return await _makeApiRequest(provider, providerConfig, message, apiKey, fullSystemPrompt);
     } 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/database.js

@@ -1,73 +1,83 @@
-/**
- * 💾 VANTUZ DATABASE v3.2
- * SQLite veritabanı - ESM modülü
- */
-
-import { Sequelize, DataTypes } from 'sequelize';
+// core/database.js
+import sqlite3 from 'sqlite3';
+import { open } from 'sqlite';
 import path from 'path';
 import os from 'os';
+import { fileURLToPath } from 'url'; // Import fileURLToPath
+import { log } from './ai-provider.js';
 
-const VANTUZ_HOME = path.join(os.homedir(), '.vantuz');
-const dbPath = path.join(VANTUZ_HOME, 'vantuz.sqlite');
+const __filename = fileURLToPath(import.meta.url); // Define __filename
+const __dirname = path.dirname(__filename); // Define __dirname
 
-const sequelize = new Sequelize({
-    dialect: 'sqlite',
-    storage: dbPath,
-    logging: false
-});
+const DB_PATH = path.join(os.homedir(), '.vantuz', 'eia_data.db');
 
-// --- MODELLER ---
+class Database {
+    constructor() {
+        this.db = null;
+    }
 
-// Mağaza Ayarları (API Keyler vb.)
-const Store = sequelize.define('Store', {
-    name: { type: DataTypes.STRING, allowNull: false },
-    platform: { type: DataTypes.STRING, allowNull: false },
-    credentials: { type: DataTypes.JSON, allowNull: false },
-    isActive: { type: DataTypes.BOOLEAN, defaultValue: true }
-});
+    async init() {
+        if (this.db) return this.db;
 
-// Ürünler
-const Product = sequelize.define('Product', {
-    name: { type: DataTypes.STRING, allowNull: false },
-    barcode: { type: DataTypes.STRING, unique: true },
-    sku: { type: DataTypes.STRING },
-    description: { type: DataTypes.TEXT },
-    brand: { type: DataTypes.STRING },
-    images: { type: DataTypes.JSON },
-    marketData: { type: DataTypes.JSON },
-    aiAnalysis: { type: DataTypes.TEXT }
-});
+        try {
+            this.db = await open({
+                filename: DB_PATH,
+                driver: sqlite3.Database
+            });
+            await this.db.migrate({
+                migrationsPath: path.join(__dirname, 'migrations')
+            });
+            log('INFO', 'SQLite database initialized and migrated');
+            return this.db;
+        } catch (error) {
+            log('ERROR', `Failed to initialize database: ${error.message}`, { error });
+            throw error;
+        }
+    }
 
-// Siparişler
-const Order = sequelize.define('Order', {
-    platform: { type: DataTypes.STRING, allowNull: false },
-    orderNumber: { type: DataTypes.STRING, unique: true },
-    customerName: { type: DataTypes.STRING },
-    totalAmount: { type: DataTypes.FLOAT },
-    currency: { type: DataTypes.STRING, defaultValue: 'TRY' },
-    status: { type: DataTypes.STRING },
-    orderDate: { type: DataTypes.DATE },
-    items: { type: DataTypes.JSON }
-});
+    async close() {
+        if (this.db) {
+            await this.db.close();
+            this.db = null;
+            log('INFO', 'SQLite database closed');
+        }
+    }
 
-// AI Önerileri
-const Insight = sequelize.define('Insight', {
-    type: { type: DataTypes.STRING },
-    message: { type: DataTypes.TEXT },
-    priority: { type: DataTypes.INTEGER },
-    isRead: { type: DataTypes.BOOLEAN, defaultValue: false }
-});
+    // Example: Save product data
+    async saveProduct(product) {
+        const { id, name, price, cost, platform } = product;
+        await this.db.run(
+            `INSERT OR REPLACE INTO products (id, name, price, cost, platform, lastUpdated) VALUES (?, ?, ?, ?, ?, ?)`,
+            id, name, price, cost, platform, new Date().toISOString()
+        );
+        log('INFO', `Product ${name} saved/updated`);
+    }
 
-// Veritabanını Başlat
-export async function initDB() {
-    try {
-        await sequelize.sync({ alter: true });
-        return true;
-    } catch (error) {
-        console.error('Veritabanı hatası:', error);
-        return false;
+    // Example: Get product by ID
+    async getProduct(id) {
+        return this.db.get(`SELECT * FROM products WHERE id = ?`, id);
+    }
+
+    // Example: Save historical price
+    async saveHistoricalPrice(productId, price, timestamp) {
+        await this.db.run(
+            `INSERT INTO historical_prices (productId, price, timestamp) VALUES (?, ?, ?)`,
+            productId, price, timestamp
+        );
+        log('INFO', `Historical price for product ${productId} saved`);
+    }
+
+    // Example: Get historical prices for a product
+    async getHistoricalPrices(productId) {
+        return this.db.all(`SELECT * FROM historical_prices WHERE productId = ? ORDER BY timestamp ASC`, productId);
     }
 }
 
-export { sequelize, Store, Product, Order, Insight };
-export default { sequelize, Store, Product, Order, Insight, initDB };
+let dbInstance = null;
+
+export function getDatabase() {
+    if (!dbInstance) {
+        dbInstance = new Database();
+    }
+    return dbInstance;
+}

package/core/eia-brain.js

@@ -0,0 +1,102 @@
+// core/eia-brain.js
+import { chat as aiChat, log } from './ai-provider.js';
+
+class EIABrain {
+    constructor(config, env) {
+        this.config = config;
+        this.env = env;
+        this.systemPrompt = this._buildSystemPrompt();
+    }
+
+    _buildSystemPrompt() {
+        return `Sen bir E-Ticaret Yönetim Ajansı'nın (EIA) beynisin. Görevin, e-ticaret operasyonlarını 7/24 izlemek, analiz etmek ve **şirketin karlılığını ve büyümesini maksimize edecek proaktif aksiyon önerileri** sunmaktır. Veriye dayalı kararlar alan, sonuç odaklı ve iş stratejilerine hakim bir yönetici kişiliğine sahipsin.
+
+Aşağıdaki bilgilerle karar ver:
+- Güncel durum verileri (stok, fiyat, buybox durumu, yorumlar vb.)
+- Şirket kuralları ve hedefleri (bellekten alınacak)
+- Geçmiş stratejik kararlar (bellekten alınacak)
+
+Yanıtların kısa, öz, **iş değerine odaklı** ve eyleme yönelik olmalı. Gerekirse ek bilgi veya onay istemelisin.`;
+    }
+
+    async analyzeAndDecide(context) {
+        const fullPrompt = `${this.systemPrompt}
+
+--- GÜNCEL DURUM ---
+${context.currentSituation}
+
+--- ŞİRKET KURALLARI VE HEDEFLERİ ---
+${context.companyRules}
+
+--- GEÇMİŞ KARARLAR ---
+${context.pastDecisions}
+
+Durumu analiz et ve en uygun aksiyon önerisini veya içgörüyü sun.`;
+
+        try {
+            const response = await aiChat(fullPrompt, this.config, this.env);
+            log('INFO', 'EIA Brain analysis complete', { response: response.slice(0, 100) });
+            return response;
+        } catch (error) {
+            log('ERROR', 'EIA Brain analysis failed', { error: error.message });
+            return `Analiz sırasında bir hata oluştu: ${error.message}`;
+        }
+    }
+
+    /**
+     * Scraper'lardan gelen ham veriyi işleyip ticari içgörülere dönüştürür.
+     * Bu metod, veri modelleme ve iş mantığı kurallarını içerecektir.
+     */
+    async processRawData(rawData, dataType) {
+        log('INFO', `Processing raw data for type: ${dataType}`, { rawData: JSON.stringify(rawData).slice(0, 200) });
+
+        let insights = {};
+        switch (dataType) {
+            case 'price_changes':
+                insights = {
+                    type: 'price_change_insight',
+                    summary: `Fiyat değişikliği verisi işlendi. ${rawData.length} adet kayıt mevcut.`,
+                    details: rawData.map(item => `Ürün: ${item.productName}, Eski Fiyat: ${item.oldPrice}, Yeni Fiyat: ${item.newPrice}, Platform: ${item.platform}`)
+                };
+                break;
+            case 'buybox_status':
+                insights = {
+                    type: 'buybox_insight',
+                    summary: `Buybox durumu verisi işlendi.`,
+                    details: rawData.map(item => `Ürün: ${item.productName}, Durum: ${item.status}, Platform: ${item.platform}`)
+                };
+                break;
+            case 'stock_movements':
+                insights = {
+                    type: 'stock_insight',
+                    summary: `Stok hareketi verisi işlendi.`,
+                    details: rawData.map(item => `Ürün: ${item.productName}, Miktar: ${item.quantityChange}, Platform: ${item.platform}`)
+                };
+                break;
+            case 'product_reviews':
+                insights = {
+                    type: 'review_insight',
+                    summary: `Ürün yorumları verisi işlendi.`,
+                    details: rawData.map(item => `Ürün: ${item.productName}, Yorum: ${item.reviewText.slice(0, 50)}, Puan: ${item.rating}`)
+                };
+                break;
+            default:
+                insights = {
+                    type: 'general_insight',
+                    summary: 'Bilinen bir veri tipi değil, ham veri olarak işlendi.',
+                    rawData: rawData
+                };
+                break;
+        }
+        return insights;
+    }
+}
+
+let eiaBrainInstance = null;
+
+export function getEIABrain(config, env) {
+    if (!eiaBrainInstance) {
+        eiaBrainInstance = new EIABrain(config, env);
+    }
+    return eiaBrainInstance;
+}