natureco-cli 2.23.28 → 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/channels.js

@@ -61,6 +61,66 @@ function listChannels() {
     });
   }
 
+  if (config.signalBotId) {
+    channels.push({
+      name: 'Signal',
+      icon: '🔒',
+      status: 'bağlı',
+      detail: `hesap: ${config.signalAccount || 'bağlı'}`,
+      chats: 0,
+    });
+  }
+
+  if (config.ircBotId) {
+    channels.push({
+      name: 'IRC',
+      icon: '💬',
+      status: 'bağlı',
+      detail: `${config.ircHost}:${config.ircPort} (${config.ircNick})`,
+      chats: 0,
+    });
+  }
+
+  if (config.mattermostBotId) {
+    channels.push({
+      name: 'Mattermost',
+      icon: '📢',
+      status: 'bağlı',
+      detail: `sunucu: ${config.mattermostBaseUrl || 'bağlı'}`,
+      chats: 0,
+    });
+  }
+
+  if (config.imessageBotId) {
+    channels.push({
+      name: 'iMessage',
+      icon: '💬',
+      status: 'bağlı',
+      detail: 'macOS bridge',
+      chats: 0,
+    });
+  }
+
+  if (config.smsBotId) {
+    channels.push({
+      name: 'SMS (Twilio)',
+      icon: '📨',
+      status: 'bağlı',
+      detail: `numara: ${config.smsFromNumber || 'bağlı'}`,
+      chats: 0,
+    });
+  }
+
+  if (config.webhooks && config.webhooks.length > 0) {
+    channels.push({
+      name: 'Webhooks',
+      icon: '🔗',
+      status: 'bağlı',
+      detail: `${config.webhooks.length} route`,
+      chats: 0,
+    });
+  }
+
   console.log('');
   console.log(chalk.gray('  ' + '─'.repeat(48)));
   console.log(chalk.cyan.bold('\n  Kanallar\n'));
@@ -71,7 +131,13 @@ function listChannels() {
     console.log(chalk.cyan('    natureco telegram connect'));
     console.log(chalk.cyan('    natureco whatsapp connect'));
     console.log(chalk.cyan('    natureco discord connect'));
-    console.log(chalk.cyan('    natureco slack connect\n'));
+    console.log(chalk.cyan('    natureco slack connect'));
+    console.log(chalk.cyan('    natureco signal connect'));
+    console.log(chalk.cyan('    natureco irc connect'));
+    console.log(chalk.cyan('    natureco mattermost connect'));
+    console.log(chalk.cyan('    natureco imessage connect'));
+    console.log(chalk.cyan('    natureco sms connect'));
+    console.log(chalk.cyan('    natureco webhooks connect\n'));
     return;
   }
 
