natureco-cli 1.0.0

package/src/commands/setup.js

@@ -0,0 +1,222 @@
+const chalk = require('chalk');
+const boxen = require('boxen');
+const inquirer = require('inquirer');
+const fs = require('fs');
+const { saveConfig, CONFIG_DIR, CONFIG_FILE } = require('../utils/config');
+const { getBots } = require('../utils/api');
+
+async function setup() {
+  // Kurulum ekranı
+  const welcomeBox = boxen(
+    chalk.green.bold('🌿 NatureCo Terminal\n') +
+    chalk.green.bold('   İlk Kurulum\n'),
+    {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: 'green',
+      align: 'center',
+    }
+  );
+
+  console.clear();
+  console.log(welcomeBox);
+  console.log(chalk.yellow('Hoş geldiniz! NatureCo CLI\'yi ilk kez'));
+  console.log(chalk.yellow('kullanıyorsunuz.\n'));
+
+  // Klasör oluştur
+  console.log(chalk.cyan('✦ ~/.natureco/ klasörü oluşturuluyor...'));
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  console.log(chalk.green('  ✓ Klasör oluşturuldu\n'));
+
+  console.log(chalk.cyan('✦ Varsayılan ayarlar yükleniyor...'));
+  console.log(chalk.green('  ✓ Ayarlar hazır\n'));
+
+  // API key sor
+  process.stdin.resume();
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'apiKey',
+      message: 'API key girin:',
+      validate: async (input) => {
+        if (!input || input.trim().length === 0) {
+          return 'API key gerekli';
+        }
+
+        const trimmed = input.trim();
+        if (!trimmed.startsWith('nc_') && !trimmed.startsWith('nco_')) {
+          return 'API key nc_ veya nco_ ile başlamalı';
+        }
+
+        // API key'i validate et
+        console.log(chalk.yellow('\n  ⏳ API key doğrulanıyor...'));
+        try {
+          const response = await fetch('https://api.natureco.me/api/v1/bots', {
+            headers: {
+              'Authorization': `Bearer ${trimmed}`,
+              'Content-Type': 'application/json',
+            },
+          });
+
+          if (!response.ok) {
+            return 'Geçersiz API key';
+          }
+
+          const data = await response.json();
+          if (!data.bots || data.bots.length === 0) {
+            return 'Bu API key ile bot bulunamadı';
+          }
+
+          console.log(chalk.green('  ✓ API key doğrulandı\n'));
+          return true;
+        } catch (err) {
+          return `API hatası: ${err.message}`;
+        }
+      },
+    },
+  ]);
+
+  const trimmedApiKey = apiKey.trim();
+
+  // Botları çek
+  console.log(chalk.yellow('⏳ Botlar yükleniyor...\n'));
+  let botList;
+  try {
+    botList = await getBots(trimmedApiKey);
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Hata: ${err.message}\n`));
+    process.exit(1);
+  }
+
+  if (!botList || !botList.bots || botList.bots.length === 0) {
+    console.log(chalk.red('❌ Bot bulunamadı.\n'));
+    process.exit(1);
+  }
+
+  // Bot seç
+  process.stdin.resume();
+  const { selectedBotId } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'selectedBotId',
+      message: 'Varsayılan bot seçin:',
+      choices: botList.bots.map(b => ({
+        name: b.name,
+        value: b.id,
+      })),
+    },
+  ]);
+
+  const selectedBot = botList.bots.find(b => b.id === selectedBotId);
+
+  // Telegram bağlantısı
+  process.stdin.resume();
+  const { connectTelegram } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'connectTelegram',
+      message: 'Telegram bağlamak ister misiniz?',
+      default: false,
+    },
+  ]);
+
+  let telegramConnected = false;
+  let telegramSkipped = false;
+
+  if (connectTelegram) {
+    process.stdin.resume();
+    const { telegramToken } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'telegramToken',
+        message: 'Telegram Bot Token girin (BotFather\'dan alınır):',
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return 'Token gerekli';
+          }
+          return true;
+        },
+      },
+    ]);
+
+    process.stdin.resume();
+    const { telegramUserId } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'telegramUserId',
+        message: 'Telegram kullanıcı ID\'niz nedir? (t.me/userinfobot ile öğrenebilirsiniz):',
+        validate: (val) => val.trim() !== '' || 'Kullanıcı ID boş olamaz',
+      },
+    ]);
+
+    console.log(chalk.yellow('\n⏳ Telegram bağlanıyor...\n'));
+
+    try {
+      const response = await fetch('https://api.natureco.me/api/agent/telegram/connect', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${trimmedApiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          agent_id: selectedBotId,
+          telegram_bot_token: telegramToken.trim(),
+          telegram_user_id: telegramUserId.trim(),
+        }),
+      });
+
+      if (response.ok) {
+        console.log(chalk.green('✅ Telegram bağlandı\n'));
+        telegramConnected = true;
+        
+        // Config'e telegramUserId ekle
+        config.telegramUserId = telegramUserId.trim();
+      } else {
+        const errorText = await response.text();
+        console.log(chalk.red(`❌ Telegram bağlanamadı: ${errorText}\n`));
+      }
+    } catch (err) {
+      console.log(chalk.red(`❌ Telegram bağlanamadı: ${err.message}\n`));
+    }
+  } else {
+    telegramSkipped = true;
+  }
+
+  // Config kaydet
+  const config = {
+    apiKey: trimmedApiKey,
+    defaultBot: selectedBot.name,
+    defaultBotId: selectedBot.id,
+    skills: {
+      enabled: true,
+      list: [],
+    },
+    mcpServers: {},
+    setupCompleted: true,
+    setupDate: new Date().toISOString(),
+  };
+
+  saveConfig(config);
+
+  // Kurulum tamamlandı
+  console.log(chalk.green.bold('✅ Kurulum tamamlandı!\n'));
+  console.log(chalk.cyan('Aktif bot:'), chalk.white(selectedBot.name));
+  
+  if (telegramConnected) {
+    console.log(chalk.cyan('Telegram:'), chalk.green('✅ Bağlı'));
+  } else if (telegramSkipped) {
+    console.log(chalk.cyan('Telegram:'), chalk.gray('⏭ Atlandı'));
+  } else {
+    console.log(chalk.cyan('Telegram:'), chalk.red('❌ Bağlanamadı'));
+  }
+  
+  console.log(chalk.cyan('Config:'), chalk.white(CONFIG_FILE));
+  console.log('');
+  console.log(chalk.yellow('Başlamak için:'), chalk.cyan('natureco chat'));
+  console.log('');
+}
+
+module.exports = setup;

package/src/commands/skills.js

@@ -0,0 +1,161 @@
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { getSkills, installSkill, removeSkill, updateAllSkills, createSkillTemplate } = require('../utils/skills');
+
+async function skills(args) {
+  const [action, ...params] = args;
+
+  if (!action || action === 'list') {
+    await listSkills();
+    return;
+  }
+
+  if (action === 'install') {
+    const slug = params[0];
+    if (!slug) {
+      console.log(chalk.red('\n❌ Kullanım: natureco skills install <slug>\n'));
+      process.exit(1);
+    }
+    await installSkillCommand(slug);
+    return;
+  }
+
+  if (action === 'remove') {
+    const slug = params[0];
+    if (!slug) {
+      console.log(chalk.red('\n❌ Kullanım: natureco skills remove <slug>\n'));
+      process.exit(1);
+    }
+    await removeSkillCommand(slug);
+    return;
+  }
+
+  if (action === 'update') {
+    const flag = params[0];
+    if (flag === '--all') {
+      await updateAllSkillsCommand();
+    } else {
+      console.log(chalk.red('\n❌ Kullanım: natureco skills update --all\n'));
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (action === 'create') {
+    const name = params[0];
+    if (!name) {
+      console.log(chalk.red('\n❌ Kullanım: natureco skills create <ad>\n'));
+      process.exit(1);
+    }
+    await createSkillCommand(name);
+    return;
+  }
+
+  console.log(chalk.red(`\n❌ Geçersiz action: ${action}\n`));
+  console.log(chalk.gray('Kullanım: natureco skills [list|install|remove|update|create]\n'));
+  process.exit(1);
+}
+
+async function listSkills() {
+  console.log(chalk.green.bold('\n╭─ Yüklü Skill\'ler ─╮\n'));
+
+  const allSkills = getSkills();
+
+  if (allSkills.length === 0) {
+    console.log(chalk.gray('Hiç skill yüklü değil.\n'));
+    console.log(chalk.yellow('Skill yüklemek için:'), chalk.white('natureco skills install <slug>\n'));
+    return;
+  }
+
+  allSkills.forEach((skill, index) => {
+    const sourceLabel = skill.source === 'builtin' ? chalk.blue('[Yerleşik]') :
+                        skill.source === 'user' ? chalk.cyan('[Kişisel]') :
+                        chalk.magenta('[Proje]');
+    
+    console.log(chalk.white(`${index + 1}. ${skill.name}`) + ' ' + sourceLabel);
+    console.log(chalk.gray(`   ${skill.description}`));
+    
+    if (skill.metadata?.requires?.bins) {
+      console.log(chalk.gray(`   Gerekli: ${skill.metadata.requires.bins.join(', ')}`));
+    }
+    
+    if (skill.metadata?.os) {
+      console.log(chalk.gray(`   Platform: ${skill.metadata.os.join(', ')}`));
+    }
+    
+    console.log('');
+  });
+
+  console.log(chalk.green('╰────────────────────╯\n'));
+  console.log(chalk.gray(`Toplam: ${allSkills.length} skill\n`));
+}
+
+async function installSkillCommand(slug) {
+  console.log(chalk.yellow(`\n⏳ "${slug}" skill'i yükleniyor...\n`));
+
+  try {
+    await installSkill(slug);
+    console.log(chalk.green(`✅ "${slug}" başarıyla yüklendi!\n`));
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Hata: ${err.message}\n`));
+    process.exit(1);
+  }
+}
+
+async function removeSkillCommand(slug) {
+  const { confirm } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirm',
+      message: `"${slug}" skill'ini silmek istediğinizden emin misiniz?`,
+      default: false,
+    },
+  ]);
+
+  if (!confirm) {
+    console.log(chalk.gray('\nİptal edildi.\n'));
+    return;
+  }
+
+  try {
+    removeSkill(slug);
+    console.log(chalk.green(`\n✅ "${slug}" silindi.\n`));
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Hata: ${err.message}\n`));
+    process.exit(1);
+  }
+}
+
+async function updateAllSkillsCommand() {
+  console.log(chalk.yellow('\n⏳ Tüm skill\'ler güncelleniyor...\n'));
+
+  try {
+    const updated = await updateAllSkills();
+    if (updated.length === 0) {
+      console.log(chalk.gray('Güncellenecek skill bulunamadı.\n'));
+    } else {
+      console.log(chalk.green(`✅ ${updated.length} skill güncellendi:\n`));
+      updated.forEach(s => console.log(chalk.cyan(`  - ${s}`)));
+      console.log('');
+    }
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Hata: ${err.message}\n`));
+    process.exit(1);
+  }
+}
+
+async function createSkillCommand(name) {
+  console.log(chalk.yellow(`\n⏳ "${name}" skill şablonu oluşturuluyor...\n`));
+
+  try {
+    const skillPath = createSkillTemplate(name);
+    console.log(chalk.green(`✅ Skill şablonu oluşturuldu:\n`));
+    console.log(chalk.cyan(`   ${skillPath}\n`));
+    console.log(chalk.gray('SKILL.md dosyasını düzenleyerek skill\'i özelleştirin.\n'));
+  } catch (err) {
+    console.log(chalk.red(`\n❌ Hata: ${err.message}\n`));
+    process.exit(1);
+  }
+}
+
+module.exports = skills;

