natureco-cli 2.23.30 → 2.23.32

package/src/commands/config.js

@@ -1,26 +1,41 @@
 const chalk = require('chalk');
+const F = require('../utils/format');
 const path = require('path');
-const { getConfig, setConfigValue, getAllConfig, listBackups, restoreConfig, CONFIG_BACKUP_DIR } = require('../utils/config');
+const fs = require('fs');
+const { getConfig, setConfigValue, getAllConfig, listBackups, restoreConfig, saveConfig, CONFIG_FILE, CONFIG_BACKUP_DIR } = require('../utils/config');
+const TB = require('../utils/token-budget');
 
 function config(args) {
   const [action, key, ...valueParts] = args;
 
   if (!action) {
-    console.log(chalk.red('\n❌ Kullanım: natureco config <get|set|list|backups|restore> [key] [value]\n'));
+    F.error('Kullanım: natureco config <get|set|unset|list|file|schema|validate|backups|restore> [key] [value]');
     process.exit(1);
   }
 
+  const SENSITIVE_KEYS = ['apiKey', 'providerApiKey', 'providerApiKey1', 'providerApiKey2', 'secret', 'token', 'password', 'webhookSecret'];
+
+  function maskSensitive(key, value) {
+    if (typeof value !== 'string' || value.length < 8) return value;
+    const lower = key.toLowerCase();
+    if (!SENSITIVE_KEYS.some(sk => lower.includes(sk.toLowerCase()))) return value;
+    return value.slice(0, 4) + '*'.repeat(Math.min(value.length - 8, 16)) + value.slice(-4);
+  }
+
   if (action === 'list') {
     const cfg = getAllConfig();
-    console.log(chalk.green.bold('\n╭─ Config ─╮\n'));
-    console.log(JSON.stringify(cfg, null, 2));
-    console.log('');
+    F.header('Configuration');
+    const rows = Object.entries(cfg).map(([k, v]) => [
+      k,
+      maskSensitive(k, typeof v === 'string' ? v : JSON.stringify(v)),
+    ]);
+    F.table(['Key', 'Value'], rows);
     return;
   }
 
   if (action === 'get') {
     if (!key) {
-      console.log(chalk.red('\n❌ Key belirtilmedi.\n'));
+      F.error('Key belirtilmedi.');
       process.exit(1);
     }
     const cfg = getConfig();
@@ -30,21 +45,20 @@ function config(args) {
       value = value?.[k];
     }
     if (value === undefined) {
-      console.log(chalk.gray(`\n${key}: (tanımlı değil)\n`));
+      F.info(`${key}: (tanımlı değil)`);
     } else {
-      console.log(chalk.cyan(`\n${key}:`), chalk.white(JSON.stringify(value, null, 2)));
-      console.log('');
+      F.kv(key, maskSensitive(key, JSON.stringify(value, null, 2)));
     }
     return;
   }
 
   if (action === 'set') {
     if (!key) {
-      console.log(chalk.red('\n❌ Key belirtilmedi.\n'));
+      F.error('Key belirtilmedi.');
       process.exit(1);
     }
     if (valueParts.length === 0) {
-      console.log(chalk.red('\n❌ Value belirtilmedi.\n'));
+      F.error('Value belirtilmedi.');
       process.exit(1);
     }
     const value = valueParts.join(' ');
@@ -55,24 +69,121 @@ function config(args) {
     } catch {}
 
     setConfigValue(key, parsedValue);
-    console.log(chalk.green(`\n✅ ${key} = ${JSON.stringify(parsedValue)}\n`));
+    F.success(`${key} = ${JSON.stringify(parsedValue)}`);
+    return;
+  }
+
+  if (action === 'unset') {
+    if (!key) {
+      F.error('Key belirtilmedi.');
+      process.exit(1);
+    }
+    const cfg = getConfig();
+    const keys = key.split('.');
+    let obj = cfg;
+    for (let i = 0; i < keys.length - 1; i++) {
+      obj = obj?.[keys[i]];
+    }
+    if (obj && keys[keys.length - 1] in obj) {
+      delete obj[keys[keys.length - 1]];
+    }
+    saveConfig(cfg);
+    F.success(`Unset: ${key}`);
+    return;
+  }
+
+  if (action === 'file') {
+    const configPath = CONFIG_FILE;
+    const exists = fs.existsSync(configPath);
+    F.header('Config File');
+    F.kv('Path', configPath);
+    if (exists) {
+      const stats = fs.statSync(configPath);
+      const sizeKB = (stats.size / 1024).toFixed(2);
+      F.kv('Size', `${sizeKB} KB`);
+      F.kv('Last Modified', String(stats.mtime));
+      const content = fs.readFileSync(configPath, 'utf8');
+      try {
+        const parsed = JSON.parse(content);
+        const keys = Object.keys(parsed);
+        F.kv('Keys', keys.length ? keys.join(', ') : '(empty)');
+      } catch {
+        F.error('(invalid JSON)');
+      }
+    } else {
+      F.warning('(file does not exist)');
+    }
+    return;
+  }
+
+  if (action === 'schema') {
+    F.section('Config Schema');
+    const schema = {
+      apiKey: { type: 'string', description: 'API key for the provider', required: true },
+      providerUrl: { type: 'string', description: 'Base URL of the provider API', required: true },
+      providerModel: { type: 'string', description: 'Default model identifier', required: false, default: 'gpt-4' },
+      temperature: { type: 'number', description: 'Sampling temperature (0-2)', required: false, default: 0.7 },
+      maxTokens: { type: 'number', description: 'Maximum tokens per response', required: false, default: 2048 },
+      systemPrompt: { type: 'string', description: 'Custom system prompt', required: false },
+      proxy: { type: 'object', description: 'Proxy configuration', required: false, properties: { host: { type: 'string' }, port: { type: 'number' } } },
+      timeout: { type: 'number', description: 'Request timeout in milliseconds', required: false, default: 30000 },
+      organization: { type: 'string', description: 'Organization ID for multi-tenant setups', required: false },
+    };
+    const rows = Object.entries(schema).map(([k, v]) => [
+      v.required ? `${k}*` : k,
+      v.type,
+      v.description,
+      v.default !== undefined ? JSON.stringify(v.default) : '—',
+    ]);
+    F.table(['Field', 'Type', 'Description', 'Default'], rows);
+    F.meta('* = required');
+    return;
+  }
+
+  if (action === 'validate') {
+    const cfg = getConfig();
+    F.section('Config Validation');
+    const checks = [
+      { field: 'apiKey', label: 'API Key', required: true },
+      { field: 'providerUrl', label: 'Provider URL', required: true },
+      { field: 'providerModel', label: 'Provider Model', required: false },
+    ];
+    let allPass = true;
+    for (const check of checks) {
+      const value = cfg[check.field];
+      if (check.required && (!value || typeof value !== 'string')) {
+        F.error(`${check.label}: FAIL (required)`);
+        allPass = false;
+      } else if (value && typeof value !== 'string') {
+        F.warning(`${check.label}: WARN (expected string, got ${typeof value})`);
+      } else if (value) {
+        F.success(`${check.label}: PASS`);
+      } else {
+        F.info(`${check.label}: not set`);
+      }
+    }
+    if (allPass) {
+      F.success('All required fields are set.');
+    } else {
+      F.error('Some required fields are missing.');
+    }
     return;
   }
 
   if (action === 'backups' || action === 'backup') {
     const backups = listBackups();
-    console.log(chalk.cyan.bold('\n  Config Yedekleri\n'));
+    F.section('Config Yedekleri');
     if (backups.length === 0) {
-      console.log(chalk.gray('  Henüz yedek alınmamış.\n'));
+      F.info('Hen\u00fcz yedek al\u0131nmam\u0131\u015f.');
       return;
     }
-    backups.forEach((f, i) => {
+    const rows = backups.map((f, i) => {
       const ts = f.replace(/^config-|\.json$/g, '').replace(/T/, ' ').replace(/-/g, ':').replace(/:[^:]*$/, '');
-      console.log(chalk.white(`  ${i + 1}. ${ts}`));
-      console.log(chalk.gray(`     ${path.join(CONFIG_BACKUP_DIR, f)}`));
+      return [String(i + 1), ts, path.join(CONFIG_BACKUP_DIR, f)];
     });
-    console.log(chalk.gray(`\n  Geri yüklemek için: natureco config restore <dosya-adı>`));
-    console.log(chalk.gray(`  Örnek: natureco config restore ${backups[0] || 'config-....json'}\n`));
+    F.table(['#', 'Tarih', 'Dosya'], rows);
+    F.meta('Geri y\u00fcklemek i\u00e7in: natureco config restore <dosya-ad\u0131>');
+    F.meta(`\u00d6rnek: natureco config restore ${backups[0] || 'config-....json'}`);
     return;
   }
 
@@ -81,31 +192,118 @@ function config(args) {
     if (!backupId) {
       const backups = listBackups();
       if (backups.length === 0) {
-        console.log(chalk.red('\n❌ Geri yüklenecek yedek bulunamadı.\n'));
+        F.error('Geri y\u00fcklenecek yedek bulunamad\u0131.');
         process.exit(1);
       }
-      console.log(chalk.cyan.bold('\n  Geri Yükleme\n'));
-      console.log(chalk.gray('  En son yedek: ') + chalk.white(backups[0]));
-      console.log('');
-      console.log(chalk.gray('  Kullanım: ') + chalk.cyan(`natureco config restore ${backups[0]}`));
-      console.log(chalk.gray('  Yedekleri listelemek için: ') + chalk.cyan('natureco config backups\n'));
+      F.section('Geri Y\u00fckleme');
+      F.kv('En son yedek', backups[0]);
+      F.meta(`Kullan\u0131m: natureco config restore ${backups[0]}`);
+      F.meta('Yedekleri listelemek i\u00e7in: natureco config backups');
       return;
     }
 
     try {
       const result = restoreConfig(backupId);
-      console.log(chalk.green(`\n✅ Config geri yüklendi: ${result.timestamp}\n`));
-      console.log(chalk.gray(`  Kaynak: ${result.path}\n`));
+      F.success(`Config geri y\u00fcklendi: ${result.timestamp}`);
+      F.meta(`Kaynak: ${result.path}`);
     } catch (err) {
-      console.log(chalk.red(`\n❌ Geri yükleme başarısız: ${err.message}\n`));
+      F.error(`Geri y\u00fckleme ba\u015far\u0131s\u0131z: ${err.message}`);
       process.exit(1);
     }
     return;
   }
 
-  console.log(chalk.red(`\n❌ Geçersiz action: ${action}\n`));
-  console.log(chalk.gray('  Kullanım: natureco config <get|set|list|backups|restore> [key] [value]\n'));
+  if (action === 'budget') {
+    return configBudget(key, valueParts);
+  }
+
+  F.error(`Ge\u00e7ersiz action: ${action}`);
+  F.meta('Kullan\u0131m: natureco config <get|set|unset|list|file|schema|validate|backups|restore|budget> [key] [value]');
   process.exit(1);
 }
 
+function configBudget(sub, args) {
+  if (!sub || sub === 'show') {
+    const b = TB.load();
+    F.header('Token Budget');
+    F.kv('Preset', b.preset || 'balanced');
+    F.kv('Max Context Tokens', String(b.maxContextTokens));
+    F.kv('Preserve Recent Tokens', String(b.preserveRecentTokens));
+    F.kv('Tail Turns', String(b.tailTurns));
+    F.divider();
+    F.section('Output Limits');
+    F.kv('Tool Max Lines', String(b.toolMaxLines));
+    F.kv('Tool Max Chars', String(b.toolMaxChars));
+    F.kv('MCP Desc Max Chars', String(b.mcpDescMaxChars));
+    F.divider();
+    F.section('Content Truncation');
+    F.kv('System Prompt Max', String(b.systemPromptMaxChars));
+    F.kv('Memory Max Facts', String(b.memoryMaxFacts));
+    F.kv('Project Memory Max', String(b.projectMemoryMaxChars));
+    F.kv('File Content Max', String(b.fileContentMaxChars));
+    F.divider();
+    F.section('Conversation');
+    F.kv('Messages on Disk', String(b.conversationOnDisk));
+    F.kv('Messages in Context', String(b.conversationInContext));
+    F.kv('Auto Compact', String(b.autoCompact));
+    F.kv('Reserved Tokens', String(b.reservedTokens));
+    F.meta('');
+    F.meta('Switch preset: natureco config budget preset <efficient|balanced|quality>');
+    F.meta('Set a value:   natureco config budget set <key> <value>');
+    return;
+  }
+
+  if (sub === 'preset') {
+    const name = args[0];
+    if (!name || !['efficient', 'balanced', 'quality'].includes(name)) {
+      F.error('Preset: efficient, balanced, quality');
+      F.table(['Preset', 'Description', 'Context'], TB.getPresets().map(p => [p.key, p.label, String(p.maxContextTokens)]));
+      return;
+    }
+    TB.setPreset(name);
+    F.success('Token budget preset: ' + name);
+    return;
+  }
+
+  if (sub === 'set') {
+    const key = args[0];
+    const val = args[1];
+    if (!key || val === undefined) {
+      F.error('Kullan\u0131m: natureco config budget set <key> <value>');
+      return;
+    }
+    const budget = TB.load();
+    if (!(key in budget)) {
+      F.error('Bilinmeyen budget key: ' + key);
+      return;
+    }
+    const num = Number(val);
+    budget[key] = isNaN(num) ? val : num;
+    TB.save(budget);
+    F.success(key + ' = ' + budget[key]);
+    return;
+  }
+
+  if (sub === 'usage') {
+    const usage = TB.getAllUsage();
+    if (!usage || Object.keys(usage).length === 0) {
+      F.info('Hen\u00fcz token kullan\u0131m\u0131 kaydedilmedi.');
+      return;
+    }
+    F.header('Token Usage');
+    const rows = Object.entries(usage).map(([sid, u]) => [
+      sid.slice(0, 20),
+      String(u.total || 0),
+      String(u.input || 0),
+      String(u.output || 0),
+      String(u.count || 0)
+    ]);
+    F.table(['Session', 'Total', 'Input', 'Output', 'Calls'], rows);
+    return;
+  }
+
+  F.error('Budget alt komutu: ' + sub);
+  F.meta('Kullan\u0131m: natureco config budget <show|preset|set|usage>');
+}
+
 module.exports = config;

package/src/commands/configure.js

@@ -1,6 +1,23 @@
 const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 const readline = require('readline');
 
+const BASE_DIR = path.join(os.homedir(), '.natureco');
+const CONFIG_FILE = path.join(BASE_DIR, 'config.json');
+
+function getConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); }
+  catch { return {}; }
+}
+
+function saveConfig(data) {
+  if (!fs.existsSync(BASE_DIR)) fs.mkdirSync(BASE_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
 function rlQuestion(query) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise(resolve => {
@@ -8,86 +25,86 @@ function rlQuestion(query) {
   });
 }
 
-async function configure(args) {
-  console.log(chalk.cyan('\n  ⚙️  Interactive Configuration\n'));
-  console.log(chalk.gray('  Press Ctrl+C anytime to cancel.\n'));
+async function configure(params) {
+  try {
+    const [action] = params || [];
 
-  const { getConfig, saveConfig } = require('../utils/config');
-  const config = getConfig();
+    if (!action) return cmdMenu();
+    if (action === 'gateway') return await cmdGateway();
+    if (action === 'auth') return await cmdAuth();
+    if (action === 'channels') return cmdChannels();
+    if (action === 'plugins') return cmdPlugins();
+    if (action === 'skills') return cmdSkills();
 
-  console.log('  1) AI Provider & Model');
-  console.log('  2) Gateway Settings');
-  console.log('  3) Channels');
-  console.log('  4) Voice / TTS');
-  console.log('  5) API Keys');
-  console.log('  6) View Current Config');
-  console.log('  7) Cancel');
-  console.log();
+    console.log(chalk.red(`\n  Unknown configure action: ${action}\n`));
+    console.log(chalk.gray('  Usage: natureco configure [gateway|auth|channels|plugins|skills]\n'));
+  } catch (err) {
+    console.log(chalk.red(`\n  Configure error: ${err.message}\n`));
+  }
+}
 
-  const choice = await rlQuestion('  Select [1-7]: ');
+function cmdMenu() {
+  console.log(chalk.cyan('\n  Configure\n'));
+  console.log(chalk.gray('  Run with an action:'));
+  console.log(chalk.gray('    natureco configure gateway   Update gateway config'));
+  console.log(chalk.gray('    natureco configure auth      Update provider keys'));
+  console.log(chalk.gray('    natureco configure channels   Re-run channels setup'));
+  console.log(chalk.gray('    natureco configure plugins    Re-run plugin setup'));
+  console.log(chalk.gray('    natureco configure skills     Re-run skills setup\n'));
+}
 
-  if (choice === '7' || choice === '') {
-    console.log(chalk.gray('\n  Cancelled.\n'));
-    return;
-  }
+async function cmdGateway() {
+  const cfg = getConfig();
+  console.log(chalk.cyan('\n  Gateway Configuration\n'));
+  console.log(chalk.gray('  Current: ') + chalk.white(cfg.gatewayUrl || 'not set'));
 
-  if (choice === '6') {
-    console.log(chalk.cyan('\n' + JSON.stringify(config, null, 2) + '\n'));
-    return;
-  }
+  const url = await rlQuestion(`  Gateway URL (${cfg.gatewayUrl || 'ws://localhost:3848'}): `);
+  const port = await rlQuestion(`  Port (${cfg.gatewayPort || 3848}): `);
 
-  if (choice === '1') {
-    const provider = await rlQuestion(`  Provider (${config.provider || 'openai'}): `);
-    const model = await rlQuestion(`  Model (${config.model || 'gpt-4o'}): `);
-    config.provider = provider || config.provider || 'openai';
-    config.model = model || config.model || 'gpt-4o';
-    saveConfig(config);
-    console.log(chalk.green(`\n  ✅ Provider: ${config.provider}, Model: ${config.model}\n`));
-    return;
-  }
+  cfg.gatewayUrl = url || cfg.gatewayUrl || 'ws://localhost:3848';
+  cfg.gatewayPort = parseInt(port) || cfg.gatewayPort || 3848;
+  saveConfig(cfg);
 
-  if (choice === '2') {
-    const url = await rlQuestion(`  Gateway URL (${config.gatewayUrl || 'ws://localhost:3848'}): `);
-    const port = await rlQuestion(`  Gateway port (${config.gatewayPort || 3848}): `);
-    config.gatewayUrl = url || config.gatewayUrl || 'ws://localhost:3848';
-    config.gatewayPort = parseInt(port) || config.gatewayPort || 3848;
-    saveConfig(config);
-    console.log(chalk.green(`\n  ✅ Gateway: ${config.gatewayUrl}\n`));
-    return;
-  }
+  console.log(chalk.green(`\n  Gateway updated: ${cfg.gatewayUrl}:${cfg.gatewayPort}\n`));
+}
 
-  if (choice === '3') {
-    console.log(chalk.gray('\n  Configure channels using:'));
-    console.log(chalk.cyan('    natureco channels add'));
-    console.log(chalk.cyan('    natureco telegram connect'));
-    console.log(chalk.cyan('    natureco whatsapp connect\n'));
-    return;
-  }
+async function cmdAuth() {
+  const cfg = getConfig();
+  console.log(chalk.cyan('\n  Auth Configuration\n'));
+  console.log(chalk.gray('  Current provider key: ') + chalk.white(cfg.providerApiKey ? '(set)' : '(not set)'));
 
-  if (choice === '4') {
-    const tts = await rlQuestion(`  TTS Provider (${config.tts?.provider || 'openai'}): `);
-    const voiceId = await rlQuestion(`  Voice ID (${config.tts?.voiceId || '(none)'}): `);
-    if (!config.tts) config.tts = {};
-    config.tts.provider = tts || config.tts.provider || 'openai';
-    if (voiceId) config.tts.voiceId = voiceId;
-    saveConfig(config);
-    console.log(chalk.green(`\n  ✅ Voice: ${config.tts.provider}\n`));
-    return;
+  const key = await rlQuestion('  Provider API Key (leave blank to keep current): ');
+  if (key) {
+    cfg.providerApiKey = key;
+    saveConfig(cfg);
+    console.log(chalk.green('\n  API key updated.\n'));
+  } else {
+    console.log(chalk.gray('\n  No changes made.\n'));
   }
+}
 
-  if (choice === '5') {
-    const openai = await rlQuestion(`  OpenAI API Key (${config.openaiApiKey ? '(set)' : '(none)'}): `);
-    const anthropic = await rlQuestion(`  Anthropic API Key (${config.anthropicApiKey ? '(set)' : '(none)'}): `);
-    const tavily = await rlQuestion(`  Tavily Search Key (${config.tavilyApiKey ? '(set)' : '(none)'}): `);
-    if (openai) config.openaiApiKey = openai;
-    if (anthropic) config.anthropicApiKey = anthropic;
-    if (tavily) config.tavilyApiKey = tavily;
-    saveConfig(config);
-    console.log(chalk.green('\n  ✅ API Keys saved\n'));
-    return;
+function cmdChannels() {
+  console.log(chalk.cyan('\n  Channels Setup\n'));
+  console.log(chalk.gray('  To connect a channel:'));
+  const channels = ['telegram', 'whatsapp', 'discord', 'slack', 'signal', 'irc', 'mattermost', 'imessage'];
+  for (const ch of channels) {
+    console.log(chalk.gray('    natureco ' + ch + ' connect'));
   }
+  console.log('');
+}
+
+function cmdPlugins() {
+  console.log(chalk.cyan('\n  Plugin Setup\n'));
+  console.log(chalk.gray('  To manage plugins:'));
+  console.log(chalk.cyan('    natureco plugins list'));
+  console.log(chalk.cyan('    natureco plugins add <url>\n'));
+}
 
-  console.log(chalk.red('\n  ❌ Invalid choice\n'));
+function cmdSkills() {
+  console.log(chalk.cyan('\n  Skills Setup\n'));
+  console.log(chalk.gray('  To manage skills:'));
+  console.log(chalk.cyan('    natureco skills list'));
+  console.log(chalk.cyan('    natureco skills add <name>\n'));
 }
 
 module.exports = configure;