natureco-cli 4.7.4 → 4.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "4.7.4",
+  "version": "4.8.0",
   "description": "OpenClaw'dan daha güvenli, daha hızlı, daha ucuz AI agent CLI. Multi-agent, self-evolving skills, audit log, maliyet optimizasyonu ve NatureCo platform-native.",
   "bin": {
     "natureco": "bin/natureco.js"

package/src/commands/repl.js

@@ -22,6 +22,20 @@ const https = require('https');
 const { spawn } = require('child_process');
 const chalk = require('chalk');
 const tui = require('../utils/tui');
+const { loadToolDefinitions, toOpenAIFormat, executeTool } = require('../utils/tools');
+
+// v4.8.0: Tool definitions — başlangıçta bir kez yükle (performans)
+let _toolDefs = null;
+function getToolDefs() {
+  if (!_toolDefs) {
+    try {
+      _toolDefs = loadToolDefinitions();
+    } catch (e) {
+      _toolDefs = [];
+    }
+  }
+  return _toolDefs;
+}
 
 // CLI komutları (REPL içinden çalıştırılabilir)
 const CLI_COMMANDS = {
@@ -194,55 +208,183 @@ function apiRequest(providerUrl, providerApiKey, body, stream = false) {
   });
 }
 
-async function sendStreaming(providerUrl, providerApiKey, messages, model, onChunk) {
+async function sendStreaming(providerUrl, providerApiKey, messages, model, onChunk, onToolCall) {
   const isMM = isMiniMax(providerUrl);
-  const body = { model, messages, stream: !isMM, temperature: 0.3, max_tokens: 2048 };
-  if (!body.stream) {
-    const res = await apiRequest(providerUrl, providerApiKey, body, false);
-    const content = res.choices?.[0]?.message?.content || '';
-    for (const char of content) {
-      onChunk(char);
-      await new Promise(r => setTimeout(r, 8));
-    }
-    return content;
-  }
-  const endpoint = `${providerUrl.replace(/\/+$/, '')}/chat/completions`;
-  return new Promise((resolve, reject) => {
-    const req = https.request(endpoint, {
-      method: 'POST',
-      headers: { 'Authorization': `Bearer ${providerApiKey}`, 'Content-Type': 'application/json' },
-      timeout: 60000,
-    }, (res) => {
-      if (res.statusCode !== 200) {
-        let data = '';
-        res.on('data', c => data += c);
-        res.on('end', () => reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`)));
-        return;
+  const toolDefs = getToolDefs();
+  const toolParam = isMM ? undefined : toOpenAIFormat(toolDefs);
+
+  // v4.8.0: Tool calling + streaming + multi-turn tool execution
+  let currentMessages = messages;
+  let fullText = '';
+  let iterations = 0;
+  const MAX_TOOL_ITERATIONS = 5; // Sonsuz döngüyü önle
+
+  while (iterations < MAX_TOOL_ITERATIONS) {
+    iterations++;
+    const body = {
+      model,
+      messages: currentMessages,
+      stream: !isMM,
+      temperature: 0.3,
+      max_tokens: 2048,
+    };
+    if (toolParam) body.tools = toolParam;
+
+    if (!body.stream) {
+      // MiniMax (non-stream) — tool_calls desteklemiyor varsayalım
+      const res = await apiRequest(providerUrl, providerApiKey, body, false);
+      const msg = res.choices?.[0]?.message || {};
+      const content = msg.content || '';
+      for (const char of content) {
+        onChunk(char);
+        await new Promise(r => setTimeout(r, 8));
       }
-      let buffer = ''; let full = '';
-      res.on('data', (chunk) => {
-        buffer += chunk.toString('utf8');
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed || !trimmed.startsWith('data:')) continue;
-          const data = trimmed.slice(5).trim();
-          if (data === '[DONE]') { resolve(full); return; }
-          try {
-            const parsed = JSON.parse(data);
-            const delta = parsed.choices?.[0]?.delta?.content || '';
-            if (delta) { full += delta; onChunk(delta); }
-          } catch {}
+      fullText = content;
+      // Non-stream tool call desteği
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        const toolResults = await processToolCalls(msg.tool_calls, onToolCall);
+        currentMessages.push(msg);
+        currentMessages.push(...toolResults);
+        continue; // Tekrar API çağır
+      }
+      break;
+    }
+
+    // OpenAI uyumlu streaming
+    const endpoint = `${providerUrl.replace(/\/+$/, '')}/chat/completions`;
+    const result = await new Promise((resolve, reject) => {
+      const req = https.request(endpoint, {
+        method: 'POST',
+        headers: { 'Authorization': `Bearer ${providerApiKey}`, 'Content-Type': 'application/json' },
+        timeout: 60000,
+      }, (res) => {
+        if (res.statusCode !== 200) {
+          let data = '';
+          res.on('data', c => data += c);
+          res.on('end', () => reject(new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`)));
+          return;
         }
+        let buffer = '';
+        let streamText = '';
+        const toolCalls = []; // { index, id, name, args }
+        res.on('data', (chunk) => {
+          buffer += chunk.toString('utf8');
+          const lines = buffer.split('\n');
+          buffer = lines.pop() || '';
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('data:')) continue;
+            const data = trimmed.slice(5).trim();
+            if (data === '[DONE]') {
+              resolve({ streamText, toolCalls });
+              return;
+            }
+            try {
+              const parsed = JSON.parse(data);
+              const choice = parsed.choices?.[0];
+              if (!choice) continue;
+              const delta = choice.delta;
+
+              // Text content
+              if (delta.content) {
+                streamText += delta.content;
+                onChunk(delta.content);
+              }
+
+              // Tool calls (streaming delta)
+              if (delta.tool_calls) {
+                for (const tcDelta of delta.tool_calls) {
+                  const idx = tcDelta.index;
+                  if (!toolCalls[idx]) {
+                    toolCalls[idx] = { index: idx, id: '', name: '', args: '' };
+                  }
+                  if (tcDelta.id) toolCalls[idx].id = tcDelta.id;
+                  if (tcDelta.function?.name) toolCalls[idx].name += tcDelta.function.name;
+                  if (tcDelta.function?.arguments) toolCalls[idx].args += tcDelta.function.arguments;
+                }
+              }
+            } catch {}
+          }
+        });
+        res.on('end', () => resolve({ streamText, toolCalls }));
       });
