vantuz 3.5.18 → 4.0.3

package/core/automation.js

@@ -1,10 +1,10 @@
 // core/automation.js
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import crypto from 'crypto';
-import { log, chat as aiChat } from './ai-provider.js';
-import { getScheduler } from './scheduler.js';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { log, chat as aiChat } = require('./ai-provider.js');
+const { getScheduler } = require('./scheduler.js');
 
 const VANTUZ_HOME = path.join(os.homedir(), '.vantuz');
 const CONFIG_JSON = path.join(VANTUZ_HOME, 'config.json');
@@ -212,7 +212,7 @@ function fallbackPlan(message) {
     };
 }
 
-export class AutomationManager {
+module.exports = AutomationManager {
     constructor(engine) {
         this.engine = engine;
         this.scheduler = getScheduler();
@@ -520,4 +520,4 @@ export class AutomationManager {
     }
 }
 
-export default AutomationManager;
+module.exports = AutomationManager;

package/core/cache-manager.js

@@ -0,0 +1,232 @@
+/**
+ * 🐙 VANTUZ Cache Manager - Database Query Caching
+ * Sık kullanılan veriler için in-memory cache
+ */
+
+const logger = require('./logger');
+
+class CacheManager {
+    constructor(options = {}) {
+        this.ttl = options.ttl || 300000; // 5 dakika varsayılan
+        this.maxSize = options.maxSize || 100; // Maksimum entry sayısı
+        this.cache = new Map();
+        this.stats = { hits: 0, misses: 0 };
+    }
+
+    /**
+     * Cache'e veri ekle
+     */
+    set(key, value, ttl = null) {
+        const effectiveTtl = ttl || this.ttl;
+        
+        // Boyut kontrolü
+        if (this.cache.size >= this.maxSize) {
+            // En eski entry'yi sil
+            const firstKey = this.cache.keys().next().value;
+            this.cache.delete(firstKey);
+        }
+
+        this.cache.set(key, {
+            value,
+            expires: Date.now() + effectiveTtl
+        });
+
+        logger.debug('Cache set', { key, ttl: effectiveTtl });
+    }
+
+    /**
+     * Cache'den veri getir
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        
+        if (!entry) {
+            this.stats.misses++;
+            logger.debug('Cache miss', { key });
+            return null;
+        }
+
+        // Süre dolmuş mu?
+        if (Date.now() > entry.expires) {
+            this.cache.delete(key);
+            this.stats.misses++;
+            logger.debug('Cache expired', { key });
+            return null;
+        }
+
+        this.stats.hits++;
+        logger.debug('Cache hit', { key });
+        return entry.value;
+    }
+
+    /**
+     * Cache'den veri sil
+     */
+    delete(key) {
+        return this.cache.delete(key);
+    }
+
+    /**
+     * Tüm cache'i temizle
+     */
+    clear() {
+        this.cache.clear();
+        logger.info('Cache temizlendi');
+    }
+
+    /**
+     * Süresi dolmuş entry'leri temizle
+     */
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        
+        for (const [key, entry] of this.cache) {
+            if (now > entry.expires) {
+                this.cache.delete(key);
+                cleaned++;
+            }
+        }
+
+        logger.info('Cache cleanup', { cleaned });
+        return cleaned;
+    }
+
+    /**
+     * Cache istatistikleri
+     */
+    getStats() {
+        const total = this.stats.hits + this.stats.misses;
+        const hitRate = total > 0 ? (this.stats.hits / total * 100).toFixed(2) : 0;
+        
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            hitRate: `${hitRate}%`
+        };
+    }
+}
+
+/**
+ * Query cache decorator
+ */
+function cachedQuery(cache, keyPrefix = 'query') {
+    return async function(queryFn, key, ttl) {
+        const cacheKey = `${keyPrefix}:${key}`;
+        const cached = cache.get(cacheKey);
+        
+        if (cached !== null) {
+            return cached;
+        }
+
+        const result = await queryFn();
+        cache.set(cacheKey, result, ttl);
+        return result;
+    };
+}
+
+/**
+ * Debounce fonksiyonu - çoklu istekleri birleştir
+ */
+function debounce(fn, delay = 300) {
+    let timeoutId = null;
+    let pendingArgs = null;
+
+    return function(...args) {
+        pendingArgs = args;
+
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+
+        timeoutId = setTimeout(() => {
+            if (pendingArgs !== null) {
+                fn.apply(this, pendingArgs);
+                pendingArgs = null;
+            }
+            timeoutId = null;
+        }, delay);
+    };
+}
+
+/**
+ * Throttle fonksiyonu - istekleri sınırla
+ */
+function throttle(fn, limit = 10) {
+    let inThrottle = false;
+    let lastResult = null;
+
+    return function(...args) {
+        if (!inThrottle) {
+            inThrottle = true;
+            lastResult = fn.apply(this, args);
+            setTimeout(() => inThrottle = false, limit);
+        }
+        return lastResult;
+    };
+}
+
+/**
+ * Lazy loader - sayfa açılınca veri çek
+ */
+function createLazyLoader(loadFn) {
+    let isLoaded = false;
+    let data = null;
+    let loading = false;
+
+    return {
+        async get() {
+            if (isLoaded && data) {
+                return data;
+            }
+
+            if (loading) {
+                // Zaten yükleniyorsa bekle
+                while (loading) {
+                    await new Promise(r => setTimeout(r, 50));
+                }
+                return data;
+            }
+
+            loading = true;
+            try {
+                data = await loadFn();
+                isLoaded = true;
+                logger.debug('Lazy load tamamlandı');
+                return data;
+            } finally {
+                loading = false;
+            }
+        },
+
+        refresh() {
+            isLoaded = false;
+            data = null;
+        }
+    };
+}
+
+// Global cache instance
+const globalCache = new CacheManager({
+    ttl: 300000, // 5 dakika
+    maxSize: 200
+});
+
+// Periyodik cleanup
+setInterval(() => {
+    const cleaned = globalCache.cleanup();
+    if (cleaned > 0) {
+        logger.info('Periyodik cache cleanup', { cleaned });
+    }
+}, 60000); // Her dakika
+
+module.exports = {
+    CacheManager,
+    cachedQuery,
+    debounce,
+    throttle,
+    createLazyLoader,
+    globalCache
+};

