natureco-cli 1.0.14 → 1.0.16

package/src/commands/discord.js

@@ -0,0 +1,159 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { getApiKey, getConfig, saveConfig } = require('../utils/config');
+const { getBots } = require('../utils/api');
+
+async function discord(action) {
+  if (!action || action === 'connect') {
+    return connectDiscord();
+  }
+  
+  if (action === 'disconnect') {
+    return disconnectDiscord();
+  }
+  
+  if (action === 'status') {
+    return statusDiscord();
+  }
+  
+  console.log(chalk.red('\n❌ Unknown action\n'));
+  console.log(chalk.gray('Available actions: connect, disconnect, status\n'));
+  process.exit(1);
+}
+
+async function connectDiscord() {
+  const apiKey = getApiKey();
+  
+  if (!apiKey) {
+    console.log(chalk.red('\n❌ Not logged in. Run "natureco login" first.\n'));
+    process.exit(1);
+  }
+  
+  const config = getConfig();
+  
+  console.log(chalk.yellow('\n⏳ Loading bots...\n'));
+  
+  let botList;
+  try {
+    botList = await getBots(apiKey);
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Error: ${err.message}\n`));
+    process.exit(1);
+  }
+  
+  if (!botList || !botList.bots || botList.bots.length === 0) {
+    console.log(chalk.gray('No bots found. Create one at https://developers.natureco.me\n'));
+    process.exit(1);
+  }
+  
+  process.stdin.resume();
+  
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'botId',
+      message: 'Select bot to connect:',
+      choices: botList.bots.map(b => ({ name: b.name, value: b.id })),
+    },
+    {
+      type: 'input',
+      name: 'token',
+      message: 'Discord bot token:',
+      validate: (val) => val.trim() !== '' || 'Token cannot be empty',
+    },
+  ]);
+  
+  const selectedBot = botList.bots.find(b => b.id === answers.botId);
+  
+  console.log(chalk.yellow('\n⏳ Connecting to Discord...\n'));
+  
+  try {
+    const response = await fetch('https://api.natureco.me/api/agent/discord/connect', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        agent_id: answers.botId,
+        discord_bot_token: answers.token.trim(),
+      }),
+    });
+    
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(error);
+    }
+    
+    const data = await response.json();
+    
+    console.log(chalk.green('✅ Discord connected successfully!\n'));
+    console.log(chalk.cyan('Bot:'), chalk.white(selectedBot.name));
+    console.log(chalk.cyan('Discord Bot:'), chalk.white(data.bot_username || 'Unknown'));
+    console.log(chalk.gray('\nYour bot is now active on Discord.'));
+    console.log(chalk.gray('Users can interact with /sor command.\n'));
+    
+    // Save to config
+    config.discordToken = answers.token.trim();
+    config.discordBotId = answers.botId;
+    saveConfig(config);
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Connection failed: ${err.message}\n`));
+    process.exit(1);
+  }
+}
+
+async function disconnectDiscord() {
+  const config = getConfig();
+  
+  if (!config.discordToken) {
+    console.log(chalk.gray('\n⚠️  No Discord connection found\n'));
+    return;
+  }
+  
+  process.stdin.resume();
+  
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: 'Are you sure you want to disconnect Discord?',
+      default: false,
+    },
+  ]);
+  
+  if (!confirm) {
+    console.log(chalk.gray('\nCancelled\n'));
+    return;
+  }
+  
+  // Remove from config
+  delete config.discordToken;
+  delete config.discordBotId;
+  saveConfig(config);
+  
+  console.log(chalk.green('\n✅ Discord disconnected\n'));
+  console.log(chalk.gray('Note: The bot is still registered on Discord.'));
+  console.log(chalk.gray('You may need to manually remove it from Discord Developer Portal.\n'));
+}
+
+function statusDiscord() {
+  const config = getConfig();
+  
+  if (!config.discordToken) {
+    console.log(chalk.gray('\n⚠️  Discord not connected\n'));
+    console.log(chalk.gray('Connect with: natureco discord connect\n'));
+    return;
+  }
+  
+  console.log(chalk.green('\n✅ Discord connected\n'));
+  console.log(chalk.cyan('Token:'), chalk.white(config.discordToken.slice(0, 20) + '...'));
+  
+  if (config.discordBotId) {
+    console.log(chalk.cyan('Bot ID:'), chalk.white(config.discordBotId));
+  }
+  
+  console.log(chalk.gray('\nDisconnect with: natureco discord disconnect\n'));
+}
+
+module.exports = discord;