package/src/commands/update.js

@@ -0,0 +1,61 @@
+const chalk = require('chalk');
+const { execSync } = require('child_process');
+const packageJson = require('../../package.json');
+
+async function update() {
+  const currentVersion = packageJson.version;
+
+  console.log(chalk.yellow('\n⏳ Güncelleme kontrol ediliyor...\n'));
+
+  try {
+    // npm'den en son versiyonu al
+    const latestVersion = execSync('npm view natureco-cli version', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'ignore'],
+    }).trim();
+
+    console.log(chalk.cyan('Mevcut versiyon:'), chalk.white(currentVersion));
+    console.log(chalk.cyan('En son versiyon:'), chalk.white(latestVersion));
+    console.log('');
+
+    if (currentVersion === latestVersion) {
+      console.log(chalk.green('✅ NatureCo CLI güncel!\n'));
+      return;
+    }
+
+    // Versiyon karşılaştırması
+    const isNewer = compareVersions(latestVersion, currentVersion) > 0;
+
+    if (isNewer) {
+      console.log(chalk.yellow('🔔 Yeni versiyon mevcut!\n'));
+      console.log(chalk.gray('Güncellemek için:\n'));
+      console.log(chalk.cyan('  npm install -g natureco-cli@latest\n'));
+      console.log(chalk.gray('veya\n'));
+      console.log(chalk.cyan('  npm update -g natureco-cli\n'));
+    } else {
+      console.log(chalk.green('✅ NatureCo CLI güncel!\n'));
+    }
+  } catch (err) {
+    // npm view başarısız olursa (paket henüz yayınlanmamış)
+    console.log(chalk.gray('Güncelleme kontrolü yapılamadı.\n'));
+    console.log(chalk.gray('Paket henüz npm\'de yayınlanmamış olabilir.\n'));
+  }
+}
+
+// Versiyon karşılaştırma (semver)
+function compareVersions(v1, v2) {
+  const parts1 = v1.split('.').map(Number);
+  const parts2 = v2.split('.').map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    const p1 = parts1[i] || 0;
+    const p2 = parts2[i] || 0;
+
+    if (p1 > p2) return 1;
+    if (p1 < p2) return -1;
+  }
+
+  return 0;
+}
+
+module.exports = update;