package/core/channels.js

@@ -7,16 +7,16 @@
  * - Telegram (Bot API / Gateway)
  */
 
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { log } from './ai-provider.js';
-import { getGateway } from './gateway.js';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { log } = require('./ai-provider.js');
+const { getGateway } = require('./gateway.js');
 
 const VANTUZ_HOME = path.join(os.homedir(), '.vantuz');
 const CONFIG_PATH = path.join(VANTUZ_HOME, '.env');
 
-export class ChannelManager {
+module.exports = ChannelManager {
     constructor() {
         this.gateway = null;
         this.status = {
@@ -158,7 +158,7 @@ export class ChannelManager {
 // Singleton
 let managerInstance = null;
 
-export async function getChannelManager() {
+module.exports.getChannelManager = async function() {
     if (!managerInstance) {
         managerInstance = new ChannelManager();
         await managerInstance.initAll();
@@ -166,4 +166,4 @@ export async function getChannelManager() {
     return managerInstance;
 }
 
-export default ChannelManager;
+module.exports = ChannelManager;

package/core/dashboard.js

@@ -2,8 +2,8 @@
 // System Health Dashboard — Vantuz OS V2 Control Tower
 // Aggregates status from all modules into a single real-time overview.
 
-import os from 'os';
-import { log } from './ai-provider.js';
+const os = require('os');
+const { log } = require('./ai-provider.js');
 
 // ═══════════════════════════════════════════════════════════════════════════
 // UPTIME TRACKER
@@ -195,7 +195,7 @@ class Dashboard {
 
 let dashboardInstance = null;
 
-export function getDashboard() {
+module.exports.getDashboard = function() {
     if (!dashboardInstance) {
         dashboardInstance = new Dashboard();
     }
@@ -206,7 +206,7 @@ export function getDashboard() {
  * Helper: Wire up all V2 modules to the dashboard.
  * Call this after all modules are initialized.
  */
-export function wireModulesToDashboard(refs = {}) {
+module.exports.w = functionireModulesToDashboard(refs = {}) {
     const dash = getDashboard();
 
     if (refs.agentLoop) dash.registerModule('AgentLoop', () => refs.agentLoop.getStatus());
@@ -227,4 +227,4 @@ export function wireModulesToDashboard(refs = {}) {
     return dash;
 }
 
-export default Dashboard;
+module.exports = Dashboard;

package/core/database-manager.js

@@ -0,0 +1,331 @@
+/**
+ * 🐙 VANTUZ Database Manager - Auto-migration, Backup & Integrity
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const logger = require('./logger');
+const { withErrorHandler } = require('./error-handler');
+
+class DatabaseManager {
+    constructor(db, dbPath) {
+        this.db = db;
+        this.dbPath = dbPath;
+        this.backupDir = path.join(path.dirname(dbPath), 'backups');
+        this.migrationsDir = path.join(__dirname, 'migrations');
+        this.schemaVersion = 1;
+        
+        // Backup klasörü yoksa oluştur
+        if (!fs.existsSync(this.backupDir)) {
+            fs.mkdirSync(this.backupDir, { recursive: true });
+        }
+    }
+
+    /**
+     * Auto-migration sistemi
+     */
+    async runMigrations() {
+        logger.info('Migration kontrol ediliyor', { currentVersion: this.schemaVersion });
+
+        const migrations = this.getAvailableMigrations();
+        
+        for (const migration of migrations) {
+            if (migration.version > this.schemaVersion) {
+                logger.info(`Migration çalıştırılıyor: v${migration.version}`, { name: migration.name });
+                
+                try {
+                    await migration.up(this.db);
+                    this.schemaVersion = migration.version;
+                    logger.info(`Migration tamamlandı: v${migration.version}`);
+                } catch (error) {
+                    logger.error('Migration hatası', { 
+                        version: migration.version, 
+                        error: error.message 
+                    });
+                    throw error;
+                }
+            }
+        }
+    }
+
+    /**
+     * Mevcut migration'ları listele
+     */
+    getAvailableMigrations() {
+        const migrations = [];
+        
+        if (fs.existsSync(this.migrationsDir)) {
+            const files = fs.readdirSync(this.migrationsDir)
+                .filter(f => f.endsWith('.js') && f.startsWith('migration-'))
+                .sort();
+
+            for (const file of files) {
+                const match = file.match(/migration-v(\d+)-(.+)\.js/);
+                if (match) {
+                    const migration = require(path.join(this.migrationsDir, file));
+                    migrations.push({
+                        version: parseInt(match[1]),
+                        name: match[2],
+                        up: migration.up,
+                        down: migration.down
+                    });
+                }
+            }
+        }
+
+        return migrations;
+    }
+
+    /**
+     * Manuel migration kaydet (tabloya)
+     */
+    async recordMigration(version, name) {
+        const migrationsTable = `
+            CREATE TABLE IF NOT EXISTS SchemaMigrations (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                version INTEGER UNIQUE,
+                name TEXT,
+                appliedAt TEXT
+            )
+        `;
+        this.db.run(migrationsTable);
+        this.db.run(
+            'INSERT OR IGNORE INTO SchemaMigrations (version, name, appliedAt) VALUES (?, ?, ?)',
+            [version, name, new Date().toISOString()]
+        );
+    }
+
+    /**
+     * Günlük backup
+     */
+    async createBackup(reason = 'scheduled') {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const backupFile = path.join(this.backupDir, `vantuz-${timestamp}.sqlite`);
+        
+        logger.info('Backup oluşturuluyor', { reason, file: backupFile });
+
+        try {
+            // DB export
+            const data = this.db.export();
+            const buffer = Buffer.from(data);
+            
+            // Hash hesapla
+            const hash = crypto.createHash('sha256').update(buffer).digest('hex');
+            
+            // Backup dosyasına yaz
+            fs.writeFileSync(backupFile, buffer);
+            
+            // Metadata
+            const meta = {
+                date: timestamp,
+                reason,
+                size: buffer.length,
+                hash,
+                version: this.schemaVersion
+            };
+            
+            fs.writeFileSync(backupFile + '.meta.json', JSON.stringify(meta, null, 2));
+            
+            logger.info('Backup tamamlandı', { file: backupFile, size: buffer.length });
+            return { success: true, file: backupFile, hash };
+        } catch (error) {
+            logger.error('Backup hatası', { error: error.message });
+            return { success: false, error: error.message };
+        }
+    }
+
+    /**
+     * Veri bütünlüğü kontrolü
+     */
+    async checkIntegrity() {
+        logger.info('Veri bütünlüğü kontrol ediliyor...');
+        
+        const issues = [];
+        
+        try {
+            // 1. DB dosyası mevcut mu?
+            if (!fs.existsSync(this.dbPath)) {
+                issues.push({ type: 'missing', message: 'Veritabanı dosyası bulunamadı' });
+                return { valid: false, issues };
+            }
+
+            // 2. Hash kontrolü (son backup ile)
+            const latestBackup = this.getLatestBackup();
+            if (latestBackup) {
+                const currentHash = this.calculateHash();
+                if (currentHash !== latestBackup.hash) {
+                    // Değişiklik var, bu normal olabilir
+                    logger.info('Veritabanı değişikliği tespit edildi', {
+                        oldHash: latestBackup.hash.substring(0, 8),
+                        newHash: currentHash.substring(0, 8)
+                    });
+                }
+            }
+
+            // 3. Temel tabloları kontrol et
+            const tables = ['Stores', 'Products', 'Orders', 'Insights'];
+            for (const table of tables) {
+                const result = this.db.get(`SELECT COUNT(*) as count FROM ${table}`);
+                if (result === undefined) {
+                    issues.push({ type: 'missing_table', table });
+                }
+            }
+
+            // 4. Orphaned records kontrolü
+            const orphanedOrders = this.db.all(`
+                SELECT o.* FROM Orders o 
+                LEFT JOIN Stores s ON o.platform = s.platform 
+                WHERE s.id IS NULL
+            `);
+            
+            if (orphanedOrders.length > 0) {
+                issues.push({ 
+                    type: 'orphaned_records', 
+                    table: 'Orders', 
+                    count: orphanedOrders.length 
+                });
+            }
+
+            // 5. Index kontrolü
+            const requiredIndexes = [
+                { table: 'Products', column: 'barcode' },
+                { table: 'Orders', column: 'orderNumber' }
+            ];
+
+            for (const idx of requiredIndexes) {
+                const indexName = `idx_${idx.table}_${idx.column}`;
+                const hasIndex = this.db.get(
+                    "SELECT name FROM sqlite_master WHERE type='index' AND name=?",
+                    [indexName]
+                );
+                if (!hasIndex) {
+                    this.db.run(`CREATE INDEX ${indexName} ON ${idx.table} (${idx.column})`);
+                    logger.info('Eksik index oluşturuldu', { index: indexName });
+                }
+            }
+
+            const valid = issues.filter(i => i.type !== 'orphaned_records').length === 0;
+            
+            logger.info('Bütünlük kontrolü tamamlandı', { valid, issues: issues.length });
+            return { valid, issues };
+            
+        } catch (error) {
+            logger.error('Bütünlük kontrolü hatası', { error: error.message });
+            return { valid: false, issues: [{ type: 'error', message: error.message }] };
+        }
+    }
+
+    /**
+     * Hash hesapla
+     */
+    calculateHash() {
+        if (!fs.existsSync(this.dbPath)) return null;
+        const buffer = fs.readFileSync(this.dbPath);
+        return crypto.createHash('sha256').update(buffer).digest('hex');
+    }
+
+    /**
+     * Son backup'ı getir
+     */
+    getLatestBackup() {
+        if (!fs.existsSync(this.backupDir)) return null;
+        
+        const files = fs.readdirSync(this.backupDir)
+            .filter(f => f.endsWith('.sqlite.meta.json'))
+            .sort()
+            .reverse();
+
+        if (files.length === 0) return null;
+
+        try {
+            const meta = JSON.parse(
+                fs.readFileSync(path.join(this.backupDir, files[0]), 'utf-8')
+            );
+            return meta;
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Backup'tan geri yükle
+     */
+    async restoreFromBackup(backupFile) {
+        if (!fs.existsSync(backupFile)) {
+            throw new Error('Backup dosyası bulunamadı');
+        }
+
+        logger.info('Backup geri yükleniyor', { file: backupFile });
+
+        // Mevcut DB'yi yedekle
+        if (fs.existsSync(this.dbPath)) {
+            const emergencyBackup = this.dbPath + '.emergency-' + Date.now();
+            fs.copyFileSync(this.dbPath, emergencyBackup);
+            logger.warn('Mevcut DB yedeklendi', { file: emergencyBackup });
+        }
+
+        // Backup'ı geri yükle
+        const buffer = fs.readFileSync(backupFile);
+        const newDb = new (require('sql.js'))();
+        newDb.run(buffer);
+        
+        // Mevcut db'yi değiştir
+        Object.assign(this.db, newDb);
+        
+        logger.info('Backup geri yüklendi');
+        return { success: true };
+    }
+
+    /**
+     * Eski backup'ları temizle (son 30 gün)
+     */
+    cleanupOldBackups() {
+        const thirtyDaysAgo = Date.now() - (30 * 24 * 60 * 60 * 1000);
+        
+        if (!fs.existsSync(this.backupDir)) return 0;
+
+        const files = fs.readdirSync(this.backupDir);
+        let cleaned = 0;
+
+        for (const file of files) {
+            const filePath = path.join(this.backupDir, file);
+            const stats = fs.statSync(filePath);
+            
+            if (stats.mtimeMs < thirtyDaysAgo) {
+                fs.unlinkSync(filePath);
+                cleaned++;
+            }
+        }
+
+        logger.info('Eski backup\'lar temizlendi', { cleaned });
+        return cleaned;
+    }
+}
+
+/**
+ * Günlük backup scheduler
+ */
+function scheduleDailyBackup(dbManager, hour = 3, minute = 0) {
+    const now = new Date();
+    const target = new Date();
+    target.setHours(hour, minute, 0, 0);
+
+    if (target <= now) {
+        target.setDate(target.getDate() + 1);
+    }
+
+    const msUntilTarget = target - now;
+
+    setTimeout(() => {
+        dbManager.createBackup('scheduled');
+        scheduleDailyBackup(dbManager, hour, minute);
+    }, msUntilTarget);
+
+    logger.info('Günlük backup planlandı', { time: `${hour}:${minute}` });
+}
+
+module.exports = {
+    DatabaseManager,
+    scheduleDailyBackup
+};