package/src/commands/doctor.js

@@ -0,0 +1,362 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const net = require('net');
+const { getConfig, saveConfig, CONFIG_FILE, CONFIG_DIR } = require('../utils/config');
+const { getBots } = require('../utils/api');
+const { getSkills } = require('../utils/skills');
+
+async function doctor(options) {
+  const shouldFix = options && (options.includes('--fix') || options.includes('-f'));
+  
+  console.log(chalk.cyan.bold('\n🔍 NatureCo CLI Sistem Kontrolü\n'));
+  
+  const results = [];
+  let passed = 0;
+  let total = 0;
+  let criticalPassed = 0;
+  let criticalTotal = 0;
+  
+  // 1. Node.js versiyon kontrolü
+  total++;
+  criticalTotal++;
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0]);
+  if (nodeMajor >= 18) {
+    console.log(chalk.green('✅ Node.js versiyonu:'), chalk.white(nodeVersion));
+    passed++;
+    criticalPassed++;
+    results.push({ status: 'ok', message: 'Node.js 18+' });
+  } else {
+    console.log(chalk.red('❌ Node.js versiyonu:'), chalk.white(nodeVersion), chalk.gray('(18+ gerekli)'));
+    results.push({ status: 'error', message: 'Node.js 18+ gerekli', fix: 'Node.js güncelleyin: https://nodejs.org' });
+  }
+  
+  // 2. Config dosyası kontrolü
+  total++;
+  criticalTotal++;
+  let config = null;
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+      config = JSON.parse(data);
+      console.log(chalk.green('✅ Config dosyası:'), chalk.white(CONFIG_FILE));
+      passed++;
+      criticalPassed++;
+      results.push({ status: 'ok', message: 'Config dosyası geçerli' });
+    } catch (err) {
+      console.log(chalk.red('❌ Config dosyası:'), chalk.white('Bozuk JSON'));
+      results.push({ status: 'error', message: 'Config dosyası bozuk', fix: 'Config yeniden oluşturulacak' });
+      
+      if (shouldFix) {
+        console.log(chalk.yellow('   🔧 Config yeniden oluşturuluyor...'));
+        config = { setupCompleted: false, skills: { enabled: true, list: [] }, mcpServers: {} };
+        saveConfig(config);
+        console.log(chalk.green('   ✓ Config oluşturuldu'));
+      }
+    }
+  } else {
+    console.log(chalk.yellow('⚠️  Config dosyası:'), chalk.white('Bulunamadı'));
+    results.push({ status: 'warning', message: 'Config dosyası yok', fix: 'Config oluşturulacak' });
+    
+    if (shouldFix) {
+      console.log(chalk.yellow('   🔧 Config oluşturuluyor...'));
+      if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      }
+      config = { setupCompleted: false, skills: { enabled: true, list: [] }, mcpServers: {} };
+      saveConfig(config);
+      console.log(chalk.green('   ✓ Config oluşturuldu'));
+    }
+  }
+  
+  // 3. API key kontrolü
+  total++;
+  criticalTotal++;
+  let apiKeyValid = false;
+  if (config && config.apiKey) {
+    try {
+      const response = await fetch('https://api.natureco.me/api/v1/bots', {
+        headers: { 'Authorization': `Bearer ${config.apiKey}` },
+      });
+      
+      if (response.ok) {
+        console.log(chalk.green('✅ API key:'), chalk.white(config.apiKey.slice(0, 8) + '...'));
+        passed++;
+        criticalPassed++;
+        apiKeyValid = true;
+        results.push({ status: 'ok', message: 'API key geçerli' });
+      } else {
+        console.log(chalk.red('❌ API key:'), chalk.white('Geçersiz'));
+        results.push({ status: 'error', message: 'API key geçersiz', fix: 'Setup çalıştırılacak' });
+      }
+    } catch (err) {
+      console.log(chalk.red('❌ API key:'), chalk.white('Test edilemedi'));
+      results.push({ status: 'error', message: 'API key test edilemedi' });
+    }
+  } else {
+    console.log(chalk.yellow('⚠️  API key:'), chalk.white('Kayıtlı değil'));
+    results.push({ status: 'warning', message: 'API key yok', fix: 'Setup çalıştırılacak' });
+  }
+  
+  if (shouldFix && !apiKeyValid) {
+    console.log(chalk.yellow('   🔧 Setup başlatılıyor...'));
+    console.log(chalk.gray('   Lütfen setup\'ı manuel çalıştırın: natureco setup'));
+  }
+  
+  // 4. Varsayılan bot kontrolü
+  total++;
+  if (config && config.defaultBot && config.defaultBotId) {
+    console.log(chalk.green('✅ Varsayılan bot:'), chalk.white(config.defaultBot));
+    passed++;
+    results.push({ status: 'ok', message: 'Varsayılan bot ayarlanmış' });
+  } else {
+    console.log(chalk.yellow('⚠️  Varsayılan bot:'), chalk.white('Ayarlanmamış'));
+    results.push({ status: 'warning', message: 'Varsayılan bot yok', fix: 'Setup ile ayarlanabilir' });
+  }
+  
+  // 5. Skills kontrolü
+  total++;
+  try {
+    const skills = getSkills();
+    const skillCount = skills.length;
+    
+    if (skillCount > 0) {
+      console.log(chalk.green('✅ Skills:'), chalk.white(`${skillCount} yüklü`));
+      passed++;
+      results.push({ status: 'ok', message: `${skillCount} skill yüklü` });
+    } else {
+      console.log(chalk.yellow('⚠️  Skills:'), chalk.white('Yüklü skill yok'));
+      results.push({ status: 'warning', message: 'Skill yok', fix: 'Yerleşik skill\'ler yüklenebilir' });
+    }
+  } catch (err) {
+    console.log(chalk.yellow('⚠️  Skills:'), chalk.white('Kontrol edilemedi'));
+    results.push({ status: 'warning', message: 'Skills kontrol edilemedi' });
+  }
+  
+  // 6. MCP sunucuları kontrolü
+  total++;
+  const mcpCount = config && config.mcpServers ? Object.keys(config.mcpServers).length : 0;
+  if (mcpCount > 0) {
+    console.log(chalk.green('✅ MCP sunucuları:'), chalk.white(`${mcpCount} kayıtlı`));
+    passed++;
+    results.push({ status: 'ok', message: `${mcpCount} MCP sunucusu` });
+  } else {
+    console.log(chalk.yellow('⚠️  MCP sunucuları:'), chalk.white('Kayıtlı sunucu yok'));
+    results.push({ status: 'warning', message: 'MCP sunucusu yok' });
+  }
+  
+  // 7. Hafıza kontrolü
+  total++;
+  const memoryDir = path.join(CONFIG_DIR, 'memory');
+  let memoryActive = false;
+  
+  if (fs.existsSync(memoryDir)) {
+    try {
+      const files = fs.readdirSync(memoryDir);
+      const memoryFiles = files.filter(f => f.endsWith('.json'));
+      if (memoryFiles.length > 0) {
+        memoryActive = true;
+        console.log(chalk.green('✅ Hafıza:'), chalk.white(`Aktif (${memoryFiles.length} dosya)`));
+        passed++;
+        results.push({ status: 'ok', message: `Hafıza aktif (${memoryFiles.length} dosya)` });
+      } else {
+        console.log(chalk.yellow('⚠️  Hafıza:'), chalk.white('Klasör var, dosya yok'));
+        results.push({ status: 'warning', message: 'Hafıza dosyası yok' });
+      }
+    } catch (err) {
+      console.log(chalk.yellow('⚠️  Hafıza:'), chalk.white('Kontrol edilemedi'));
+      results.push({ status: 'warning', message: 'Hafıza kontrol edilemedi' });
+    }
+  } else {
+    console.log(chalk.yellow('⚠️  Hafıza:'), chalk.white('Pasif'));
+    results.push({ status: 'warning', message: 'Hafıza pasif' });
+  }
+  
+  // 8. Telegram kontrolü (opsiyonel)
+  if (config && config.telegramToken) {
+    console.log(chalk.green('✅ Telegram:'), chalk.white('Bağlı'));
+    results.push({ status: 'ok', message: 'Telegram bağlı', optional: true });
+  } else {
+    console.log(chalk.gray('⚪ Telegram:'), chalk.white('Bağlı değil'));
+    results.push({ status: 'info', message: 'Telegram bağlı değil', optional: true });
+  }
+  
+  // 9. Discord kontrolü (opsiyonel)
+  if (config && config.discordToken) {
+    console.log(chalk.green('✅ Discord:'), chalk.white('Bağlı'));
+    results.push({ status: 'ok', message: 'Discord bağlı', optional: true });
+  } else {
+    console.log(chalk.gray('⚪ Discord:'), chalk.white('Bağlı değil'));
+    results.push({ status: 'info', message: 'Discord bağlı değil', optional: true });
+  }
+  
+  // 10. Slack kontrolü (opsiyonel)
+  if (config && config.slackToken) {
+    console.log(chalk.green('✅ Slack:'), chalk.white('Bağlı'));
+    results.push({ status: 'ok', message: 'Slack bağlı', optional: true });
+  } else {
+    console.log(chalk.gray('⚪ Slack:'), chalk.white('Bağlı değil'));
+    results.push({ status: 'info', message: 'Slack bağlı değil', optional: true });
+  }
+  
+  // 11. WhatsApp kontrolü (opsiyonel)
+  if (config && config.whatsappConnected) {
+    console.log(chalk.green('✅ WhatsApp:'), chalk.white('Bağlı'));
+    results.push({ status: 'ok', message: 'WhatsApp bağlı', optional: true });
+  } else {
+    console.log(chalk.gray('⚪ WhatsApp:'), chalk.white('Bağlı değil'));
+    results.push({ status: 'info', message: 'WhatsApp bağlı değil', optional: true });
+  }
+  
+  // 12. Dashboard kontrolü (opsiyonel)
+  const dashboardRunning = await checkPort(3848);
+  if (dashboardRunning) {
+    console.log(chalk.green('✅ Dashboard:'), chalk.white('Çalışıyor (port 3848)'));
+    results.push({ status: 'ok', message: 'Dashboard çalışıyor', optional: true });
+  } else {
+    console.log(chalk.gray('⚪ Dashboard:'), chalk.white('Çalışmıyor'));
+    results.push({ status: 'info', message: 'Dashboard çalışmıyor', fix: 'natureco dashboard start', optional: true });
+    
+    if (shouldFix) {
+      console.log(chalk.yellow('   🔧 Dashboard başlatılıyor...'));
+      console.log(chalk.gray('   Lütfen manuel başlatın: natureco dashboard start'));
+    }
+  }
+  
+  // 13. Gateway kontrolü (opsiyonel)
+  const gatewayRunning = await checkPort(3847);
+  if (gatewayRunning) {
+    console.log(chalk.green('✅ Gateway:'), chalk.white('Çalışıyor (port 3847)'));
+    results.push({ status: 'ok', message: 'Gateway çalışıyor', optional: true });
+  } else {
+    console.log(chalk.gray('⚪ Gateway:'), chalk.white('Çalışmıyor'));
+    results.push({ status: 'info', message: 'Gateway çalışmıyor', fix: 'natureco gateway start', optional: true });
+  }
+  
+  // 14. Internet bağlantısı kontrolü
+  total++;
+  criticalTotal++;
+  try {
+    const response = await fetch('https://api.natureco.me/health', { 
+      method: 'GET',
+      signal: AbortSignal.timeout(5000),
+    });
+    
+    if (response.ok || response.status === 404) {
+      console.log(chalk.green('✅ Internet:'), chalk.white('api.natureco.me erişilebilir'));
+      passed++;
+      criticalPassed++;
+      results.push({ status: 'ok', message: 'API erişilebilir' });
+    } else {
+      console.log(chalk.yellow('⚠️  Internet:'), chalk.white('API yanıt vermiyor'));
+      results.push({ status: 'warning', message: 'API yanıt vermiyor' });
+    }
+  } catch (err) {
+    console.log(chalk.red('❌ Internet:'), chalk.white('api.natureco.me erişilemiyor'));
+    results.push({ status: 'error', message: 'API erişilemiyor' });
+  }
+  
+  // 15. Güncelleme kontrolü
+  total++;
+  try {
+    const packageJson = require('../../package.json');
+    const currentVersion = packageJson.version;
+    
+    const response = await fetch('https://registry.npmjs.org/natureco-cli/latest', {
+      signal: AbortSignal.timeout(5000),
+    });
+    
+    if (response.ok) {
+      const data = await response.json();
+      const latestVersion = data.version;
+      
+      if (currentVersion === latestVersion) {
+        console.log(chalk.green('✅ Versiyon:'), chalk.white(`${currentVersion} (güncel)`));
+        passed++;
+        results.push({ status: 'ok', message: 'Versiyon güncel' });
+      } else {
+        console.log(chalk.yellow('⚠️  Versiyon:'), chalk.white(`${currentVersion} → ${latestVersion} mevcut`));
+        results.push({ status: 'warning', message: 'Yeni versiyon mevcut', fix: 'npm install -g natureco-cli@latest' });
+        
+        if (shouldFix) {
+          console.log(chalk.yellow('   🔧 Güncelleme başlatılıyor...'));
+          console.log(chalk.gray('   Lütfen manuel güncelleyin: npm install -g natureco-cli@latest'));
+        }
+      }
+    } else {
+      console.log(chalk.gray('⚪ Versiyon:'), chalk.white('Kontrol edilemedi'));
+      results.push({ status: 'info', message: 'Versiyon kontrol edilemedi' });
+    }
+  } catch (err) {
+    console.log(chalk.gray('⚪ Versiyon:'), chalk.white('Kontrol edilemedi'));
+    results.push({ status: 'info', message: 'Versiyon kontrol edilemedi' });
+  }
+  
+  // Özet
+  console.log(chalk.cyan('\n────────────────────────────────'));
+  
+  // Kritik kontroller için durum
+  const criticalPercentage = criticalTotal > 0 ? Math.round((criticalPassed / criticalTotal) * 100) : 100;
+  let statusColor = chalk.green;
+  let statusText = 'Mükemmel';
+  
+  if (criticalPercentage < 75) {
+    statusColor = chalk.red;
+    statusText = 'Kritik';
+  } else if (criticalPercentage < 100) {
+    statusColor = chalk.yellow;
+    statusText = 'Dikkat';
+  } else if (passed < total) {
+    statusColor = chalk.cyan;
+    statusText = 'İyi';
+  }
+  
+  console.log(statusColor.bold(`Sistem Durumu: ${statusText}`));
+  console.log(chalk.white(`${passed}/${total} kontrol geçti`));
+  console.log(chalk.gray(`Kritik: ${criticalPassed}/${criticalTotal}`));
+  
+  // Sorunlar
+  const errors = results.filter(r => r.status === 'error');
+  const warnings = results.filter(r => r.status === 'warning');
+  
+  if (errors.length > 0) {
+    console.log(chalk.red(`\n❌ ${errors.length} hata bulundu`));
+  }
+  
+  if (warnings.length > 0) {
+    console.log(chalk.yellow(`⚠️  ${warnings.length} uyarı bulundu`));
+  }
+  
+  if (!shouldFix && (errors.length > 0 || warnings.length > 0)) {
+    console.log(chalk.gray('\nOtomatik onarım için: natureco doctor --fix'));
+  }
+  
+  console.log(chalk.cyan('────────────────────────────────\n'));
+}
+
+function checkPort(port) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    
+    socket.setTimeout(1000);
+    
+    socket.on('connect', () => {
+      socket.destroy();
+      resolve(true);
+    });
+    
+    socket.on('timeout', () => {
+      socket.destroy();
+      resolve(false);
+    });
+    
+    socket.on('error', () => {
+      resolve(false);
+    });
+    
+    socket.connect(port, '127.0.0.1');
+  });
+}
+
+module.exports = doctor;