vantuz 4.0.0 → 4.0.3

package/cli.js

@@ -5,15 +5,15 @@
  * Vantuz Gateway entegrasyonlu komut satırı arayüzü
  */
 
-import path from 'path';
-import os from 'os';
-import fs from 'fs';
-import readline from 'readline';
-import { log, getLogs, clearLogs } from './core/ai-provider.js';
-import { getEngine } from './core/engine.js';
-import { getGateway } from './core/gateway.js';
-import { licenseManager } from './core/license.js'; // Lisans yöneticisi
-import { Configurator } from './config.js'; // Import the new Configurator
+const path = require('path');;
+const os = require('os');;
+const fs = require('fs');;
+const readline = require('readline');;
+const { log, getLogs, clearLogs } = require('./core/ai-provider.js');;
+const { getEngine } = require('./core/engine.js');;
+const { getGateway } = require('./core/gateway.js');;
+const { licenseManager } = require('./core/license.js');; // Lisans yöneticisi
+const { Configurator } = require('./config.js');; // Import the new Configurator
 
 // ═══════════════════════════════════════════════════════════════════════════
 // CONFIG

package/config.js

@@ -5,12 +5,12 @@
  * v3.2.7 - Gateway Entegrasyonlu
  */
 
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import readline from 'readline';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { PROVIDER_CONFIG } from './core/ai-provider.js'; // Import PROVIDER_CONFIG
+const fs = require('fs');;
+const path = require('path');;
+const os = require('os');;
+const readline = require('readline');;
+const { fileURLToPath, pathToFileURL } = require('url');;
+const { PROVIDER_CONFIG } = require('./core/ai-provider.js');; // Import PROVIDER_CONFIG
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const VANTUZ_HOME = path.join(os.homedir(), '.vantuz');

package/core/agent-loop.js

@@ -2,10 +2,10 @@
 // The Heartbeat of Vantuz OS V2 — Autonomous Agent Loop
 // Cron-driven cycle that orchestrates all intelligence modules.
 
-import { log } from './ai-provider.js';
-import { getLearning } from './learning.js';
-import { getSelfHealer } from './self-healer.js';
-import { CronJob } from 'cron';
+const { log } = require('./ai-provider.js');
+const { getLearning } = require('./learning.js');
+const { getSelfHealer } = require('./self-healer.js');
+const { CronJob } = require('cron');
 
 // ═══════════════════════════════════════════════════════════════════════════
 // AGENT LOOP
