vantuz 3.3.6 → 3.4.0

package/modules/team/agents/dev.js

@@ -0,0 +1,33 @@
+// modules/team/agents/dev.js
+import { BaseAgent } from './base.js';
+
+export class DevAgent extends BaseAgent {
+    constructor(api) {
+        super('Dev', 'Dev Agent', { api });
+    }
+
+    async getSystemPrompt() {
+        const base = await super.getSystemPrompt();
+        return `${base}
+        
+## SENİN ÖZEL ROLÜN: YAZILIM AJANI (DEV)
+- Titiz, detaycı ve güvenlik bilinci yüksek birisin.
+- **Sorumlulukların**:
+    - Sistem sağlığını (loglar, hatalar) izlemek.
+    - Yeni özelliklerin teknik uygulamasını incelemek.
+    - Teknik borçları yönetmek.
+- **Araçlar**:
+    - Log Analizi
+    - Konfigürasyon Yönetimi
+
+## GÜNLÜK RUTİN
+- Sistem loglarında hata olup olmadığını kontrol et.
+- API bağlantılarını doğrula.
+`;
+    }
+
+    async checkSystemHealth() {
+        // Placeholder for health check logic
+        return { status: 'healthy', timestamp: new Date() };
+    }
+}

package/modules/team/agents/josh.js

@@ -0,0 +1,40 @@
+// modules/team/agents/josh.js
+import { BaseAgent } from './base.js';
+import { repricerTool } from '../../plugins/vantuz/tools/repricer.js';
+import { analyticsTool } from '../../plugins/vantuz/tools/analytics.js';
+
+export class JoshAgent extends BaseAgent {
+    constructor(api) {
+        super('Josh', 'Business & Growth Analyst', { api });
+    }
+
+    async getSystemPrompt() {
+        const base = await super.getSystemPrompt();
+        return `${base}
+        
+## SENİN ÖZEL ROLÜN: JOSH (İŞ ANALİSTİ)
+- Sen sayılarla konuşan adamsın. Pragmatik, sonuç odaklı.
+- **Sorumlulukların**:
+    - Ciro, kar ve marjları takip etmek.
+    - Rakip fiyatlandırmasını izlemek.
+    - Fiyatlandırma stratejileri önermek.
+- **Araçlar**:
+    - Rakip Analizi (Repricer)
+    - Satış Raporları (Analytics)
+
+## GÜNLÜK RUTİN
+- Sabah 09:00'da temel metrikleri çek.
+- Kar marjları hedefin altına düşerse takımı uyar.
+`;
+    }
+
+    // Agent-specific actions
+    async checkCompetitors(barcode) {
+        // Use existing Vantuz tools
+        return await repricerTool.analyzeCompetitors(barcode, this.context);
+    }
+
+    async getSalesReport() {
+        return await analyticsTool.getSalesReport('7d', this.context);
+    }
+}

package/modules/team/agents/marketing.js

@@ -0,0 +1,33 @@
+// modules/team/agents/marketing.js
+import { BaseAgent } from './base.js';
+import { sentimentTool } from '../../plugins/vantuz/tools/sentiment.js';
+
+export class MarketingAgent extends BaseAgent {
+    constructor(api) {
+        super('Marketing', 'Marketing Researcher', { api });
+    }
+
+    async getSystemPrompt() {
+        const base = await super.getSystemPrompt();
+        return `${base}
+        
+## SENİN ÖZEL ROLÜN: PAZARLAMA AJANI
+- Yaratıcı, trendleri takip eden ve meraklı birisin.
+- **Sorumlulukların**:
+    - Sosyal medya için içerik fikirleri üretmek.
+    - Müşteri duyarlılığını (yorumlar, sorular) izlemek.
+    - SEO optimizasyonları.
+- **Araçlar**:
+    - Duygu Analizi (Sentiment)
+    - Vision AI (ürün fotoğrafları için)
+
+## GÜNLÜK RUTİN
+- Her gün 3 içerik fikri sun.
+- Negatif yorum trendlerini kontrol et.
+`;
+    }
+
+    async analyzeSentiment(productId) {
+        return await sentimentTool.execute({ productId, platform: 'all', period: '7d' }, this.context);
+    }
+}

