natureco-cli 1.0.61 → 1.1.0

package/README.md

@@ -9,6 +9,7 @@ Terminal-native AI agent CLI — chat with your bots, automate workflows, and co
 ## ✨ Features
 
 - **🤖 Multi-Bot Chat** — Interactive conversations with AI bots, support for multi-word bot names, auto-selection when no default
+- **🛠️ Local Tool Execution** — Bash commands, file operations, HTTP requests — bots can execute tools locally with automatic retry loop
 - **🔌 Multi-Platform Integration** — Telegram, Discord, Slack, WhatsApp (QR code auth with Baileys)
 - **🎯 Skill System** — Extend capabilities with NatureHub and ClawHub skills
 - **🔧 MCP Support** — Model Context Protocol servers for filesystem, GitHub, databases

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "1.0.61",
+  "version": "1.1.0",
   "description": "NatureCo AI Bot Terminal Interface",
   "main": "bin/natureco.js",
   "bin": {

package/src/commands/chat.js

@@ -2,7 +2,7 @@ const inquirer = require('inquirer');
 const chalk = require('chalk');
 const readline = require('readline');
 const { getApiKey } = require('../utils/config');
-const { getBots, sendMessage } = require('../utils/api');
+const { getBots, sendMessage, _sendMessage } = require('../utils/api');
 const { getSkillPrompts, getSkills } = require('../utils/skills');
 const { getAgentsPrompt } = require('../utils/agents');
 const { addToHistory, getCommandHistory, clearHistory } = require('../utils/history');
@@ -11,6 +11,8 @@ const { getCommands, getCommandContent } = require('../utils/commands');
 const { runHooks } = require('../utils/hooks');
 const { createSession, loadSession, getLatestSession, addMessageToSession } = require('../utils/sessions');
 const { addBackgroundTask, updateBackgroundTask } = require('../utils/background');
+const { getToolDefinitions, executeToolCalls } = require('../utils/tool-runner');
+const { extractToolCalls } = require('../utils/tool-adapter');
 
 async function chat(botName, options = {}) {
   const apiKey = getApiKey();
@@ -466,7 +468,11 @@ ${lastCodeBlock}
     const loadingInterval = startLoadingAnimation();
 
     try {
-      const response = await sendMessage(apiKey, bot.id, userMessage, conversationId, systemPrompt);
+      // Get tool definitions
+      const toolDefinitions = getToolDefinitions();
+      
+      // Initial API call with tools
+      let response = await _sendMessage(apiKey, bot.id, userMessage, conversationId, systemPrompt, toolDefinitions);
       
       stopLoadingAnimation(loadingInterval);
 
@@ -474,6 +480,50 @@ ${lastCodeBlock}
         conversationId = response.conversation_id;
       }
 
+      // Tool execution loop
+      let maxIterations = 5;
+      let iteration = 0;
+      
+      while (iteration < maxIterations) {
+        // Check for tool calls
+        const toolCalls = extractToolCalls(response);
+        
+        if (!toolCalls || toolCalls.length === 0) {
+          // No more tool calls, break loop
+          break;
+        }
+        
+        console.log(chalk.yellow(`\n🔧 Executing ${toolCalls.length} tool(s)...\n`));
+        
+        // Execute tools
+        const toolResults = await executeToolCalls(toolCalls);
+        
+        // Format results as message
+        const toolResultMessage = toolResults.map(tr => {
+          const resultStr = tr.result.success 
+            ? (tr.result.output || JSON.stringify(tr.result))
+            : `Error: ${tr.result.error}`;
+          return `Tool: ${tr.name}\nResult: ${resultStr}`;
+        }).join('\n\n');
+        
+        console.log(chalk.blue('\n📤 Sending tool results back to bot...\n'));
+        
+        // Send tool results back to API
+        const loadingInterval2 = startLoadingAnimation();
+        response = await _sendMessage(apiKey, bot.id, toolResultMessage, conversationId, systemPrompt, toolDefinitions);
+        stopLoadingAnimation(loadingInterval2);
+        
+        if (response.conversation_id) {
+          conversationId = response.conversation_id;
+        }
+        
+        iteration++;
+      }
+      
+      if (iteration >= maxIterations) {
+        console.log(chalk.yellow('\n⚠️  Max tool iterations reached\n'));
+      }
+
       let botReply = response.reply || response.message || 'No response';
       
       // Run post-message hooks

package/src/commands/dashboard.js

@@ -211,7 +211,7 @@ body::before{
         <div class="header-bot-name" id="header-bot-name">Nature Bot</div>
         <div class="header-bot-model" id="header-bot-model">NatureCo</div>
       </div>
-      <div class="version-badge" id="version-badge">v1.0.61</div>
+      <div class="version-badge" id="version-badge">v1.1.0</div>
     </div>
     <div class="messages" id="messages"></div>
     <div class="input-area">
@@ -341,7 +341,7 @@ function dashboard(action) {
           apiKey: cfg.apiKey,
           defaultBot: cfg.defaultBot,
           defaultBotId: cfg.defaultBotId,
-          version: 'v1.0.61',
+          version: 'v1.1.0',
           bots: cfg.bots || [],
           telegramToken: cfg.telegramToken || null,
           whatsappConnected: cfg.whatsappConnected || false,

package/src/tools/bash.js

@@ -0,0 +1,37 @@
+const { execSync } = require('child_process');
+
+module.exports = {
+  name: 'bash',
+  description: 'Execute bash commands in the terminal',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      command: {
+        type: 'string',
+        description: 'The bash command to execute'
+      }
+    },
+    required: ['command']
+  },
+  
+  async execute(params) {
+    try {
+      const output = execSync(params.command, {
+        encoding: 'utf-8',
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+        timeout: 30000 // 30 seconds
+      });
+      
+      return {
+        success: true,
+        output: output.trim()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        stderr: error.stderr?.toString() || ''
+      };
+    }
+  }
+};

package/src/tools/filesystem.js

@@ -0,0 +1,67 @@
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  name: 'filesystem',
+  description: 'List files and directories',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      path: {
+        type: 'string',
+        description: 'Directory path to list'
+      },
+      recursive: {
+        type: 'boolean',
+        description: 'List recursively',
+        default: false
+      }
+    },
+    required: ['path']
+  },
+  
+  async execute(params) {
+    try {
+      const targetPath = path.resolve(params.path);
+      
+      if (!fs.existsSync(targetPath)) {
+        return {
+          success: false,
+          error: 'Path does not exist'
+        };
+      }
+      
+      const stats = fs.statSync(targetPath);
+      
+      if (!stats.isDirectory()) {
+        return {
+          success: false,
+          error: 'Path is not a directory'
+        };
+      }
+      
+      const files = fs.readdirSync(targetPath);
+      const items = files.map(file => {
+        const filePath = path.join(targetPath, file);
+        const fileStats = fs.statSync(filePath);
+        return {
+          name: file,
+          type: fileStats.isDirectory() ? 'directory' : 'file',
+          size: fileStats.size,
+          modified: fileStats.mtime
+        };
+      });
+      
+      return {
+        success: true,
+        path: targetPath,
+        items
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+};

package/src/tools/http.js

@@ -0,0 +1,56 @@
+module.exports = {
+  name: 'http',
+  description: 'Make HTTP requests',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      url: {
+        type: 'string',
+        description: 'URL to request'
+      },
+      method: {
+        type: 'string',
+        description: 'HTTP method (GET, POST, etc.)',
+        default: 'GET'
+      },
+      headers: {
+        type: 'object',
+        description: 'Request headers'
+      },
+      body: {
+        type: 'string',
+        description: 'Request body'
+      }
+    },
+    required: ['url']
+  },
+  
+  async execute(params) {
+    try {
+      const options = {
+        method: params.method || 'GET',
+        headers: params.headers || {}
+      };
+      
+      if (params.body) {
+        options.body = params.body;
+      }
+      
+      const response = await fetch(params.url, options);
+      const text = await response.text();
+      
+      return {
+        success: true,
+        status: response.status,
+        statusText: response.statusText,
+        headers: Object.fromEntries(response.headers.entries()),
+        body: text
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+};

package/src/tools/read_file.js

@@ -0,0 +1,53 @@
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  name: 'read_file',
+  description: 'Read content from a file',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      path: {
+        type: 'string',
+        description: 'File path to read'
+      }
+    },
+    required: ['path']
+  },
+  
+  async execute(params) {
+    try {
+      const filePath = path.resolve(params.path);
+      
+      if (!fs.existsSync(filePath)) {
+        return {
+          success: false,
+          error: 'File does not exist'
+        };
+      }
+      
+      const stats = fs.statSync(filePath);
+      
+      if (!stats.isFile()) {
+        return {
+          success: false,
+          error: 'Path is not a file'
+        };
+      }
+      
+      const content = fs.readFileSync(filePath, 'utf-8');
+      
+      return {
+        success: true,
+        path: filePath,
+        content,
+        size: stats.size
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+};

package/src/tools/write_file.js

@@ -0,0 +1,48 @@
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  name: 'write_file',
+  description: 'Write content to a file',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      path: {
+        type: 'string',
+        description: 'File path to write'
+      },
+      content: {
+        type: 'string',
+        description: 'Content to write'
+      }
+    },
+    required: ['path', 'content']
+  },
+  
+  async execute(params) {
+    try {
+      const filePath = path.resolve(params.path);
+      const dir = path.dirname(filePath);
+      
+      // Create directory if it doesn't exist
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      
+      fs.writeFileSync(filePath, params.content, 'utf-8');
+      
+      const stats = fs.statSync(filePath);
+      
+      return {
+        success: true,
+        path: filePath,
+        size: stats.size
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+};

package/src/utils/api.js

@@ -24,7 +24,7 @@ async function getBots(apiKey) {
   });
 }
 
-async function _sendMessage(apiKey, botId, message, conversationId = null, skillPrompts = '') {
+async function _sendMessage(apiKey, botId, message, conversationId = null, skillPrompts = '', toolDefinitions = null) {
   const { getConfig } = require('./config');
   const config = getConfig();
   
@@ -54,6 +54,11 @@ async function _sendMessage(apiKey, botId, message, conversationId = null, skill
     }
   }
 
+  // Tool definitions ekle
+  if (toolDefinitions && toolDefinitions.length > 0) {
+    body.tools = toolDefinitions;
+  }
+
   const data = await request('/api/agent/chat', {
     method: 'POST',
     headers: { 
@@ -97,4 +102,5 @@ module.exports = {
   getBots,
   sendMessage,
   validateApiKey,
+  _sendMessage, // Export for tool execution loop
 };

package/src/utils/tool-adapter.js

@@ -0,0 +1,133 @@
+/**
+ * Tool Adapter - Normalize different provider formats
+ */
+
+/**
+ * Extract tool calls from API response
+ * Supports: Anthropic, OpenAI, Groq, Gemini
+ */
+function extractToolCalls(response, provider) {
+  if (!response) return [];
+  
+  // Anthropic format
+  if (response.content && Array.isArray(response.content)) {
+    return response.content
+      .filter(block => block.type === 'tool_use')
+      .map(block => ({
+        id: block.id,
+        name: block.name,
+        input: block.input
+      }));
+  }
+  
+  // OpenAI/Groq format
+  if (response.tool_calls && Array.isArray(response.tool_calls)) {
+    return response.tool_calls.map(call => ({
+      id: call.id,
+      name: call.function.name,
+      input: JSON.parse(call.function.arguments)
+    }));
+  }
+  
+  // Gemini format
+  if (response.functionCall) {
+    return [{
+      id: 'gemini_' + Date.now(),
+      name: response.functionCall.name,
+      input: response.functionCall.args
+    }];
+  }
+  
+  return [];
+}
+
+/**
+ * Format tool result for API request
+ */
+function formatToolResult(toolCallId, toolName, result, provider) {
+  const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
+  
+  // Anthropic format
+  if (provider === 'anthropic') {
+    return {
+      type: 'tool_result',
+      tool_use_id: toolCallId,
+      content: resultStr
+    };
+  }
+  
+  // OpenAI/Groq format
+  if (provider === 'openai' || provider === 'groq') {
+    return {
+      role: 'tool',
+      tool_call_id: toolCallId,
+      name: toolName,
+      content: resultStr
+    };
+  }
+  
+  // Gemini format
+  if (provider === 'gemini') {
+    return {
+      functionResponse: {
+        name: toolName,
+        response: result
+      }
+    };
+  }
+  
+  // Default format
+  return {
+    tool_call_id: toolCallId,
+    name: toolName,
+    result: resultStr
+  };
+}
+
+/**
+ * Convert tool definitions to provider format
+ */
+function formatToolDefinitions(tools, provider) {
+  // Anthropic format
+  if (provider === 'anthropic') {
+    return tools.map(tool => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.inputSchema
+    }));
+  }
+  
+  // OpenAI/Groq format
+  if (provider === 'openai' || provider === 'groq') {
+    return tools.map(tool => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema
+      }
+    }));
+  }
+  
+  // Gemini format
+  if (provider === 'gemini') {
+    return tools.map(tool => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }));
+  }
+  
+  // Default format (Anthropic-like)
+  return tools.map(tool => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema
+  }));
+}
+
+module.exports = {
+  extractToolCalls,
+  formatToolResult,
+  formatToolDefinitions
+};