@@ -180,11 +180,11 @@ class AgentLoop {
 
 let loopInstance = null;
 
-export function getAgentLoop() {
+module.exports.getAgentLoop = function() {
     if (!loopInstance) {
         loopInstance = new AgentLoop();
     }
     return loopInstance;
 }
 
-export default AgentLoop;
+module.exports = AgentLoop;

package/core/agent.js

@@ -1,8 +1,8 @@
-import fs from 'fs';
-import path from 'path';
-import { exec } from 'child_process';
-import https from 'https';
-import http from 'http';
+const fs = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+const https = require('https');
+const http = require('http');
 
 const DEFAULT_ALLOW_CMDS = [
     'dir', 'ls', 'rg', 'cat', 'type', 'node', 'npm', 'git', 'curl'
@@ -60,7 +60,7 @@ function httpGet(url, timeoutMs = 15000) {
     });
 }
 
-export async function executeTool(tool, args = {}, config = {}) {
+module.exports.executeTool = async function(tool, args = {}, config = {}) {
     switch (tool) {
         case 'exec': {
             const command = args.command || '';

package/core/ai-copilot.js

@@ -0,0 +1,461 @@
+/**
+ * 🤖 Vantuz AI Copilot v4.0
+ * Tam Sistem Erişimli Akıllı Asistan
+ * Dosya sistemi, veritabanı, marketplace ve görev yönetimi
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { exec, execSync } = require('child_process');
+
+// Paths
+const VANTUZ_DIR = path.join(os.homedir(), '.vantuz');
+const LOG_FILE = path.join(VANTUZ_DIR, 'vantuz.log');
+const DB_PATH = path.join(process.cwd(), 'vantuz.sqlite');
+
+/**
+ * Ana Copilot Sınıfı - Tüm sisteme erişim sağlar
+ */
+class AICopilot {
+    constructor() {
+        this.name = 'VantuzCopilot';
+        this.version = '4.0.0';
+        this.context = {};
+        this.permissionLevel = 'full'; // full, restricted, read-only
+        this._db = null;
+    }
+
+    async _getDb() {
+        if (this._db) return this._db;
+        
+        try {
+            const initSqlJs = require('sql.js');
+            const SQL = await initSqlJs();
+            
+            if (fs.existsSync(DB_PATH)) {
+                const buffer = fs.readFileSync(DB_PATH);
+                this._db = new SQL.Database(buffer);
+            } else {
+                this._db = new SQL.Database();
+            }
+            
+            return this._db;
+        } catch (error) {
+            console.error('Database init error:', error.message);
+            return null;
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // DOSYA SİSTEMİ ERİŞİMİ
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Dosya oku
+     */
+    readFile(filePath, options = {}) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return { success: false, error: 'Dosya bulunamadı', path: filePath };
+            }
+            const content = fs.readFileSync(filePath, options.encoding || 'utf-8');
+            return { success: true, content, path: filePath };
+        } catch (error) {
+            return { success: false, error: error.message, path: filePath };
+        }
+    }
+
+    /**
+     * Dosya yaz
+     */
+    writeFile(filePath, content, options = {}) {
+        try {
+            // Dizin yoksa oluştur
+            const dir = path.dirname(filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(filePath, content, options.encoding || 'utf-8');
+            return { success: true, path: filePath, size: content.length };
+        } catch (error) {
+            return { success: false, error: error.message, path: filePath };
+        }
+    }
+
+    /**
+     * Dosya sil (geri dönüşümlü - backup alınır)
+     */
+    deleteFile(filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return { success: false, error: 'Dosya bulunamadı' };
+            }
+            // Backup al
+            const backupPath = filePath + '.backup.' + Date.now();
+            fs.renameSync(filePath, backupPath);
+            return { success: true, backupPath, message: 'Dosya backup alınarak silindi' };
+        } catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+
+    /**
+     * Dizin listele
+     */
+    listDir(dirPath) {
+        try {
+            if (!fs.existsSync(dirPath)) {
+                return { success: false, error: 'Dizin bulunamadı' };
+            }
+            const items = fs.readdirSync(dirPath);
+            const result = items.map(item => {
+                const fullPath = path.join(dirPath, item);
+                const stats = fs.statSync(fullPath);
+                return {
+                    name: item,
+                    path: fullPath,
+                    isDirectory: stats.isDirectory(),
+                    size: stats.size,
+                    modified: stats.mtime
+                };
+            });
+            return { success: true, items: result, path: dirPath };
+        } catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+
+    /**
+     * Dosya ara
+     */
+    findFiles(pattern, rootDir = process.cwd()) {
+        const results = [];
+        
+        function search(dir) {
+            try {
+                const items = fs.readdirSync(dir);
+                for (const item of items) {
+                    const fullPath = path.join(dir, item);
+                    if (item.includes(pattern)) {
+                        results.push(fullPath);
+                    }
+                    if (fs.statSync(fullPath).isDirectory()) {
+                        search(fullPath);
+                    }
+                }
+            } catch (e) { /* permission denied */ }
+        }
+        
+        search(rootDir);
+        return { success: true, results, pattern };
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // VERİTABANI ERİŞİMİ (CRUD)
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * SQL sorgusu çalıştır
+     */
+    async query(sql, params = []) {
+        try {
+            const db = await this._getDb();
+            if (!db) return { success: false, error: 'Database not initialized' };
+            
+            const results = [];
+            const stmt = db.prepare(sql);
+            if (params.length > 0) stmt.bind(params);
+            while (stmt.step()) {
+                results.push(stmt.getAsObject());
+            }
+            stmt.free();
+            
+            // Değişiklik varsa kaydet
+            if (sql.toUpperCase().startsWith('INSERT') || 
+                sql.toUpperCase().startsWith('UPDATE') || 
+                sql.toUpperCase().startsWith('DELETE')) {
+                fs.writeFileSync(DB_PATH, Buffer.from(db.export()));
+            }
+            
+            return { success: true, results, count: results.length };
+        } catch (error) {
+            return { success: false, error: error.message, sql };
+        }
+    }
+
+    /**
+     * Tabloyu oku
+     */
+    async getTable(tableName) {
+        return this.query(`SELECT * FROM ${tableName}`);
+    }
+
+    /**
+     * Veri ekle
+     */
+    async insert(tableName, data) {
+        const keys = Object.keys(data);
+        const values = Object.values(data).map(v => 
+            typeof v === 'object' ? JSON.stringify(v) : v
+        );
+        const placeholders = keys.map(() => '?').join(', ');
+        const sql = `INSERT INTO ${tableName} (${keys.join(', ')}) VALUES (${placeholders})`;
+        return this.query(sql, values);
+    }
+
+    /**
+     * Veri güncelle
+     */
+    async update(tableName, data, where) {
+        const setClause = Object.keys(data).map(k => `${k} = ?`).join(', ');
+        const whereClause = Object.keys(where).map(k => `${k} = ?`).join(' AND ');
+        const values = [...Object.values(data), ...Object.values(where)];
+        const sql = `UPDATE ${tableName} SET ${setClause} WHERE ${whereClause}`;
+        return this.query(sql, values);
+    }
+
+    /**
+     * Veri sil
+     */
+    async delete(tableName, where) {
+        const whereClause = Object.keys(where).map(k => `${k} = ?`).join(' AND ');
+        const values = Object.values(where);
+        const sql = `DELETE FROM ${tableName} WHERE ${whereClause}`;
+        return this.query(sql, values);
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // MARKETPLACE ENTEGRASYONLARI
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Marketplace durumunu kontrol et
+     */
+    getMarketplaceStatus() {
+        const marketplaces = ['trendyol', 'hepsiburada', 'n11', 'amazon', 'ciceksepeti', 'pttavm', 'pazarama'];
+        const status = {};
+        
+        for (const mp of marketplaces) {
+            const configPath = path.join(VANTUZ_DIR, `marketplaces`, `${mp}.json`);
+            const connected = fs.existsSync(configPath);
+            status[mp] = {
+                connected,
+                lastSync: connected ? fs.statSync(configPath).mtime : null
+            };
+        }
+        
+        return { success: true, marketplaces: status };
+    }
+
+    /**
+     * Marketplace API'sini çağır
+     */
+    async callMarketplaceAPI(marketplace, endpoint, method = 'GET', data = null) {
+        const configPath = path.join(VANTUZ_DIR, `marketplaces`, `${marketplace}.json`);
+        
+        if (!fs.existsSync(configPath)) {
+            return { success: false, error: `${marketplace} bağlı değil` };
+        }
+        
+        try {
+            const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            const axios = require('axios');
+            
+            const response = await axios({
+                method,
+                url: `${config.apiUrl}${endpoint}`,
+                headers: config.headers || {},
+                data
+            });
+            
+            return { success: true, data: response.data };
+        } catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // SİSTEM YÖNETİMİ
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Vantuz'u yeniden başlat
+     */
+    restartVantuz() {
+        try {
+            exec(`cd ${process.cwd()} && node index.js &`, { detached: true });
+            return { success: true, message: 'Vantuz yeniden başlatılıyor...' };
+        } catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+
+    /**
+     * Sistem durumunu al
+     */
+    getSystemStatus() {
+        const status = {
+            uptime: process.uptime(),
+            memory: process.memoryUsage(),
+            cpu: process.cpuUsage(),
+            platform: os.platform(),
+            nodeVersion: process.version
+        };
+        
+        // Veritabanı durumu
+        status.database = {
+            exists: fs.existsSync(DB_PATH),
+            size: fs.existsSync(DB_PATH) ? fs.statSync(DB_PATH).size : 0
+        };
+        
+        // Log durumu
+        if (fs.existsSync(LOG_FILE)) {
+            status.log = {
+                exists: true,
+                size: fs.statSync(LOG_FILE).size,
+                lines: fs.readFileSync(LOG_FILE, 'utf-8').split('\n').length
+            };
+        }
+        
+        return { success: true, status };
+    }
+
+    /**
+     * Log oku
+     */
+    getLogs(lines = 50) {
+        try {
+            if (!fs.existsSync(LOG_FILE)) {
+                return { success: false, error: 'Log dosyası bulunamadı' };
+            }
+            const content = fs.readFileSync(LOG_FILE, 'utf-8');
+            const allLines = content.split('\n').filter(l => l.trim());
+            const recentLines = allLines.slice(-lines);
+            return { success: true, logs: recentLines.join('\n'), count: recentLines.length };
+        } catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+
+    /**
+     * Log temizle
+     */
+    clearLogs() {
+        try {
+            fs.writeFileSync(LOG_FILE, '');
+            return { success: true, message: 'Loglar temizlendi' };
+        } catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+
+    // ═══════════════════════════════════════════════════════════════════════
+    // YARDIMCI FONKSİYONLAR
+    // ═══════════════════════════════════════════════════════════════════════
+
+    /**
+     * Shell komutu çalıştır
+     */
+    runCommand(cmd, timeout = 30000) {
+        try {
+            const output = execSync(cmd, { encoding: 'utf-8', timeout });
+            return { success: true, output };
+        } catch (error) {
+            return { success: false, error: error.message, stdout: error.stdout, stderr: error.stderr };
+        }
+    }
+
+    /**
+     * JSON parse et
+     */
+    parseJSON(data) {
+        try {
+            return { success: true, data: JSON.parse(data) };
+        } catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+
+    /**
+     * Obje stringify et
+     */
+    stringifyJSON(obj, indent = 2) {
+        try {
+            return { success: true, data: JSON.stringify(obj, null, indent) };
+        } catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+
+    /**
+     * Tarih/saat al
+     */
+    getDateTime(format = 'iso') {
+        const now = new Date();
+        
+        if (format === 'iso') {
+            return { success: true, datetime: now.toISOString() };
+        } else if (format === 'human') {
+            return { success: true, datetime: now.toLocaleString('tr-TR') };
+        } else if (format === 'timestamp') {
+            return { success: true, datetime: now.getTime() };
+        }
+        
+        return { success: true, datetime: now.toISOString() };
+    }
+
+    /**
+     * Yardım metni
+     */
+    getHelp() {
+        return `
+🤖 **Vantuz AI Copilot - Komut Listesi**
+
+**📁 Dosya İşlemleri:**
+- readFile <yol> - Dosya oku
+- writeFile <yol> <içerik> - Dosya yaz
+- deleteFile <yol> - Dosya sil (backup ile)
+- listDir <yol> - Dizin içeriği
+- findFiles <desen> - Dosya ara
+
+**🗄️ Veritabanı:**
+- query <SQL> - SQL sorgusu
+- getTable <tablo> - Tablo oku
+- insert <tablo> <veri> - Veri ekle
+- update <tablo> <veri> <koşul> - Veri güncelle
+- delete <tablo> <koşul> - Veri sil
+
+**🛒 Marketplace:**
+- marketplaceStatus - Bağlı marketplace'leri göster
+- marketplaceAPI <mp> <endpoint> - Marketplace API çağır
+
+**⚙️ Sistem:**
+- systemStatus - Sistem durumu
+- restartVantuz - Vantuz'u yeniden başlat
+- getLogs <satır> - Log oku
+- clearLogs - Log temizle
+- runCommand <komut> - Shell komutu çalıştır
+- getDateTime <format> - Tarih/saat
+- help - Bu yardım
+
+**💡 Örnekler:**
+- "Stokta kaç ürün var?"
+- "Trendyol'daki siparişleri listele"
+- "Ürün fiyatlarını göster"
+- "Son 100 satırı oku"
+        `.trim();
+    }
+}
+
+// Singleton instance
+let copilotInstance = null;
+
+module.exports.getCopilot = function() {
+    if (!copilotInstance) {
+        copilotInstance = new AICopilot();
+    }
+    return copilotInstance;
+};
+
+module.exports.AICopilot = AICopilot;

package/core/ai-provider.js

@@ -3,14 +3,14 @@
  * Gerçek AI API çağrıları + Context desteği
  */
 
-import axios from 'axios';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
+const axios = require('axios');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 
 const LOG_FILE = path.join(os.homedir(), '.vantuz', 'vantuz.log');
 
-export const PROVIDER_CONFIG = {
+module.exports.PROVIDER_CONFIG = {
     gemini: {
         url: (apiKey) => `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=${apiKey}`,
         body: (systemPrompt, message) => ({
@@ -110,7 +110,7 @@ export const PROVIDER_CONFIG = {
 // LOGGING
 // ═══════════════════════════════════════════════════════════════════════════
 
-export function log(level, message, data = null) {
+module.exports.log = function(level, message, data = null) {
     const timestamp = new Date().toISOString();
     const logLine = `[${timestamp}] [${level}] ${message}${data ? ' | ' + JSON.stringify(data) : ''}\n`;
 
@@ -119,7 +119,7 @@ export function log(level, message, data = null) {
     } catch (e) { }
 }
 
-export function getLogs(lines = 50) {
+module.exports.getLogs = function(lines = 50) {
     try {
         if (!fs.existsSync(LOG_FILE)) {
             return 'Log dosyası bulunamadı.';
@@ -132,7 +132,7 @@ export function getLogs(lines = 50) {
     }
 }
 
-export function clearLogs() {
+module.exports.clearLogs = function() {
     try {
         fs.writeFileSync(LOG_FILE, '');
         return true;
@@ -239,7 +239,7 @@ async function _makeApiRequest(providerName, providerConfig, message, apiKey, sy
     return text;
 }
 
-export async function chat(message, config, env) {
+module.exports.chat = async function(message, config, env) {
     const provider = config.aiProvider || 'gemini';
     const providerConfig = PROVIDER_CONFIG[provider];
 
@@ -248,6 +248,12 @@ export async function chat(message, config, env) {
     const workspaceIdentity = loadWorkspaceIdentity();
     const fullSystemPrompt = VANTUZ_SYSTEM_PROMPT + contextInfo + (workspaceIdentity ? `\n\n## MARKA KİMLİĞİ VE STRATEJİ\nAşağıdaki kurallara MUTLAKA uy:${workspaceIdentity}` : '');
 
+    // Copilot fonksiyonlarını JSON olarak ekle
+    const copilotFunctions = getCopilotFunctions();
+    const toolsContext = `\n\n## KULLANABİLECEĞİN ARAÇLAR (FUNCTIONS)\nAI Copilot şu araçları kullanabilir:\n${copilotFunctions.help()}\n\nÖNEMLİ: Kullanıcı bir görev istediğinde, bu araçları kullanarak görevi yerine getir. Örneğin:\n- "Stok durumunu göster" derse → copilot.query() veya copilot.getTable() kullan\n- "Dosya oku" derse → copilot.readFile() kullan\n- "Komut çalıştır" derse → copilot.runCommand() kullan\n- "Marketplace durumunu göster" derse → copilot.marketplaceStatus() kullan`;
+
+    const finalSystemPrompt = fullSystemPrompt + toolsContext;
+
     log('INFO', `AI isteği: ${provider}`, { message: message.slice(0, 100) });
 
     if (!providerConfig) {
@@ -295,4 +301,48 @@ export async function chat(message, config, env) {
 
 
 
-export default { chat, log, getLogs, clearLogs };
+module.exports = { chat, log, getLogs, clearLogs, getCopilot, loadWorkspaceIdentity };
+
+// ═══════════════════════════════════════════════════════════════════════════
+// AI COPILOT ENTEGRASYONU
+// ═══════════════════════════════════════════════════════════════════════════
+
+const { getCopilot } = require('./ai-copilot');
+
+/**
+ * AI Copilot fonksiyonlarını döndürür
+ * Chat fonksiyonuna context olarak eklenebilir
+ */
+function getCopilotFunctions() {
+    const copilot = getCopilot();
+    return {
+        // Dosya işlemleri
+        readFile: (path) => copilot.readFile(path),
+        writeFile: (path, content) => copilot.writeFile(path, content),
+        deleteFile: (path) => copilot.deleteFile(path),
+        listDir: (path) => copilot.listDir(path),
+        findFiles: (pattern, root) => copilot.findFiles(pattern, root),
+        
+        // Veritabanı
+        query: (sql, params) => copilot.query(sql, params),
+        getTable: (table) => copilot.getTable(table),
+        insert: (table, data) => copilot.insert(table, data),
+        update: (table, data, where) => copilot.update(table, data, where),
+        delete: (table, where) => copilot.delete(table, where),
+        
+        // Marketplace
+        marketplaceStatus: () => copilot.getMarketplaceStatus(),
+        marketplaceAPI: (mp, endpoint, method, data) => copilot.callMarketplaceAPI(mp, endpoint, method, data),
+        
+        // Sistem
+        systemStatus: () => copilot.getSystemStatus(),
+        restartVantuz: () => copilot.restartVantuz(),
+        getLogs: (lines) => copilot.getLogs(lines),
+        clearLogs: () => copilot.clearLogs(),
+        runCommand: (cmd, timeout) => copilot.runCommand(cmd, timeout),
+        getDateTime: (format) => copilot.getDateTime(format),
+        help: () => copilot.getHelp()
+    };
+}
+
+module.exports.getCopilotFunctions = getCopilotFunctions;