package/src/utils/agents.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+
+const AGENTS_FILE = path.join(process.cwd(), '.natureco', 'AGENTS.md');
+
+// Read AGENTS.md content
+function getAgentsPrompt() {
+  if (!fs.existsSync(AGENTS_FILE)) {
+    return '';
+  }
+
+  try {
+    const content = fs.readFileSync(AGENTS_FILE, 'utf8');
+    return content.trim();
+  } catch {
+    return '';
+  }
+}
+
+// Check if AGENTS.md exists
+function hasAgentsFile() {
+  return fs.existsSync(AGENTS_FILE);
+}
+
+module.exports = {
+  getAgentsPrompt,
+  hasAgentsFile,
+};

package/src/utils/api.js

@@ -0,0 +1,64 @@
+const API_BASE = 'https://api.natureco.me';
+
+async function request(endpoint, options = {}) {
+  const url = `${API_BASE}${endpoint}`;
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      'Content-Type': 'application/json',
+      ...options.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`API Error: ${response.status} - ${text}`);
+  }
+
+  return response.json();
+}
+
+async function getBots(apiKey) {
+  return request('/api/v1/bots', {
+    headers: { Authorization: `Bearer ${apiKey}` },
+  });
+}
+
+async function sendMessage(apiKey, botId, message, conversationId = null, skillPrompts = '') {
+  const body = {
+    agent_id: botId,
+    message,
+    conversation_id: conversationId,
+    platform: 'cli',
+    user_id: 'cli-user'
+  };
+
+  // Skill prompts varsa system_prompt olarak ekle
+  if (skillPrompts && skillPrompts.trim().length > 0) {
+    body.system_prompt = skillPrompts;
+  }
+
+  return request('/api/agent/chat', {
+    method: 'POST',
+    headers: { 
+      Authorization: `Bearer ${apiKey}`,
+      'X-User-ID': 'cli-user'
+    },
+    body: JSON.stringify(body),
+  });
+}
+
+async function validateApiKey(apiKey) {
+  try {
+    const result = await getBots(apiKey);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+module.exports = {
+  getBots,
+  sendMessage,
+  validateApiKey,
+};

package/src/utils/config.js

@@ -0,0 +1,81 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.natureco');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+function saveConfig(data) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(CONFIG_FILE, 'utf8');
+    return JSON.parse(content);
+  } catch (err) {
+    return null;
+  }
+}
+
+function deleteConfig() {
+  if (fs.existsSync(CONFIG_FILE)) {
+    fs.unlinkSync(CONFIG_FILE);
+  }
+}
+
+function getApiKey() {
+  const config = loadConfig();
+  return config?.apiKey || null;
+}
+
+function saveApiKey(apiKey) {
+  const config = loadConfig() || {};
+  config.apiKey = apiKey;
+  saveConfig(config);
+}
+
+function getConfig() {
+  return loadConfig() || {};
+}
+
+function getAllConfig() {
+  return loadConfig() || {};
+}
+
+function setConfigValue(key, value) {
+  const config = loadConfig() || {};
+  const keys = key.split('.');
+  let current = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (!current[keys[i]]) {
+      current[keys[i]] = {};
+    }
+    current = current[keys[i]];
+  }
+  current[keys[keys.length - 1]] = value;
+  saveConfig(config);
+}
+
+module.exports = {
+  saveConfig,
+  loadConfig,
+  deleteConfig,
+  getApiKey,
+  saveApiKey,
+  getConfig,
+  getAllConfig,
+  setConfigValue,
+  CONFIG_FILE,
+  CONFIG_DIR,
+};

