vantuz 3.3.0 → 3.3.2

package/core/engine.js

@@ -16,8 +16,11 @@ import platformHub from '../plugins/vantuz/platforms/index.js';
 // AI Provider & Gateway
 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
+import { getGateway } from './gateway.js';
+import { getEIAMonitor } from './eia-monitor.js'; // New import
+import AutomationManager from './automation.js';
+import OpenClawBridge from './openclaw-bridge.js';
+import { executeTool } from './agent.js';
 
 // Tools
 import { repricerTool } from '../plugins/vantuz/tools/repricer.js';
@@ -37,10 +40,10 @@ const PLATFORM_CONFIG_MAP = {
         envPrefix: 'HEPSIBURADA',
         keys: ['merchantId', 'username', 'password']
     },
-    n11: {
-        envPrefix: 'N11',
-        keys: ['apiKey', 'apiSecret']
-    },
+    n11: {
+        envPrefix: 'N11',
+        keys: ['apiKey', 'apiSecret']
+    },
     amazon: {
         envPrefix: 'AMAZON',
         nested: {
@@ -79,7 +82,7 @@ const CONFIG_JSON = path.join(VANTUZ_HOME, 'config.json');
 // ═══════════════════════════════════════════════════════════════════════════
 
 export class VantuzEngine {
-    constructor() {
+    constructor() {
         this.initialized = false;
         this.config = {};
         this.env = {};
@@ -90,7 +93,9 @@ export class VantuzEngine {
             products: [],
             connectedPlatforms: []
         };
-        this.eiaMonitor = null; // New property
+        this.eiaMonitor = null; // New property
+        this.automation = null;
+        this.bridge = null;
 
         // Tool Registry
         this.tools = {
@@ -107,22 +112,29 @@ export class VantuzEngine {
     /**
      * Engine'i başlat
      */
-    async initialize() {
-        log('INFO', 'Vantuz Engine v3.2 başlatılıyor...');
-
-        // Config ve env yükle
-        this._loadConfig();
-        this._loadEnv();
-
-        // Vantuz Gateway bağlantısı
-        try {
-            this.gateway = await getGateway();
-            if (this.gateway.isConnected()) {
-                log('INFO', 'Vantuz Gateway bağlı', this.gateway.getInfo());
-            }
-        } catch (e) {
-            log('WARN', 'Gateway bağlantısı başarısız, direkt mod', { error: e.message });
-        }
+    async initialize() {
+        log('INFO', 'Vantuz Engine v3.2 başlatılıyor...');
+
+        // Config ve env yükle
+        this._loadConfig();
+        this._loadEnv();
+
+        // Vantuz Gateway bağlantısı
+        try {
+            this.gateway = await getGateway();
+            if (this.gateway.isConnected()) {
+                log('INFO', 'Vantuz Gateway bağlı', this.gateway.getInfo());
+            } else if (this._shouldAutoStartGateway()) {
+                const started = await this.gateway.ensureRunning();
+                if (started.success) {
+                    log('INFO', 'Vantuz Gateway otomatik başlatıldı', this.gateway.getInfo());
+                } else {
+                    log('WARN', 'Gateway otomatik başlatılamadı', { error: started.error });
+                }
+            }
+        } catch (e) {
+            log('WARN', 'Gateway bağlantısı başarısız, direkt mod', { error: e.message });
+        }
 
         // Channel Manager'ı başlat
         this.channels = await getChannelManager();
@@ -134,17 +146,70 @@ export class VantuzEngine {
         await this._buildContext();
 
         // Initialize and start EIA Monitor
-        this.eiaMonitor = getEIAMonitor(this.config, this.env);
-        await this.eiaMonitor.initMonitoringTasks(); // New line
-
-        this.initialized = true;
+        this.eiaMonitor = getEIAMonitor(this.config, this.env);
+        await this.eiaMonitor.initMonitoringTasks(); // New line
+
+        // Automation manager
+        this.automation = new AutomationManager(this);
+        this.automation.init();
+
+        // Gateway WS bridge (inbound)
+        if (this._shouldStartBridge()) {
+            try {
+                this.bridge = new OpenClawBridge(this, this.gateway);
+                this.bridge.start();
+            } catch (e) {
+                log('WARN', 'Gateway bridge başlatılamadı', { error: e.message });
+            }
+        }
+
+        this.initialized = true;
         log('INFO', 'Vantuz Engine hazır', {
             platforms: this.context.connectedPlatforms.length,
             gateway: this.gateway?.isConnected() || false
         });
 
-        return this;
-    }
+        return this;
+    }
+
+    /**
+     * Gelişmiş mesaj işleme (otomasyon + onay)
+     */
+    async handleMessage(message, meta = { channel: 'local', from: 'local' }) {
+        if (!this.initialized) await this.initialize();
+        if (this.automation) {
+            const result = await this.automation.handleMessage(message, meta);
+            if (result?.handled) {
+                return result.response;
+            }
+        }
+        return await this.chat(message);
+    }
+
+    /**
+     * Gateway otomatik başlatılsın mı?
+     */
+    _shouldAutoStartGateway() {
+        const envValue = this.env.VANTUZ_GATEWAY_AUTOSTART;
+        if (envValue !== undefined) {
+            return !['0', 'false', 'no'].includes(String(envValue).toLowerCase());
+        }
+        if (this.config && this.config.gatewayAutoStart !== undefined) {
+            return this.config.gatewayAutoStart !== false;
+        }
+        return true;
+    }
+
+    _shouldStartBridge() {
+        const envValue = this.env.VANTUZ_OPENCLAW_BRIDGE;
+        if (envValue !== undefined) {
+            return !['0', 'false', 'no'].includes(String(envValue).toLowerCase());
+        }
+        if (this.config && this.config.openclawBridge !== undefined) {
+            return this.config.openclawBridge !== false;
+        }
+        return true;
+    }
 
     /**
      * Config dosyasını yükle
@@ -186,36 +251,61 @@ export class VantuzEngine {
 
         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 = {};
+
+            if (platformName === 'amazon') { // Handle Amazon's specific nested structure first
+                const amazonConfig = {};
+                let hasAmazonEnv = false;
+
                 // Handle EU configuration
                 const euConfig = {};
                 let hasEuEnv = false;
                 for (const key of PLATFORM_CONFIG_MAP.amazon.nested.eu.keys) {
-                    const envKey = `AMAZON_${key.toUpperCase()}`;
+                    const envKey = `AMAZON_EU_${key.toUpperCase()}`; // Assuming EU specific env keys
                     if (this.env[envKey]) {
                         euConfig[key] = this.env[envKey];
                         hasEuEnv = true;
                     }
                 }
                 if (hasEuEnv) {
-                    platformConfig.amazon.eu = euConfig;
+                    amazonConfig.eu = euConfig;
+                    hasAmazonEnv = true;
                 }
 
-                // Handle US configuration if needed (add similar logic here)
+                // Handle US configuration (add similar logic here if needed)
+                const usConfig = {};
+                let hasUsEnv = false;
+                for (const key of PLATFORM_CONFIG_MAP.amazon.nested.us.keys) {
+                    const envKey = `AMAZON_US_${key.toUpperCase()}`; // Assuming US specific env keys
+                    if (this.env[envKey]) {
+                        usConfig[key] = this.env[envKey];
+                        hasUsEnv = true;
+                    }
+                }
+                if (hasUsEnv) {
+                    amazonConfig.us = usConfig;
+                    hasAmazonEnv = true;
+                }
+
+                if (hasAmazonEnv) {
+                    platformConfig[platformName] = amazonConfig;
+                }
+            } else if (platformMap.envPrefix && platformMap.keys) { // Handle other platforms with direct keys
+                const config = {};
+                let hasRequiredEnv = false;
+                for (const key of platformMap.keys) {
+                    const upper = key.toUpperCase();
+                    const snake = key.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
+                    const envKey = `${platformMap.envPrefix}_${upper}`;
+                    const altEnvKey = `${platformMap.envPrefix}_${snake}`;
+                    const value = this.env[envKey] || this.env[altEnvKey];
+                    if (value) {
+                        config[key] = value;
+                        hasRequiredEnv = true;
+                    }
+                }
+                if (hasRequiredEnv) {
+                    platformConfig[platformName] = config;
+                }
             }
         }
 
@@ -234,40 +324,50 @@ export class VantuzEngine {
     async _buildContext() {
         this.context.connectedPlatforms = platformHub.getConnected();
 
-        for (const platform of this.context.connectedPlatforms) {
-            try {
-                const api = platformHub.resolve(platform);
-                if (api && typeof api.getProducts === 'function') {
-                    const result = await api.getProducts({ page: 0, size: 10 });
-                    if (result?.success) {
-                        const products = result.data?.content || result.data || [];
-                        this.context.products.push(...products.map(p => ({
-                            ...p,
-                            _platform: platform
-                        })));
-                    }
-                }
-            } catch (e) {
-                log('ERROR', `${platform} veri çekme hatası`, { error: e.message });
-            }
-        }
+        for (const platform of this.context.connectedPlatforms) {
+            try {
+                const api = platformHub.resolve(platform);
+                if (api && typeof api.getProducts === 'function') {
+                    const result = await api.getProducts({ page: 0, size: 10 });
+                    if (result?.success) {
+                        const data = result.data;
+                        let products = [];
+                        if (Array.isArray(data?.content)) products = data.content;
+                        else if (Array.isArray(data)) products = data;
+                        else if (Array.isArray(data?.productList?.product)) products = data.productList.product;
+                        if (products.length > 0) {
+                            this.context.products.push(...products.map(p => ({
+                                ...p,
+                                _platform: platform
+                            })));
+                        }
+                    }
+                }
+            } catch (e) {
+                log('ERROR', `${platform} veri çekme hatası`, { error: e.message });
+            }
+        }
     }
 
     /**
      * AI ile sohbet - Tool destekli
      */
-    async chat(message) {
-        if (!this.initialized) await this.initialize();
-
-        // 1. Basit komut kontrolü (Tool çağırma)
-        const toolResult = await this._tryExecuteToolFromMessage(message);
-        if (toolResult) return toolResult;
-
-        // 2. Gateway üzerinden AI (Eğer varsa)
-        if (this.gateway?.isConnected()) {
-            try {
-                const gatewayResult = await this.gateway.chat(message, {
-                    systemPrompt: this._buildContextInfo()
+    async chat(message) {
+        if (!this.initialized) await this.initialize();
+
+        // 1. Basit komut kontrolü (Tool çağırma)
+        const toolResult = await this._tryExecuteToolFromMessage(message);
+        if (toolResult) return toolResult;
+
+        // 1.5 Gelişmiş ajan (araç çağrıları)
+        const agentResult = await this._tryAgent(message);
+        if (agentResult) return agentResult;
+
+        // 2. Gateway üzerinden AI (Eğer varsa)
+        if (this.gateway?.isConnected()) {
+            try {
+                const gatewayResult = await this.gateway.chat(message, {
+                    systemPrompt: this._buildContextInfo()
                 });
                 if (gatewayResult.success) return gatewayResult.response;
             } catch (e) { }
@@ -279,17 +379,95 @@ export class VantuzEngine {
             systemContext: this._buildContextInfo()
         };
 
-        return await aiChat(message, enrichedConfig, this.env);
-    }
+        return await aiChat(message, enrichedConfig, this.env);
+    }
+
+    async _tryAgent(message) {
+        const mode = this.config?.agentMode || this.env.VANTUZ_AGENT_MODE;
+        if (!mode || mode === 'off') return null;
+
+        const systemPrompt = [
+            'Sen Vantuz gelişmiş ajanısın.',
+            'Gerekirse aşağıdaki araçlardan birini çağır:',
+            'exec, readFile, listDir, httpGet, apiQuery',
+            'Sadece JSON döndür.',
+            'Şema: { "tool": "exec|readFile|listDir|httpGet|apiQuery", "args": { ... } }',
+            'apiQuery args: { "platform": "n11|trendyol|hepsiburada|amazon|ciceksepeti|pazarama|pttavm", "action": "orders|products|stock|categories", "params": { ... } }',
+            'Eğer araç gerekmezse: { "final": "cevap" }',
+            'Dosya yollarını ve komutları kısa tut.'
+        ].join('\n');
+
+        const plan = await aiChat(message, {
+            aiProvider: this.config.aiProvider || 'gemini',
+            systemContext: systemPrompt
+        }, this.env);
+
+        const jsonMatch = plan.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) return null;
+        let obj;
+        try { obj = JSON.parse(jsonMatch[0]); } catch { return null; }
+        if (obj.final) return obj.final;
+        if (!obj.tool) return null;
+
+        let toolResult;
+        if (obj.tool === 'apiQuery') {
+            toolResult = await this._runApiQuery(obj.args || {});
+        } else {
+            toolResult = await executeTool(obj.tool, obj.args || {}, this.config);
+        }
+        const followup = await aiChat(
+            `Kullanıcı mesajı: ${message}\nAraç çıktısı:\n${toolResult.output}\nCevap ver.`,
+            { aiProvider: this.config.aiProvider || 'gemini' },
+            this.env
+        );
+        return followup;
+    }
+
+    async _runApiQuery(args = {}) {
+        const platform = (args.platform || '').toLowerCase();
+        const action = (args.action || '').toLowerCase();
+        const params = args.params || {};
+        const api = platformHub.resolve(platform);
+        if (!api) return { success: false, output: 'Platform bulunamadı.' };
+
+        try {
+            if (action === 'orders' && api.getOrders) {
+                const result = await api.getOrders(params);
+                return { success: true, output: JSON.stringify(result?.data || result || {}, null, 2) };
+            }
+            if (action === 'products' && api.getProducts) {
+                const result = await api.getProducts(params);
+                return { success: true, output: JSON.stringify(result?.data || result || {}, null, 2) };
+            }
+            if (action === 'stock' && api.getProducts) {
+                const result = await api.getProducts(params);
+                return { success: true, output: JSON.stringify(result?.data || result || {}, null, 2) };
+            }
+            if (action === 'categories' && api.getTopCategories) {
+                const result = await api.getTopCategories(params);
+                return { success: true, output: JSON.stringify(result?.data || result || {}, null, 2) };
+            }
+            return { success: false, output: 'Bu platform için istenen action desteklenmiyor.' };
+        } catch (e) {
+            return { success: false, output: e.message };
+        }
+    }
 
     /**
      * Mesajdan Tool tespiti (Basit NLP)
      */
-    async _tryExecuteToolFromMessage(message) {
-        const lower = message.toLowerCase().trim();
-
-        // Check for explicit commands
-        if (lower.startsWith('/')) {
+    async _tryExecuteToolFromMessage(message) {
+        const lower = message.toLowerCase().trim();
+        const normalized = lower
+            .replace(/[çÇ]/g, 'c')
+            .replace(/[ğĞ]/g, 'g')
+            .replace(/[ıİ]/g, 'i')
+            .replace(/[öÖ]/g, 'o')
+            .replace(/[şŞ]/g, 's')
+            .replace(/[üÜ]/g, 'u');
+
+        // Check for explicit commands
+        if (lower.startsWith('/')) {
             const parts = lower.substring(1).split(' ');
             const command = parts[0];
             const args = parts.slice(1);
@@ -307,12 +485,63 @@ export class VantuzEngine {
                 case 'help':
                     return "Kullanabileceğin komutlar: /rakip, /stok-durumu";
                 default:
-                    return `Bilinmeyen komut: /${command}. Yardım için /help yazabilirsin.`;
-            }
-        }
-
-        return null;
-    }
+                    return `Bilinmeyen komut: /${command}. Yardım için /help yazabilirsin.`;
+            }
+        }
+
+        // Natural language shortcuts (no hallucination)
+        if (
+            lower.includes('hangi pazaryerleri bağlı') ||
+            lower.includes('hangi pazaryeri bağlı') ||
+            lower.includes('hangi platformlar bağlı') ||
+            normalized.includes('hangi pazaryerleri bagli') ||
+            normalized.includes('hangi platformlar bagli')
+        ) {
+            const connected = this.context.connectedPlatforms;
+            if (connected.length === 0) return 'Şu an bağlı pazaryeri yok.';
+            return `Bağlı pazaryerleri: ${connected.map(p => p.toUpperCase()).join(', ')}`;
+        }
+
+        const orderKeywords = [
+            'sipariş',
+            'siparis'
+        ];
+        const hasOrderKeyword = orderKeywords.some(k => lower.includes(k) || normalized.includes(k));
+
+        if (hasOrderKeyword) {
+            const orders = await this.getOrders({ size: 50, allStatuses: true });
+            if (!orders || orders.length === 0) {
+                return 'Sipariş verisine ulaşılamadı. Lütfen platform API bağlantılarını kontrol edin.';
+            }
+            const summary = this._summarizeOrdersByStatus(orders);
+            return `Şu an bağlı platformlardan gelen toplam ${orders.length} sipariş var.${summary ? ` Durum kırılımı: ${summary}` : ''}`;
+        }
+
+        if (lower.includes('onaylanan')) {
+            const orders = await this.getOrders({ size: 100, status: 'Picking' });
+            return `Şu an onaylanan (Picking) ${orders.length} sipariş var.`;
+        }
+
+        if (lower.includes('kargoya verilmemiş') || lower.includes('henüz kargoya') || lower.includes('kargoya verilmedi') || normalized.includes('kargoya verilmemis')) {
+            const orders = await this.getOrders({ size: 100, status: 'Created' });
+            return `Şu an kargoya verilmemiş (Created) ${orders.length} sipariş var.`;
+        }
+
+        return null;
+    }
+
+    _summarizeOrdersByStatus(orders = []) {
+        if (!Array.isArray(orders) || orders.length === 0) return '';
+        const counts = {};
+        orders.forEach(o => {
+            const s = (o.status || o.shipmentPackageStatus || o.orderStatus || 'UNKNOWN').toString();
+            counts[s] = (counts[s] || 0) + 1;
+        });
+        const entries = Object.entries(counts)
+            .sort((a, b) => b[1] - a[1])
+            .map(([s, n]) => `${s}:${n}`);
+        return entries.join(', ');
+    }
 
     /**
      * Context bilgisi oluştur (AI system prompt için)

package/core/gateway.js

@@ -9,11 +9,11 @@
  * - Sistem durumu sorgulama
  */
 
-import axios from 'axios';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { log } from './ai-provider.js';
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { log } from './ai-provider.js';
 
 // ═══════════════════════════════════════════════════════════════════════════
 // CONFIG - Gateway ayarları
@@ -42,15 +42,15 @@ function getGatewayToken(config) {
 // GATEWAY CLIENT
 // ═══════════════════════════════════════════════════════════════════════════
 
-export class VantuzGateway {
+export class VantuzGateway {
     constructor() {
         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.version = null;
+    }
 
     /**
      * HTTP Headers (token auth)
@@ -101,14 +101,66 @@ export class VantuzGateway {
     /**
      * Gateway sağlık kontrolü
      */
-    async health() {
-        const result = await this._request('GET', '/health');
-        this.connected = result.success;
-        if (result.success) {
-            this.version = result.data?.version || 'unknown';
-        }
-        return result;
-    }
+    async health() {
+        const result = await this._request('GET', '/health');
+        this.connected = result.success;
+        if (result.success) {
+            this.version = result.data?.version || 'unknown';
+        }
+        return result;
+    }
+
+    /**
+     * Gateway sürecini başlat (lokal gateway.cmd)
+     */
+    async start() {
+        const gatewayCmd = path.join(process.cwd(), '.openclaw', 'gateway.cmd');
+        if (!fs.existsSync(gatewayCmd)) {
+            return { success: false, error: 'Gateway başlatma dosyası bulunamadı: gateway.cmd' };
+        }
+
+        try {
+            const { spawn } = await import('child_process');
+            const child = spawn(gatewayCmd, [], {
+                detached: true,
+                stdio: 'ignore',
+                shell: true
+            });
+            child.unref();
+            return { success: true };
+        } catch (e) {
+            return { success: false, error: e.message };
+        }
+    }
+
+    /**
+     * Gateway çalışmıyorsa başlat ve sağlık kontrolü yap
+     */
+    async ensureRunning(options = {}) {
+        const {
+            retries = 5,
+            intervalMs = 1000
+        } = options;
+
+        if (this.isConnected()) {
+            return { success: true, already: true };
+        }
+
+        const started = await this.start();
+        if (!started.success) {
+            return started;
+        }
+
+        for (let i = 0; i < retries; i++) {
+            await new Promise(r => setTimeout(r, intervalMs));
+            const health = await this.health();
+            if (health.success) {
+                return { success: true, started: true };
+            }
+        }
+
+        return { success: false, error: 'Gateway başlatıldı ancak sağlık kontrolü geçmedi' };
+    }
 
     /**
      * Detaylı sistem durumu

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

@@ -0,0 +1,20 @@
+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
+);
+
+-- down
+DROP TABLE IF EXISTS historical_prices;
+DROP TABLE IF EXISTS products;