natureco-cli 1.1.5 → 2.0.0

package/package.json

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

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.1.5</div>
+      <div class="version-badge" id="version-badge">v2.0.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.1.5',
+          version: 'v2.0.0',
           bots: cfg.bots || [],
           telegramToken: cfg.telegramToken || null,
           whatsappConnected: cfg.whatsappConnected || false,

package/src/tools/list_dir.js

@@ -0,0 +1,115 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * List Directory Tool
+ * Lists files and directories in a given path
+ */
+
+module.exports = {
+  name: 'list_dir',
+  description: 'List files and directories in a given path. Returns file names, sizes, and types.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      path: {
+        type: 'string',
+        description: 'Directory path to list (relative or absolute). Use "." for current directory.'
+      }
+    },
+    required: ['path']
+  },
+  
+  async execute(params) {
+    try {
+      const dirPath = params.path || '.';
+      const absolutePath = path.resolve(dirPath);
+      
+      // Check if directory exists
+      if (!fs.existsSync(absolutePath)) {
+        return {
+          success: false,
+          error: `Directory not found: ${dirPath}`
+        };
+      }
+      
+      // Check if it's a directory
+      const stats = fs.statSync(absolutePath);
+      if (!stats.isDirectory()) {
+        return {
+          success: false,
+          error: `Not a directory: ${dirPath}`
+        };
+      }
+      
+      // Read directory
+      const entries = fs.readdirSync(absolutePath, { withFileTypes: true });
+      
+      // Format entries
+      const items = entries.map(entry => {
+        const itemPath = path.join(absolutePath, entry.name);
+        let size = 0;
+        let type = 'unknown';
+        
+        try {
+          const itemStats = fs.statSync(itemPath);
+          size = itemStats.size;
+          
+          if (entry.isDirectory()) {
+            type = 'directory';
+          } else if (entry.isFile()) {
+            type = 'file';
+          } else if (entry.isSymbolicLink()) {
+            type = 'symlink';
+          }
+        } catch (err) {
+          // Ignore stat errors
+        }
+        
+        return {
+          name: entry.name,
+          type: type,
+          size: size
+        };
+      });
+      
+      // Sort: directories first, then files
+      items.sort((a, b) => {
+        if (a.type === 'directory' && b.type !== 'directory') return -1;
+        if (a.type !== 'directory' && b.type === 'directory') return 1;
+        return a.name.localeCompare(b.name);
+      });
+      
+      // Format output
+      let output = `Directory: ${absolutePath}\n`;
+      output += `Total items: ${items.length}\n\n`;
+      
+      items.forEach(item => {
+        const typeIcon = item.type === 'directory' ? '📁' : '📄';
+        const sizeStr = item.type === 'file' ? ` (${formatSize(item.size)})` : '';
+        output += `${typeIcon} ${item.name}${sizeStr}\n`;
+      });
+      
+      return {
+        success: true,
+        output: output,
+        items: items,
+        path: absolutePath
+      };
+      
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+};
+
+function formatSize(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
+}

package/src/utils/api.js

@@ -1,111 +1,221 @@
-const API_BASE = 'https://api.natureco.me';
-
-async function request(endpoint, options = {}) {
-  const url = `${API_BASE}${endpoint}`;
-  const response = await fetch(url, {
-    ...options,
-    headers: {
-      'Content-Type': 'application/json',
-      ...options.headers,
-    },
-  });
-
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`API Error: ${response.status} - ${text}`);
-  }
+// NatureCo CLI v2.0.0 - Direct Groq Integration with Local Tool Execution
+// Bypass NatureCo backend, connect directly to Groq API
 
-  return response.json();
-}
+const { getConfig } = require('./config');
+const { getToolDefinitions, executeToolCalls } = require('./tool-runner');
 
-async function getBots(apiKey) {
-  return request('/api/v1/bots', {
-    headers: { Authorization: `Bearer ${apiKey}` },
-  });
-}
+// Conversation history for multi-turn chat
+const conversationHistory = new Map();
 