package/src/utils/history.js

@@ -0,0 +1,87 @@
+const fs = require('fs');
+const path = require('path');
+const { CONFIG_DIR } = require('./config');
+
+const HISTORY_DIR = path.join(CONFIG_DIR, 'history');
+
+// Ensure history directory exists
+function ensureHistoryDir() {
+  if (!fs.existsSync(HISTORY_DIR)) {
+    fs.mkdirSync(HISTORY_DIR, { recursive: true });
+  }
+}
+
+// Get history file path for a bot
+function getHistoryFilePath(botId) {
+  ensureHistoryDir();
+  return path.join(HISTORY_DIR, `${botId}.json`);
+}
+
+// Load conversation history for a bot
+function loadHistory(botId) {
+  const filePath = getHistoryFilePath(botId);
+  
+  if (!fs.existsSync(filePath)) {
+    return [];
+  }
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return [];
+  }
+}
+
+// Save conversation history for a bot
+function saveHistory(botId, history) {
+  const filePath = getHistoryFilePath(botId);
+  
+  try {
+    fs.writeFileSync(filePath, JSON.stringify(history, null, 2), 'utf8');
+  } catch (err) {
+    // Silently fail - history is not critical
+  }
+}
+
+// Add message to history
+function addToHistory(botId, userMessage, botReply, conversationId = null) {
+  const history = loadHistory(botId);
+  
+  history.push({
+    timestamp: new Date().toISOString(),
+    user: userMessage,
+    bot: botReply,
+    conversationId,
+  });
+
+  // Keep only last 100 messages
+  if (history.length > 100) {
+    history.shift();
+  }
+
+  saveHistory(botId, history);
+}
+
+// Get command history (only user messages)
+function getCommandHistory(botId) {
+  const history = loadHistory(botId);
+  return history.map(h => h.user);
+}
+
+// Clear history for a bot
+function clearHistory(botId) {
+  const filePath = getHistoryFilePath(botId);
+  
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+}
+
+module.exports = {
+  loadHistory,
+  saveHistory,
+  addToHistory,
+  getCommandHistory,
+  clearHistory,
+};