-      res.on('end', () => resolve(full));
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+      req.write(JSON.stringify(body));
+      req.end();
     });
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
-    req.write(JSON.stringify(body));
-    req.end();
-  });
+
+    fullText = result.streamText;
+
+    // Tool call var mı?
+    if (result.toolCalls && result.toolCalls.length > 0 && result.toolCalls[0].name) {
+      // Assistant mesajını ekle (tool_calls ile)
+      currentMessages.push({
+        role: 'assistant',
+        content: result.streamText || null,
+        tool_calls: result.toolCalls.map(tc => ({
+          id: tc.id || `call_${Date.now()}_${tc.index}`,
+          type: 'function',
+          function: { name: tc.name, arguments: tc.args },
+        })),
+      });
+      // Her tool call'ı çalıştır, sonuçları tool mesajı olarak ekle
+      const toolResults = await processToolCalls(result.toolCalls, onToolCall);
+      currentMessages.push(...toolResults);
+      // Devam — model sonuçları görsün, cevap versin
+      continue;
+    }
+
+    break; // Tool call yok, çık
+  }
+
+  return fullText;
+}
+
+/**
+ * Tool call'ları çalıştır, sonuçları OpenAI uyumlu tool mesajlarına dönüştür.
+ * @param toolCalls - API'den gelen tool_calls array
+ * @param onToolCall - UI callback (her tool call'ı kullanıcıya göster)
+ * @returns messages array — { role: 'tool', tool_call_id, content }
+ */
+async function processToolCalls(toolCalls, onToolCall) {
+  const toolDefs = getToolDefs();
+  const messages = [];
+
+  for (const tc of toolCalls) {
+    const name = tc.function?.name || tc.name;
+    const argsStr = tc.function?.arguments || tc.args || '{}';
+    const id = tc.id || `call_${Date.now()}`;
+
+    let args = {};
+    try {
+      args = typeof argsStr === 'string' ? JSON.parse(argsStr) : argsStr;
+    } catch (e) {
+      args = { _parse_error: e.message, _raw: argsStr };
+    }
+
+    // UI callback — tool çalıştırılıyor bildir
+    if (onToolCall) {
+      onToolCall({ name, args, status: 'running' });
+    }
+
+    // Tool çalıştır
+    const result = await executeTool(name, args, toolDefs);
+
+    if (onToolCall) {
+      onToolCall({ name, args, status: 'done', result });
+    }
+
+    messages.push({
+      role: 'tool',
+      tool_call_id: id,
+      content: result.error
+        ? JSON.stringify({ error: result.error })
+        : (typeof result.result === 'string' ? result.result : JSON.stringify(result.result).slice(0, 8000)),
+    });
+  }
+
+  return messages;
 }
 
 function printHelp() {
@@ -517,9 +659,33 @@ async function startRepl(args) {
     process.stdout.write(tui.styled('\n  AI   ', { color: tui.PALETTE.secondary, bold: true }));
     try {
       const apiMessages = messages.filter(m => !m._internal);
-      const reply = await sendStreaming(providerUrl, providerApiKey, apiMessages, model, (chunk) => {
-        process.stdout.write(chunk);
-      });
+      const reply = await sendStreaming(
+        providerUrl,
+        providerApiKey,
+        apiMessages,
+        model,
+        // Text chunk callback
+        (chunk) => process.stdout.write(chunk),
+        // Tool call callback — kullanıcıya göster
+        (toolEvent) => {
+          if (toolEvent.status === 'running') {
+            process.stdout.write('\n');
+            console.log(tui.styled('  🔧 Tool: ' + toolEvent.name, { color: tui.PALETTE.accent, bold: true }));
+            const argsStr = JSON.stringify(toolEvent.args).slice(0, 120);
+            console.log(tui.styled('     Args: ' + argsStr, { color: tui.PALETTE.muted }));
+          } else if (toolEvent.status === 'done') {
+            if (toolEvent.result.error) {
+              console.log(tui.styled('     ✗ Hata: ' + toolEvent.result.error.slice(0, 100), { color: tui.PALETTE.danger }));
+            } else {
+              const resultStr = typeof toolEvent.result.result === 'string'
+                ? toolEvent.result.result.slice(0, 200)
+                : JSON.stringify(toolEvent.result.result).slice(0, 200);
+              console.log(tui.styled('     ✓ Sonuç: ' + resultStr, { color: tui.PALETTE.success }));
+            }
+            process.stdout.write(tui.styled('  AI   ', { color: tui.PALETTE.secondary, bold: true }));
+          }
+        }
+      );
       process.stdout.write('\n');
       messages.push({ role: 'assistant', content: reply });
       totalInputTokens += apiMessages.reduce((s, m) => s + Math.ceil((m.content || '').length / 4), 0);

package/src/utils/tools.js

@@ -0,0 +1,96 @@
+/**
+ * NatureCo CLI — Tool Definitions for OpenAI-compatible APIs
+ *
+ * src/tools/*.js dosyalarını OpenAI uyumlu function calling format'ına dönüştürür.
+ * Her tool'un:
+ *   - name: tool adı
+ *   - description: ne yaptığı
+ *   - parameters: JSON schema
+ *
+ * REPL bu listeyi API'ye gönderir, model tool çağrısı yapar,
+ * biz tool'u çalıştırır, sonucu modele geri veririz.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const TOOLS_DIR = path.join(__dirname, '..', 'tools');
+
+/**
+ * src/tools/*.js dosyalarını oku, her birinin export'ladığı
+ * tool metadata'sını topla. Eğer tool'un export'unda
+ * { name, description, parameters, execute } varsa kullan,
+ * yoksa dosya adından otomatik üret.
+ */
+function loadToolDefinitions() {
+  const tools = [];
+  const files = fs.readdirSync(TOOLS_DIR).filter(f => f.endsWith('.js'));
+
+  for (const file of files) {
+    try {
+      const toolPath = path.join(TOOLS_DIR, file);
+      const mod = require(toolPath);
+
+      // Tool metadata çıkar
+      const meta = {
+        name: mod.name || path.basename(file, '.js'),
+        description: mod.description || `${path.basename(file, '.js')} tool`,
+        parameters: mod.parameters || mod.inputSchema || { type: 'object', properties: {} },
+        execute: mod.execute || (mod.default && mod.default.execute) || null,
+      };
+
+      // Eğer execute fonksiyonu varsa ekle (CLI'da çalıştırmak için)
+      if (meta.execute) {
+        tools.push(meta);
+      }
+    } catch (e) {
+      // Sessizce atla — bozuk tool dosyaları kritik değil
+    }
+  }
+
+  return tools;
+}
+
+/**
+ * OpenAI uyumlu API'ye gönderilecek format:
+ *   [{ type: "function", function: { name, description, parameters } }]
+ */
+function toOpenAIFormat(toolDefs) {
+  return toolDefs.map(t => ({
+    type: 'function',
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters,
+    },
+  }));
+}
+
+/**
+ * Tool çağrısını çalıştır
+ * @param toolName - tool adı
+ * @param args - tool argümanları (object)
+ * @param toolDefs - loadToolDefinitions() sonucu
+ * @returns { result, error }
+ */
+async function executeTool(toolName, args, toolDefs) {
+  const tool = toolDefs.find(t => t.name === toolName);
+  if (!tool) {
+    return { error: `Tool bulunamadı: ${toolName}` };
+  }
+  if (!tool.execute) {
+    return { error: `Tool execute fonksiyonu yok: ${toolName}` };
+  }
+  try {
+    const result = await tool.execute(args || {});
+    return { result };
+  } catch (e) {
+    return { error: e.message || String(e) };
+  }
+}
+
+module.exports = {
+  loadToolDefinitions,
+  toOpenAIFormat,
+  executeTool,
+};