package/modules/team/agents/milo.js

@@ -0,0 +1,36 @@
+// modules/team/agents/milo.js
+import { BaseAgent } from './base.js';
+import sharedMemory from '../shared-memory.js';
+
+export class MiloAgent extends BaseAgent {
+    constructor(api) {
+        super('Milo', 'Strategy Lead', { api });
+    }
+
+    async getSystemPrompt() {
+        const base = await super.getSystemPrompt();
+        return `${base}
+        
+## SENİN ÖZEL ROLÜN: MILO (STRATEJİ LİDERİ)
+- Sen takım liderisin. Kendine güvenen, karizmatik ve büyük resmi gören birisin.
+- **Sorumlulukların**:
+    - Takımı yönetmek (Josh, Pazarlama, Yazılım).
+    - Haftalık hedefleri GOALS.md dosyasına girmek.
+    - Diğer ajanlardan gelen raporları sentezlemek.
+    - Üst düzey kararlar almak.
+- **Araçlar**:
+    - Diğer ajanlardan rapor isteyebilirsin.
+    - GOALS.md dosyasını güncelleyebilirsin.
+
+## GÜNLÜK RUTİN
+- Gece yapılan ilerlemeyi incele.
+- Sabah toplantı özetini yayınla.
+- Gün sonu özeti geç.
+`;
+    }
+
+    async setGoal(goalText) {
+        sharedMemory.writeFile('GOALS.md', `# Current Goals & OKRs\n\n${goalText}`);
+        return 'Goals updated successfully.';
+    }
+}

package/modules/team/index.js

@@ -0,0 +1,78 @@
+// modules/team/index.js
+import { MiloAgent } from './agents/milo.js';
+import { JoshAgent } from './agents/josh.js';
+import { MarketingAgent } from './agents/marketing.js';
+import { DevAgent } from './agents/dev.js';
+import sharedMemory from './shared-memory.js';
+import { log } from '../../core/ai-provider.js';
+
+class TeamModule {
+    constructor(api) {
+        this.api = api;
+        this.agents = {};
+        this.initialized = false;
+    }
+
+    async initialize() {
+        if (this.initialized) return;
+
+        this.agents = {
+            milo: new MiloAgent(this.api),
+            josh: new JoshAgent(this.api),
+            marketing: new MarketingAgent(this.api),
+            dev: new DevAgent(this.api)
+        };
+
+        // Ensure shared memory structure
+        sharedMemory.ensureStructure();
+
+        this.initialized = true;
+        log('INFO', 'Team Module initialized with agents: Milo, Josh, Marketing, Dev');
+    }
+
+    getAgent(name) {
+        return this.agents[name.toLowerCase()];
+    }
+
+    async chat(agentName, message, depth = 0) {
+        if (depth > 3) return "Hata: Çok fazla delegasyon döngüsü (max 3).";
+
+        const agent = this.getAgent(agentName);
+        if (!agent) {
+            return `Agent '${agentName}' bulunamadı. Mevcut: ${Object.keys(this.agents).join(', ')}`;
+        }
+
+        let response = await agent.process(message);
+
+        // Delegasyon Kontrolü: [DELEGATE: TargetAgent Message]
+        const delegateMatch = response.match(/\[DELEGATE:\s*(\w+)\s+(.*?)\]/i);
+        if (delegateMatch) {
+            const targetAgentName = delegateMatch[1];
+            const targetMessage = delegateMatch[2];
+
+            log('INFO', `Delegasyon: ${agentName} -> ${targetAgentName}: ${targetMessage}`);
+
+            const delegateResponse = await this.chat(targetAgentName, targetMessage, depth + 1);
+
+            // Cevabı orijinal ajana geri bildir ve nihai cevabı al
+            const followupMessage = `[SİSTEM]: ${targetAgentName} şu cevabı verdi: "${delegateResponse}". Buna göre kullanıcıya nihai cevabını ver.`;
+            response = await agent.process(followupMessage);
+        }
+
+        return response;
+    }
+
+    async broadcast(message) {
+        const results = {};
+        for (const [name, agent] of Object.entries(this.agents)) {
+            results[name] = await agent.process(message);
+        }
+        return results;
+    }
+
+    getSharedMemory() {
+        return sharedMemory;
+    }
+}
+
+export default TeamModule;