-async function _sendMessage(apiKey, botId, message, conversationId = null, skillPrompts = '', toolDefinitions = null) {
-  const { getConfig } = require('./config');
+/**
+ * Get Groq API key from config
+ */
+function getGroqApiKey() {
   const config = getConfig();
+  return config.groqApiKey || null;
+}
+
+/**
+ * Format tool definitions for Groq API
+ */
+function formatToolsForGroq() {
+  const tools = getToolDefinitions();
   
-  // bot_id boş veya undefined ise config'den oku
-  const finalBotId = botId || config.defaultBotId;
+  return tools.map(tool => ({
+    type: 'function',
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }
+  }));
+}
+
+/**
+ * Send message to Groq with tool support
+ */
+async function sendMessageToGroq(apiKey, message, conversationId = null, systemPrompt = null) {
+  const groqApiKey = getGroqApiKey();
   
-  const body = {
-    message,
-    user_id: 'cli-user',
-    bot_id: finalBotId
-  };
+  if (!groqApiKey) {
+    throw new Error('Groq API key not found. Set it with: natureco config set groqApiKey gsk_xxx');
+  }
 
-  // Custom AI provider varsa ekle
-  if (config.aiProvider && config.aiApiKey) {
-    body.custom_provider = config.aiProvider;
-    body.custom_api_key = config.aiApiKey;
-    
-    // Model varsa ekle
-    if (config.aiModel) {
-      body.model = config.aiModel;
+  // Get or create conversation history
+  const convId = conversationId || `conv_${Date.now()}`;
+  if (!conversationHistory.has(convId)) {
+    conversationHistory.set(convId, []);
+  }
+  const history = conversationHistory.get(convId);
+
+  // Add system prompt if provided
+  const messages = [];
+  if (systemPrompt) {
+    messages.push({ role: 'system', content: systemPrompt });
+  }
+
+  // Add conversation history
+  messages.push(...history);
+
+  // Add user message
+  messages.push({ role: 'user', content: message });
+
+  // Get tool definitions
+  const tools = formatToolsForGroq();
+
+  console.log('\n[Groq] Sending request...');
+  console.log('[Groq] Messages:', messages.length);
+  console.log('[Groq] Tools:', tools.length);
+
+  // Tool execution loop (max 10 iterations)
+  let iteration = 0;
+  const maxIterations = 10;
+  let finalResponse = null;
+
+  while (iteration < maxIterations) {
+    iteration++;
+    console.log(`\n[Groq] Iteration ${iteration}/${maxIterations}`);
+
+    // Call Groq API
+    const response = await fetch('https://api.groq.com/openai/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${groqApiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: 'llama-3.3-70b-versatile',
+        messages: messages,
+        tools: tools,
+        tool_choice: 'auto',
+        temperature: 0.7,
+        max_tokens: 2000,
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error('[Groq] Error:', errorText);
+      throw new Error(`Groq API error: ${response.status} - ${errorText}`);
     }
+
+    const data = await response.json();
+    const assistantMessage = data.choices[0].message;
+
+    console.log('[Groq] Response type:', assistantMessage.tool_calls ? 'tool_calls' : 'text');
+
+    // Add assistant message to history
+    messages.push(assistantMessage);
+
+    // Check for tool calls
+    if (assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0) {
+      console.log(`[Groq] Tool calls: ${assistantMessage.tool_calls.length}`);
+
+      // Execute tools locally
+      const toolCalls = assistantMessage.tool_calls.map(tc => ({
+        id: tc.id,
+        name: tc.function.name,
+        input: JSON.parse(tc.function.arguments)
+      }));
+
+      const toolResults = await executeToolCalls(toolCalls);
+
+      // Add tool results to messages
+      for (const result of toolResults) {
+        const toolCall = assistantMessage.tool_calls.find(tc => tc.id === result.id);
+        
+        messages.push({
+          role: 'tool',
+          tool_call_id: result.id,
+          name: result.name,
+          content: result.result.success 
+            ? (result.result.output || JSON.stringify(result.result))
+            : `Error: ${result.result.error}`
+        });
+      }
+
+      // Continue loop to get final response
+      continue;
+    }
+
+    // No tool calls, we have final response
+    finalResponse = assistantMessage.content;
+    break;
   }
 
-  // Debug: Request body'yi logla
-  console.log('\n[DEBUG] API Request Body:', JSON.stringify(body, null, 2));
-
-  const data = await request('/api/agent/message', {
-    method: 'POST',
-    headers: { 
-      Authorization: `Bearer ${apiKey}`,
-      'X-User-ID': 'cli-user'
-    },
-    body: JSON.stringify(body),
-  });
-
-  // Debug: API response'u logla
-  console.log('[DEBUG] API Response:', JSON.stringify(data, null, 2), '\n');
-
-  // Backend response formatını CLI formatına çevir
-  // Backend: { response: "...", message_id: "...", bot_id: "..." }
-  // CLI beklediği: { reply: "...", conversation_id: "..." }
-  if (data.response && !data.reply) {
-    data.reply = data.response;
+  if (iteration >= maxIterations) {
+    console.log('\n[Groq] Max iterations reached');
+    finalResponse = finalResponse || 'Max tool execution iterations reached.';
   }
-  if (data.message_id && !data.conversation_id) {
-    data.conversation_id = data.message_id;
+
+  // Save to conversation history (only user and final assistant message)
+  history.push({ role: 'user', content: message });
+  history.push({ role: 'assistant', content: finalResponse });
+
+  // Keep history limited to last 20 messages
+  if (history.length > 20) {
+    conversationHistory.set(convId, history.slice(-20));
   }
 
-  return data;
+  return {
+    reply: finalResponse,
+    conversation_id: convId,
+    message_id: `msg_${Date.now()}`,
+    success: true
+  };
 }
 
-async function callWithRetry(fn, maxRetries = 3, delay = 2000) {
-  for (let i = 0; i < maxRetries; i++) {
-    const result = await fn();
-    const reply = result?.reply || result?.message || '';
-    if (reply && !reply.includes('Şu an yanıt veremiyorum') && !reply.includes('cannot respond')) {
-      return result;
-    }
-    if (i < maxRetries - 1) {
-      await new Promise(r => setTimeout(r, delay));
-    }
+/**
+ * Clear conversation history
+ */
+function clearConversation(conversationId) {
+  if (conversationId) {
+    conversationHistory.delete(conversationId);
+  } else {
+    conversationHistory.clear();
   }
-  return { reply: 'API şu an meşgul, lütfen tekrar deneyin.' };
 }
 
-async function sendMessage(...args) {
-  return callWithRetry(() => _sendMessage(...args));
+/**
+ * Legacy function for compatibility
+ */
+async function sendMessage(apiKey, botId, message, conversationId = null, skillPrompts = '') {
+  // System prompt for terminal assistant
+  const systemPrompt = "You are a terminal assistant. When users ask for file listing, command execution, or directory viewing, you MUST use the available tools (bash, read_file, write_file, list_dir). Never say 'run this command' - execute it yourself using tools and show the result.";
+  
+  return sendMessageToGroq(apiKey, message, conversationId, systemPrompt);
 }
 
+/**
+ * Validate API key (not used in v2.0.0, kept for compatibility)
+ */
 async function validateApiKey(apiKey) {
-  try {
-    const result = await getBots(apiKey);
-    return true;
-  } catch (err) {
-    return false;
-  }
+  const groqApiKey = getGroqApiKey();
+  return groqApiKey !== null;
+}
+
+/**
+ * Get bots (not used in v2.0.0, kept for compatibility)
+ */
+async function getBots(apiKey) {
+  return {
+    bots: [
+      {
+        id: 'groq-direct',
+        name: 'Groq Direct',
+        ai_provider: 'groq',
+        model: 'llama-3.3-70b-versatile'
+      }
+    ]
+  };
 }
 
 module.exports = {
-  getBots,
   sendMessage,
+  sendMessageToGroq,
   validateApiKey,
-  _sendMessage, // Export for tool execution loop
+  getBots,
+  clearConversation,
+  getGroqApiKey,
+  _sendMessage: sendMessage, // Alias for compatibility
 };