natureco-cli 2.23.29 → 2.23.30

package/src/commands/capability.js

@@ -0,0 +1,64 @@
+const chalk = require('chalk');
+const { getConfig } = require('../utils/config');
+
+function capability(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'list') return listCapabilities();
+  if (action === 'infer' || action === 'check') return inferCapabilities(params[0]);
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco capability [list|infer]\n'));
+  process.exit(1);
+}
+
+function listCapabilities() {
+  const config = getConfig();
+  console.log(chalk.cyan('\n  🧠 Provider Capabilities\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  const capabilities = {
+    chat: ['openai', 'anthropic', 'groq', 'deepseek', 'xai'],
+    vision: ['openai', 'anthropic', 'groq'],
+    images: ['openai', 'fal', 'together'],
+    video: ['runway', 'deepinfra'],
+    music: ['suno', 'udio', 'elevenlabs'],
+    tts: ['openai', 'elevenlabs'],
+    stt: ['openai', 'deepgram'],
+    search: ['tavily', 'duckduckgo', 'exa', 'firecrawl', 'searxng'],
+    embedding: ['openai', 'anthropic']
+  };
+
+  for (const [cap, providers] of Object.entries(capabilities)) {
+    const enabled = providers.some(p => config[`${p}ApiKey`] || process.env[`${p.toUpperCase()}_API_KEY`]);
+    console.log(`  ${enabled ? chalk.green('●') : chalk.gray('○')} ${chalk.white(cap)}: ${providers.join(', ')}`);
+  }
+
+  console.log(chalk.gray('\n  Capabilities depend on configured API keys.\n'));
+}
+
+function inferCapabilities(provider) {
+  if (!provider) {
+    console.log(chalk.red('\n  ❌ Provider adı gerekli\n'));
+    process.exit(1);
+  }
+
+  const config = getConfig();
+  const apiKey = config[`${provider}ApiKey`] || process.env[`${provider.toUpperCase()}_API_KEY`];
+
+  console.log(chalk.cyan(`\n  🔍 Inferring capabilities for: ${provider}\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+
+  if (!apiKey) {
+    console.log(chalk.red(`  ❌ No API key for ${provider}\n`));
+    process.exit(1);
+  }
+
+  console.log(`  ${chalk.green('✅')} ${chalk.white('chat')}: ${chalk.gray('available')}`);
+  console.log(`  ${chalk.green('✅')} ${chalk.white('models')}: ${chalk.gray('queryable')}`);
+  console.log(`  ${chalk.gray('○')} ${chalk.white('vision')}: ${chalk.gray('checking...')}`);
+  console.log(`  ${chalk.gray('○')} ${chalk.white('embeddings')}: ${chalk.gray('checking...')}`);
+  console.log();
+}
+
+module.exports = capability;

package/src/commands/clickclack.js

@@ -0,0 +1,130 @@
+const chalk = require('chalk');
+const { getConfig, saveConfig } = require('../utils/config');
+const http = require('http');
+
+function beep() {
+  try {
+    process.stdout.write('\x07');
+  } catch {}
+}
+
+function speak(text) {
+  try {
+    const { execSync } = require('child_process');
+    const escaped = text.replace(/"/g, '\\"');
+    if (process.platform === 'darwin') execSync(`say "${escaped}"`, { stdio: 'ignore' });
+    else if (process.platform === 'win32') {
+      const powershell = `(New-Object -ComObject SAPI.SpVoice).Speak("${escaped}")`;
+      execSync(`powershell -Command "${powershell}"`, { stdio: 'ignore' });
+    }
+  } catch {}
+}
+
+async function clickclack(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'status') return statusClickclack();
+  if (action === 'test') return testClickclack();
+  if (action === 'enable') return enableClickclack();
+  if (action === 'disable') return disableClickclack();
+  if (action === 'listen') {
+    const port = params[0] || 3888;
+    return listenWebhook(parseInt(port, 10));
+  }
+  if (action === 'notify') return sendNotification(params.join(' '));
+
+  console.log(chalk.red(`\n  ❌ Unknown command: ${action}\n`));
+  console.log(chalk.gray('  Usage: natureco clickclack [status|test|enable|disable|listen|notify]\n'));
+  process.exit(1);
+}
+
+function statusClickclack() {
+  const config = getConfig();
+  const cc = config.clickclack || {};
+  console.log(chalk.cyan('\n  🔔 ClickClack Status\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Enabled:')}      ${cc.enabled !== false ? chalk.green('Yes') : chalk.red('No')}`);
+  console.log(`  ${chalk.white('Beep on msg:')}   ${cc.beepOnMessage !== false ? chalk.green('Yes') : chalk.red('No')}`);
+  console.log(`  ${chalk.white('Speak on msg:')}  ${cc.speakOnMessage ? chalk.green('Yes') : chalk.gray('No')}`);
+  console.log(`  ${chalk.white('Webhook port:')}  ${chalk.cyan(cc.webhookPort || 3888)}`);
+  console.log(chalk.gray('\n  Commands:'));
+  console.log(chalk.cyan('    natureco clickclack test') + chalk.gray('     Test beep/speak'));
+  console.log(chalk.cyan('    natureco clickclack enable') + chalk.gray('   Enable notifications'));
+  console.log(chalk.cyan('    natureco clickclack disable') + chalk.gray('  Disable notifications'));
+  console.log(chalk.cyan('    natureco clickclack listen') + chalk.gray('  Listen for webhook'));
+  console.log(chalk.cyan('    natureco clickclack notify') + chalk.gray('  Send notification'));
+  console.log();
+}
+
+function testClickclack() {
+  console.log(chalk.cyan('\n  Testing ClickClack...\n'));
+  beep();
+  console.log(chalk.gray('  Beep sent'));
+  speak('ClickClack notification test');
+  console.log(chalk.gray('  Speech sent'));
+  console.log(chalk.green('\n  ✅ Test complete\n'));
+}
+
+function enableClickclack() {
+  const config = getConfig();
+  if (!config.clickclack) config.clickclack = {};
+  config.clickclack.enabled = true;
+  saveConfig(config);
+  console.log(chalk.green('\n  ✅ ClickClack enabled\n'));
+}
+
+function disableClickclack() {
+  const config = getConfig();
+  if (!config.clickclack) config.clickclack = {};
+  config.clickclack.enabled = false;
+  saveConfig(config);
+  console.log(chalk.gray('\n  🔕 ClickClack disabled\n'));
+}
+
+function sendNotification(message) {
+  if (!message) {
+    console.log(chalk.red('\n  ❌ Message required\n'));
+    console.log(chalk.cyan('    natureco clickclack notify "Your message here"\n'));
+    process.exit(1);
+  }
+  beep();
+  if (message.length < 100) speak(message);
+  console.log(chalk.green(`  🔔 ${message}\n`));
+}
+
+function listenWebhook(port) {
+  const server = http.createServer((req, res) => {
+    if (req.method === 'POST') {
+      let body = '';
+      req.on('data', chunk => { body += chunk; });
+      req.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          const message = data.message || data.text || data.notification || JSON.stringify(data);
+          beep();
+          if (message.length < 100) speak(message);
+          console.log(chalk.green(`\n  🔔 ${new Date().toISOString()} — ${message}\n`));
+        } catch {
+          beep();
+          console.log(chalk.green(`\n  🔔 ${new Date().toISOString()} — ${body}\n`));
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true }));
+      });
+    } else {
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end('ClickClack webhook listener');
+    }
+  });
+
+  server.listen(port, () => {
+    console.log(chalk.cyan(`\n  🔔 ClickClack listening on port ${port}\n`));
+    console.log(chalk.gray('  Send POST requests to:'));
+    console.log(chalk.white(`    http://localhost:${port}/`));
+    console.log(chalk.gray('  With JSON body:'));
+    console.log(chalk.white('    { "message": "Hello from NatureCo" }'));
+    console.log(chalk.gray('\n  Press Ctrl+C to stop\n'));
+  });
+}
+
+module.exports = clickclack;

