vantuz 3.4.1 → 3.5.0

package/core/brand-analyst.js

@@ -0,0 +1,101 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+
+module.exports = {
+    /**
+     * Analyzes the store name and creates a BRAND.md file.
+     * @param {string} storeName - The name of the store (e.g., "TechMaster")
+     * @param {Object} config - The Conf instance
+     */
+    async analyzeAndSave(storeName, config) {
+        const spinner = ora('Yapay Zeka marka kimliğini analiz ediyor...').start();
+
+        try {
+            // Dynamic import because ai-provider is ESM
+            const { default: ai } = await import('./ai-provider.js');
+
+            // Get API configuration
+            // index.js uses 'vantuz' key for plugin config, but product-manager uses 'ai'.
+            // We'll inspect both or default to what's available.
+            const aiConfig = config.get('ai') || {};
+            const vantuzConfig = config.get('vantuz') || {};
+
+            // Prepare environment variables for the provider
+            // The AI provider expects env vars like GEMINI_API_KEY
+            const env = {};
+            if (aiConfig.apiKey) {
+                // Guess the key name based on provider or default to OPENAI
+                const provider = aiConfig.provider || 'openai';
+                env[`${provider.toUpperCase()}_API_KEY`] = aiConfig.apiKey;
+            } else if (process.env.OPENAI_API_KEY) {
+                env.OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+            }
+
+            // If no key found, we can't analyze
+            if (Object.keys(env).length === 0 && !process.env.GEMINI_API_KEY) {
+                spinner.warn(chalk.yellow('AI API Anahtarı bulunamadı. Marka analizi atlanıyor.'));
+                return;
+            }
+
+            const prompt = `
+            Analyze the store name: "${storeName}".
+            Based on this name, infer:
+            1. The likely Industry (Electronic, Fashion, Home, etc.)
+            2. Target Audience (Young, Professional, Budget, Luxury)
+            3. Brand Voice (Professional, Friendly, Tech-savvy, Traditional)
+            
+            Then, generate the content for a "BRAND.md" file.
+            The content should look like this:
+            
+            # Brand Identity: ${storeName}
+            
+            ## Industry
+            [Industry]
+            
+            ## Target Audience
+            [Audience]
+            
+            ## Brand Voice
+            [Voice Description]
+            
+            ## Communication Guidelines
+            - Rule 1
+            - Rule 2
+            
+            Return ONLY the markdown content.
+            `;
+
+            const aiOptions = {
+                aiProvider: aiConfig.provider || 'openai',
+                systemContext: 'You are a Brand Strategist.'
+            };
+
+            const response = await ai.chat(prompt, aiOptions, env);
+
+            // Clean response (remove markdown code blocks if any)
+            const cleanContent = response.replace(/^```markdown/, '').replace(/^```/, '').trim();
+
+            // Setup workspace
+            const workspaceDir = path.join(process.cwd(), 'workspace');
+            if (!fs.existsSync(workspaceDir)) {
+                fs.mkdirSync(workspaceDir, { recursive: true });
+            }
+
+            const brandPath = path.join(workspaceDir, 'BRAND.md');
+            fs.writeFileSync(brandPath, cleanContent, 'utf-8');
+
+            spinner.succeed(chalk.green('Marka kimliği oluşturuldu: workspace/BRAND.md'));
+
+            // Show a preview
+            console.log(chalk.gray('----------------------------------------'));
+            console.log(cleanContent.split('\n').slice(0, 10).join('\n') + '\n...');
+            console.log(chalk.gray('----------------------------------------'));
+
+        } catch (error) {
+            spinner.fail('Marka analizi başarısız.');
+            console.error(chalk.red(error.message));
+        }
+    }
+};

package/core/channels.js

