vantuz 3.2.7 → 3.3.0

package/core/eia-monitor.js

@@ -0,0 +1,220 @@
+// core/eia-monitor.js
+import { getScheduler } from './scheduler.js';
+import { TrendyolScraper } from './scrapers/TrendyolScraper.js'; // Example scraper
+import { getEIABrain } from './eia-brain.js';
+import { getDatabase } from './database.js'; // Import database
+import { getVectorDB } from './vector-db.js'; // Import vector DB
+import { log } from './ai-provider.js';
+
+class EIAMonitor {
+    constructor(config, env) {
+        this.scheduler = getScheduler();
+        this.eiaBrain = getEIABrain(config, env);
+        this.db = getDatabase(); // Initialize database
+        this.vectorDb = getVectorDB(); // Initialize vector DB
+        this.config = config;
+        this.env = env;
+        this.productUrls = this._parseUrls(this.env.EIA_PRODUCT_URLS);
+        this.competitorUrls = this._parseUrls(this.env.EIA_COMPETITOR_URLS);
+        this.targetProfitMargin = parseFloat(this.env.EIA_TARGET_PROFIT_MARGIN || '15'); // Default 15%
+        this.scrapers = {
+            trendyol: new TrendyolScraper() // Initialize other scrapers here
+        };
+        log('INFO', 'EIA Monitor initialized');
+    }
+
+    _parseUrls(urlsString) {
+        return urlsString ? urlsString.split(',').map(url => url.trim()).filter(Boolean) : [];
+    }
+
+    async initMonitoringTasks() {
+        // Ensure DB is initialized before registering tasks
+        await this.db.init();
+
+        const cronSchedule = '*/30 * * * *'; // Every 30 minutes, for example
+
+        // Monitor product URLs
+        for (const productUrl of this.productUrls) {
+            // Assuming a way to extract productId and platform from URL
+            const { productId, platform } = this._extractProductInfoFromUrl(productUrl);
+            if (productId && platform) {
+                // Register monitoring for various data types
+                this.startMonitoring(productId, platform, productUrl, 'price_changes', cronSchedule);
+                this.startMonitoring(productId, platform, productUrl, 'buybox_status', cronSchedule);
+                this.startMonitoring(productId, platform, productUrl, 'stock_movements', cronSchedule);
+                this.startMonitoring(productId, platform, productUrl, 'product_reviews', cronSchedule);
+            } else {
+                log('WARN', `Could not extract product info from URL: ${productUrl}`);
+            }
+        }
+
+        // Monitor competitor URLs (for price changes and buybox status)
+        for (const competitorUrl of this.competitorUrls) {
+            const { productId, platform } = this._extractProductInfoFromUrl(competitorUrl);
+            if (productId && platform) {
+                this.startMonitoring(`comp-${productId}`, platform, competitorUrl, 'price_changes', cronSchedule);
+                this.startMonitoring(`comp-${productId}`, platform, competitorUrl, 'buybox_status', cronSchedule);
+            } else {
+                log('WARN', `Could not extract product info from competitor URL: ${competitorUrl}`);
+            }
+        }
+
+        // Load company rules into vector DB (placeholder)
+        await this._loadCompanyRules();
+    }
+
+    _extractProductInfoFromUrl(url) {
+        // Placeholder: Implement logic to extract product ID and platform from various marketplace URLs
+        // This will be crucial for mapping URLs to specific scraper methods and DB entries
+        // For Trendyol example: trendyol.com/s/product-id -> platform: 'trendyol', productId: 'product-id'
+        if (url.includes('trendyol.com')) {
+            const match = url.match(/\/s\/(.*?)(?:\?|$)/);
+            return { platform: 'trendyol', productId: match ? match[1] : url };
+        }
+        // Add logic for Hepsiburada, Amazon, etc.
+        return { platform: 'unknown', productId: url };
+    }
+
+    async _loadCompanyRules() {
+        // Placeholder: Load company rules from a file or config and embed them into the vector DB
+        const rules = [
+            'Asla %10 marjın altına düşme.',
+            'Müşteri şikayetlerine 24 saat içinde yanıt ver.',
+            'Rakip fiyatı %5 düşürürse kendi fiyatını %2 düşür.'
+        ];
+        for (const rule of rules) {
+            // This would require an embedding model to convert text to vector
+            // For now, use a dummy vector
+            const dummyVector = Array.from({ length: 1536 }, () => Math.random()); // Example: OpenAI embedding size
+            await this.vectorDb.add('company_rules', dummyVector, { type: 'rule', text: rule });
+        }
+        log('INFO', `${rules.length} company rules loaded into vector DB.`);
+    }
+
+    /**
+     * Start monitoring a product for a specific data type.
+     * @param {string} productId Unique identifier for the product.
+     * @param {string} platform Platform name (e.g., 'trendyol').
+     * @param {string} productUrl URL of the product page.
+     * @param {string} dataType Type of data to monitor (e.g., 'price_changes', 'buybox_status').
+     * @param {string} cronSchedule Cron schedule for monitoring (e.g., '0 * * * *').
+     */
+    async startMonitoring(productId, platform, productUrl, dataType, cronSchedule) {
+        const jobName = `monitor-${platform}-${productId}-${dataType}`;
+        const scraper = this.scrapers[platform];
+
+        if (!scraper) {
+            log('ERROR', `No scraper found for platform: ${platform}`);
+            return;
+        }
+
+        const task = async () => {
+            log('INFO', `Monitoring ${dataType} for product ${productId} on ${platform}`);
+            let rawData;
+            try {
+                // Scrape Data
+                switch (dataType) {
+                    case 'price_changes':
+                        rawData = await scraper.getPriceChanges(productUrl);
+                        break;
+                    case 'buybox_status':
+                        rawData = await scraper.getBuyboxStatus(productUrl);
+                        break;
+                    case 'stock_movements':
+                        rawData = await scraper.getStockMovements(productUrl);
+                        break;
+                    case 'product_reviews':
+                        rawData = await scraper.getProductReviewsAndRatings(productUrl);
+                        break;
+                    default:
+                        log('WARN', `Unknown data type for monitoring: ${dataType}`);
+                        return;
+                }
+
+                // Process Raw Data & Compare with Baseline (Placeholder)
+                const insights = await this.eiaBrain.processRawData(rawData, dataType); // Use EIA Brain for processing
+                const anomaly = this._detectAnomaly(productId, dataType, insights); // Implement anomaly detection
+
+                if (anomaly) {
+                    log('WARN', `Anomaly detected for ${dataType} on product ${productId}: ${JSON.stringify(anomaly)}`);
+                    await this._alertUserViaLLM(productId, platform, dataType, anomaly, insights);
+                } else {
+                    log('INFO', `No anomaly detected for ${dataType} on product ${productId}.`);
+                }
+
+            } catch (error) {
+                log('ERROR', `Error during monitoring job ${jobName}: ${error.message}`, { error });
+            }
+        };
+
+        this.scheduler.addJob(jobName, cronSchedule, task);
+        log('INFO', `Started monitoring job "${jobName}" for ${productUrl} every ${cronSchedule}`);
+    }
+
+    /**
+     * Placeholder for anomaly detection logic.
+     * This will involve comparing current data with historical baseline data.
+     */
+    _detectAnomaly(productId, dataType, currentInsights) {
+        // For demonstration, let's say any new data is an "anomaly" if no baseline exists
+        // In a real system, this would be a sophisticated comparison
+        if (!this.baselineData[dataType]?.[productId]) {
+            this.baselineData[dataType] = this.baselineData[dataType] || {};
+            this.baselineData[dataType][productId] = currentInsights; // Store current as baseline
+            return null; // No anomaly, first data point
+        }
+
+        // Simple example: if a price changes from baseline
+        if (dataType === 'price_changes' && currentInsights.currentPrice !== this.baselineData.prices[productId].currentPrice) {
+            return {
+                type: 'price_change',
+                oldPrice: this.baselineData.prices[productId].currentPrice,
+                newPrice: currentInsights.currentPrice
+            };
+        }
+        return null;
+    }
+
+    /**
+     * Placeholder for alerting the user via LLM.
+     */
+    async _alertUserViaLLM(productId, platform, dataType, anomaly, insights) {
+        let currentSituationDescription = `🚨 Anomali Tespiti!
+Ürün ID: ${productId}
+Platform: ${platform}
+Veri Tipi: ${dataType}`;
+
+        if (dataType === 'price_changes' && anomaly.type === 'price_change') {
+            currentSituationDescription += `\nFiyat Değişikliği Tespit Edildi: Ürünün eski fiyatı ${anomaly.oldPrice} iken, yeni fiyatı ${anomaly.newPrice} oldu.`;
+            currentSituationDescription += `\nİçgörü Özeti: ${insights.summary}`;
+            currentSituationDescription += `\nİçgörü Detayları: ${insights.details.join('; ')}`;
+        } else if (dataType === 'buybox_status') {
+            currentSituationDescription += `\nBuybox Durumu: ${anomaly.status}.`;
+            currentSituationDescription += `\nİçgörü Özeti: ${insights.summary}`;
+        }
+        // Add more specific descriptions for other anomaly types as needed
+
+        // Fetch relevant company rules from vector DB (placeholder for actual embedding and search)
+        const relevantRules = await this.vectorDb.search('company_rules', [/* dummy embedding */], 2); // Assume some query vector
+        const companyRulesContext = relevantRules.map(r => r.metadata.text).join('\n- ');
+        
+        // Fetch past strategic decisions (placeholder)
+        const pastDecisionsContext = "Daha önce benzer bir durumda fiyat düşürme kararı alınmıştı."; // Placeholder
+
+        const llmResponse = await this.eiaBrain.analyzeAndDecide({
+            currentSituation: currentSituationDescription,
+            companyRules: companyRulesContext || 'Şirket kuralları bulunamadı.',
+            pastDecisions: pastDecisionsContext
+        });
+        log('INFO', 'Alert sent via LLM', { llmResponse: llmResponse.slice(0, 100) });
+    }
+}
+
+let eiaMonitorInstance = null;
+
+export function getEIAMonitor(config, env) {
+    if (!eiaMonitorInstance) {
+        eiaMonitorInstance = new EIAMonitor(config, env);
+    }
+    return eiaMonitorInstance;
+}