@@ -98,6 +164,12 @@ function statusChannels() {
     { name: 'WhatsApp', ok: !!config.whatsappConnected },
     { name: 'Discord',  ok: !!config.discordToken },
     { name: 'Slack',    ok: !!config.slackToken },
+    { name: 'Signal',   ok: !!config.signalBotId },
+    { name: 'IRC',      ok: !!config.ircBotId },
+    { name: 'Mattermost', ok: !!config.mattermostBotId },
+    { name: 'iMessage', ok: !!config.imessageBotId },
+    { name: 'SMS',      ok: !!config.smsBotId },
+    { name: 'Webhooks', ok: !!(config.webhooks && config.webhooks.length > 0) },
   ];
 
   checks.forEach(ch => {
@@ -110,13 +182,13 @@ function statusChannels() {
   const connected = checks.filter(c => c.ok).length;
   console.log('');
   console.log(chalk.gray('  ' + '─'.repeat(48)));
-  console.log(chalk.gray(`  ${connected}/4 kanal aktif\n`));
+  console.log(chalk.gray(`  ${connected}/${checks.length} kanal aktif\n`));
 }
 
 function removeChannel(channel) {
   if (!channel) {
     console.log(chalk.red('\n  ❌ Kanal adı gerekli\n'));
-    console.log(chalk.gray('  Kullanım: natureco channels remove <telegram|whatsapp|discord|slack>\n'));
+    console.log(chalk.gray('  Kullanım: natureco channels remove <telegram|whatsapp|discord|slack|signal|irc|mattermost|imessage|sms|webhooks>\n'));
     process.exit(1);
   }
 
@@ -128,7 +200,6 @@ function removeChannel(channel) {
     delete config.telegramBotId;
     delete config.telegramAllowedChats;
   } else if (ch === 'whatsapp') {
-    // Session dosyalarını sil
     if (config.whatsappBotId) {
       const sessionDir = path.join(os.homedir(), '.natureco', 'whatsapp-sessions', config.whatsappBotId);
       if (fs.existsSync(sessionDir)) {
@@ -145,6 +216,25 @@ function removeChannel(channel) {
   } else if (ch === 'slack') {
     delete config.slackToken;
     delete config.slackBotId;
+  } else if (ch === 'signal') {
+    delete config.signalHttpUrl;
+    delete config.signalAccount;
+    delete config.signalDmPolicy;
+    delete config.signalBotId;
+  } else if (ch === 'irc') {
+    delete config.ircHost; delete config.ircPort; delete config.ircTls;
+    delete config.ircNick; delete config.ircUsername; delete config.ircPassword;
+    delete config.ircChannels; delete config.ircDmPolicy; delete config.ircBotId;
+  } else if (ch === 'mattermost') {
+    delete config.mattermostBaseUrl; delete config.mattermostToken;
+    delete config.mattermostDmPolicy; delete config.mattermostBotId;
+  } else if (ch === 'imessage') {
+    delete config.imessageCliPath; delete config.imessageDmPolicy; delete config.imessageBotId;
+  } else if (ch === 'sms') {
+    delete config.smsAccountSid; delete config.smsAuthToken; delete config.smsFromNumber;
+    delete config.smsPublicWebhookUrl; delete config.smsDmPolicy; delete config.smsBotId;
+  } else if (ch === 'webhooks') {
+    delete config.webhooks; delete config.webhookEnabled;
   } else {
     console.log(chalk.red(`\n  ❌ Bilinmeyen kanal: ${channel}\n`));
     process.exit(1);

package/src/commands/chat.js

@@ -13,8 +13,8 @@ const { getMemoryPrompt, extractMemoryFromMessage, loadMemory, clearMemory, addM
 const { getCommands, getCommandContent } = require('../utils/commands');
 const { runHooks } = require('../utils/hooks');
 const { createSession, loadSession, getLatestSession, addMessageToSession, loadLastSession, listSessions, saveSession } = require('../utils/sessions');
-const { getToolDefinitions, executeToolCalls, getSessionStats, resetSessionStats } = require('../utils/tool-runner');
-const { extractToolCalls } = require('../utils/tool-adapter');
+const { NatureCoError, ApiError, handleError } = require('../utils/errors');
+const { getToolDefinitions, getSessionStats, resetSessionStats } = require('../utils/tool-runner');
 
 // ── ASCII Logo ────────────────────────────────────────────────────────────────
 const ASCII_LOGO = [
@@ -80,10 +80,9 @@ async function chat(botName, options = {}) {
   // ── Bot seçimi ──────────────────────────────────────────────────────────────
   let botList;
   try {
-    botList = await getBots(apiKey || config.providerApiKey || '');
+    botList = await getBots(apiKey ?? config.providerApiKey ?? '');
   } catch (err) {
-    console.log(chalk.red(`\n❌ Error: ${err.message}\n`));
-    process.exit(1);
+    handleError(err, { prefix: '❌ Error', exit: true });
   }
 
   if (!botList?.bots?.length) {
@@ -311,7 +310,7 @@ async function chat(botName, options = {}) {
               console.log();
               addToHistory(bot.id, userMessage, reply, conversationId);
               addMessageToSession(bot.id, session.id, userMessage, reply);
-            } catch (e) { stopLoading(); console.log(chalk.red(`Error: ${e.message}`)); console.log(); }
+            } catch (e) { stopLoading(); handleError(e, { prefix: 'Error', exit: false }); console.log(); }
           } else {
             console.log(chalk.red(`Bilinmeyen komut: /${cmd}`));
             console.log();
@@ -336,27 +335,12 @@ async function chat(botName, options = {}) {
 
     try {
       const toolDefinitions = getToolDefinitions();
-      let response = await _sendMessage(apiKey || config.providerApiKey, bot.id, userMessage, conversationId, systemPrompt, toolDefinitions, options);
+      let response = await _sendMessage(apiKey ?? config.providerApiKey, bot.id, userMessage, conversationId, systemPrompt, toolDefinitions, options);
       stopLoading();
 
-      if (response.conversation_id) conversationId = response.conversation_id;
-
-      // Tool loop — api.js zaten tool loop yapıyor, bu loop çalışmamalı
-      let iter = 0;
-      while (iter < 5) {
-        const toolCalls = extractToolCalls(response);
-        if (!toolCalls?.length) break;
-        console.log(chalk.yellow(`🔧 ${toolCalls.length} tool çalıştırılıyor...`));
-        const toolResults = await executeToolCalls(toolCalls);
-        const toolMsg = toolResults.map(tr => `Tool: ${tr.name}\nResult: ${tr.result.success ? (tr.result.output || '') : tr.result.error}`).join('\n\n');
-        startLoading();
-        response = await _sendMessage(apiKey || config.providerApiKey, bot.id, toolMsg, conversationId, systemPrompt, toolDefinitions, options);
-        stopLoading();
-        if (response.conversation_id) conversationId = response.conversation_id;
-        iter++;
-      }
+      if (response?.conversation_id) conversationId = response.conversation_id;
 
-      let botReply = response.reply || response.message || 'No response';
+      let botReply = response?.reply ?? response?.message ?? 'No response';
       botReply = await runHooks('post-message', botReply, { botId: bot.id, botName: bot.name });
 
       console.log(chalk.cyan(`${displayBotName}  `) + botReply);
@@ -370,7 +354,9 @@ async function chat(botName, options = {}) {
 
     } catch (err) {
       stopLoading();
-      const errMsg = err.message.split('"message":"')[1]?.split('"')[0] || err.message;
+      const errMsg = err instanceof NatureCoError
+        ? err.message
+        : (err?.message?.split('"message":"')[1]?.split('"')[0] ?? err?.message ?? 'Unknown error');
       console.log(chalk.red(`Error: ${errMsg}`));
       console.log();
     }

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;