package/modules/team/shared-memory.js

@@ -0,0 +1,87 @@
+// modules/team/shared-memory.js
+import fs from 'fs';
+import path from 'path';
+import { log } from '../../core/ai-provider.js';
+
+const TEAM_DIR = path.join(process.cwd(), 'workspace', 'team');
+
+export class SharedMemory {
+    constructor() {
+        this.ensureStructure();
+    }
+
+    ensureStructure() {
+        if (!fs.existsSync(TEAM_DIR)) {
+            fs.mkdirSync(TEAM_DIR, { recursive: true });
+        }
+
+        // Standart dosyaların varlığını kontrol et
+        const defaults = {
+            'GOALS.md': '# Mevcut Hedefler & OKR\'lar\n\nHenüz bir hedef belirlenmedi.',
+            'DECISIONS.md': '# Karar Günlüğü\n\nHenüz bir karar alınmadı.',
+            'PROJECT_STATUS.md': '# Proje Durumu\n\nDurum: Başlatılıyor...'
+        };
+
+        for (const [file, content] of Object.entries(defaults)) {
+            const filePath = path.join(TEAM_DIR, file);
+            if (!fs.existsSync(filePath)) {
+                fs.writeFileSync(filePath, content, 'utf-8');
+            }
+        }
+    }
+
+    getAgentDir(agentName) {
+        const dir = path.join(TEAM_DIR, 'agents', agentName);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        return dir;
+    }
+
+    readFile(filename) {
+        try {
+            const filePath = path.join(TEAM_DIR, filename);
+            if (fs.existsSync(filePath)) {
+                return fs.readFileSync(filePath, 'utf-8');
+            }
+        } catch (e) {
+            log('ERROR', `SharedMemory read failed: ${filename}`, { error: e.message });
+        }
+        return '';
+    }
+
+    writeFile(filename, content) {
+        try {
+            const filePath = path.join(TEAM_DIR, filename);
+            fs.writeFileSync(filePath, content, 'utf-8');
+            log('INFO', `SharedMemory updated: ${filename}`);
+            return true;
+        } catch (e) {
+            log('ERROR', `SharedMemory write failed: ${filename}`, { error: e.message });
+            return false;
+        }
+    }
+
+    appendFile(filename, content) {
+        try {
+            const filePath = path.join(TEAM_DIR, filename);
+            const timestamp = new Date().toISOString().replace('T', ' ').substring(0, 19);
+            const formatted = `\n\n### [${timestamp}] Update\n${content}`;
+            fs.appendFileSync(filePath, formatted, 'utf-8');
+            return true;
+        } catch (e) {
+            log('ERROR', `SharedMemory append failed: ${filename}`, { error: e.message });
+            return false;
+        }
+    }
+
+    getEverything() {
+        return {
+            goals: this.readFile('GOALS.md'),
+            decisions: this.readFile('DECISIONS.md'),
+            status: this.readFile('PROJECT_STATUS.md')
+        };
+    }
+}
+
+export default new SharedMemory();

package/modules/war-room/competitor-tracker.js