package/core/engine.js

@@ -17,6 +17,7 @@ import platformHub from '../plugins/vantuz/platforms/index.js';
 import { getChannelManager } from './channels.js';
 import { chat as aiChat, log } from './ai-provider.js';
 import { getGateway } from './gateway.js';
+import { getEIAMonitor } from './eia-monitor.js'; // New import
 
 // Tools
 import { repricerTool } from '../plugins/vantuz/tools/repricer.js';
@@ -27,6 +28,44 @@ import { productTool } from '../plugins/vantuz/tools/product.js';
 import { analyticsTool } from '../plugins/vantuz/tools/analytics.js';
 import { quickReportTool } from '../plugins/vantuz/tools/quick-report.js';
 
+const PLATFORM_CONFIG_MAP = {
+    trendyol: {
+        envPrefix: 'TRENDYOL',
+        keys: ['supplierId', 'apiKey', 'apiSecret']
+    },
+    hepsiburada: {
+        envPrefix: 'HEPSIBURADA',
+        keys: ['merchantId', 'username', 'password']
+    },
+    n11: {
+        envPrefix: 'N11',
+        keys: ['apiKey', 'apiSecret']
+    },
+    amazon: {
+        envPrefix: 'AMAZON',
+        nested: {
+            eu: {
+                keys: ['sellerId', 'clientId', 'refreshToken']
+            },
+            us: {
+                keys: ['sellerId', 'clientId', 'refreshToken']
+            }
+        }
+    },
+    ciceksepeti: {
+        envPrefix: 'CICEKSEPETI',
+        keys: ['apiKey', 'apiSecret']
+    },
+    pttavm: {
+        envPrefix: 'PTTAVM',
+        keys: ['apiKey', 'apiSecret']
+    },
+    pazarama: {
+        envPrefix: 'PAZARAMA',
+        keys: ['apiKey', 'apiSecret']
+    }
+};
+
 // ═══════════════════════════════════════════════════════════════════════════
 // CONFIG
 // ═══════════════════════════════════════════════════════════════════════════
