natureco-cli 2.23.29 → 2.23.31

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;

package/src/commands/models.js

@@ -116,9 +116,11 @@ async function models(args) {
   }
   if (action === 'aliases') return manageAliases(params);
   if (action === 'fallbacks') return manageFallbacks(params);
+  if (action === 'set-image') return setImageModel(params[0]);
+  if (action === 'image-fallbacks') return manageImageFallbacks(params);
 
   console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
-  console.log(chalk.gray('  Kullanım: natureco models [list|set|scan|aliases|fallbacks]\n'));
+  console.log(chalk.gray('  Kullanım: natureco models [list|set|scan|aliases|fallbacks|set-image|image-fallbacks]\n'));
   process.exit(1);
 }
 
@@ -469,6 +471,42 @@ function manageFallbacks(params) {
   console.log(chalk.gray('\n  Kullanım: natureco models fallbacks [list|set <model-id>|clear]\n'));
 }
 
+function setImageModel(modelId) {
+  if (!modelId) {
+    console.log(chalk.cyan('\n  Current image model: ') + chalk.white(getConfig().imageModel || 'not set'));
+    console.log(chalk.gray('\n  Usage: natureco models set-image <model-id>\n'));
+    return;
+  }
+  const config = getConfig();
+  config.imageModel = modelId;
+  saveConfig(config);
+  console.log(chalk.green(`\n  ✓ Image model set: ${modelId}\n`));
+}
+
+function manageImageFallbacks(params) {
+  const config = getConfig();
+  if (params.length === 0 || params[0] === 'list') {
+    console.log(chalk.cyan.bold('\n  Image Model Fallbacks\n'));
+    console.log(chalk.gray('  Primary    : ') + chalk.white(config.imageModel || 'not set'));
+    console.log(chalk.gray('  Fallback   : ') + chalk.white(config.imageFallbackModel || 'not set'));
+    console.log(chalk.gray('\n  Set: natureco models image-fallbacks set <model-id>'));
+    console.log(chalk.gray('  Clear: natureco models image-fallbacks clear\n'));
+    return;
+  }
+  if (params[0] === 'set' && params[1]) {
+    config.imageFallbackModel = params[1];
+    saveConfig(config);
+    console.log(chalk.green(`\n  ✓ Image fallback set: ${params[1]}\n`));
+    return;
+  }
+  if (params[0] === 'clear') {
+    delete config.imageFallbackModel;
+    saveConfig(config);
+    console.log(chalk.green('\n  ✓ Image fallback cleared\n'));
+    return;
+  }
+}
+
 function resolveModel(input) {
   const config = getConfig();
   const aliases = config.modelAliases || {};

package/src/commands/node.js

@@ -0,0 +1,98 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const NODES_FILE = path.join(os.homedir(), '.natureco', 'nodes.json');
+
+function loadNodes() {
+  if (!fs.existsSync(NODES_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(NODES_FILE, 'utf8')); }
+  catch { return {}; }
+}
+
+function saveNodes(nodes) {
+  const dir = path.dirname(NODES_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(NODES_FILE, JSON.stringify(nodes, null, 2), 'utf8');
+}
+
+function node(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'status') return cmdStatus(params[0]);
+  if (action === 'run') return cmdRun(params[0], params.slice(1));
+  if (action === 'install') return cmdInstall();
+  if (action === 'uninstall') return cmdUninstall(params[0]);
+  if (action === 'stop') return cmdStop(params[0]);
+  if (action === 'restart') return cmdRestart(params[0]);
+
+  console.log(chalk.red(`\n  Unknown node action: ${action}\n`));
+  console.log(chalk.gray('  Usage: natureco node <action> [params]'));
+  console.log(chalk.gray('  Actions: run <id>, status <id>, install, uninstall, stop <id>, restart <id>\n'));
+  process.exit(1);
+}
+
+function cmdRun(id) {
+  if (!id) { console.log(chalk.red('\n  Usage: natureco node run <id>\n')); process.exit(1); }
+  const nodes = loadNodes();
+  const n = nodes[id];
+  if (!n) { console.log(chalk.yellow(`\n  Node "${id}" not found.\n`)); return; }
+  console.log(chalk.cyan(`\n  Running command on node "${id}"...\n`));
+  console.log(chalk.gray('  (Stub — command execution not implemented)\n'));
+}
+
+function cmdStatus(id) {
+  if (!id) { console.log(chalk.red('\n  Usage: natureco node status <id>\n')); process.exit(1); }
+  const nodes = loadNodes();
+  const n = nodes[id];
+
+  console.log(chalk.cyan(`\n  Node: ${id || '(all)'}\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  if (!n) {
+    console.log(chalk.yellow(`  Node "${id}" not found.\n`));
+    return;
+  }
+
+  console.log(`  ${chalk.white('ID:')}       ${chalk.cyan(n.id || id)}`);
+  console.log(`  ${chalk.white('Host:')}     ${chalk.white(n.host || n.hostname || '—')}`);
+  console.log(`  ${chalk.white('Port:')}     ${chalk.white(n.port || '—')}`);
+  console.log(`  ${chalk.white('Status:')}   ${n.online ? chalk.green('online') : chalk.gray('offline')}`);
+  console.log(`  ${chalk.white('Version:')}  ${chalk.gray(n.version || '—')}`);
+  console.log('');
+}
+
+function cmdInstall() {
+  console.log(chalk.cyan('\n  Installing node software...\n'));
+  console.log(chalk.gray('  (Stub — installation not implemented)\n'));
+}
+
+function cmdUninstall(id) {
+  if (!id) { console.log(chalk.red('\n  Usage: natureco node uninstall <id>\n')); process.exit(1); }
+  const nodes = loadNodes();
+  if (!nodes[id]) { console.log(chalk.yellow(`\n  Node "${id}" not found.\n`)); return; }
+  delete nodes[id];
+  saveNodes(nodes);
+  console.log(chalk.gray(`\n  Node "${id}" uninstalled.\n`));
+}
+
+function cmdStop(id) {
+  if (!id) { console.log(chalk.red('\n  Usage: natureco node stop <id>\n')); process.exit(1); }
+  const nodes = loadNodes();
+  if (!nodes[id]) { console.log(chalk.yellow(`\n  Node "${id}" not found.\n`)); return; }
+  nodes[id].online = false;
+  saveNodes(nodes);
+  console.log(chalk.gray(`\n  Node "${id}" stopped.\n`));
+}
+
+function cmdRestart(id) {
+  if (!id) { console.log(chalk.red('\n  Usage: natureco node restart <id>\n')); process.exit(1); }
+  const nodes = loadNodes();
+  if (!nodes[id]) { console.log(chalk.yellow(`\n  Node "${id}" not found.\n`)); return; }
+  nodes[id].online = true;
+  saveNodes(nodes);
+  console.log(chalk.gray(`\n  Node "${id}" restarted.\n`));
+}
+
+module.exports = node;