vantuz 3.5.18 → 4.0.3

package/core/learning.js

@@ -2,10 +2,10 @@
 // Reinforcement Learning Module for Vantuz OS V2
 // Weighted scoring system — tracks AI decisions and adjusts behavior.
 
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { log } from './ai-provider.js';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { log } = require('./ai-provider.js');
 
 const LEARNING_FILE = path.join(os.homedir(), '.vantuz', 'memory', 'learning.json');
 
@@ -203,12 +203,12 @@ class LearningModule {
 
 let learningInstance = null;
 
-export function getLearning() {
+module.exports.getLearn = functioning() {
     if (!learningInstance) {
         learningInstance = new LearningModule();
     }
     return learningInstance;
 }
 
-export { SCORE_WEIGHTS, AUTONOMY_THRESHOLD };
-export default LearningModule;
+module.exports = { SCORE_WEIGHTS, AUTONOMY_THRESHOLD };
+module.exports = LearningModule;

package/core/license-manager.js

@@ -1,5 +1,5 @@
 const crypto = require('crypto');
-const fs = require('path');
+const fs = require('fs');
 
 // Müşteriye Gidecek Olan PUBLIC KEY (Sadece doğrulama yapar)
 // BU KEY, admin-keygen.js'deki private.pem ile eşleşmeli

package/core/license.js

@@ -1,14 +1,14 @@
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-import os from 'os';
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const os = require('os');
 
 const LICENSE_FILE = path.join(os.homedir(), '.vantuz', 'license.json');
 
 // Basit anahtar doğrulama - VM için
 const VALID_KEYS = new Set();
 
-export class LicenseManager {
+module.exports = LicenseManager {
     constructor() {
         this.data = this._load();
     }
@@ -86,4 +86,4 @@ export class LicenseManager {
     }
 }
 
-export const licenseManager = new LicenseManager();
+module.exports.l =icenseManager = new LicenseManager();

package/core/logger.js

@@ -0,0 +1,228 @@
+/**
+ * 🐙 VANTUZ Logger - Structured JSON Logging System
+ * Log seviyeleri: debug, info, warn, error
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const LOG_LEVELS = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+    FATAL: 4
+};
+
+const LOG_DIR = path.join(process.cwd(), 'logs');
+const LOG_FILE = path.join(LOG_DIR, 'vantuz.log');
+const SESSION_FILE = path.join(LOG_DIR, 'session.log');
+
+// Log seviyesi - env'den veya varsayılan
+const currentLevel = process.env.LOG_LEVEL ? 
+    LOG_LEVELS[process.env.LOG_LEVEL.toUpperCase()] : LOG_LEVELS.INFO;
+
+// Klasör yoksa oluştur
+if (!fs.existsSync(LOG_DIR)) {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+}
+
+/**
+ * Structured log entry oluştur
+ */
+function createLogEntry(level, message, meta = {}) {
+    return {
+        timestamp: new Date().toISOString(),
+        level,
+        message,
+        meta: {
+            ...meta,
+            pid: process.pid,
+            nodeVersion: process.version,
+            memoryUsage: process.memoryUsage(),
+            uptime: process.uptime()
+        }
+    };
+}
+
+/**
+ * Log dosyasına yaz
+ */
+function writeToFile(entry) {
+    try {
+        fs.appendFileSync(LOG_FILE, JSON.stringify(entry) + '\n');
+    } catch (e) {
+        console.error('Log yazma hatası:', e.message);
+    }
+}
+
+/**
+ * Console output - renkli format
+ */
+function formatConsole(entry) {
+    const colors = {
+        DEBUG: '\x1b[36m',  // Cyan
+        INFO: '\x1b[32m',   // Green
+        WARN: '\x1b[33m',   // Yellow
+        ERROR: '\x1b[31m',  // Red
+        FATAL: '\x1b[35m',  // Magenta
+        RESET: '\x1b[0m'
+    };
+
+    const icons = {
+        DEBUG: '🔍',
+        INFO: 'ℹ️',
+        WARN: '⚠️',
+        ERROR: '❌',
+        FATAL: '💀'
+    };
+
+    const color = colors[entry.level] || colors.INFO;
+    const icon = icons[entry.level] || icons.INFO;
+    
+    let output = `${color}${icon} [${entry.timestamp}] ${entry.message}${colors.RESET}`;
+    
+    if (Object.keys(entry.meta).length > 5) {
+        const metaStr = JSON.stringify(entry.meta, null, 2);
+        output += `\n${color}${metaStr}${colors.RESET}`;
+    }
+    
+    return output;
+}
+
+/**
+ * Ana logger object
+ */
+const logger = {
+    /**
+     * DEBUG seviyesi
+     */
+    debug(message, meta = {}) {
+        if (currentLevel <= LOG_LEVELS.DEBUG) {
+            const entry = createLogEntry('DEBUG', message, meta);
+            writeToFile(entry);
+            console.log(formatConsole(entry));
+        }
+    },
+
+    /**
+     * INFO seviyesi
+     */
+    info(message, meta = {}) {
+        if (currentLevel <= LOG_LEVELS.INFO) {
+            const entry = createLogEntry('INFO', message, meta);
+            writeToFile(entry);
+            console.log(formatConsole(entry));
+        }
+    },
+
+    /**
+     * WARN seviyesi
+     */
+    warn(message, meta = {}) {
+        if (currentLevel <= LOG_LEVELS.WARN) {
+            const entry = createLogEntry('WARN', message, meta);
+            writeToFile(entry);
+            console.warn(formatConsole(entry));
+        }
+    },
+
+    /**
+     * ERROR seviyesi
+     */
+    error(message, meta = {}) {
+        if (currentLevel <= LOG_LEVELS.ERROR) {
+            const entry = createLogEntry('ERROR', message, meta);
+            writeToFile(entry);
+            console.error(formatConsole(entry));
+        }
+    },
+
+    /**
+     * FATAL seviyesi
+     */
+    fatal(message, meta = {}) {
+        if (currentLevel <= LOG_LEVELS.FATAL) {
+            const entry = createLogEntry('FATAL', message, meta);
+            writeToFile(entry);
+            console.error(formatConsole(entry));
+        }
+    },
+
+    /**
+     * Session log başlat
+     */
+    startSession(sessionId) {
+        const entry = createLogEntry('INFO', 'Session başladı', { sessionId });
+        writeToFile(entry);
+        try {
+            fs.appendFileSync(SESSION_FILE, JSON.stringify(entry) + '\n');
+        } catch (e) {}
+    },
+
+    /**
+     * Session log bitir
+     */
+    endSession(sessionId, duration, stats = {}) {
+        const entry = createLogEntry('INFO', 'Session bitti', { sessionId, duration, ...stats });
+        writeToFile(entry);
+        try {
+            fs.appendFileSync(SESSION_FILE, JSON.stringify(entry) + '\n');
+        } catch (e) {}
+    },
+
+    /**
+     * Error reporting - crash dump
+     */
+    reportError(error, context = {}) {
+        const entry = createLogEntry('ERROR', error.message, {
+            stack: error.stack,
+            ...context
+        });
+        writeToFile(entry);
+        return entry;
+    },
+
+    /**
+     * Log oku
+     */
+    getLogs(count = 100) {
+        try {
+            if (!fs.existsSync(LOG_FILE)) return [];
+            const lines = fs.readFileSync(LOG_FILE, 'utf-8').split('\n').filter(Boolean);
+            return lines.slice(-count).map(line => JSON.parse(line));
+        } catch (e) {
+            return [];
+        }
+    },
+
+    /**
+     * Session log oku
+     */
+    getSessionLogs() {
+        try {
+            if (!fs.existsSync(SESSION_FILE)) return [];
+            const lines = fs.readFileSync(SESSION_FILE, 'utf-8').split('\n').filter(Boolean);
+            return lines.map(line => JSON.parse(line));
+        } catch (e) {
+            return [];
+        }
+    },
+
+    /**
+     * Log temizle
+     */
+    clearLogs() {
+        try {
+            if (fs.existsSync(LOG_FILE)) fs.unlinkSync(LOG_FILE);
+            if (fs.existsSync(SESSION_FILE)) fs.unlinkSync(SESSION_FILE);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    },
+
+    LOG_LEVELS
+};
+
+module.exports = logger;

package/core/marketplace-adapter.js

@@ -2,7 +2,7 @@
 // Formal MarketplaceAdapter Interface for Vantuz OS V2
 // Validates that any platform plugin implements required methods.
 
-import { log } from './ai-provider.js';
+const { log } = require('./ai-provider.js');
 
 // ═══════════════════════════════════════════════════════════════════════════
 // REQUIRED METHODS DEFINITION
@@ -34,7 +34,7 @@ const OPTIONAL_METHODS = [
  * @param {object} adapter - Adapter instance or export object
  * @returns {{ valid: boolean, missing: string[] }}
  */
-export function validateAdapter(name, adapter) {
+module.exports.val = functionidateAdapter(name, adapter) {
     const missing = [];
 
     for (const method of REQUIRED_METHODS) {
@@ -59,7 +59,7 @@ export function validateAdapter(name, adapter) {
  * @param {object} adapter
  * @returns {string[]} List of supported optional method names.
  */
-export function getAdapterCapabilities(adapter) {
+module.exports.getAdapterCapab = functionilities(adapter) {
     return OPTIONAL_METHODS.filter(m => typeof adapter[m] === 'function');
 }
 
@@ -158,11 +158,11 @@ class AdapterRegistry {
 // Singleton
 let registryInstance = null;
 
-export function getAdapterRegistry() {
+module.exports.getAdapterReg = functionistry() {
     if (!registryInstance) {
         registryInstance = new AdapterRegistry();
     }
     return registryInstance;
 }
 
-export default AdapterRegistry;
+module.exports = AdapterRegistry;

package/core/memory.js

@@ -2,10 +2,10 @@
 // Persistent Memory Module for Vantuz AI
 // Provides long-term fact storage and recall via JSON files.
 
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { log } from './ai-provider.js';
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { log } = require('./ai-provider.js');
 
 const MEMORY_DIR = path.join(os.homedir(), '.vantuz', 'memory');
 const FACTS_FILE = path.join(MEMORY_DIR, 'facts.json');
@@ -180,11 +180,11 @@ class Memory {
 
 let memoryInstance = null;
 
-export function getMemory() {
+module.exports.getMemory = function() {
     if (!memoryInstance) {
         memoryInstance = new Memory();
     }
     return memoryInstance;
 }
 
-export default Memory;
+module.exports = Memory;

package/core/multi-agent.js

@@ -0,0 +1,180 @@
+const EventEmitter = require('events');
+
+// Multi-Agent Communication Core
+// Enables autonomous task delegation and inter-agent chat
+
+class MultiAgentSystem extends EventEmitter {
+    constructor() {
+        super();
+        this.agents = new Map();
+        this.meetingMode = false;
+        this.meetingHistory = [];
+        this.logger = console;
+    }
+
+    /**
+     * Register an agent
+     * @param {string} id - Unique agent identifier
+     * @param {object} agent - Agent instance with 'name', 'role', and 'process' method
+     */
+    register(id, agent) {
+        if (this.agents.has(id)) {
+            this.logger.warn(`Agent ${id} already registered. Updating instead.`);
+        }
+        this.agents.set(id, {
+            ...agent,
+            id,
+            status: 'idle',
+            lastActive: new Date().toISOString()
+        });
+        this.logger.log(`🤖 Agent registered: ${agent.name} (${agent.role})`);
+        this.emit('agent:registered', { id, agent });
+    }
+
+    /**
+     * Send a message to all agents or specific ones
+     * @param {string} message - The content
+     * @param {object} options - { target: 'all' | 'market' | 'orders' | specificId, context: {} }
+     */
+    async broadcast(message, options = {}) {
+        const { target = 'all', context = {} } = options;
+        const timestamp = new Date().toISOString();
+        
+        const record = { message, target, context, timestamp, sender: 'user' };
+        this.meetingHistory.push(record);
+        this.emit('meeting:message', record);
+
+        const promises = [];
+
+        if (target === 'all') {
+            for (const [id, agent] of this.agents) {
+                promises.push(this.routeToAgent(id, message, context));
+            }
+        } else {
+            const targetAgents = [];
+            if (target === 'market') {
+                targetAgents.push('market-agent', 'competitor-agent');
+            } else if (target === 'orders') {
+                targetAgents.push('order-agent');
+            } else {
+                targetAgents.push(target);
+            }
+
+            for (const id of targetAgents) {
+                if (this.agents.has(id)) {
+                    promises.push(this.routeToAgent(id, message, context));
+                }
+            }
+        }
+
+        // Wait for all (or timeout)
+        const results = await Promise.allSettled(promises);
+        return results.map((r, i) => ({
+            agentId: target === 'all' ? [...this.agents.keys()][i] : target,
+            status: r.status,
+            response: r.status === 'fulfilled' ? r.value : r.reason
+        }));
+    }
+
+    /**
+     * Internal method to route message to a specific agent
+     */
+    async routeToAgent(agentId, message, context) {
+        const agent = this.agents.get(agentId);
+        if (!agent) return { error: 'Agent not found' };
+
+        agent.status = 'processing';
+        agent.lastActive = new Date().toISOString();
+        
+        try {
+            // Context includes who else is in the room if in meeting mode
+            const response = await agent.process(message, {
+                ...context,
+                meetingMode: this.meetingMode,
+                agentsAvailable: [...this.agents.keys()]
+            });
+            
+            agent.status = 'idle';
+            
+            // If in meeting mode, emit the response so UI can show it
+            if (this.meetingMode) {
+                this.emit('meeting:response', {
+                    agentId,
+                    agentName: agent.name,
+                    response,
+                    timestamp: new Date().toISOString()
+                });
+            }
+
+            return response;
+        } catch (error) {
+            agent.status = 'error';
+            return { error: error.message };
+        }
+    }
+
+    /**
+     * Enable Meeting Mode (UI integration)
+     */
+    enableMeetingMode() {
+        this.meetingMode = true;
+        this.logger.log('🗣️ Meeting Mode ENABLED');
+        this.emit('meeting:status', { active: true });
+    }
+
+    disableMeetingMode() {
+        this.meetingMode = false;
+        this.logger.log('🗣️ Meeting Mode DISABLED');
+        this.emit('meeting:status', { active: false });
+    }
+
+    getMeetingHistory() {
+        return this.meetingHistory;
+    }
+
+    getSystemStatus() {
+        const agents = [];
+        for (const [id, data] of this.agents) {
+            agents.push({ id, ...data, memory: undefined }); // exclude functions/memory
+        }
+        return {
+            mode: this.meetingMode ? 'Meeting' : 'Standard',
+            agentCount: this.agents.size,
+            agents
+        };
+    }
+}
+
+// Singleton export
+const mas = new MultiAgentSystem();
+
+// Default Agents
+class BaseAgent {
+    constructor(name, role) {
+        this.name = name;
+        this.role = role;
+    }
+    async process(msg, ctx) { return `Agent ${this.name} received: ${msg}`; }
+}
+
+class OrderAgent extends BaseAgent {
+    constructor() { super('OrderBot', 'orders'); }
+    async process(msg, ctx) {
+        // Simulated order logic
+        return `📦 Sipariş Ajansı: "${msg}" mesajını işledim. Mevcut siparişlerin analizi yapılıyor.`;
+    }
+}
+
+class MarketAgent extends BaseAgent {
+    constructor() { super('MarketBot', 'market'); }
+    async process(msg, ctx) {
+        return `📊 Pazar Ajansı: "${msg}" için verileri topluyorum. Trend analizi yapılıyor.`;
+    }
+}
+
+// Register defaults
+mas.register('order-agent', new OrderAgent());
+mas.register('market-agent', new MarketAgent());
+
+module.exports = { mas, MultiAgentSystem };
+module.exports = mas;

package/core/openclaw-bridge.js

@@ -1,8 +1,8 @@
 // core/openclaw-bridge.js
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-import { log } from './ai-provider.js';
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { log } = require('./ai-provider.js');
 
 const DEFAULT_PORT = 18789;
 
@@ -88,7 +88,7 @@ function appendEventLog(evt) {
     } catch { }
 }
 
-export class OpenClawBridge {
+module.exports = OpenClawBridge {
     constructor(engine, gateway) {
         this.engine = engine;
         this.gateway = gateway;
@@ -188,4 +188,4 @@ export class OpenClawBridge {
     }
 }
 
-export default OpenClawBridge;
+module.exports = OpenClawBridge;

package/core/queue.js

@@ -2,7 +2,7 @@
 // Critical Operation Queue (Lane Queue) for Vantuz AI
 // Ensures write operations (price/stock updates) execute serially, never in parallel.
 
-import { log } from './ai-provider.js';
+const { log } = require('./ai-provider.js');
 
 class CriticalQueue {
     constructor() {
@@ -110,11 +110,11 @@ class CriticalQueue {
 
 let queueInstance = null;
 
-export function getCriticalQueue() {
+module.exports.getCr = functioniticalQueue() {
     if (!queueInstance) {
         queueInstance = new CriticalQueue();
     }
     return queueInstance;
 }
 
-export default CriticalQueue;
+module.exports = CriticalQueue;

package/core/scheduler.js

@@ -2,11 +2,11 @@
 // Persistent Scheduler for Vantuz AI
 // Jobs survive restarts via JSON file persistence.
 
-import { CronJob } from 'cron';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { log } from './ai-provider.js';
+const { CronJob } = require('cron');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { log } = require('./ai-provider.js');
 
 const JOBS_FILE = path.join(os.homedir(), '.vantuz', 'cron', 'jobs.json');
 
@@ -152,7 +152,7 @@ class Scheduler {
 
 let schedulerInstance = null;
 
-export function getScheduler() {
+module.exports.getScheduler = function() {
     if (!schedulerInstance) {
         schedulerInstance = new Scheduler();
     }

package/core/scrapers/Scraper.js

@@ -1,5 +1,5 @@
 // core/scrapers/Scraper.js
-import { chromium } from 'playwright';
+const { chromium } = require('playwright');;
 
 export class Scraper {
     constructor() {

package/core/scrapers/TrendyolScraper.js

@@ -1,5 +1,5 @@
 // core/scrapers/TrendyolScraper.js
-import { Scraper } from './Scraper.js';
+const { Scraper } = require('./Scraper.js');;
 
 export class TrendyolScraper extends Scraper {
     constructor() {

package/core/self-healer.js

@@ -2,10 +2,10 @@
 // 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 fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { log } = require('./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');
@@ -304,11 +304,13 @@ class SelfHealer {
 
 let healerInstance = null;
 
-export function getSelfHealer() {
+function getSelfHealer() {
     if (!healerInstance) {
         healerInstance = new SelfHealer();
     }
     return healerInstance;
 }
 
-export default SelfHealer;
+// Export both the class and the getter
+module.exports = SelfHealer;
+module.exports.getSelfHealer = getSelfHealer;