vantuz 3.3.6 → 3.3.7

package/core/vision-service.js

@@ -0,0 +1,113 @@
+// core/vision-service.js
+// Decoupled Vision AI Service
+// Extracted from plugins/vantuz/tools/vision.js for API/Gateway access.
+// Can be called from CLI, API endpoint, or Warehouse Node.
+
+import axios from 'axios';
+import fs from 'fs';
+import { log } from './ai-provider.js';
+
+/**
+ * Analyze a product image and return structured data.
+ * Accepts: file path, URL, or raw Base64 string.
+ *
+ * @param {string} imageInput - File path, URL, or base64 data URI.
+ * @param {object} aiConfig - { apiKey, baseUrl?, model? }
+ * @returns {object} { detected, confidence, attributes, suggestedPrice, seo_keywords }
+ */
+export async function analyzeProductImage(imageInput, aiConfig) {
+    if (!aiConfig?.apiKey) {
+        throw new Error('AI API anahtarı gerekli (aiConfig.apiKey)');
+    }
+
+    // Normalize image to base64 data URI
+    let imageData = imageInput;
+
+    if (imageInput.startsWith('http://') || imageInput.startsWith('https://')) {
+        log('INFO', 'Vision: Downloading image from URL...');
+        const response = await axios.get(imageInput, { responseType: 'arraybuffer', timeout: 15000 });
+        imageData = `data:image/jpeg;base64,${Buffer.from(response.data).toString('base64')}`;
+    } else if (imageInput.startsWith('data:')) {
+        // Already a data URI
+        imageData = imageInput;
+    } else if (fs.existsSync(imageInput)) {
+        log('INFO', 'Vision: Reading local file...');
+        const buffer = fs.readFileSync(imageInput);
+        imageData = `data:image/jpeg;base64,${buffer.toString('base64')}`;
+    } else {
+        // Assume raw base64 string
+        imageData = `data:image/jpeg;base64,${imageInput}`;
+    }
+
+    const model = aiConfig.model || 'gpt-4o';
+    const baseUrl = aiConfig.baseUrl || 'https://api.openai.com/v1';
+
+    log('INFO', `Vision: Analyzing with ${model}...`);
+
+    const response = await axios.post(`${baseUrl}/chat/completions`, {
+        model,
+        messages: [
+            {
+                role: 'user',
+                content: [
+                    {
+                        type: 'text',
+                        text: `Bu ürün fotoğrafını analiz et. JSON formatında yanıt ver:
+{
+  "detected": "Ürün tipi",
+  "confidence": 0.95,
+  "attributes": {
+    "color": "Renk",
+    "material": "Malzeme",
+    "style": "Stil",
+    "pattern": "Desen",
+    "condition": "Durum (yeni/kullanılmış/hasarlı)"
+  },
+  "suggestedPrice": { "min": 100, "max": 200, "optimal": 149 },
+  "seo_keywords": ["anahtar1", "anahtar2"],
+  "defects": "Görünür hasar/kusur varsa açıkla, yoksa null"
+}`
+                    },
+                    {
+                        type: 'image_url',
+                        image_url: { url: imageData }
+                    }
+                ]
+            }
+        ],
+        max_tokens: 1000
+    }, {
+        headers: {
+            'Authorization': `Bearer ${aiConfig.apiKey}`,
+            'Content-Type': 'application/json'
+        },
+        timeout: 30000
+    });
+
+    const content = response.data.choices[0].message.content;
+    const jsonMatch = content.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+        const result = JSON.parse(jsonMatch[0]);
+        log('INFO', 'Vision: Analysis complete', { detected: result.detected });
+        return result;
+    }
+
+    throw new Error('AI Vision yanıtı parse edilemedi');
+}
+
+/**
+ * Quick damage check for returns.
+ * @param {string} imageInput - Image path/URL/base64.
+ * @param {object} aiConfig - AI config.
+ * @returns {object} { isDamaged, severity, description }
+ */
+export async function checkReturnDamage(imageInput, aiConfig) {
+    const analysis = await analyzeProductImage(imageInput, aiConfig);
+    return {
+        isDamaged: !!analysis.defects,
+        severity: analysis.defects ? 'check_required' : 'ok',
+        condition: analysis.attributes?.condition || 'unknown',
+        description: analysis.defects || 'Görünür hasar tespit edilmedi.',
+        fullAnalysis: analysis
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "vantuz",
-    "version": "3.3.6",
+    "version": "3.3.7",
     "description": "Yapay Zeka Destekli E-Ticaret Yönetim Platformu - 7 Pazaryeri + WhatsApp/Telegram",
     "type": "module",
     "main": "cli.js",

package/server/app.js

@@ -61,35 +61,35 @@ app.get('/api/orders', async (req, res) => {
 });
 
 // 4. AI Chat
-app.post('/api/chat', async (req, res) => {
-    const { message } = req.body;
-    if (!message) return res.status(400).json({ error: 'Mesaj gerekli' });
-
-    try {
-        const instance = await initEngine();
-        const response = await instance.chat(message);
-        res.json({ response });
-    } catch (e) {
-        res.status(500).json({ error: e.message });
-    }
-});
-
-// 4b. Inbound message (channels)
-app.post('/api/inbound', async (req, res) => {
-    const { message, channel, from } = req.body || {};
-    if (!message) return res.status(400).json({ error: 'Mesaj gerekli' });
-
-    try {
-        const instance = await initEngine();
-        const response = await instance.handleMessage(message, {
-            channel: channel || 'local',
-            from: from || 'unknown'
-        });
-        res.json({ response });
-    } catch (e) {
-        res.status(500).json({ error: e.message });
-    }
-});
+app.post('/api/chat', async (req, res) => {
+    const { message } = req.body;
+    if (!message) return res.status(400).json({ error: 'Mesaj gerekli' });
+
+    try {
+        const instance = await initEngine();
+        const response = await instance.chat(message);
+        res.json({ response });
+    } catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+
+// 4b. Inbound message (channels)
+app.post('/api/inbound', async (req, res) => {
+    const { message, channel, from } = req.body || {};
+    if (!message) return res.status(400).json({ error: 'Mesaj gerekli' });
+
+    try {
+        const instance = await initEngine();
+        const response = await instance.handleMessage(message, {
+            channel: channel || 'local',
+            from: from || 'unknown'
+        });
+        res.json({ response });
+    } catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
 
 // 5. Logs
 app.get('/api/logs', async (req, res) => {
@@ -134,6 +134,119 @@ app.get('/api/doctor', async (req, res) => {
     }
 });
 
+// ═══════════════════════════════════════════════════════════════════════════
+// 9. WEBHOOKS - Platform Event Receivers
+// ═══════════════════════════════════════════════════════════════════════════
+
+app.post('/api/webhooks/:platform', async (req, res) => {
+    const { platform } = req.params;
+    const secret = req.headers['x-webhook-secret'] || '';
+    const expectedSecret = process.env.WEBHOOK_SECRET || '';
+
+    if (expectedSecret && secret !== expectedSecret) {
+        log('WARN', `Webhook rejected: invalid secret`, { platform });
+        return res.status(401).json({ error: 'Unauthorized' });
+    }
+
+    const event = req.body;
+    log('INFO', `Webhook received from ${platform}`, {
+        type: event.type || event.eventType || 'unknown'
+    });
+
+    try {
+        const instance = await initEngine();
+        const eventType = (event.type || event.eventType || '').toLowerCase();
+
+        if (eventType.includes('order') || eventType.includes('siparis')) {
+            await instance.chat(`📦 [${platform.toUpperCase()}] Yeni sipariş olayı: ${eventType}`);
+        } else if (eventType.includes('stock') || eventType.includes('stok')) {
+            await instance.chat(`📊 [${platform.toUpperCase()}] Stok olayı: ${eventType}`);
+        } else if (eventType.includes('return') || eventType.includes('iade')) {
+            await instance.chat(`🔄 [${platform.toUpperCase()}] İade talebi alındı`);
+        }
+
+        if (instance.memory) {
+            instance.memory.remember(`${platform}: ${eventType}`, 'webhook');
+        }
+
+        res.json({ received: true, platform, eventType });
+    } catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 10. VISION API
+// ═══════════════════════════════════════════════════════════════════════════
+
+app.post('/api/vision/analyze', async (req, res) => {
+    const { image, checkDamage } = req.body;
+    if (!image) return res.status(400).json({ error: 'image parametresi gerekli' });
+
+    try {
+        const { analyzeProductImage, checkReturnDamage } = await import('../core/vision-service.js');
+        const instance = await initEngine();
+        const aiConfig = {
+            apiKey: instance.env?.OPENAI_API_KEY || instance.env?.GEMINI_API_KEY,
+            model: 'gpt-4o'
+        };
+
+        const result = checkDamage
+            ? await checkReturnDamage(image, aiConfig)
+            : await analyzeProductImage(image, aiConfig);
+        res.json(result);
+    } catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 11. QUEUE & MEMORY API
+// ═══════════════════════════════════════════════════════════════════════════
+
+app.get('/api/queue', async (req, res) => {
+    const instance = await initEngine();
+    res.json(instance.queue ? instance.queue.getStatus() : { error: 'Queue not initialized' });
+});
+
+app.get('/api/memory', async (req, res) => {
+    const instance = await initEngine();
+    if (!instance.memory) return res.json({ error: 'Memory not initialized' });
+    res.json({
+        factsCount: instance.memory.facts.length,
+        strategiesCount: instance.memory.strategies.length,
+        recentFacts: instance.memory.getRecentFacts(10),
+        strategies: instance.memory.getStrategies()
+    });
+});
+
+app.post('/api/memory/remember', async (req, res) => {
+    const { fact, category } = req.body;
+    if (!fact) return res.status(400).json({ error: 'fact gerekli' });
+    const instance = await initEngine();
+    if (!instance.memory) return res.json({ error: 'Memory not initialized' });
+    res.json(instance.memory.remember(fact, category || 'general'));
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 12. SYSTEM HEALTH DASHBOARD
+// ═══════════════════════════════════════════════════════════════════════════
+
+app.get('/api/dashboard', async (req, res) => {
+    try {
+        const { getDashboard } = await import('../core/dashboard.js');
+        const dash = getDashboard();
+        const format = req.query.format;
+        if (format === 'text') {
+            res.type('text/plain').send(dash.getSummary());
+        } else {
+            res.json(dash.getHealth());
+        }
+    } catch (e) {
+        res.status(500).json({ error: e.message });
+    }
+});
+
 // Frontend Serve
 app.get('*', (req, res) => {
     if (req.path.startsWith('/api')) return res.status(404).json({ error: 'Not Found' });