vantuz 3.3.6 → 3.3.7

package/core/self-healer.js

@@ -0,0 +1,314 @@
+// core/self-healer.js
+// Self-Healing Module for Vantuz OS V2
+// Monitors errors, auto-repairs simple issues, and rolls back broken states.
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { log } from './ai-provider.js';
+
+const SNAPSHOT_DIR = path.join(os.homedir(), '.vantuz', 'snapshots');
+const ERROR_LOG_FILE = path.join(os.homedir(), '.vantuz', 'memory', 'error-log.json');
+
+// ═══════════════════════════════════════════════════════════════════════════
+// ERROR CLASSIFICATION
+// ═══════════════════════════════════════════════════════════════════════════
+
+const AUTO_FIXABLE = {
+    'ETIMEDOUT': { fix: 'retry', description: 'Timeout — tekrar deneniyor' },
+    'ECONNRESET': { fix: 'retry', description: 'Bağlantı koptu — tekrar deneniyor' },
+    'ECONNREFUSED': { fix: 'retry_delay', description: 'Bağlantı reddedildi — gecikmeli tekrar' },
+    'ERR_BAD_REQUEST': { fix: 'inspect', description: 'Hatalı istek — parametre kontrolü' },
+    '401': { fix: 'refresh_token', description: 'Auth hatası — token yenileniyor' },
+    '403': { fix: 'refresh_token', description: 'Yetki hatası — token yenileniyor' },
+    '429': { fix: 'backoff', description: 'Rate limit — bekleniyor' },
+    '500': { fix: 'retry_delay', description: 'Sunucu hatası — gecikmeli tekrar' },
+    '503': { fix: 'retry_delay', description: 'Servis dışı — gecikmeli tekrar' },
+    'SyntaxError': { fix: 'rollback', description: 'JSON parse hatası — rollback' },
+};
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SELF HEALER
+// ═══════════════════════════════════════════════════════════════════════════
+
+class SelfHealer {
+    constructor() {
+        this.errorLog = this._loadErrorLog();
+        this.escalationCallbacks = [];
+        this.maxRetries = 3;
+        this._ensureDirs();
+        log('INFO', 'SelfHealer initialized', { knownErrors: this.errorLog.length });
+    }
+
+    _ensureDirs() {
+        if (!fs.existsSync(SNAPSHOT_DIR)) fs.mkdirSync(SNAPSHOT_DIR, { recursive: true });
+        const memDir = path.dirname(ERROR_LOG_FILE);
+        if (!fs.existsSync(memDir)) fs.mkdirSync(memDir, { recursive: true });
+    }
+
+    /**
+     * Register escalation handler for un-fixable errors.
+     */
+    onEscalation(callback) {
+        this.escalationCallbacks.push(callback);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────
+    // STATE SNAPSHOTS (Rollback Support)
+    // ─────────────────────────────────────────────────────────────────────
+
+    /**
+     * Save a state snapshot before a risky operation.
+     * @param {string} name - Snapshot name (e.g., 'pricing-run-2026-02-13').
+     * @param {object} state - State data to snapshot.
+     */
+    saveSnapshot(name, state) {
+        const file = path.join(SNAPSHOT_DIR, `${name}.json`);
+        fs.writeFileSync(file, JSON.stringify({
+            name,
+            timestamp: new Date().toISOString(),
+            state
+        }, null, 2), 'utf-8');
+        log('INFO', `Snapshot saved: ${name}`);
+    }
+
+    /**
+     * Load a snapshot by name.
+     */
+    loadSnapshot(name) {
+        const file = path.join(SNAPSHOT_DIR, `${name}.json`);
+        if (!fs.existsSync(file)) return null;
+        return JSON.parse(fs.readFileSync(file, 'utf-8'));
+    }
+
+    /**
+     * List available snapshots.
+     */
+    listSnapshots() {
+        if (!fs.existsSync(SNAPSHOT_DIR)) return [];
+        return fs.readdirSync(SNAPSHOT_DIR)
+            .filter(f => f.endsWith('.json'))
+            .map(f => {
+                const data = JSON.parse(fs.readFileSync(path.join(SNAPSHOT_DIR, f), 'utf-8'));
+                return { name: data.name, timestamp: data.timestamp };
+            })
+            .sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+    }
+
+    /**
+     * Rollback: restore state from the last snapshot.
+     * @param {string} name - Snapshot name to restore.
+     * @returns {object|null} The restored state, or null if not found.
+     */
+    rollback(name) {
+        const snapshot = this.loadSnapshot(name);
+        if (!snapshot) {
+            log('WARN', `Rollback failed: snapshot "${name}" not found`);
+            return null;
+        }
+        log('INFO', `🔄 ROLLBACK: "${name}" snapshot'ına geri dönüldü. Devam ediyorum.`, {
+            snapshotTime: snapshot.timestamp
+        });
+        return snapshot.state;
+    }
+
+    // ─────────────────────────────────────────────────────────────────────
+    // ERROR HANDLING + AUTO-REPAIR
+    // ─────────────────────────────────────────────────────────────────────
+
+    /**
+     * Attempt to heal an error.
+     * @param {Error|object} error - The error object.
+     * @param {string} module - Which module threw the error.
+     * @param {function} retryFn - Function to retry if applicable.
+     * @returns {{ healed: boolean, action: string, result?: any }}
+     */
+    async heal(error, module, retryFn = null) {
+        const errorCode = this._classifyError(error);
+        const fixEntry = AUTO_FIXABLE[errorCode];
+
+        this._logError(error, module, errorCode);
+
+        if (!fixEntry) {
+            // Unfixable → escalate
+            this._escalate(error, module, errorCode);
+            return { healed: false, action: 'escalated', message: 'Manuel müdahale gerekiyor' };
+        }
+
+        log('INFO', `SelfHealer: ${fixEntry.description}`, { module, errorCode });
+
+        switch (fixEntry.fix) {
+            case 'retry':
+                return await this._retry(retryFn, 1000);
+
+            case 'retry_delay':
+                return await this._retry(retryFn, 5000);
+
+            case 'backoff':
+                return await this._retry(retryFn, 30000); // 30 sec backoff
+
+            case 'refresh_token':
+                log('WARN', 'Token yenileme denemesi yapılıyor...', { module });
+                return await this._retry(retryFn, 2000);
+
+            case 'rollback':
+                const snapshots = this.listSnapshots();
+                if (snapshots.length > 0) {
+                    const restored = this.rollback(snapshots[0].name);
+                    return {
+                        healed: !!restored,
+                        action: 'rollback',
+                        message: restored
+                            ? `Geri aldım, devam ediyorum (${snapshots[0].name})`
+                            : 'Rollback başarısız'
+                    };
+                }
+                return { healed: false, action: 'rollback_failed', message: 'Snapshot bulunamadı' };
+
+            case 'inspect':
+                return { healed: false, action: 'needs_inspection', message: fixEntry.description };
+
+            default:
+                return { healed: false, action: 'unknown', message: 'Bilinmeyen fix tipi' };
+        }
+    }
+
+    /**
+     * Wrap an async operation with self-healing.
+     * @param {string} module - Module name for logging.
+     * @param {function} fn - Async function to execute.
+     * @param {string} snapshotName - Optional: snapshot name for rollback support.
+     * @param {object} snapshotState - Optional: state to snapshot before execution.
+     */
+    async withHealing(module, fn, snapshotName = null, snapshotState = null) {
+        // Save snapshot if provided
+        if (snapshotName && snapshotState) {
+            this.saveSnapshot(snapshotName, snapshotState);
+        }
+
+        try {
+            return await fn();
+        } catch (error) {
+            log('WARN', `Error caught by SelfHealer in ${module}`, { error: error.message });
+            const healResult = await this.heal(error, module, fn);
+
+            if (healResult.healed) {
+                log('INFO', `✅ ${module}: Hata düzeltildi — ${healResult.message || healResult.action}`);
+                return healResult.result;
+            } else {
+                log('ERROR', `❌ ${module}: Hata düzeltilemedi — ${healResult.message || healResult.action}`);
+                throw error; // Re-throw if we can't fix
+            }
+        }
+    }
+
+    getStatus() {
+        const recent = this.errorLog.slice(-20);
+        return {
+            totalErrors: this.errorLog.length,
+            recentErrors: recent.length,
+            snapshots: this.listSnapshots().length,
+            autoFixable: recent.filter(e => AUTO_FIXABLE[e.code]).length,
+            escalated: recent.filter(e => !AUTO_FIXABLE[e.code]).length
+        };
+    }
+
+    // ─────────────────────────────────────────────────────────────────────
+
+    _classifyError(error) {
+        const msg = (error.message || error.toString()).toUpperCase();
+        const status = error.response?.status || error.status || error.code;
+
+        // Check status code first
+        if (status && AUTO_FIXABLE[String(status)]) return String(status);
+
+        // Check error code
+        if (error.code && AUTO_FIXABLE[error.code]) return error.code;
+
+        // Check message patterns
+        if (msg.includes('ETIMEDOUT') || msg.includes('TIMEOUT')) return 'ETIMEDOUT';
+        if (msg.includes('ECONNRESET')) return 'ECONNRESET';
+        if (msg.includes('ECONNREFUSED')) return 'ECONNREFUSED';
+        if (msg.includes('SYNTAXERROR') || msg.includes('UNEXPECTED TOKEN')) return 'SyntaxError';
+        if (msg.includes('429') || msg.includes('RATE LIMIT')) return '429';
+
+        return 'UNKNOWN';
+    }
+
+    async _retry(fn, delayMs) {
+        if (!fn) return { healed: false, action: 'no_retry_fn', message: 'Retry fonksiyonu yok' };
+
+        for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+            try {
+                await new Promise(r => setTimeout(r, delayMs * attempt));
+                const result = await fn();
+                return { healed: true, action: 'retry', attempt, result };
+            } catch (e) {
+                if (attempt === this.maxRetries) {
+                    return { healed: false, action: 'retry_exhausted', message: `${this.maxRetries} deneme başarısız` };
+                }
+            }
+        }
+    }
+
+    _logError(error, module, code) {
+        this.errorLog.push({
+            module,
+            code,
+            message: error.message || String(error),
+            timestamp: new Date().toISOString()
+        });
+
+        if (this.errorLog.length > 500) {
+            this.errorLog = this.errorLog.slice(-500);
+        }
+
+        this._saveErrorLog();
+    }
+
+    _loadErrorLog() {
+        try {
+            if (fs.existsSync(ERROR_LOG_FILE)) {
+                return JSON.parse(fs.readFileSync(ERROR_LOG_FILE, 'utf-8'));
+            }
+        } catch (e) { /* ignore */ }
+        return [];
+    }
+
+    _saveErrorLog() {
+        try {
+            const tmp = ERROR_LOG_FILE + '.tmp';
+            fs.writeFileSync(tmp, JSON.stringify(this.errorLog, null, 2), 'utf-8');
+            fs.renameSync(tmp, ERROR_LOG_FILE);
+        } catch (e) { /* ignore */ }
+    }
+
+    _escalate(error, module, code) {
+        const ticket = {
+            type: 'SUPPORT_TICKET',
+            severity: 'critical',
+            module,
+            errorCode: code,
+            message: error.message || String(error),
+            timestamp: new Date().toISOString(),
+            note: `Kritik hata: ${module}. Otomatik düzeltme başarısız. Müdahale gerekli.`
+        };
+
+        log('ERROR', `🎫 SUPPORT TICKET: ${module} — ${code}`, ticket);
+
+        for (const cb of this.escalationCallbacks) {
+            try { cb(ticket); } catch (e) { /* swallow */ }
+        }
+    }
+}
+
+let healerInstance = null;
+
+export function getSelfHealer() {
+    if (!healerInstance) {
+        healerInstance = new SelfHealer();
+    }
+    return healerInstance;
+}
+
+export default SelfHealer;