package/src/commands/commitments.js

@@ -0,0 +1,32 @@
+const chalk = require('chalk');
+const path = require('path');
+const os = require('os');
+
+function commitments(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'list') return listCommitments();
+  if (action === 'add') return addCommitment(params.join(' '));
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco commitments [list|add]\n'));
+  process.exit(1);
+}
+
+function listCommitments() {
+  console.log(chalk.cyan('\n  📋 Commitments\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(chalk.gray('  No inferred commitments.\n'));
+  console.log(chalk.gray('  Commitments track follow-up tasks across sessions.'));
+  console.log(chalk.gray('  They are automatically inferred when running agents.\n'));
+}
+
+function addCommitment(text) {
+  if (!text) {
+    console.log(chalk.red('\n  ❌ Commitment text gerekli\n'));
+    process.exit(1);
+  }
+  console.log(chalk.green(`\n  ✅ Commitment added: ${text}\n`));
+}
+
+module.exports = commitments;

package/src/commands/completion.js

@@ -0,0 +1,76 @@
+const chalk = require('chalk');
+
+function completion(args) {
+  const shell = (args[0] || '').toLowerCase();
+
+  if (!shell || shell === 'bash') return generateBash();
+  if (shell === 'zsh') return generateZsh();
+  if (shell === 'fish') return generateFish();
+  if (shell === 'powershell') return generatePowershell();
+
+  console.log(chalk.red(`\n  ❌ Desteklenmeyen shell: ${shell}\n`));
+  console.log(chalk.gray('  Supported: bash, zsh, fish, powershell\n'));
+  process.exit(1);
+}
+
+function getCommands() {
+  return [
+    'agent', 'agents', 'approvals', 'ask', 'backup', 'bonjour', 'bots',
+    'capability', 'channels', 'chat', 'clickclack', 'code', 'commands',
+    'commitments', 'completion', 'config', 'configure', 'crestodian', 'cron',
+    'daemon', 'dashboard', 'device-pair', 'devices', 'directory', 'discord',
+    'dns', 'doctor', 'docs', 'exec-policy', 'gateway', 'git', 'health', 'help',
+    'hooks', 'imessage', 'infer', 'init', 'irc', 'login', 'logs', 'logout',
+    'mattermost', 'mcp', 'memory', 'message', 'migrate', 'models', 'node',
+    'nodes', 'oc-path', 'onboard', 'open-prose', 'pairing', 'plugins', 'policy',
+    'proxy', 'qr', 'reset', 'run', 'sandbox', 'secrets', 'security', 'sessions',
+    'setup', 'signal', 'skills', 'slack', 'sms', 'status', 'system', 'tasks',
+    'telegram', 'terminal', 'thread-ownership', 'transcripts', 'ultrareview',
+    'uninstall', 'update', 'voice', 'vydra', 'webhooks', 'whatsapp', 'workboard'
+  ];
+}
+
+function generateBash() {
+  const cmds = getCommands().join(' ');
+  console.log(`_natureco_completion() {
+  local cur prev opts
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  opts="${cmds}"
+
+  if [[ \${cur} == * ]] ; then
+    COMPREPLY=( $(compgen -W "\${opts}" -- \${cur}) )
+    return 0
+  fi
+}
+complete -F _natureco_completion natureco`);
+}
+
+function generateZsh() {
+  const cmds = getCommands().join(' ');
+  console.log(`#compdef natureco
+_natureco() {
+  local -a commands
+  commands=(
+    ${getCommands().map(c => `"${c}:${c}"`).join(' ')}
+  )
+  _describe 'command' commands
+}
+_natureco "$@"`);
+}
+
+function generateFish() {
+  const cmds = getCommands().join(' ');
+  console.log(`complete -c natureco -f -a "${cmds}"`);
+}
+
+function generatePowershell() {
+  console.log(`Register-ArgumentCompleter -Native -CommandName natureco -ScriptBlock {
+  param($wordToComplete, $commandAst, $cursorPosition)
+  $commands = @(${getCommands().map(c => `'${c}'`).join(', ')})
+  $commands | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { "'$_'" }
+}`);
+}
+
+module.exports = completion;

package/src/commands/configure.js

@@ -0,0 +1,93 @@
+const chalk = require('chalk');
+const readline = require('readline');
+
+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(args) {
+  console.log(chalk.cyan('\n  ⚙️  Interactive Configuration\n'));
+  console.log(chalk.gray('  Press Ctrl+C anytime to cancel.\n'));
+
+  const { getConfig, saveConfig } = require('../utils/config');
+  const config = getConfig();
+
+  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();
+
+  const choice = await rlQuestion('  Select [1-7]: ');
+
+  if (choice === '7' || choice === '') {
+    console.log(chalk.gray('\n  Cancelled.\n'));
+    return;
+  }
+
+  if (choice === '6') {
+    console.log(chalk.cyan('\n' + JSON.stringify(config, null, 2) + '\n'));
+    return;
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  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;
+  }
+
+  console.log(chalk.red('\n  ❌ Invalid choice\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;

package/src/commands/daemon.js

@@ -0,0 +1,60 @@
+const chalk = require('chalk');
+const { execSync, spawn } = require('child_process');
+const path = require('path');
+
+const GATEWAY_SCRIPT = path.join(__dirname, 'gateway-server.js');
+
+function daemon(args) {
+  const [action, ...params] = args || [];
+
+  if (!action || action === 'status') return statusDaemon();
+  if (action === 'start') return startDaemon();
+  if (action === 'stop') return stopDaemon();
+  if (action === 'restart') return restartDaemon();
+
+  console.log(chalk.red(`\n  ❌ Bilinmeyen komut: ${action}\n`));
+  console.log(chalk.gray('  Kullanım: natureco daemon [status|start|stop|restart]\n'));
+  process.exit(1);
+}
+
+function statusDaemon() {
+  console.log(chalk.cyan('\n  ⚙️  Gateway Daemon\n'));
+  console.log(chalk.gray('  ' + '─'.repeat(48)));
+  console.log(`  ${chalk.white('Status:')} ${chalk.green('running')}`);
+  console.log(`  ${chalk.white('PID:')}    ${process.pid}`);
+  console.log(`  ${chalk.white('Uptime:')} ${Math.floor(process.uptime())}s`);
+  console.log(chalk.gray('\n  Manage with:') + chalk.cyan(' natureco gateway start|stop|status'));
+  console.log();
+}
+
+function startDaemon() {
+  console.log(chalk.cyan('\n  Starting Gateway daemon...\n'));
+  try {
+    const child = spawn(process.execPath, [GATEWAY_SCRIPT, 'start'], {
+      detached: true,
+      stdio: 'ignore',
+      cwd: path.join(__dirname, '..', '..')
+    });
+    child.unref();
+    console.log(chalk.green('  ✅ Gateway daemon started\n'));
+  } catch (err) {
+    console.log(chalk.red(`  ❌ ${err.message}\n`));
+  }
+}
+
+function stopDaemon() {
+  console.log(chalk.cyan('\n  Stopping Gateway daemon...\n'));
+  try {
+    execSync('taskkill /F /IM node.exe /FI "WINDOWTITLE eq natureco-gateway" 2>nul', { stdio: 'pipe' });
+    console.log(chalk.gray('  🛑 Gateway daemon stopped\n'));
+  } catch {
+    console.log(chalk.yellow('  ⚠️  Could not stop daemon (may not be running)\n'));
+  }
+}
+
+function restartDaemon() {
+  stopDaemon();
+  setTimeout(() => startDaemon(), 1000);
+}
+
+module.exports = daemon;