package/src/utils/tool-runner.js

@@ -0,0 +1,93 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Tool Runner - Execute tools locally
+ */
+
+// Load all tools from src/tools/
+function loadTools() {
+  const toolsDir = path.join(__dirname, '..', 'tools');
+  const tools = {};
+  
+  if (!fs.existsSync(toolsDir)) {
+    return tools;
+  }
+  
+  const files = fs.readdirSync(toolsDir).filter(f => f.endsWith('.js'));
+  
+  for (const file of files) {
+    try {
+      const tool = require(path.join(toolsDir, file));
+      if (tool.name && tool.execute) {
+        tools[tool.name] = tool;
+      }
+    } catch (err) {
+      console.error(chalk.red(`Failed to load tool ${file}:`, err.message));
+    }
+  }
+  
+  return tools;
+}
+
+// Get tool definitions for API
+function getToolDefinitions() {
+  const tools = loadTools();
+  return Object.values(tools).map(tool => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema
+  }));
+}
+
+// Execute a single tool
+async function executeTool(toolName, params) {
+  const tools = loadTools();
+  const tool = tools[toolName];
+  
+  if (!tool) {
+    return {
+      success: false,
+      error: `Tool '${toolName}' not found`
+    };
+  }
+  
+  console.log(chalk.blue(`\n🔧 Executing tool: ${toolName}`));
+  console.log(chalk.gray(`   Params: ${JSON.stringify(params)}`));
+  
+  try {
+    const result = await tool.execute(params);
+    console.log(chalk.green(`   ✓ Success`));
+    return result;
+  } catch (error) {
+    console.log(chalk.red(`   ✗ Error: ${error.message}`));
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+// Execute multiple tool calls
+async function executeToolCalls(toolCalls) {
+  const results = [];
+  
+  for (const call of toolCalls) {
+    const result = await executeTool(call.name, call.input);
+    results.push({
+      id: call.id,
+      name: call.name,
+      result
+    });
+  }
+  
+  return results;
+}
+
+module.exports = {
+  loadTools,
+  getToolDefinitions,
+  executeTool,
+  executeToolCalls
+};