natureco-cli 2.23.28 → 2.23.30

package/src/commands/memory-cmd.js

@@ -16,9 +16,17 @@ async function memoryCmd(args) {
   if (action === 'show') return showMemory(params[0]);
   if (action === 'clear') return clearMemoryCmd(params[0]);
   if (action === 'index') return indexMemory();
+  if (action === 'export') return exportMemoryCmd(params[0], params[1]);
+  if (action === 'import') return importMemoryCmd(params[0], params[1]);
+  if (action === 'semantic') return semanticSearchCmd(params.join(' '));
+  // Wiki pages
+  if (action === 'wiki') return wikiCmd(params[0], params.slice(1));
+  if (action === 'wiki-create') return wikiCreateCmd(params[0], params.slice(1).join(' '));
+  if (action === 'wiki-list') return wikiListCmd();
+  if (action === 'wiki-search') return wikiSearchCmd(params.join(' '));
 
   console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
-  console.log(chalk.gray('  Kullanım: natureco memory [status|list|search|show|clear|index]\n'));
+  console.log(chalk.gray('  Kullanım: natureco memory [status|list|search|show|clear|index|export|import|semantic|wiki|wiki-create|wiki-list|wiki-search]\n'));
   process.exit(1);
 }
 
@@ -202,4 +210,129 @@ function indexMemory() {
   console.log(chalk.green(`\n  ✓ ${indexed} hafıza dosyası yeniden indexlendi\n`));
 }
 