@@ -0,0 +1,250 @@
+// modules/war-room/competitor-tracker.js
+// Competitor Price Tracker for Vantuz OS V2
+// Monitors rival prices with POLITENESS MODE to avoid IP bans.
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { log } from '../../core/ai-provider.js';
+
+const HISTORY_FILE = path.join(os.homedir(), '.vantuz', 'memory', 'competitor-history.json');
+const MAX_HISTORY = 1000;
+
+// ═══════════════════════════════════════════════════════════════════════════
+// POLITENESS MODE — Anti-Ban Protection
+// ═══════════════════════════════════════════════════════════════════════════
+
+function randomDelay(minMs = 2000, maxMs = 5000) {
+    const delay = Math.floor(Math.random() * (maxMs - minMs + 1)) + minMs;
+    return new Promise(resolve => setTimeout(resolve, delay));
+}
+
+const RATE_LIMITS = new Map(); // platform -> { count, resetAt }
+const MAX_REQUESTS_PER_HOUR = 120;
+
+function checkRateLimit(platform) {
+    const now = Date.now();
+    let limit = RATE_LIMITS.get(platform);
+
+    if (!limit || now > limit.resetAt) {
+        limit = { count: 0, resetAt: now + 3600000 }; // 1 hour window
+        RATE_LIMITS.set(platform, limit);
+    }
+
+    if (limit.count >= MAX_REQUESTS_PER_HOUR) {
+        log('WARN', `Rate limit reached for ${platform}`, {
+            count: limit.count,
+            resetIn: Math.round((limit.resetAt - now) / 60000) + ' min'
+        });
+        return false;
+    }
+
+    limit.count++;
+    return true;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// HISTORY PERSISTENCE
+// ═══════════════════════════════════════════════════════════════════════════
+
+function loadHistory() {
+    try {
+        if (fs.existsSync(HISTORY_FILE)) {
+            return JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf-8'));
+        }
+    } catch (e) { /* ignore */ }
+    return {};
+}
+
+function saveHistory(history) {
+    const dir = path.dirname(HISTORY_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const tmp = HISTORY_FILE + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(history, null, 2), 'utf-8');
+    fs.renameSync(tmp, HISTORY_FILE);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// COMPETITOR TRACKER
+// ═══════════════════════════════════════════════════════════════════════════
+
+class CompetitorTracker {
+    constructor() {
+        this.history = loadHistory(); // barcode -> [{timestamp, platform, competitors[]}]
+        this.adapters = null; // Set by init()
+        log('INFO', 'CompetitorTracker initialized', {
+            trackedProducts: Object.keys(this.history).length
+        });
+    }
+
+    /**
+     * Set adapter registry reference.
+     */
+    setAdapters(adapterRegistry) {
+        this.adapters = adapterRegistry;
+    }
+
+    /**
+     * Track competitor prices for a single product.
+     * @param {string} barcode
+     * @param {string} platform - Platform to check (default: all active).
+     * @returns {{ competitors: array, alert: string|null }}
+     */
+    async trackProduct(barcode, platform = null) {
+        const competitors = [];
+        const platforms = platform
+            ? [platform]
+            : (this.adapters?.getActive() || []).map(a => a.name);
+
+        for (const pName of platforms) {
+            // Rate limit check
+            if (!checkRateLimit(pName)) {
+                log('WARN', `Skipping ${pName} for ${barcode}: rate limited`);
+                continue;
+            }
+
+            const adapter = this.adapters?.get(pName);
+            if (!adapter || typeof adapter.getCompetitorPrices !== 'function') {
+                continue;
+            }
+
+            try {
+                // POLITENESS MODE: Random delay before each request
+                await randomDelay(2000, 5000);
+
+                const result = await adapter.getCompetitorPrices(barcode);
+                if (result?.success && result.data) {
+                    for (const comp of result.data) {
+                        competitors.push({
+                            platform: pName,
+                            seller: comp.seller || comp.merchantName || 'unknown',
+                            price: parseFloat(comp.price || comp.salePrice || 0),
+                            stock: comp.stock ?? comp.hasStock ?? null,
+                            rating: comp.rating || null,
+                            fetchedAt: new Date().toISOString()
+                        });
+                    }
+                }
+            } catch (e) {
+                log('ERROR', `Competitor fetch failed: ${pName}/${barcode}`, { error: e.message });
+            }
+        }
+
+        // Store in history
+        this._recordHistory(barcode, competitors);
+
+        // Detect alerts
+        const alert = this._detectAlerts(barcode, competitors);
+
+        return { barcode, competitors, alert };
+    }
+
+    /**
+     * Track multiple products in batch (respects rate limits).
+     * @param {string[]} barcodes
+     */
+    async trackBatch(barcodes) {
+        const results = [];
+
+        for (const barcode of barcodes) {
+            const result = await this.trackProduct(barcode);
+            results.push(result);
+
+            // Extra delay between products for politeness
+            await randomDelay(1000, 3000);
+        }
+
+        log('INFO', `Batch tracking complete`, {
+            products: barcodes.length,
+            totalCompetitors: results.reduce((s, r) => s + r.competitors.length, 0)
+        });
+
+        return results;
+    }
+
+    /**
+     * Get price history for a product.
+     */
+    getHistory(barcode) {
+        return this.history[barcode] || [];
+    }
+
+    /**
+     * Get competitor summary: cheapest, average, count.
+     */
+    getSummary(barcode) {
+        const entries = this.history[barcode] || [];
+        if (entries.length === 0) return null;
+
+        const latest = entries[entries.length - 1];
+        const prices = latest.competitors.map(c => c.price).filter(p => p > 0);
+
+        return {
+            barcode,
+            sellerCount: latest.competitors.length,
+            cheapest: prices.length > 0 ? Math.min(...prices) : null,
+            average: prices.length > 0 ? prices.reduce((a, b) => a + b, 0) / prices.length : null,
+            mostExpensive: prices.length > 0 ? Math.max(...prices) : null,
+            lastChecked: latest.timestamp
+        };
+    }
+
+    // ─────────────────────────────────────────────────────────────────────
+    // PRIVATE
+    // ─────────────────────────────────────────────────────────────────────
+
+    _recordHistory(barcode, competitors) {
+        if (!this.history[barcode]) {
+            this.history[barcode] = [];
+        }
+
+        this.history[barcode].push({
+            timestamp: new Date().toISOString(),
+            competitors
+        });
+
+        // Keep only recent entries per product
+        if (this.history[barcode].length > 50) {
+            this.history[barcode] = this.history[barcode].slice(-50);
+        }
+
+        // Limit total history size
+        const total = Object.values(this.history).reduce((s, arr) => s + arr.length, 0);
+        if (total > MAX_HISTORY) {
+            // Remove oldest product histories
+            const sorted = Object.entries(this.history)
+                .sort((a, b) => a[1].length - b[1].length);
+            delete this.history[sorted[0][0]];
+        }
+
+        saveHistory(this.history);
+    }
+
+    _detectAlerts(barcode, competitors) {
+        if (competitors.length === 0) return null;
+
+        const prices = competitors.map(c => c.price).filter(p => p > 0);
+        if (prices.length === 0) return null;
+
+        const cheapest = Math.min(...prices);
+        const lowStockSellers = competitors.filter(c => c.stock !== null && c.stock < 5);
+
+        // Alert: all competitors low stock → opportunity!
+        if (lowStockSellers.length > 0 && lowStockSellers.length >= competitors.length * 0.7) {
+            return `🔥 FIRSAT: ${barcode} — Rakiplerin %${Math.round(lowStockSellers.length / competitors.length * 100)}'i düşük stokta. Fiyat artırma fırsatı!`;
+        }
+
+        return null;
+    }
+}
+
+let trackerInstance = null;
+
+export function getCompetitorTracker() {
+    if (!trackerInstance) {
+        trackerInstance = new CompetitorTracker();
+    }
+    return trackerInstance;
+}
+
+export default CompetitorTracker;