@@ -51,6 +90,7 @@ export class VantuzEngine {
             products: [],
             connectedPlatforms: []
         };
+        this.eiaMonitor = null; // New property
 
         // Tool Registry
         this.tools = {
@@ -93,6 +133,10 @@ export class VantuzEngine {
         // Context oluştur (bağlı platformlardan veri çek)
         await this._buildContext();
 
+        // Initialize and start EIA Monitor
+        this.eiaMonitor = getEIAMonitor(this.config, this.env);
+        await this.eiaMonitor.initMonitoringTasks(); // New line
+
         this.initialized = true;
         log('INFO', 'Vantuz Engine hazır', {
             platforms: this.context.connectedPlatforms.length,
@@ -140,35 +184,39 @@ export class VantuzEngine {
     async _initPlatforms() {
         const platformConfig = {};
 
-        // Otomatik config eşleme
-        if (this.env.TRENDYOL_API_KEY) {
-            platformConfig.trendyol = {
-                supplierId: this.env.TRENDYOL_SUPPLIER_ID,
-                apiKey: this.env.TRENDYOL_API_KEY,
-                apiSecret: this.env.TRENDYOL_API_SECRET
-            };
-        }
-        if (this.env.HEPSIBURADA_MERCHANT_ID) {
-            platformConfig.hepsiburada = {
-                merchantId: this.env.HEPSIBURADA_MERCHANT_ID,
-                username: this.env.HEPSIBURADA_USERNAME,
-                password: this.env.HEPSIBURADA_PASSWORD
-            };
-        }
-        if (this.env.N11_API_KEY) {
-            platformConfig.n11 = {
-                apiKey: this.env.N11_API_KEY,
-                apiSecret: this.env.N11_API_SECRET
-            };
-        }
-        if (this.env.AMAZON_SELLER_ID) {
-            platformConfig.amazon = {
-                eu: {
-                    sellerId: this.env.AMAZON_SELLER_ID,
-                    clientId: this.env.AMAZON_CLIENT_ID,
-                    refreshToken: this.env.AMAZON_REFRESH_TOKEN
+        for (const platformName in PLATFORM_CONFIG_MAP) {
+            const platformMap = PLATFORM_CONFIG_MAP[platformName];
+            if (platformMap.envPrefix) {
+                const config = {};
+                let hasRequiredEnv = false;
+                for (const key of platformMap.keys) {
+                    const envKey = `${platformMap.envPrefix}_${key.toUpperCase()}`;
+                    if (this.env[envKey]) {
+                        config[key] = this.env[envKey];
+                        hasRequiredEnv = true;
+                    }
                 }
-            };
+                if (hasRequiredEnv) {
+                    platformConfig[platformName] = config;
+                }
+            } else if (platformName === 'amazon' && this.env.AMAZON_SELLER_ID) { // Specific handling for Amazon's nested structure
+                platformConfig.amazon = {};
+                // Handle EU configuration
+                const euConfig = {};
+                let hasEuEnv = false;
+                for (const key of PLATFORM_CONFIG_MAP.amazon.nested.eu.keys) {
+                    const envKey = `AMAZON_${key.toUpperCase()}`;
+                    if (this.env[envKey]) {
+                        euConfig[key] = this.env[envKey];
+                        hasEuEnv = true;
+                    }
+                }
+                if (hasEuEnv) {
+                    platformConfig.amazon.eu = euConfig;
+                }
+
+                // Handle US configuration if needed (add similar logic here)
+            }
         }
 
         // Platform Hub'ı başlat
@@ -238,17 +286,29 @@ export class VantuzEngine {
      * Mesajdan Tool tespiti (Basit NLP)
      */
     async _tryExecuteToolFromMessage(message) {
-        const lower = message.toLowerCase();
-
-        // Repricer
-        if (lower.includes('fiyat analizi') || lower.includes('rakip analizi')) {
-            return "Repricer aracı çalıştırılıyor... (Detaylı parametreler için /rakip komutunu kullanın)";
-        }
-
-        // Stok
-        if (lower.includes('stok durumu')) {
-            const stocks = await this.getStock();
-            return JSON.stringify(stocks.map(s => ({ platform: s.platform, items: s.products.length })), null, 2);
+        const lower = message.toLowerCase().trim();
+
+        // Check for explicit commands
+        if (lower.startsWith('/')) {
+            const parts = lower.substring(1).split(' ');
+            const command = parts[0];
+            const args = parts.slice(1);
+
+            switch (command) {
+                case 'repricer':
+                case 'rakip':
+                case 'fiyat-analizi':
+                    // In a real scenario, you'd parse args and pass them to repricerTool
+                    return "Repricer aracı çalıştırılıyor... (Detaylı parametreler için /rakip komutunu kullanın)";
+                case 'stock':
+                case 'stok-durumu':
+                    const stocks = await this.getStock();
+                    return JSON.stringify(stocks.map(s => ({ platform: s.platform, items: s.products.length })), null, 2);
+                case 'help':
+                    return "Kullanabileceğin komutlar: /rakip, /stok-durumu";
+                default:
+                    return `Bilinmeyen komut: /${command}. Yardım için /help yazabilirsin.`;
+            }
         }
 
         return null;

package/core/gateway.js

@@ -34,24 +34,7 @@ function loadGatewayConfig() {
     return null;
 }
 
-function getGatewayUrl() {
-    // Gateway cmd dosyasından port oku
-    const gatewayCmd = path.join(OPENCLAW_HOME, 'gateway.cmd');
-    let port = 18789; // Varsayılan
-
-    try {
-        if (fs.existsSync(gatewayCmd)) {
-            const content = fs.readFileSync(gatewayCmd, 'utf-8');
-            const portMatch = content.match(/OPENCLAW_GATEWAY_PORT=(\d+)/);
-            if (portMatch) port = parseInt(portMatch[1]);
-        }
-    } catch (e) { }
-
-    return `http://localhost:${port}`;
-}
-
-function getGatewayToken() {
-    const config = loadGatewayConfig();
+function getGatewayToken(config) {
     return config?.gateway?.auth?.token || null;
 }
 
@@ -61,11 +44,12 @@ function getGatewayToken() {
 
 export class VantuzGateway {
     constructor() {
-        this.baseUrl = getGatewayUrl();
-        this.token = getGatewayToken();
+        this.config = loadGatewayConfig();
+        const port = this.config?.gateway?.port || 18789;
+        this.baseUrl = `http://localhost:${port}`;
+        this.token = getGatewayToken(this.config);
         this.connected = false;
         this.version = null;
-        this.config = loadGatewayConfig();
     }
 
     /**

package/core/migrations/001-initial-schema.js

@@ -0,0 +1,28 @@
+// core/migrations/001-initial-schema.js
+export async function up(db) {
+    await db.exec(`
+        CREATE TABLE products (
+            id TEXT PRIMARY KEY,
+            name TEXT NOT NULL,
+            price REAL,
+            cost REAL,
+            platform TEXT NOT NULL,
+            lastUpdated TEXT
+        );
+
+        CREATE TABLE historical_prices (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            productId TEXT NOT NULL,
+            price REAL NOT NULL,
+            timestamp TEXT NOT NULL,
+            FOREIGN KEY (productId) REFERENCES products(id) ON DELETE CASCADE
+        );
+    `);
+}
+
+export async function down(db) {
+    await db.exec(`
+        DROP TABLE IF EXISTS historical_prices;
+        DROP TABLE IF EXISTS products;
+    `);
+}

package/core/scheduler.js

@@ -0,0 +1,80 @@
+// core/scheduler.js
+import { CronJob } from 'cron';
+import { log } from './ai-provider.js';
+
+class Scheduler {
+    constructor() {
+        this.jobs = new Map();
+        log('INFO', 'Scheduler initialized');
+    }
+
+    /**
+     * Bir görevi belirli bir cron zamanlamasına göre kaydeder ve başlatır.
+     * @param {string} name Görevin benzersiz adı.
+     * @param {string} cronTime Cron zamanlama dizesi (örn. '0 * * * *' her saat başı).
+     * @param {function} task Çalıştırılacak asenkron fonksiyon.
+     * @param {boolean} startImmediately Hemen başlatılsın mı? (Varsayılan: true)
+     */
+    addJob(name, cronTime, task, startImmediately = true) {
+        if (this.jobs.has(name)) {
+            log('WARN', `Job with name "${name}" already exists. Skipping.`);
+            return;
+        }
+
+        const job = new CronJob(cronTime, async () => {
+            log('INFO', `Running scheduled job: ${name}`);
+            try {
+                await task();
+                log('INFO', `Scheduled job "${name}" completed successfully.`);
+            } catch (error) {
+                log('ERROR', `Scheduled job "${name}" failed: ${error.message}`, { error });
+            }
+        }, null, startImmediately, 'UTC'); // UTC timezone for consistency
+
+        this.jobs.set(name, job);
+        log('INFO', `Scheduled job "${name}" added and started with cron: "${cronTime}"`);
+    }
+
+    /**
+     * Kayıtlı bir görevi durdurur.
+     * @param {string} name Durdurulacak görevin adı.
+     */
+    stopJob(name) {
+        const job = this.jobs.get(name);
+        if (job) {
+            job.stop();
+            this.jobs.delete(name);
+            log('INFO', `Scheduled job "${name}" stopped and removed.`);
+        } else {
+            log('WARN', `Job with name "${name}" not found. Cannot stop.`);
+        }
+    }
+
+    /**
+     * Tüm kayıtlı görevleri durdurur.
+     */
+    stopAllJobs() {
+        for (const [name, job] of this.jobs) {
+            job.stop();
+            log('INFO', `Scheduled job "${name}" stopped.`);
+        }
+        this.jobs.clear();
+        log('INFO', 'All scheduled jobs stopped.');
+    }
+
+    /**
+     * Tüm aktif görevlerin listesini döner.
+     */
+    listJobs() {
+        return Array.from(this.jobs.keys());
+    }
+}
+
+let schedulerInstance = null;
+
+export function getScheduler() {
+    if (!schedulerInstance) {
+        schedulerInstance = new Scheduler();
+    }
+    return schedulerInstance;
+}

package/core/scrapers/Scraper.js

@@ -0,0 +1,61 @@
+// core/scrapers/Scraper.js
+import { chromium } from 'playwright';
+
+export class Scraper {
+    constructor() {
+        this.browser = null;
+        this.page = null;
+    }
+
+    async init() {
+        if (!this.browser) {
+            this.browser = await chromium.launch({ headless: true }); // headless: true for production
+        }
+        this.page = await this.browser.newPage();
+    }
+
+    async close() {
+        if (this.page) {
+            await this.page.close();
+            this.page = null;
+        }
+        if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+        }
+    }
+
+    async goTo(url) {
+        if (!this.page) {
+            throw new Error('Scraper not initialized. Call init() first.');
+        }
+        await this.page.goto(url);
+    }
+
+    async extractText(selector) {
+        if (!this.page) return null;
+        return this.page.locator(selector).textContent();
+    }
+
+    async extractAttribute(selector, attribute) {
+        if (!this.page) return null;
+        return this.page.locator(selector).getAttribute(attribute);
+    }
+
+    async extractAllText(selector) {
+        if (!this.page) return [];
+        return this.page.locator(selector).allTextContents();
+    }
+
+    async type(selector, text) {
+        if (!this.page) return;
+        await this.page.locator(selector).type(text);
+    }
+
+    async click(selector) {
+        if (!this.page) return;
+        await this.page.locator(selector).click();
+    }
+
+    // You can add more generic scraping methods here
+}