+// ── Export Memory ──────────────────────────────────────────────────────────────
+function exportMemoryCmd(botId, outputFile) {
+  const id = botId || 'universal-provider';
+  const mem = exportMemory(id);
+  const filePath = outputFile || path.join(process.cwd(), `memory-${id}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(mem, null, 2));
+  console.log(chalk.green(`\n  ✓ Hafıza dışa aktarıldı: ${filePath}\n`));
+}
+
+// ── Import Memory ──────────────────────────────────────────────────────────────
+function importMemoryCmd(botId, sourceFile) {
+  if (!sourceFile) {
+    console.log(chalk.red('\n  ❌ Kaynak dosya gerekli\n'));
+    console.log(chalk.gray('  Kullanım: natureco memory import <botId> <dosya.json>\n'));
+    return;
+  }
+  const resolvedPath = path.resolve(sourceFile.replace(/^~/, os.homedir()));
+  if (!fs.existsSync(resolvedPath)) {
+    console.log(chalk.red(`\n  ❌ Dosya bulunamadı: ${resolvedPath}\n`));
+    return;
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(resolvedPath, 'utf-8'));
+    importMemory(botId || 'universal-provider', data);
+    console.log(chalk.green(`\n  ✓ Hafıza içe aktarıldı: ${botId || 'universal-provider'}\n`));
+  } catch (err) {
+    console.log(chalk.red(`\n  ❌ Hata: ${err.message}\n`));
+  }
+}
+
+// ── Semantic Search ────────────────────────────────────────────────────────────
+function semanticSearchCmd(query) {
+  if (!query) {
+    console.log(chalk.red('\n  ❌ Arama sorgusu gerekli\n'));
+    return;
+  }
+  const results = semanticSearchMemory(query, 10);
+  console.log(chalk.cyan.bold(`\n  Semantic: "${query}" → ${results.length} sonuç\n`));
+  if (results.length === 0) {
+    console.log(chalk.gray('  Sonuç bulunamadı.\n'));
+    return;
+  }
+  results.forEach((r, i) => {
+    const pct = Math.round(r.score * 100);
+    const bar = chalk.green('█'.repeat(Math.floor(pct / 10))) + chalk.gray('░'.repeat(10 - Math.floor(pct / 10)));
+    console.log(`  ${chalk.white(`${i + 1}.`)} ${bar} ${chalk.white(r.value.slice(0, 70))}`);
+    console.log(chalk.gray(`     [${r.bot}]  alaka: %${pct}`));
+  });
+  console.log('');
+}
+
+// ── Wiki Commands ──────────────────────────────────────────────────────────────
+function wikiCmd(action, params) {
+  if (!action || action === 'list') return wikiListCmd();
+  if (action === 'show') {
+    const slug = params?.[0];
+    if (!slug) { console.log(chalk.red('\n  ❌ Sayfa adı gerekli\n')); return; }
+    const page = getWikiPage(slug);
+    if (!page) { console.log(chalk.yellow(`\n  ⚠ Sayfa bulunamadı: ${slug}\n`)); return; }
+    console.log(chalk.cyan.bold(`\n  Wiki: ${page.slug}\n`));
+    console.log(chalk.white(page.content));
+    console.log(chalk.gray(`\n  Son güncelleme: ${page.updatedAt}\n`));
+    return;
+  }
+  if (action === 'create' || action === 'edit') {
+    const slug = params?.[0];
+    const content = params?.slice(1).join(' ');
+    if (!slug || !content) {
+      console.log(chalk.red('\n  ❌ Kullanım: natureco memory wiki create <slug> <içerik>\n'));
+      return;
+    }
+    saveWikiPage(slug, content);
+    console.log(chalk.green(`\n  ✓ Wiki sayfası kaydedildi: ${slug}\n`));
+    return;
+  }
+  if (action === 'search') {
+    const query = params?.join(' ');
+    if (!query) { console.log(chalk.red('\n  ❌ Arama sorgusu gerekli\n')); return; }
+    const results = searchWikiPages(query);
+    console.log(chalk.cyan.bold(`\n  Wiki: "${query}" → ${results.length} sonuç\n`));
+    if (results.length === 0) { console.log(chalk.gray('  Sonuç bulunamadı.\n')); return; }
+    results.forEach(p => {
+      console.log(`  ${chalk.white(p.slug)} ${chalk.gray('—')} ${chalk.gray((p.content || '').slice(0, 60))}`);
+    });
+    console.log('');
+    return;
+  }
+  console.log(chalk.red(`\n  ❌ Bilinmeyen wiki aksiyonu: ${action}\n`));
+}
+
+function wikiCreateCmd(slug, content) {
+  if (!slug || !content) {
+    console.log(chalk.red('\n  ❌ Kullanım: natureco memory wiki-create <slug> <içerik>\n'));
+    return;
+  }
+  saveWikiPage(slug, content);
+  console.log(chalk.green(`\n  ✓ Wiki sayfası oluşturuldu: ${slug}\n`));
+}
+
+function wikiListCmd() {
+  const pages = listWikiPages();
+  console.log(chalk.cyan.bold(`\n  Wiki Sayfaları (${pages.length})\n`));
+  if (pages.length === 0) {
+    console.log(chalk.gray('  Henüz sayfa yok.\n'));
+    console.log(chalk.gray('  Oluşturmak: ') + chalk.cyan('natureco memory wiki create <slug> <içerik>\n'));
+    return;
+  }
+  pages.forEach(p => {
+    const preview = (p.content || '').slice(0, 60).replace(/\n/g, ' ');
+    console.log(`  ${chalk.white(p.slug)} ${chalk.gray('—')} ${chalk.gray(preview)}`);
+    console.log(chalk.gray(`    ${p.updatedAt}\n`));
+  });
+}
+
+function wikiSearchCmd(query) {
+  if (!query) { console.log(chalk.red('\n  ❌ Arama sorgusu gerekli\n')); return; }
+  const results = searchWikiPages(query);
+  console.log(chalk.cyan.bold(`\n  Wiki Ara: "${query}" → ${results.length} sonuç\n`));
+  if (results.length === 0) { console.log(chalk.gray('  Sonuç bulunamadı.\n')); return; }
+  results.forEach(p => {
+    console.log(`  ${chalk.white(p.slug)}`);
+    console.log(chalk.gray(`    ${(p.content || '').slice(0, 80)}\n`));
+  });
+}
+
 module.exports = memoryCmd;

package/src/commands/message.js

@@ -3,6 +3,7 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { getConfig } = require('../utils/config');
+const { ApiError } = require('../utils/errors');
 
 const PID_FILE = path.join(os.homedir(), '.natureco', 'gateway.pid');
 const GATEWAY_HTTP_URL = 'http://127.0.0.1:3847/send';
@@ -32,8 +33,8 @@ async function message(args) {
     process.exit(1);
   }
   
-  if (!['whatsapp', 'telegram'].includes(channel)) {
-    console.log(chalk.red('\n❌ Geçersiz kanal. Sadece "whatsapp" veya "telegram" kullanılabilir\n'));
+  if (!['whatsapp', 'telegram', 'signal', 'irc', 'sms', 'mattermost'].includes(channel)) {
+    console.log(chalk.red('\n❌ Geçersiz kanal. Kullanılabilir: whatsapp, telegram, signal, irc, sms, mattermost\n'));
     process.exit(1);
   }
   
@@ -68,12 +69,37 @@ async function message(args) {
     process.exit(1);
   }
   
+  if (channel === 'signal' && !config.signalBotId) {
+    console.log(chalk.red('\n❌ Signal bağlı değil\n'));
+    console.log(chalk.yellow('Önce Signal\'ı bağlayın:'), chalk.cyan('natureco signal connect\n'));
+    process.exit(1);
+  }
+  
+  if (channel === 'irc' && !config.ircBotId) {
+    console.log(chalk.red('\n❌ IRC bağlı değil\n'));
+    console.log(chalk.yellow('Önce IRC\'yi bağlayın:'), chalk.cyan('natureco irc connect\n'));
+    process.exit(1);
+  }
+  
+  if (channel === 'sms' && !config.smsBotId) {
+    console.log(chalk.red('\n❌ SMS bağlı değil\n'));
+    console.log(chalk.yellow('Önce SMS\'i bağlayın:'), chalk.cyan('natureco sms connect\n'));
+    process.exit(1);
+  }
+  
+  if (channel === 'mattermost' && (!config.mattermostBotId || !config.mattermostToken)) {
+    console.log(chalk.red('\n❌ Mattermost bağlı değil\n'));
+    console.log(chalk.yellow('Önce Mattermost\'u bağlayın:'), chalk.cyan('natureco mattermost connect\n'));
+    process.exit(1);
+  }
+  
   // Send message via HTTP endpoint
   await sendMessageViaHttp(channel, target, messageText);
 }
 
 async function sendMessageViaHttp(channel, target, messageText) {
-  console.log(chalk.yellow(`\n⏳ ${channel === 'whatsapp' ? 'WhatsApp' : 'Telegram'} mesajı gönderiliyor...\n`));
+  const channelNames = { whatsapp: 'WhatsApp', telegram: 'Telegram', signal: 'Signal', irc: 'IRC', sms: 'SMS', mattermost: 'Mattermost' };
+  console.log(chalk.yellow(`\n⏳ ${channelNames[channel] || channel} mesajı gönderiliyor...\n`));
   
   try {
     const response = await fetch(GATEWAY_HTTP_URL, {
@@ -85,7 +111,7 @@ async function sendMessageViaHttp(channel, target, messageText) {
     const data = await response.json();
     
     if (!response.ok) {
-      throw new Error(data.error || `HTTP ${response.status}`);
+      throw new ApiError(data.error || `HTTP ${response.status}`, response.status);
     }
     
     console.log(chalk.green('✅ Mesaj gönderildi!\n'));

package/src/commands/migrate.js

@@ -35,9 +35,17 @@ function addUniqueFact(facts, newFact) {
 async function migrate(options) {
   const from = options.from || 'openclaw';
   
+  if (from === 'claude-code' || from === 'claude') {
+    return migrateClaudeCode();
+  }
+  if (from === 'hermes') {
+    return migrateHermes();
+  }
   if (from !== 'openclaw') {
-    console.log(chalk.red('\n❌ Sadece OpenClaw migration destekleniyor.\n'));
-    console.log(chalk.gray('Kullanım: natureco migrate --from openclaw\n'));
+    console.log(chalk.red('\n❌ Desteklenen kaynaklar: openclaw, claude-code, hermes\n'));
+    console.log(chalk.gray('Kullanım: natureco migrate --from openclaw'));
+    console.log(chalk.gray('         natureco migrate --from claude-code'));
+    console.log(chalk.gray('         natureco migrate --from hermes\n'));
     return;
   }
   
@@ -623,4 +631,207 @@ function copyDirRecursive(src, dest) {
   }
 }
 
+// ── Claude Code Migration ──────────────────────────────────────────────────────
+async function migrateClaudeCode() {
+  console.log(chalk.yellow('\n⏳ Claude Code → NatureCo migration başlıyor...\n'));
+
+  const claudeDir = path.join(os.homedir(), '.claude');
+  const claudeSettings = path.join(claudeDir, 'settings.json');
+  const claudeProjects = path.join(os.homedir(), '.claude', 'projects');
+
+  if (!fs.existsSync(claudeSettings)) {
+    console.log(chalk.yellow('⚠ Claude Code settings bulunamadı: ~/.claude/settings.json\n'));
+  } else {
+    try {
+      const settings = JSON.parse(fs.readFileSync(claudeSettings, 'utf-8'));
+      console.log(chalk.gray('  Claude Code ayarları bulundu.\n'));
+
+      // Migrate allowed tools
+      if (settings.allowList?.length > 0) {
+        const config = getConfig();
+        if (!config.policies) config.policies = {};
+        config.policies.claudeAllowedTools = settings.allowList;
+        setConfigValue('policies', config.policies);
+        console.log(chalk.green(`  ✅ ${settings.allowList.length} izinli araç migrate edildi`));
+      }
+
+      // Migrate permissions
+      if (settings.permissions) {
+        const config = getConfig();
+        config.claudePermissions = settings.permissions;
+        setConfigValue('claudePermissions', settings.permissions);
+        console.log(chalk.green('  ✅ Claude izinleri migrate edildi'));
+      }
+    } catch (err) {
+      console.log(chalk.red(`  ❌ Claude settings okuma hatası: ${err.message}`));
+    }
+  }
+
+  // Migrate Claude projects
+  if (fs.existsSync(claudeProjects)) {
+    try {
+      const projects = fs.readdirSync(claudeProjects).filter(f => {
+        const p = path.join(claudeProjects, f);
+        return fs.statSync(p).isDirectory() && !f.startsWith('.');
+      });
+
+      if (projects.length > 0) {
+        console.log(chalk.gray(`\n  Claude projeleri bulundu: ${projects.length}\n`));
+        const projectsDir = path.join(os.homedir(), '.natureco', 'claude-projects');
+        fs.mkdirSync(projectsDir, { recursive: true });
+
+        for (const project of projects) {
+          const src = path.join(claudeProjects, project);
+          const dst = path.join(projectsDir, project);
+          if (!fs.existsSync(dst)) {
+            fs.cpSync(src, dst, { recursive: true });
+            console.log(chalk.green(`  ✅ Proje kopyalandı: ${project}`));
+          } else {
+            console.log(chalk.yellow(`  ⚠ Proje zaten var, atlandı: ${project}`));
+          }
+        }
+      }
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Proje migrasyonu atlandı: ${err.message}`));
+    }
+  }
+
+  // Migrate MEMORY.md if exists
+  const memoryFile = path.join(claudeDir, '..', 'workspace', 'MEMORY.md');
+  if (fs.existsSync(memoryFile)) {
+    try {
+      const content = fs.readFileSync(memoryFile, 'utf-8');
+      const memory = {
+        name: '',
+        nickname: '',
+        botName: '',
+        facts: [{ value: 'Migrated from Claude Code', score: 5, updatedAt: new Date().toISOString() }],
+        preferences: []
+      };
+
+      const lines = content.split('\n');
+      for (const line of lines) {
+        if (line.toLowerCase().includes('name:')) {
+          memory.name = line.split(':')[1]?.trim() || '';
+        }
+        if (line.toLowerCase().includes('preference:') || line.toLowerCase().includes('favorite:')) {
+          memory.preferences.push({ value: line.split(':')[1]?.trim() || '', score: 5, updatedAt: new Date().toISOString() });
+        }
+      }
+
+      const memoryDir = path.join(os.homedir(), '.natureco', 'memory');
+      fs.mkdirSync(memoryDir, { recursive: true });
+      fs.writeFileSync(path.join(memoryDir, 'universal-provider.json'), JSON.stringify(memory, null, 2));
+      console.log(chalk.green('  ✅ Claude MEMORY.md migrate edildi'));
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Memory migrasyonu atlandı: ${err.message}`));
+    }
+  }
+
+  console.log(chalk.green('\n✅ Claude Code migration tamamlandı!\n'));
+}
+
+// ── Hermes Migration ──────────────────────────────────────────────────────────
+async function migrateHermes() {
+  console.log(chalk.yellow('\n⏳ Hermes → NatureCo migration başlıyor...\n'));
+
+  const hermesDir = path.join(os.homedir(), '.hermes');
+  const hermesConfig = path.join(hermesDir, 'config.json');
+  const hermesSessions = path.join(hermesDir, 'sessions');
+
+  if (!fs.existsSync(hermesDir)) {
+    console.log(chalk.yellow('⚠ Hermes dizini bulunamadı: ~/.hermes\n'));
+    return;
+  }
+
+  let migrated = { config: false, sessions: 0, memory: false };
+
+  // Migrate config
+  if (fs.existsSync(hermesConfig)) {
+    try {
+      const config = JSON.parse(fs.readFileSync(hermesConfig, 'utf-8'));
+
+      const ncConfig = getConfig();
+      if (config.provider) ncConfig.providerUrl = config.provider;
+      if (config.model) ncConfig.providerModel = config.model;
+      if (config.apiKey) ncConfig.providerApiKey = config.apiKey;
+      if (config.systemPrompt) ncConfig.systemPrompt = config.systemPrompt;
+      if (config.temperature !== undefined) ncConfig.temperature = config.temperature;
+
+      setConfigValue('providerUrl', ncConfig.providerUrl);
+      setConfigValue('providerModel', ncConfig.providerModel);
+      if (config.apiKey) setConfigValue('providerApiKey', ncConfig.providerApiKey);
+      if (config.systemPrompt) setConfigValue('systemPrompt', ncConfig.systemPrompt);
+      if (config.temperature !== undefined) setConfigValue('temperature', ncConfig.temperature);
+
+      migrated.config = true;
+      console.log(chalk.green('  ✅ Hermes config migrate edildi'));
+    } catch (err) {
+      console.log(chalk.red(`  ❌ Config okuma hatası: ${err.message}`));
+    }
+  }
+
+  // Migrate sessions
+  if (fs.existsSync(hermesSessions)) {
+    try {
+      const sessions = fs.readdirSync(hermesSessions).filter(f => f.endsWith('.json'));
+      const ncSessionsDir = path.join(os.homedir(), '.natureco', 'sessions');
+      fs.mkdirSync(ncSessionsDir, { recursive: true });
+
+      for (const session of sessions) {
+        const src = path.join(hermesSessions, session);
+        const dst = path.join(ncSessionsDir, `hermes-${session}`);
+        if (!fs.existsSync(dst)) {
+          fs.copyFileSync(src, dst);
+          migrated.sessions++;
+        }
+      }
+
+      if (migrated.sessions > 0) {
+        console.log(chalk.green(`  ✅ ${migrated.sessions} Hermes oturumu migrate edildi`));
+      }
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Session migrasyonu atlandı: ${err.message}`));
+    }
+  }
+
+  // Migrate memory
+  const hermesMemory = path.join(hermesDir, 'memory.json');
+  if (fs.existsSync(hermesMemory)) {
+    try {
+      const memData = JSON.parse(fs.readFileSync(hermesMemory, 'utf-8'));
+      const ncMemoryDir = path.join(os.homedir(), '.natureco', 'memory');
+      fs.mkdirSync(ncMemoryDir, { recursive: true });
+
+      const ncMem = {
+        name: memData.userName || '',
+        nickname: '',
+        botName: 'Hermes',
+        facts: [],
+        preferences: []
+      };
+
+      if (memData.userInfo) {
+        ncMem.facts.push({ value: memData.userInfo, score: 6, updatedAt: new Date().toISOString() });
+      }
+      if (memData.context) {
+        ncMem.facts.push({ value: memData.context, score: 5, updatedAt: new Date().toISOString() });
+      }
+
+      fs.writeFileSync(path.join(ncMemoryDir, 'hermes-migrated.json'), JSON.stringify(ncMem, null, 2));
+      migrated.memory = true;
+      console.log(chalk.green('  ✅ Hermes hafızası migrate edildi'));
+    } catch (err) {
+      console.log(chalk.yellow(`  ⚠ Memory migrasyonu atlandı: ${err.message}`));
+    }
+  }
+
+  if (!migrated.config && migrated.sessions === 0 && !migrated.memory) {
+    console.log(chalk.yellow('  ⚠ Hiçbir veri migrate edilemedi.\n'));
+    return;
+  }
+
+  console.log(chalk.green('\n✅ Hermes migration tamamlandı!\n'));
+}
+
 module.exports = migrate;