vantuz 4.0.0 → 4.0.3

package/core/database.js

@@ -1,18 +1,69 @@
-const Database = require('better-sqlite3');
+const initSqlJs = require('sql.js');
 const path = require('path');
 const fs = require('fs');
 
 const dbPath = path.join(process.cwd(), 'vantuz.sqlite');
 let db;
+let SQL;
 
-try {
-    db = new Database(dbPath);
-} catch (e) {
-    console.error('❌ Veritabanı bağlantısı başarısız:', e.message);
-    process.exit(1);
+// Initialize and create models synchronously
+let Store, Product, Order, Insight;
+
+async function init() {
+    try {
+        SQL = await initSqlJs();
+        
+        if (fs.existsSync(dbPath)) {
+            const buffer = fs.readFileSync(dbPath);
+            db = new SQL.Database(buffer);
+        } else {
+            db = new SQL.Database();
+        }
+        
+        createModels();
+    } catch (e) {
+        console.error('❌ Veritabanı bağlantısı başarısız:', e.message);
+    }
+}
+
+function run(sql, params = []) {
+    if (!db) return;
+    db.run(sql, params);
+    saveDB();
+}
+
+function get(sql, params = []) {
+    if (!db) return null;
+    const stmt = db.prepare(sql);
+    stmt.bind(params);
+    if (stmt.step()) {
+        const row = stmt.getAsObject();
+        stmt.free();
+        return row;
+    }
+    stmt.free();
+    return null;
+}
+
+function all(sql, params = []) {
+    if (!db) return [];
+    const stmt = db.prepare(sql);
+    stmt.bind(params);
+    const results = [];
+    while (stmt.step()) {
+        results.push(stmt.getAsObject());
+    }
+    stmt.free();
+    return results;
+}
+
+function saveDB() {
+    if (!db) return;
+    const data = db.export();
+    const buffer = Buffer.from(data);
+    fs.writeFileSync(dbPath, buffer);
 }
 
-// Simple Model Wrapper to mimic Sequelize API partially
 class Model {
     constructor(tableName, schema) {
         this.tableName = tableName;
@@ -21,12 +72,11 @@ class Model {
     }
 
     _initTable() {
-        // Basic schema to SQL
         const cols = Object.entries(this.schema).map(([key, props]) => {
             let type = 'TEXT';
             if (props.type === 'INTEGER') type = 'INTEGER';
             if (props.type === 'FLOAT') type = 'REAL';
-            if (props.type === 'BOOLEAN') type = 'INTEGER'; // SQLite uses 0/1
+            if (props.type === 'BOOLEAN') type = 'INTEGER';
             
             let def = `${key} ${type}`;
             if (props.allowNull === false) def += ' NOT NULL';
@@ -39,13 +89,11 @@ class Model {
         }).join(', ');
 
         const sql = `CREATE TABLE IF NOT EXISTS ${this.tableName} (id INTEGER PRIMARY KEY AUTOINCREMENT, ${cols}, createdAt TEXT, updatedAt TEXT)`;
-        db.prepare(sql).run();
+        run(sql);
     }
 
     async findAll(query = {}) {
-        // Basic implementation
-        const stmt = db.prepare(`SELECT * FROM ${this.tableName}`);
-        const rows = stmt.all();
+        const rows = all(`SELECT * FROM ${this.tableName}`);
         return rows.map(r => this._parseRow(r));
     }
 
@@ -57,8 +105,7 @@ class Model {
         const whereClause = keys.map(k => `${k} = ?`).join(' AND ');
         const values = keys.map(k => query.where[k]);
         
-        const stmt = db.prepare(`SELECT * FROM ${this.tableName} WHERE ${whereClause} LIMIT 1`);
-        const row = stmt.get(...values);
+        const row = get(`SELECT * FROM ${this.tableName} WHERE ${whereClause} LIMIT 1`, values);
         return row ? this._parseRow(row) : null;
     }
 
@@ -71,42 +118,38 @@ class Model {
         });
         
         const now = new Date().toISOString();
-        // Add timestamps
         const allKeys = [...keys, 'createdAt', 'updatedAt'];
-        const allPlaceholders = [...keys.map(() => '?'), '?', '?'];
         const allValues = [...values, now, now];
 
-        const sql = `INSERT INTO ${this.tableName} (${allKeys.join(', ')}) VALUES (${allPlaceholders.join(', ')})`;
-        const info = db.prepare(sql).run(...allValues);
-        return { ...data, id: info.lastInsertRowid, createdAt: now, updatedAt: now };
+        const sql = `INSERT INTO ${this.tableName} (${allKeys.join(', ')}) VALUES (${placeholders}, ?, ?)`;
+        run(sql, allValues);
+        
+        const idResult = get(`SELECT last_insert_rowid() as id`);
+        const id = idResult ? idResult.id : 0;
+        return { ...data, id, createdAt: now, updatedAt: now };
     }
     
     async count() {
-        const stmt = db.prepare(`SELECT COUNT(*) as count FROM ${this.tableName}`);
-        return stmt.get().count;
+        const result = get(`SELECT COUNT(*) as count FROM ${this.tableName}`);
+        return result ? result.count : 0;
     }
 
     async destroy(query = {}) {
         if (!query.where) return;
         const whereClause = Object.keys(query.where).map(k => `${k} = ?`).join(' AND ');
         const values = Object.values(query.where);
-        const sql = `DELETE FROM ${this.tableName} WHERE ${whereClause}`;
-        const stmt = db.prepare(sql);
-        return stmt.run(...values);
+        run(`DELETE FROM ${this.tableName} WHERE ${whereClause}`, values);
     }
 
     async update(data, query = {}) {
         if (!query.where) return;
         const updateClause = Object.keys(data).map(k => `${k} = ?`).join(', ');
         const whereClause = Object.keys(query.where).map(k => `${k} = ?`).join(' AND ');
-        const values = [...Object.values(data), ...Object.values(query.where)];
-        const sql = `UPDATE ${this.tableName} SET ${updateClause}, updatedAt = ? WHERE ${whereClause}`;
-        const stmt = db.prepare(sql);
-        return stmt.run(...values, new Date().toISOString());
+        const values = [...Object.values(data), ...Object.values(query.where), new Date().toISOString()];
+        run(`UPDATE ${this.tableName} SET ${updateClause}, updatedAt = ? WHERE ${whereClause}`, values);
     }
 
     _parseRow(row) {
-        // Convert JSON fields back to objects
         for (const [key, props] of Object.entries(this.schema)) {
             if (props.type === 'JSON' && row[key]) {
                 try { row[key] = JSON.parse(row[key]); } catch {}
@@ -119,7 +162,6 @@ class Model {
     }
 }
 
-// Define Models manually with simple types
 const DataTypes = {
     STRING: 'TEXT',
     TEXT: 'TEXT', 
@@ -130,62 +172,61 @@ const DataTypes = {
     DATE: 'TEXT'
 };
 
-const Store = new Model('Stores', {
-    name: { type: DataTypes.STRING, allowNull: false },
-    platform: { type: DataTypes.STRING, allowNull: false },
-    credentials: { type: DataTypes.JSON, allowNull: false },
-    isActive: { type: DataTypes.BOOLEAN, defaultValue: 1 }
-});
-
-const Product = new Model('Products', {
-    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 }
-});
-
-const Order = new Model('Orders', {
-    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 }
-});
-
-const Insight = new Model('Insights', {
-    type: { type: DataTypes.STRING },
-    message: { type: DataTypes.TEXT },
-    priority: { type: DataTypes.INTEGER },
-    isRead: { type: DataTypes.BOOLEAN, defaultValue: 0 }
-});
-
-async function initDB() {
-    return true; // Tables created in constructor
+function createModels() {
+    Store = new Model('Stores', {
+        name: { type: DataTypes.STRING, allowNull: false },
+        platform: { type: DataTypes.STRING, allowNull: false },
+        credentials: { type: DataTypes.JSON, allowNull: false },
+        isActive: { type: DataTypes.BOOLEAN, defaultValue: 1 }
+    });
+
+    Product = new Model('Products', {
+        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 }
+    });
+
+    Order = new Model('Orders', {
+        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 }
+    });
+
+    Insight = new Model('Insights', {
+        type: { type: DataTypes.STRING },
+        message: { type: DataTypes.TEXT },
+        priority: { type: DataTypes.INTEGER },
+        isRead: { type: DataTypes.BOOLEAN, defaultValue: 0 }
+    });
 }
 
-function getDatabase() {
-    return {
+// Initialize immediately
+init();
+
+// Export models directly (they'll be null initially but populated after init)
+module.exports = {
+    dbPath,  // Export dbPath for database-manager.js
+    get Store() { return Store; },
+    get Product() { return Product; },
+    get Order() { return Order; },
+    get Insight() { return Insight; },
+    init,
+    initDB: init,
+    getDatabase: async () => ({
         Store,
         Product,
         Order,
         Insight,
-        init: initDB,
-        isAvailable: true
-    };
-}
-
-module.exports = {
-    Store,
-    Product,
-    Order,
-    Insight,
-    initDB,
-    getDatabase
+        isAvailable: !!db
+    })
 };

package/core/eia-brain.js

@@ -1,5 +1,5 @@
 // core/eia-brain.js
-import { chat as aiChat, log } from './ai-provider.js';
+const { chat as aiChat, log } = require('./ai-provider.js');
 
 class EIABrain {
     constructor(config, env) {
@@ -94,7 +94,7 @@ Durumu analiz et ve en uygun aksiyon önerisini veya içgörüyü sun.`;
 
 let eiaBrainInstance = null;
 
-export function getEIABrain(config, env) {
+module.exports.getE = functionIABrain(config, env) {
     if (!eiaBrainInstance) {
         eiaBrainInstance = new EIABrain(config, env);
     }

package/core/eia-monitor.js

@@ -1,10 +1,10 @@
 // core/eia-monitor.js
-import { getScheduler } from './scheduler.js';
-import { TrendyolScraper } from './scrapers/TrendyolScraper.js'; // Example scraper
-import { getEIABrain } from './eia-brain.js';
-import dbPkg from './database.js'; // CommonJS uyumluluğu için default import
-import { getVectorDB } from './vector-db.js'; // Import vector DB
-import { log } from './ai-provider.js';
+const { getScheduler } = require('./scheduler.js');
+const { TrendyolScraper } = require('./scrapers/TrendyolScraper.js'); // Example scraper
+const { getEIABrain } = require('./eia-brain.js');
+const dbPkg = require('./database.js'); // CommonJS uyumluluğu için default import
+const { getVectorDB } = require('./vector-db.js'); // Import vector DB
+const { log } = require('./ai-provider.js');
 
 const { getDatabase } = dbPkg;
 
@@ -222,7 +222,7 @@ Veri Tipi: ${dataType}`;
 
 let eiaMonitorInstance = null;
 
-export function getEIAMonitor(config, env) {
+module.exports.getE = functionIAMonitor(config, env) {
     if (!eiaMonitorInstance) {
         eiaMonitorInstance = new EIAMonitor(config, env);
     }

package/core/engine.js

@@ -6,35 +6,35 @@
  * Entegre Tool Sistemi
  */
 
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 
 // Platform Hub
-import platformHub from '../plugins/vantuz/platforms/index.js';
+const platformHub = require('../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';
-import AutomationManager from './automation.js';
-import OpenClawBridge from './openclaw-bridge.js';
-import { executeTool } from './agent.js';
-import { getCriticalQueue } from './queue.js';
-import { getMemory } from './memory.js';
+const { getChannelManager } = require('./channels.js');
+const { chat as aiChat, log } = require('./ai-provider.js');
+const { getGateway } = require('./gateway.js');
+const { getEIAMonitor } = require('./eia-monitor.js');
+const AutomationManager = require('./automation.js');
+const OpenClawBridge = require('./openclaw-bridge.js');
+const { executeTool } = require('./agent.js');
+const { getCriticalQueue } = require('./queue.js');
+const { getMemory } = require('./memory.js');
 
 // Multi-Agent Team
-import TeamModule from '../modules/team/index.js';
+const TeamModule = require('../modules/team/index.js');
 
 // Tools
-import { repricerTool } from '../plugins/vantuz/tools/repricer.js';
-import { visionTool } from '../plugins/vantuz/tools/vision.js';
-import { sentimentTool } from '../plugins/vantuz/tools/sentiment.js';
-import { crossborderTool } from '../plugins/vantuz/tools/crossborder.js';
-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 { repricerTool } = require('../plugins/vantuz/tools/repricer.js');
+const { visionTool } = require('../plugins/vantuz/tools/vision.js');
+const { sentimentTool } = require('../plugins/vantuz/tools/sentiment.js');
+const { crossborderTool } = require('../plugins/vantuz/tools/crossborder.js');
+const { productTool } = require('../plugins/vantuz/tools/product.js');
+const { analyticsTool } = require('../plugins/vantuz/tools/analytics.js');
+const { quickReportTool } = require('../plugins/vantuz/tools/quick-report.js');
 
 const PLATFORM_CONFIG_MAP = {
     trendyol: {
@@ -79,7 +79,7 @@ const CONFIG_JSON = path.join(VANTUZ_HOME, 'config.json');
 // ENGINE CLASS
 // ═══════════════════════════════════════════════════════════════════════════
 
-export class VantuzEngine {
+module.exports = VantuzEngine {
     constructor() {
         this.initialized = false;
         this.config = {};
@@ -637,7 +637,7 @@ export class VantuzEngine {
 // Singleton instance
 let engineInstance = null;
 
-export async function getEngine() {
+module.exports.getEng = async functionine() {
     if (!engineInstance) {
         engineInstance = new VantuzEngine();
         await engineInstance.initialize();
@@ -645,4 +645,4 @@ export async function getEngine() {
     return engineInstance;
 }
 
-export default VantuzEngine;
+module.exports = VantuzEngine;

package/core/error-handler.js

@@ -0,0 +1,203 @@
+/**
+ * 🐙 VANTUZ Error Handler - Graceful Shutdown & Error Reporting
+ */
+
+const fs = require('fs');
+const path = require('path');
+const logger = require('./logger');
+
+const SHUTDOWN_TIMEOUT = 10000; // 10 seconds
+let isShuttingDown = false;
+let pendingOperations = 0;
+
+/**
+ * Graceful shutdown handler
+ */
+async function setupGracefulShutdown(server, db) {
+    const shutdown = async (signal) => {
+        if (isShuttingDown) return;
+        isShuttingDown = true;
+        
+        logger.warn(`Alınan sinyal: ${signal}`, { signal });
+        console.log(`\n🛑 ${signal} alındı. Graceful shutdown başlıyor...\n`);
+        
+        // Yeni işlemleri engelle
+        pendingOperations = 0;
+        
+        // HTTP server kapat
+        if (server) {
+            console.log('🌐 HTTP server kapatılıyor...');
+            await new Promise((resolve) => {
+                server.close(resolve);
+            });
+            console.log('✅ HTTP server kapatıldı');
+        }
+        
+        // Veritabanı kaydet
+        if (db && typeof db.saveDB === 'function') {
+            console.log('💾 Veritabanı kaydediliyor...');
+            db.saveDB();
+            console.log('✅ Veritabanı kaydedildi');
+        }
+        
+        // Session log
+        const startTime = process.env.SESSION_START || Date.now();
+        const duration = Date.now() - startTime;
+        logger.endSession(process.env.SESSION_ID || 'unknown', duration);
+        
+        console.log('👋 Güvenli çıkış yapılıyor...\n');
+        process.exit(0);
+    };
+
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    
+    // Unhandled rejection
+    process.on('unhandledRejection', (reason, promise) => {
+        logger.error('Unhandled Rejection', { reason: String(reason), stack: reason?.stack });
+        console.error('❌ Unhandled Rejection:', reason);
+    });
+    
+    // Uncaught exception
+    process.on('uncaughtException', (error) => {
+        logger.fatal('Uncaught Exception', { 
+            message: error.message, 
+            stack: error.stack 
+        });
+        console.error('❌ Uncaught Exception:', error);
+        process.exit(1);
+    });
+
+    console.log('✅ Graceful shutdown handler kuruldu');
+}
+
+/**
+ * Async işlem wrapper - try-catch
+ */
+async function withErrorHandler(fn, context = {}) {
+    try {
+        pendingOperations++;
+        const result = await fn();
+        pendingOperations--;
+        return result;
+    } catch (error) {
+        pendingOperations--;
+        logger.error(`Hata [${context.operation || 'unknown'}]`, {
+            message: error.message,
+            stack: error.stack,
+            ...context
+        });
+        throw error;
+    }
+}
+
+/**
+ * Timeout wrapper
+ */
+function withTimeout(promise, timeoutMs = 30000, operation = 'operation') {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => 
+            setTimeout(() => reject(new Error(`${operation} timeout (${timeoutMs}ms)`)), timeoutMs)
+        )
+    ]);
+}
+
+/**
+ * Database auto-reconnect
+ */
+class DatabaseAutoReconnect {
+    constructor(db, maxRetries = 5, retryDelay = 1000) {
+        this.db = db;
+        this.maxRetries = maxRetries;
+        this.retryDelay = retryDelay;
+        this.retries = 0;
+    }
+
+    async ensureConnected() {
+        if (this.db && this.db.isAvailable) return true;
+        
+        if (this.retries >= this.maxRetries) {
+            throw new Error('Veritabanı bağlantısı maksimum deneme sayısına ulaşıldı');
+        }
+
+        logger.warn('Veritabanı bağlantısı kopuk, yeniden deneniyor...', { 
+            attempt: this.retries + 1,
+            maxRetries: this.maxRetries 
+        });
+
+        await new Promise(r => setTimeout(r, this.retryDelay));
+        
+        try {
+            await this.db.initDB();
+            this.retries = 0;
+            logger.info('Veritabanı yeniden bağlandı');
+            return true;
+        } catch (error) {
+            this.retries++;
+            return this.ensureConnected();
+        }
+    }
+}
+
+/**
+ * API Timeout Handler
+ */
+class APITimeoutHandler {
+    constructor(defaultTimeout = 30000) {
+        this.defaultTimeout = defaultTimeout;
+    }
+
+    async request(fn, timeout = null) {
+        const timeoutMs = timeout || this.defaultTimeout;
+        
+        try {
+            return await withTimeout(
+                Promise.resolve(fn()),
+                timeoutMs,
+                'API Request'
+            );
+        } catch (error) {
+            if (error.message.includes('timeout')) {
+                logger.warn('API Timeout', { timeoutMs });
+                throw new Error(`API isteği zaman aşımına uğradı (${timeoutMs}ms)`);
+            }
+            throw error;
+        }
+    }
+}
+
+/**
+ * Error reporting
+ */
+function reportError(error, context = {}) {
+    const report = logger.reportError(error, {
+        ...context,
+        timestamp: new Date().toISOString(),
+        platform: process.platform,
+        arch: process.arch,
+        nodeVersion: process.version,
+        memoryUsage: process.memoryUsage(),
+        environment: process.env.NODE_ENV
+    });
+
+    // Crash dump dosyası oluştur
+    const crashDir = path.join(process.cwd(), 'crashes');
+    if (!fs.existsSync(crashDir)) {
+        fs.mkdirSync(crashDir, { recursive: true });
+    }
+
+    const crashFile = path.join(crashDir, `crash-${Date.now()}.json`);
+    fs.writeFileSync(crashFile, JSON.stringify(report, null, 2));
+
+    return report;
+}
+
+module.exports = {
+    setupGracefulShutdown,
+    withErrorHandler,
+    withTimeout,
+    DatabaseAutoReconnect,
+    APITimeoutHandler,
+    reportError
+};

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';
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { log } = require('./ai-provider.js');
 
 // ═══════════════════════════════════════════════════════════════════════════
 // CONFIG - Gateway ayarları
@@ -42,7 +42,7 @@ function getGatewayToken(config) {
 // GATEWAY CLIENT
 // ═══════════════════════════════════════════════════════════════════════════
 
-export class VantuzGateway {
+module.exports = VantuzGateway {
     constructor() {
         this.config = loadGatewayConfig();
         const port = this.config?.gateway?.port || 18789;
@@ -417,7 +417,7 @@ let gatewayInstance = null;
  * Vantuz Gateway singleton instance
  * Otomatik bağlantı kontrolü yapar
  */
-export async function getGateway() {
+module.exports.getGateway = async function() {
     if (!gatewayInstance) {
         gatewayInstance = new VantuzGateway();
 
@@ -440,8 +440,8 @@ export async function getGateway() {
 /**
  * Gateway durumunu sıfırla (reconnect için)
  */
-export function resetGateway() {
+module.exports.resetGateway = function() {
     gatewayInstance = null;
 }
 
-export default VantuzGateway;
+module.exports = VantuzGateway;