natureco-cli 2.23.29 → 2.23.31

package/src/commands/config.js

@@ -1,26 +1,32 @@
 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);
   }
 
   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,
+      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 +36,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, 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 +60,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 +183,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

@@ -0,0 +1,110 @@
+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 => {
+    rl.question(query, answer => { rl.close(); resolve(answer.trim()); });
+  });
+}
+
+async function configure(params) {
+  try {
+    const [action] = params || [];
+
+    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(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`));
+  }
+}
+
+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'));
+}
+
+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'));
+
+  const url = await rlQuestion(`  Gateway URL (${cfg.gatewayUrl || 'ws://localhost:3848'}): `);
+  const port = await rlQuestion(`  Port (${cfg.gatewayPort || 3848}): `);
+
+  cfg.gatewayUrl = url || cfg.gatewayUrl || 'ws://localhost:3848';
+  cfg.gatewayPort = parseInt(port) || cfg.gatewayPort || 3848;
+  saveConfig(cfg);
+
+  console.log(chalk.green(`\n  Gateway updated: ${cfg.gatewayUrl}:${cfg.gatewayPort}\n`));
+}
+
+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)'));
+
+  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'));
+  }
+}
+
+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'));
+}
+
+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;

package/src/commands/crestodian.js

@@ -0,0 +1,92 @@
+const chalk = require('chalk');
+const { execSync } = require('child_process');
+
+async function crestodian(args) {
+  const fixMode = args.includes('--fix') || args.includes('-f');
+
+  console.log(chalk.cyan('\n  🛠️  Crestodian — Setup & Repair Assistant\n'));
+  console.log(chalk.gray('  Diagnosing your NatureCo installation...\n'));
+
+  const checks = [];
+
+  // Check Node version
+  const nodeMajor = parseInt(process.version.slice(1).split('.')[0]);
+  checks.push({
+    name: 'Node.js version',
+    ok: nodeMajor >= 18,
+    message: `Node ${process.version} (18+ required)`,
+    fix: 'Install Node.js 18+: https://nodejs.org'
+  });
+
+  // Check npm
+  try {
+    const npmVer = execSync('npm --version', { encoding: 'utf8' }).trim();
+    checks.push({ name: 'npm', ok: true, message: `npm ${npmVer}` });
+  } catch {
+    checks.push({ name: 'npm', ok: false, message: 'npm not found', fix: 'Install Node.js (includes npm)' });
+  }
+
+  // Check config
+  try {
+    const { getConfig } = require('../utils/config');
+    const config = getConfig();
+    checks.push({
+      name: 'Configuration',
+      ok: !!(config.openaiApiKey || config.anthropicApiKey || config.provider),
+      message: config.provider ? `Provider: ${config.provider}` : 'Not configured',
+      fix: 'Run: natureco configure'
+    });
+  } catch {
+    checks.push({ name: 'Configuration', ok: false, message: 'Config error', fix: 'Run: natureco setup' });
+  }
+
+  // Check git
+  try {
+    execSync('git --version', { stdio: 'pipe', encoding: 'utf8' });
+    checks.push({ name: 'Git', ok: true, message: 'Available' });
+  } catch {
+    checks.push({ name: 'Git', ok: false, message: 'Not found', fix: 'Install git: https://git-scm.com' });
+  }
+
+  // Check Playwright
+  try {
+    require.resolve('playwright');
+    checks.push({ name: 'Playwright', ok: true, message: 'Installed' });
+  } catch {
+    checks.push({ name: 'Playwright', ok: true, message: 'Optional (not installed)', optional: true });
+  }
+
+  // Print results
+  const failed = checks.filter(c => !c.ok);
+  for (const check of checks) {
+    const icon = check.ok ? chalk.green('✅') : check.optional ? chalk.gray('⬜') : chalk.red('❌');
+    console.log(`  ${icon} ${chalk.white(check.name)} ${chalk.gray('- ' + check.message)}`);
+  }
+
+  console.log(chalk.gray('\n  ' + '─'.repeat(48)));
+
+  if (failed.length === 0) {
+    console.log(chalk.green('\n  ✅ All checks passed!\n'));
+  } else {
+    console.log(chalk.yellow(`\n  ⚠️  ${failed.length} issue(s) found:\n`));
+    for (const f of failed) {
+      console.log(`  ${chalk.yellow('●')} ${f.name}: ${f.message}`);
+      if (fixMode && f.fix) {
+        console.log(`    ${chalk.gray('Fix:')} ${f.fix}`);
+      }
+    }
+
+    if (fixMode) {
+      console.log(chalk.gray('\n  Running fixes...\n'));
+      for (const f of failed) {
+        if (f.name === 'Configuration') {
+          console.log(chalk.gray('  Run: natureco onboard'));
+        }
+      }
+    }
+
+    console.log(chalk.gray('\n  To auto-fix: ') + chalk.cyan('natureco crestodian --fix\n'));
+  }
+}
+
+module.exports = crestodian;