@@ -1,169 +1,169 @@
-/**
- * 📱 CHANNEL MANAGER v3.2
+/**
+ * 📱 CHANNEL MANAGER v3.2
  * Gateway üzerinden kanal yönetimi
- * 
- * Desteklenen kanallar:
- * - WhatsApp (Meta Business API / Gateway)
- * - Telegram (Bot API / Gateway)
- */
-
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { log } from './ai-provider.js';
-import { getGateway } from './gateway.js';
-
-const VANTUZ_HOME = path.join(os.homedir(), '.vantuz');
-const CONFIG_PATH = path.join(VANTUZ_HOME, '.env');
-
-export class ChannelManager {
-    constructor() {
-        this.gateway = null;
-        this.status = {
-            whatsapp: { connected: false, mode: 'gateway', info: '' },
-            telegram: { connected: false, mode: 'gateway', info: '' }
-        };
-    }
-
-    /**
-     * Tüm kanalları başlat
-     */
-    async initAll() {
-        const env = this._loadEnv();
-
+ * 
+ * Desteklenen kanallar:
+ * - WhatsApp (Meta Business API / Gateway)
+ * - Telegram (Bot API / Gateway)
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { log } from './ai-provider.js';
+import { getGateway } from './gateway.js';
+
+const VANTUZ_HOME = path.join(os.homedir(), '.vantuz');
+const CONFIG_PATH = path.join(VANTUZ_HOME, '.env');
+
+export class ChannelManager {
+    constructor() {
+        this.gateway = null;
+        this.status = {
+            whatsapp: { connected: false, mode: 'gateway', info: '' },
+            telegram: { connected: false, mode: 'gateway', info: '' }
+        };
+    }
+
+    /**
+     * Tüm kanalları başlat
+     */
+    async initAll() {
+        const env = this._loadEnv();
+
         // Gateway üzerinden kanal durumu kontrol et
-        try {
-            this.gateway = await getGateway();
-
-            if (this.gateway.isConnected()) {
-                const channelResult = await this.gateway.getChannels();
-                if (channelResult.success && channelResult.data) {
-                    this._syncGatewayChannels(channelResult.data);
-                    log('INFO', 'Kanal durumları gateway üzerinden alındı');
-                    return this.status;
-                }
-            }
-        } catch (e) {
-            log('WARN', 'Gateway kanal kontrolü başarısız, lokal mod', { error: e.message });
-        }
-
-        // Fallback: Lokal env kontrolü
-        if (env.TELEGRAM_BOT_TOKEN) {
-            this.status.telegram.connected = true;
-            this.status.telegram.info = 'Bot Token Configured (local)';
-        } else {
-            this.status.telegram.info = 'Token yapılandırılmamış';
-        }
-
-        if (env.WHATSAPP_ACCESS_TOKEN) {
-            this.status.whatsapp.connected = true;
-            this.status.whatsapp.info = 'Access Token Configured (local)';
-        } else {
-            this.status.whatsapp.info = 'Bağlanmak için: vantuz channels login';
-        }
-
-        return this.status;
-    }
-
-    /**
-     * Gateway'den gelen kanal verilerini senkronize et
-     */
-    _syncGatewayChannels(gatewayData) {
-        if (Array.isArray(gatewayData)) {
-            for (const ch of gatewayData) {
-                const name = ch.name?.toLowerCase();
-                if (name === 'whatsapp' || name === 'telegram') {
-                    this.status[name] = {
-                        connected: ch.connected || ch.status === 'connected',
-                        mode: 'gateway',
-                        info: ch.info || ch.status || 'Gateway üzerinden bağlı',
-                        capabilities: ch.capabilities || []
-                    };
-                }
-            }
-        } else if (typeof gatewayData === 'object') {
-            // Object format: { whatsapp: {...}, telegram: {...} }
-            for (const [name, data] of Object.entries(gatewayData)) {
-                const key = name.toLowerCase();
-                if (this.status[key]) {
-                    this.status[key] = {
-                        connected: data.connected || data.status === 'connected',
-                        mode: 'gateway',
-                        info: data.info || data.status || 'Gateway üzerinden bağlı',
-                        capabilities: data.capabilities || []
-                    };
-                }
-            }
-        }
-    }
-
-    /**
-     * Mesaj gönder (gateway üzerinden)
-     */
-    async sendMessage(channel, to, message) {
-        if (!this.gateway?.isConnected()) {
-            return { success: false, error: 'Gateway bağlı değil' };
-        }
-
-        const result = await this.gateway.sendMessage(channel, to, message);
-        if (result.success) {
-            log('INFO', `Mesaj gönderildi: ${channel} → ${to}`);
-        } else {
-            log('ERROR', `Mesaj gönderilemedi: ${channel}`, { error: result.error });
-        }
-        return result;
-    }
-
-    /**
-     * Kanal durumunu yenile
-     */
-    async refresh() {
-        return await this.initAll();
-    }
-
-    /**
-     * Env dosyasını yükle
-     */
-    _loadEnv() {
-        const env = {};
-        try {
-            if (fs.existsSync(CONFIG_PATH)) {
-                const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
-                content.split('\n').forEach(line => {
-                    const match = line.match(/^([^=]+)=(.*)$/);
-                    if (match) {
-                        env[match[1].trim()] = match[2].trim();
-                    }
-                });
-            }
-        } catch (e) { }
-        return env;
-    }
-
-    /**
-     * Kanal durumları
-     */
-    getStatus() {
-        return this.status;
-    }
-
-    /**
-     * Gateway bağlı mı?
-     */
-    isGatewayMode() {
-        return this.gateway?.isConnected() || false;
-    }
-}
-
-// Singleton
-let managerInstance = null;
-
-export async function getChannelManager() {
-    if (!managerInstance) {
-        managerInstance = new ChannelManager();
-        await managerInstance.initAll();
-    }
-    return managerInstance;
-}
-
-export default ChannelManager;
+        try {
+            this.gateway = await getGateway();
+
+            if (this.gateway.isConnected()) {
+                const channelResult = await this.gateway.getChannels();
+                if (channelResult.success && channelResult.data) {
+                    this._syncGatewayChannels(channelResult.data);
+                    log('INFO', 'Kanal durumları gateway üzerinden alındı');
+                    return this.status;
+                }
+            }
+        } catch (e) {
+            log('WARN', 'Gateway kanal kontrolü başarısız, lokal mod', { error: e.message });
+        }
+
+        // Fallback: Lokal env kontrolü
+        if (env.TELEGRAM_BOT_TOKEN) {
+            this.status.telegram.connected = true;
+            this.status.telegram.info = 'Bot Token Configured (local)';
+        } else {
+            this.status.telegram.info = 'Token yapılandırılmamış';
+        }
+
+        if (env.WHATSAPP_ACCESS_TOKEN) {
+            this.status.whatsapp.connected = true;
+            this.status.whatsapp.info = 'Access Token Configured (local)';
+        } else {
+            this.status.whatsapp.info = 'Bağlanmak için: vantuz channels login';
+        }
+
+        return this.status;
+    }
+
+    /**
+     * Gateway'den gelen kanal verilerini senkronize et
+     */
+    _syncGatewayChannels(gatewayData) {
+        if (Array.isArray(gatewayData)) {
+            for (const ch of gatewayData) {
+                const name = ch.name?.toLowerCase();
+                if (name === 'whatsapp' || name === 'telegram') {
+                    this.status[name] = {
+                        connected: ch.connected || ch.status === 'connected',
+                        mode: 'gateway',
+                        info: ch.info || ch.status || 'Gateway üzerinden bağlı',
+                        capabilities: ch.capabilities || []
+                    };
+                }
+            }
+        } else if (typeof gatewayData === 'object') {
+            // Object format: { whatsapp: {...}, telegram: {...} }
+            for (const [name, data] of Object.entries(gatewayData)) {
+                const key = name.toLowerCase();
+                if (this.status[key]) {
+                    this.status[key] = {
+                        connected: data.connected || data.status === 'connected',
+                        mode: 'gateway',
+                        info: data.info || data.status || 'Gateway üzerinden bağlı',
+                        capabilities: data.capabilities || []
+                    };
+                }
+            }
+        }
+    }
+
+    /**
+     * Mesaj gönder (gateway üzerinden)
+     */
+    async sendMessage(channel, to, message) {
+        if (!this.gateway?.isConnected()) {
+            return { success: false, error: 'Gateway bağlı değil' };
+        }
+
+        const result = await this.gateway.sendMessage(channel, to, message);
+        if (result.success) {
+            log('INFO', `Mesaj gönderildi: ${channel} → ${to}`);
+        } else {
+            log('ERROR', `Mesaj gönderilemedi: ${channel}`, { error: result.error });
+        }
+        return result;
+    }
+
+    /**
+     * Kanal durumunu yenile
+     */
+    async refresh() {
+        return await this.initAll();
+    }
+
+    /**
+     * Env dosyasını yükle
+     */
+    _loadEnv() {
+        const env = {};
+        try {
+            if (fs.existsSync(CONFIG_PATH)) {
+                const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
+                content.split('\n').forEach(line => {
+                    const match = line.match(/^([^=]+)=(.*)$/);
+                    if (match) {
+                        env[match[1].trim()] = match[2].trim();
+                    }
+                });
+            }
+        } catch (e) { }
+        return env;
+    }
+
+    /**
+     * Kanal durumları
+     */
+    getStatus() {
+        return this.status;
+    }
+
+    /**
+     * Gateway bağlı mı?
+     */
+    isGatewayMode() {
+        return this.gateway?.isConnected() || false;
+    }
+}
+
+// Singleton
+let managerInstance = null;
+
+export async function getChannelManager() {
+    if (!managerInstance) {
+        managerInstance = new ChannelManager();
+        await managerInstance.initAll();
+    }
+    return managerInstance;
+}
+
+export default ChannelManager;