vantuz 3.3.7 → 3.4.0

package/modules/crm/sentiment-crm.js

@@ -0,0 +1,231 @@
+// modules/crm/sentiment-crm.js
+// Sentiment CRM for Vantuz OS V2
+// Analyzes reviews/questions, drafts brand-persona replies, escalates angry customers.
+
+import fs from 'fs';
+import path from 'path';
+import { log } from '../../core/ai-provider.js';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SENTIMENT ANALYSIS (Local / AI-Enhanced)
+// ═══════════════════════════════════════════════════════════════════════════
+
+const SENTIMENT_KEYWORDS = {
+    angry: [
+        'rezalet', 'kötü', 'berbat', 'iade', 'şikayet', 'korkunç', 'sahtekarlık',
+        'dolandırıcı', 'cevap yok', 'pişman', 'lütfen çözün', 'iğrenç', 'saygısız',
+        'hala gelmedi', 'kırık', 'bozuk', 'yanlış ürün', 'parasını istiyorum'
+    ],
+    happy: [
+        'mükemmel', 'harika', 'güzel', 'teşekkür', 'süper', 'hızlı', 'kaliteli',
+        'memnun', 'tavsiye', 'beğendim', 'perfect', 'çok iyi', 'bravo', 'başarılı'
+    ],
+    confused: [
+        'ne zaman', 'nerede', 'nasıl', 'anlamadım', 'bilgi', 'soruyorum', 'cevap bekliyorum',
+        'açıklama', 'yardım', 'destek', 'merak ediyorum', 'ne oldu'
+    ]
+};
+
+/**
+ * Local sentiment detection (fast, no API call).
+ * @param {string} text
+ * @returns {{ sentiment: string, confidence: number, keywords: string[] }}
+ */
+function detectSentimentLocal(text) {
+    const lower = text.toLowerCase();
+    const found = { angry: [], happy: [], confused: [] };
+
+    for (const [sentiment, keywords] of Object.entries(SENTIMENT_KEYWORDS)) {
+        for (const kw of keywords) {
+            if (lower.includes(kw)) found[sentiment].push(kw);
+        }
+    }
+
+    // Score: angry keywords weigh more
+    const scores = {
+        angry: found.angry.length * 2,
+        happy: found.happy.length * 1.5,
+        confused: found.confused.length * 1
+    };
+
+    const winner = Object.entries(scores).sort((a, b) => b[1] - a[1])[0];
+
+    if (winner[1] === 0) {
+        return { sentiment: 'neutral', confidence: 0.5, keywords: [] };
+    }
+
+    return {
+        sentiment: winner[0],
+        confidence: Math.min(winner[1] / 5, 1),
+        keywords: found[winner[0]]
+    };
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// BRAND PERSONA LOADER
+// ═══════════════════════════════════════════════════════════════════════════
+
+function loadBrandTone() {
+    const brandPath = path.join(process.cwd(), 'workspace', 'BRAND.md');
+    try {
+        if (fs.existsSync(brandPath)) {
+            const content = fs.readFileSync(brandPath, 'utf-8').toLowerCase();
+            if (content.includes('samimi') || content.includes('friendly') || content.includes('emoji')) {
+                return 'friendly';
+            }
+            if (content.includes('premium') || content.includes('lüks') || content.includes('formal')) {
+                return 'formal';
+            }
+        }
+    } catch (e) { /* ignore */ }
+    return 'professional'; // default
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// CRM ENGINE
+// ═══════════════════════════════════════════════════════════════════════════
+
+class SentimentCRM {
+    constructor() {
+        this.tone = loadBrandTone();
+        this.escalationCallbacks = []; // for angry customer alerts
+        this.processed = [];           // recent analysis log
+        log('INFO', 'SentimentCRM initialized', { tone: this.tone });
+    }
+
+    /**
+     * Register an escalation handler (webhook, Slack, WhatsApp).
+     */
+    onEscalation(callback) {
+        this.escalationCallbacks.push(callback);
+    }
+
+    /**
+     * Analyze a customer message/review.
+     * @param {object} params
+     * @param {string} params.text - The message/review text.
+     * @param {string} params.customerName - Customer name.
+     * @param {string} params.platform - Source platform.
+     * @param {string} params.productBarcode - Related product barcode.
+     * @returns {{ sentiment, confidence, suggestedReply, escalated }}
+     */
+    async analyze({ text, customerName = '', platform = '', productBarcode = '' }) {
+        const analysis = detectSentimentLocal(text);
+
+        // Generate reply suggestion
+        const suggestedReply = this._generateReply(analysis.sentiment, customerName, text);
+
+        // Escalate angry customers
+        let escalated = false;
+        if (analysis.sentiment === 'angry' && analysis.confidence >= 0.5) {
+            escalated = true;
+            this._escalate({
+                customerName,
+                platform,
+                text,
+                sentiment: analysis.sentiment,
+                confidence: analysis.confidence,
+                productBarcode
+            });
+        }
+
+        const result = {
+            ...analysis,
+            customerName,
+            platform,
+            productBarcode,
+            suggestedReply,
+            escalated,
+            analyzedAt: new Date().toISOString()
+        };
+
+        this.processed.push(result);
+        if (this.processed.length > 100) this.processed = this.processed.slice(-100);
+
+        return result;
+    }
+
+    /**
+     * Batch analyze reviews.
+     */
+    async analyzeBatch(reviews) {
+        const results = [];
+        for (const review of reviews) {
+            results.push(await this.analyze(review));
+        }
+
+        const summary = {
+            total: results.length,
+            angry: results.filter(r => r.sentiment === 'angry').length,
+            happy: results.filter(r => r.sentiment === 'happy').length,
+            confused: results.filter(r => r.sentiment === 'confused').length,
+            neutral: results.filter(r => r.sentiment === 'neutral').length,
+            escalated: results.filter(r => r.escalated).length
+        };
+
+        log('INFO', 'CRM batch analysis complete', summary);
+        return { results, summary };
+    }
+
+    getRecent(limit = 20) {
+        return this.processed.slice(-limit);
+    }
+
+    getStatus() {
+        const all = this.processed;
+        return {
+            tone: this.tone,
+            totalProcessed: all.length,
+            angryCount: all.filter(r => r.sentiment === 'angry').length,
+            escalatedCount: all.filter(r => r.escalated).length
+        };
+    }
+
+    // ─────────────────────────────────────────────────────────────────────
+
+    _generateReply(sentiment, customerName, originalText) {
+        const name = customerName ? ` ${customerName} Bey/Hanım` : '';
+
+        const replies = {
+            friendly: {
+                angry: `Merhaba${name} 🙏 Yaşadığınız bu sorun için çok üzgünüz! Hemen çözmek istiyoruz. Sipariş numaranızı paylaşır mısınız?`,
+                happy: `Teşekkürler${name} 🎉 Böyle güzel yorumlar bizi çok mutlu ediyor! Tekrar bekleriz 💜`,
+                confused: `Merhaba${name} 👋 Yardımcı olmak isteriz! Detayları paylaşır mısınız?`,
+                neutral: `Merhaba${name}, yorumunuz için teşekkürler! Başka sorunuz olursa yazabilirsiniz 😊`
+            },
+            formal: {
+                angry: `Sayın${name}, yaşadığınız olumsuzluktan dolayı özür dileriz. Konuyu derhal incelemeye alıyoruz. En kısa sürede size dönüş yapacağız.`,
+                happy: `Sayın${name}, değerli görüşleriniz için teşekkür ederiz. Memnuniyetiniz bizim için büyük önem taşımaktadır.`,
+                confused: `Sayın${name}, sorularınız için teşekkür ederiz. Konuyla ilgili size detaylı bilgi sunmak isteriz.`,
+                neutral: `Sayın${name}, yorumunuz için teşekkür ederiz.`
+            },
+            professional: {
+                angry: `Merhaba${name}, yaşadığınız sorun için özür dileriz. Konuyu inceliyoruz ve en kısa sürede dönüş yapacağız.`,
+                happy: `Merhaba${name}, güzel yorumunuz için teşekkürler! Tekrar bekleriz.`,
+                confused: `Merhaba${name}, yardımcı olmak isteriz. Lütfen detayları paylaşın.`,
+                neutral: `Merhaba${name}, yorumunuz için teşekkürler.`
+            }
+        };
+
+        return (replies[this.tone] || replies.professional)[sentiment] || replies.professional.neutral;
+    }
+
+    _escalate(data) {
+        log('WARN', `🚨 ESCALATION: Kızgın müşteri — ${data.customerName || 'Anonim'} (${data.platform})`, data);
+
+        for (const cb of this.escalationCallbacks) {
+            try { cb(data); } catch (e) { /* swallow */ }
+        }
+    }
+}
+
+let crmInstance = null;
+
+export function getSentimentCRM() {
+    if (!crmInstance) {
+        crmInstance = new SentimentCRM();
+    }
+    return crmInstance;
+}
+
+export default SentimentCRM;

package/modules/healer/listing-healer.js

@@ -0,0 +1,201 @@
+// modules/healer/listing-healer.js
+// Self-Healing Listings for Vantuz OS V2
+// Audits product listings and optimizes underperforming ones.
+
+import { log } from '../../core/ai-provider.js';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// LISTING HEALTH CHECKS
+// ═══════════════════════════════════════════════════════════════════════════
+
+const HEALTH_RULES = [
+    {
+        name: 'short_title',
+        check: (p) => (p.title || '').length < 40,
+        severity: 'warning',
+        message: 'Başlık çok kısa — SEO performansı düşük',
+        fix: 'title_optimization'
+    },
+    {
+        name: 'no_images',
+        check: (p) => !p.images || p.images.length === 0,
+        severity: 'critical',
+        message: 'Ürün görseli yok — satış ihtimali çok düşük',
+        fix: 'add_images'
+    },
+    {
+        name: 'few_images',
+        check: (p) => p.images && p.images.length > 0 && p.images.length < 3,
+        severity: 'warning',
+        message: 'Görsel sayısı az — en az 3 görsel önerilir',
+        fix: 'add_images'
+    },
+    {
+        name: 'no_brand',
+        check: (p) => !p.brand || p.brand.trim() === '',
+        severity: 'info',
+        message: 'Marka belirtilmemiş',
+        fix: 'add_brand'
+    },
+    {
+        name: 'zero_stock',
+        check: (p) => p.stock === 0 && p.onSale,
+        severity: 'critical',
+        message: 'Stok sıfır ama satışta — phantom listing',
+        fix: 'deactivate_or_restock'
+    },
+    {
+        name: 'turkish_chars_missing',
+        check: (p) => {
+            const title = p.title || '';
+            // Titles with Turkish words but no Turkish chars might be poorly optimized
+            const hasTurkish = /[çğıöşüÇĞİÖŞÜ]/.test(title);
+            const looksLatin = /^[a-zA-Z0-9\s\-\+\.\,\/\(\)]+$/.test(title);
+            return looksLatin && title.length > 20; // Might be missing Turkish chars
+        },
+        severity: 'info',
+        message: 'Başlıkta Türkçe karakter yok — arama sıralaması düşebilir',
+        fix: 'title_optimization'
+    },
+    {
+        name: 'high_price_no_sales',
+        check: (p) => p.salesVelocity === 0 && p.margin > 40,
+        severity: 'warning',
+        message: 'Yüksek marj ama sıfır satış — fiyat çok yüksek olabilir',
+        fix: 'price_review'
+    }
+];
+
+// ═══════════════════════════════════════════════════════════════════════════
+// LISTING HEALER
+// ═══════════════════════════════════════════════════════════════════════════
+
+class ListingHealer {
+    constructor() {
+        this.auditResults = [];
+        log('INFO', 'ListingHealer initialized');
+    }
+
+    /**
+     * Audit a single product listing.
+     * @param {object} product - Unified product from catalog.
+     * @returns {{ barcode, issues: array, score: number }}
+     */
+    audit(product) {
+        const issues = [];
+
+        for (const rule of HEALTH_RULES) {
+            try {
+                if (rule.check(product)) {
+                    issues.push({
+                        rule: rule.name,
+                        severity: rule.severity,
+                        message: rule.message,
+                        suggestedFix: rule.fix
+                    });
+                }
+            } catch (e) {
+                // Rule check error — skip silently
+            }
+        }
+
+        // Health score: 100 = perfect
+        const penalties = {
+            critical: 30,
+            warning: 15,
+            info: 5
+        };
+        const totalPenalty = issues.reduce((sum, i) => sum + (penalties[i.severity] || 0), 0);
+        const score = Math.max(0, 100 - totalPenalty);
+
+        return {
+            barcode: product.barcode || product.sku,
+            title: product.title,
+            score,
+            issues,
+            auditedAt: new Date().toISOString()
+        };
+    }
+
+    /**
+     * Audit all products in the catalog.
+     * @param {object[]} products - Array of unified products.
+     * @returns {{ healthy, warning, critical, results }}
+     */
+    auditAll(products) {
+        const results = products.map(p => this.audit(p));
+
+        const healthy = results.filter(r => r.score >= 80).length;
+        const warning = results.filter(r => r.score >= 50 && r.score < 80).length;
+        const critical = results.filter(r => r.score < 50).length;
+
+        // Sort by worst first
+        results.sort((a, b) => a.score - b.score);
+
+        this.auditResults = results;
+
+        const report = {
+            total: results.length,
+            healthy,
+            warning,
+            critical,
+            avgScore: results.length > 0
+                ? Math.round(results.reduce((s, r) => s + r.score, 0) / results.length)
+                : 0,
+            worstListings: results.slice(0, 10), // Top 10 worst
+            auditedAt: new Date().toISOString()
+        };
+
+        log('INFO', 'Listing audit complete', {
+            total: report.total,
+            healthy,
+            warning,
+            critical,
+            avgScore: report.avgScore
+        });
+
+        return report;
+    }
+
+    /**
+     * Generate AI-powered title suggestions for a product.
+     * @param {object} product - Unified product.
+     * @param {function} aiChat - AI chat function for generating suggestions.
+     * @returns {string} Suggested title.
+     */
+    async suggestTitle(product, aiChat) {
+        if (!aiChat) return product.title;
+
+        const prompt = `Şu ürün başlığını SEO için optimize et. Türkçe arama trendlerine uygun olsun. Mevcut: "${product.title}". Kategori: ${product.category || 'bilinmiyor'}. Sadece optimize edilmiş başlığı yaz, başka bir şey yazma.`;
+
+        try {
+            const response = await aiChat(prompt);
+            return response.trim();
+        } catch (e) {
+            log('WARN', 'Title suggestion failed', { error: e.message });
+            return product.title;
+        }
+    }
+
+    getStatus() {
+        const results = this.auditResults;
+        return {
+            lastAuditSize: results.length,
+            avgScore: results.length > 0
+                ? Math.round(results.reduce((s, r) => s + r.score, 0) / results.length)
+                : 0,
+            criticalCount: results.filter(r => r.score < 50).length
+        };
+    }
+}
+
+let healerInstance = null;
+
+export function getListingHealer() {
+    if (!healerInstance) {
+        healerInstance = new ListingHealer();
+    }
+    return healerInstance;
+}
+
+export default ListingHealer;

package/modules/oracle/predictor.js

@@ -0,0 +1,214 @@
+// modules/oracle/predictor.js
+// Oracle — Predictive Analytics for Vantuz OS V2
+// Predicts stockout dates and generates reorder alerts.
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { log } from '../../core/ai-provider.js';
+
+const SALES_HISTORY_FILE = path.join(os.homedir(), '.vantuz', 'memory', 'sales-velocity.json');
+
+// ═══════════════════════════════════════════════════════════════════════════
+// SALES VELOCITY TRACKER
+// ═══════════════════════════════════════════════════════════════════════════
+
+function loadVelocityData() {
+    try {
+        if (fs.existsSync(SALES_HISTORY_FILE)) {
+            return JSON.parse(fs.readFileSync(SALES_HISTORY_FILE, 'utf-8'));
+        }
+    } catch (e) { /* ignore */ }
+    return {};
+}
+
+function saveVelocityData(data) {
+    const dir = path.dirname(SALES_HISTORY_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const tmp = SALES_HISTORY_FILE + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+    fs.renameSync(tmp, SALES_HISTORY_FILE);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// ORACLE
+// ═══════════════════════════════════════════════════════════════════════════
+
+class Oracle {
+    constructor() {
+        this.velocityData = loadVelocityData(); // barcode -> { snapshots: [{date, stock}], velocity }
+        log('INFO', 'Oracle initialized', { trackedProducts: Object.keys(this.velocityData).length });
+    }
+
+    /**
+     * Record a stock snapshot for velocity calculation.
+     * @param {string} barcode
+     * @param {number} stock - Current stock level.
+     */
+    recordSnapshot(barcode, stock) {
+        if (!this.velocityData[barcode]) {
+            this.velocityData[barcode] = { snapshots: [], velocity: 0 };
+        }
+
+        const entry = this.velocityData[barcode];
+        entry.snapshots.push({
+            date: new Date().toISOString(),
+            stock: parseInt(stock, 10)
+        });
+
+        // Keep max 30 snapshots per product
+        if (entry.snapshots.length > 30) {
+            entry.snapshots = entry.snapshots.slice(-30);
+        }
+
+        // Recalculate velocity
+        entry.velocity = this._calculateVelocity(entry.snapshots);
+
+        saveVelocityData(this.velocityData);
+    }
+
+    /**
+     * Record snapshots for multiple products.
+     */
+    recordBatch(products) {
+        for (const p of products) {
+            const barcode = p.barcode || p.sku;
+            const stock = p.stock || p.quantity || 0;
+            if (barcode) this.recordSnapshot(barcode, stock);
+        }
+    }
+
+    /**
+     * Predict stockout date for a product.
+     * @param {string} barcode
+     * @param {number} currentStock - Current stock (if not in history).
+     * @returns {{ barcode, velocity, daysLeft, stockoutDate, severity }}
+     */
+    predictStockout(barcode, currentStock = null) {
+        const entry = this.velocityData[barcode];
+        if (!entry || entry.snapshots.length < 2) {
+            return {
+                barcode,
+                velocity: 0,
+                daysLeft: null,
+                stockoutDate: null,
+                severity: 'unknown',
+                message: 'Yeterli veri yok — en az 2 snapshot gerekli'
+            };
+        }
+
+        const stock = currentStock ?? entry.snapshots[entry.snapshots.length - 1].stock;
+        const velocity = entry.velocity;
+
+        if (velocity <= 0) {
+            return {
+                barcode, velocity: 0, daysLeft: Infinity,
+                stockoutDate: null, severity: 'safe',
+                message: 'Satış hızı sıfır veya negatif — stok azalmıyor'
+            };
+        }
+
+        const daysLeft = Math.floor(stock / velocity);
+        const stockoutDate = new Date();
+        stockoutDate.setDate(stockoutDate.getDate() + daysLeft);
+
+        let severity = 'safe';
+        if (daysLeft <= 3) severity = 'critical';
+        else if (daysLeft <= 7) severity = 'warning';
+        else if (daysLeft <= 14) severity = 'attention';
+
+        return {
+            barcode,
+            currentStock: stock,
+            velocity: Math.round(velocity * 100) / 100,
+            daysLeft,
+            stockoutDate: stockoutDate.toISOString().split('T')[0],
+            severity,
+            message: this._formatMessage(barcode, daysLeft, velocity, severity)
+        };
+    }
+
+    /**
+     * Generate reorder report for all tracked products.
+     * @param {number} criticalDays - Days threshold for "critical" (default: 7).
+     * @returns {{ critical: array, warning: array, safe: number }}
+     */
+    generateReorderReport(criticalDays = 7) {
+        const critical = [];
+        const warning = [];
+        let safe = 0;
+
+        for (const barcode of Object.keys(this.velocityData)) {
+            const prediction = this.predictStockout(barcode);
+
+            if (prediction.daysLeft !== null && prediction.daysLeft <= criticalDays) {
+                const reorderQty = Math.ceil(prediction.velocity * 30); // 30 days supply
+                critical.push({
+                    ...prediction,
+                    reorderQty,
+                    reorderMessage: `⚠️ ${barcode}: ${prediction.daysLeft} gün kaldı! ${reorderQty} adet sipariş ver.`
+                });
+            } else if (prediction.severity === 'attention') {
+                warning.push(prediction);
+            } else {
+                safe++;
+            }
+        }
+
+        // Sort by urgency
+        critical.sort((a, b) => a.daysLeft - b.daysLeft);
+
+        const report = { critical, warning, safe, generatedAt: new Date().toISOString() };
+        log('INFO', 'Reorder report generated', {
+            critical: critical.length, warning: warning.length, safe
+        });
+
+        return report;
+    }
+
+    getStatus() {
+        return {
+            trackedProducts: Object.keys(this.velocityData).length,
+            critical: this.generateReorderReport().critical.length
+        };
+    }
+
+    // ─────────────────────────────────────────────────────────────────────
+
+    _calculateVelocity(snapshots) {
+        if (snapshots.length < 2) return 0;
+
+        const first = snapshots[0];
+        const last = snapshots[snapshots.length - 1];
+        const daysDiff = (new Date(last.date) - new Date(first.date)) / (1000 * 60 * 60 * 24);
+
+        if (daysDiff <= 0) return 0;
+
+        const stockConsumed = first.stock - last.stock;
+        return stockConsumed > 0 ? stockConsumed / daysDiff : 0;
+    }
+
+    _formatMessage(barcode, daysLeft, velocity, severity) {
+        if (severity === 'critical') {
+            return `🔴 KRİTİK: ${barcode} — ${daysLeft} gün içinde stok bitecek! (Günlük ${velocity.toFixed(1)} adet satılıyor)`;
+        }
+        if (severity === 'warning') {
+            return `🟡 UYARI: ${barcode} — ${daysLeft} gün stok kaldı. Sipariş planla.`;
+        }
+        if (severity === 'attention') {
+            return `🟠 DİKKAT: ${barcode} — ${daysLeft} gün stok kaldı.`;
+        }
+        return `🟢 ${barcode} — Stok yeterli (${daysLeft} gün)`;
+    }
+}
+
+let oracleInstance = null;
+
+export function getOracle() {
+    if (!oracleInstance) {
+        oracleInstance = new Oracle();
+    }
+    return oracleInstance;
+}
+
+export default Oracle;