package/core/unified-product.js

@@ -0,0 +1,214 @@
+// core/unified-product.js
+// Unified Product Model for Vantuz OS V2
+// Normalizes product data from ALL platforms into one Vantuz format.
+
+import { log } from './ai-provider.js';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// UNIFIED PRODUCT SCHEMA
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Creates a Unified Product from raw platform data.
+ * @param {object} raw - Raw product data from any platform API.
+ * @param {string} platform - Source platform name.
+ * @returns {object} Unified Product.
+ */
+export function normalizeProduct(raw, platform) {
+    const normalized = {
+        // Identity
+        sku: raw.sku || raw.stockCode || raw.merchantSku || raw.productCode || null,
+        barcode: raw.barcode || raw.barcodes?.[0] || raw.gtin || null,
+        title: raw.title || raw.productName || raw.name || '',
+        brand: raw.brand || raw.brandName || '',
+        category: raw.category || raw.categoryName || '',
+
+        // Pricing
+        price: parseFloat(raw.salePrice || raw.price || raw.listingPrice || 0),
+        listPrice: parseFloat(raw.listPrice || raw.marketPrice || raw.originalPrice || 0),
+        cost: parseFloat(raw.cost || raw.costPrice || 0),
+        currency: raw.currency || 'TRY',
+
+        // Stock
+        stock: parseInt(raw.quantity || raw.stock || raw.stockQuantity || 0, 10),
+
+        // Images
+        images: raw.images || raw.imageUrls || (raw.imageUrl ? [raw.imageUrl] : []),
+
+        // Status
+        onSale: raw.onSale ?? raw.approved ?? raw.active ?? true,
+
+        // Platform-specific data
+        platforms: {
+            [platform]: {
+                id: raw.id || raw.productId || raw.contentId || null,
+                url: raw.url || raw.productUrl || null,
+                lastSync: new Date().toISOString(),
+                raw: raw  // Keep original for debugging
+            }
+        },
+
+        // Analytics (populated by other modules)
+        competitors: [],
+        salesVelocity: 0,       // units/day — filled by Oracle
+        margin: 0,              // calculated below
+        stockoutDate: null,     // filled by Oracle
+        sentimentScore: null,   // filled by CRM
+
+        // Meta
+        _source: platform,
+        _normalizedAt: new Date().toISOString()
+    };
+
+    // Calculate margin
+    if (normalized.cost > 0 && normalized.price > 0) {
+        normalized.margin = ((normalized.price - normalized.cost) / normalized.price) * 100;
+    }
+
+    return normalized;
+}
+
+/**
+ * Merge a new platform occurrence into an existing unified product.
+ * (Same barcode, different platform.)
+ * @param {object} existing - Existing unified product.
+ * @param {object} raw - New raw data.
+ * @param {string} platform - Source platform.
+ * @returns {object} Merged product.
+ */
+export function mergeProduct(existing, raw, platform) {
+    const incoming = normalizeProduct(raw, platform);
+
+    // Add to platforms map
+    existing.platforms[platform] = incoming.platforms[platform];
+
+    // Use the lowest price as the "effective" price
+    if (incoming.price > 0 && (incoming.price < existing.price || existing.price === 0)) {
+        existing.price = incoming.price;
+    }
+
+    // Sum stock across platforms
+    existing.stock = Object.values(existing.platforms).reduce((sum, p) => {
+        const pStock = parseInt(p.raw?.quantity || p.raw?.stock || 0, 10);
+        return sum + pStock;
+    }, 0);
+
+    // Use best title (longest, usually most SEO-friendly)
+    if (incoming.title.length > existing.title.length) {
+        existing.title = incoming.title;
+    }
+
+    // Merge images (unique)
+    const allImages = [...(existing.images || []), ...(incoming.images || [])];
+    existing.images = [...new Set(allImages)];
+
+    // Recalculate margin
+    if (existing.cost > 0 && existing.price > 0) {
+        existing.margin = ((existing.price - existing.cost) / existing.price) * 100;
+    }
+
+    return existing;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// PRODUCT CATALOG (In-Memory + Disk)
+// ═══════════════════════════════════════════════════════════════════════════
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const CATALOG_FILE = path.join(os.homedir(), '.vantuz', 'memory', 'catalog.json');
+
+class ProductCatalog {
+    constructor() {
+        this.products = new Map(); // barcode -> UnifiedProduct
+        this._load();
+    }
+
+    _load() {
+        try {
+            if (fs.existsSync(CATALOG_FILE)) {
+                const data = JSON.parse(fs.readFileSync(CATALOG_FILE, 'utf-8'));
+                for (const [barcode, product] of Object.entries(data)) {
+                    this.products.set(barcode, product);
+                }
+                log('INFO', `Product catalog loaded`, { count: this.products.size });
+            }
+        } catch (e) {
+            log('WARN', 'Catalog load failed', { error: e.message });
+        }
+    }
+
+    _save() {
+        const dir = path.dirname(CATALOG_FILE);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        const obj = Object.fromEntries(this.products);
+        const tmp = CATALOG_FILE + '.tmp';
+        fs.writeFileSync(tmp, JSON.stringify(obj, null, 2), 'utf-8');
+        fs.renameSync(tmp, CATALOG_FILE);
+    }
+
+    /**
+     * Ingest raw product data from a platform.
+     */
+    ingest(rawProducts, platform) {
+        let added = 0, updated = 0;
+
+        for (const raw of rawProducts) {
+            const barcode = raw.barcode || raw.barcodes?.[0] || raw.gtin;
+            if (!barcode) continue;
+
+            if (this.products.has(barcode)) {
+                mergeProduct(this.products.get(barcode), raw, platform);
+                updated++;
+            } else {
+                this.products.set(barcode, normalizeProduct(raw, platform));
+                added++;
+            }
+        }
+
+        this._save();
+        log('INFO', `Catalog ingested from ${platform}`, { added, updated, total: this.products.size });
+        return { added, updated, total: this.products.size };
+    }
+
+    get(barcode) {
+        return this.products.get(barcode) || null;
+    }
+
+    getAll() {
+        return [...this.products.values()];
+    }
+
+    /**
+     * Find products that are low on stock.
+     * @param {number} threshold - Min stock threshold (default: 5).
+     */
+    getLowStock(threshold = 5) {
+        return this.getAll().filter(p => p.stock > 0 && p.stock <= threshold);
+    }
+
+    /**
+     * Find products below target margin.
+     * @param {number} minMargin - Minimum margin % (default: 15).
+     */
+    getLowMargin(minMargin = 15) {
+        return this.getAll().filter(p => p.margin > 0 && p.margin < minMargin);
+    }
+
+    get size() {
+        return this.products.size;
+    }
+}
+
+let catalogInstance = null;
+
+export function getCatalog() {
+    if (!catalogInstance) {
+        catalogInstance = new ProductCatalog();
+    }
+    return catalogInstance;
+}
+
+export default ProductCatalog;

package/core/vector-db.js

@@ -1,17 +1,90 @@
 // core/vector-db.js
+// Persistent Vector Database for Vantuz AI
+// Uses JSON file persistence instead of in-memory-only storage.
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
 import { log } from './ai-provider.js';
 
+const VECTOR_DIR = path.join(os.homedir(), '.vantuz', 'memory');
+const VECTOR_FILE = path.join(VECTOR_DIR, 'vectors.json');
+
+function ensureDir() {
+    if (!fs.existsSync(VECTOR_DIR)) {
+        fs.mkdirSync(VECTOR_DIR, { recursive: true });
+    }
+}
+
+function loadFromDisk() {
+    try {
+        if (fs.existsSync(VECTOR_FILE)) {
+            const raw = fs.readFileSync(VECTOR_FILE, 'utf-8');
+            const data = JSON.parse(raw);
+            // Convert plain object back to Map
+            const map = new Map();
+            for (const [name, collection] of Object.entries(data)) {
+                map.set(name, collection);
+            }
+            log('INFO', `VectorDB loaded from disk`, { collections: map.size });
+            return map;
+        }
+    } catch (e) {
+        log('WARN', 'VectorDB disk load failed, starting fresh', { error: e.message });
+    }
+    return new Map();
+}
+
+function saveToDisk(collections) {
+    ensureDir();
+    const obj = {};
+    for (const [name, collection] of collections) {
+        obj[name] = collection;
+    }
+    const tmp = VECTOR_FILE + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(obj), 'utf-8');
+    fs.renameSync(tmp, VECTOR_FILE);
+}
+
 class VectorDB {
     constructor() {
-        this.collections = new Map(); // collectionName -> { vectors: [], metadatas: [] }
-        log('INFO', 'In-memory VectorDB initialized');
+        ensureDir();
+        this.collections = loadFromDisk();
+        this._dirty = false;
+        this._saveTimer = null;
+        log('INFO', 'Persistent VectorDB initialized', { collections: this.collections.size });
+    }
+
+    /**
+     * Debounced save — writes to disk at most every 2 seconds.
+     */
+    _scheduleSave() {
+        this._dirty = true;
+        if (this._saveTimer) return;
+        this._saveTimer = setTimeout(() => {
+            if (this._dirty) {
+                saveToDisk(this.collections);
+                this._dirty = false;
+                log('INFO', 'VectorDB persisted to disk');
+            }
+            this._saveTimer = null;
+        }, 2000);
+    }
+
+    /**
+     * Force immediate save.
+     */
+    flush() {
+        if (this._saveTimer) {
+            clearTimeout(this._saveTimer);
+            this._saveTimer = null;
+        }
+        saveToDisk(this.collections);
+        this._dirty = false;
     }
 
     /**
      * Kosinüs benzerliğini hesaplar.
-     * @param {number[]} vec1
-     * @param {number[]} vec2
-     * @returns {number} Kosinüs benzerliği.
      */
     _cosineSimilarity(vec1, vec2) {
         if (vec1.length !== vec2.length) {
@@ -29,19 +102,18 @@ class VectorDB {
         magnitude2 = Math.sqrt(magnitude2);
 
         if (magnitude1 === 0 || magnitude2 === 0) {
-            return 0; // Avoid division by zero
+            return 0;
         }
         return dotProduct / (magnitude1 * magnitude2);
     }
 
     /**
      * Vektör koleksiyonu oluşturur veya alır.
-     * @param {string} collectionName
-     * @returns {{vectors: Array<number[]>, metadatas: Array<Object>}}
      */
     getCollection(collectionName) {
         if (!this.collections.has(collectionName)) {
             this.collections.set(collectionName, { vectors: [], metadatas: [] });
+            this._scheduleSave();
             log('INFO', `Vector collection "${collectionName}" created.`);
         }
         return this.collections.get(collectionName);
@@ -49,23 +121,17 @@ class VectorDB {
 
     /**
      * Koleksiyona vektör ve metadata ekler.
-     * @param {string} collectionName
-     * @param {number[]} vector
-     * @param {Object} metadata
      */
     add(collectionName, vector, metadata) {
         const collection = this.getCollection(collectionName);
         collection.vectors.push(vector);
         collection.metadatas.push(metadata);
+        this._scheduleSave();
         log('INFO', `Vector added to collection "${collectionName}"`);
     }
 
     /**
      * Bir sorgu vektörüne en benzer vektörleri bulur.
-     * @param {string} collectionName
-     * @param {number[]} queryVector
-     * @param {number} topK En çok kaç sonuç döndürülecek.
-     * @returns {Array<{metadata: Object, similarity: number}>} Sıralanmış sonuçlar.
      */
     search(collectionName, queryVector, topK = 5) {
         const collection = this.collections.get(collectionName);
@@ -81,8 +147,8 @@ class VectorDB {
             };
         });
 
-        results.sort((a, b) => b.similarity - a.similarity); // Yüksek benzerlik önde
-        log('INFO', `Search performed on collection "${collectionName}", found ${results.length} results.`);
+        results.sort((a, b) => b.similarity - a.similarity);
+        log('INFO', `Search on "${collectionName}", found ${results.length} results.`);
         return results.slice(0, topK);
     }
 }