natureco-cli 5.7.19 → 5.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "5.7.19",
+  "version": "5.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

@@ -27,7 +27,8 @@ const { accumulateToolCallDeltas, finalizeToolCalls } = require('../utils/stream
 const { createPasteSafeInput, createOutputFilter, enableBracketedPaste, disableBracketedPaste, restoreNewlines, clearPasteContext } = require('../utils/paste-safe-input');
 const { getMemoryStore } = require('../utils/memory-store');
 const { buildSkillIndex } = require('../utils/skill-index');
-const { buildTiers, assemble, stableContextKey } = require('../utils/system-prompt');
+const { buildTiers, assemble } = require('../utils/system-prompt');
+const { ToolGuardrails } = require('../utils/tool-guardrails');
 
 // v5.4.6: Model adi sizintisini engelle — global'e ata, callback'lerden erisebilir olsun
 const MODEL_NAMES_TO_HIDE = ['MiniMax-M2.5', 'MiniMaxM2.5', 'minimaxm25', 'Claude-3', 'GPT-4', 'ChatGPT'];
@@ -58,6 +59,46 @@ function getToolDefs() {
   return _toolDefs;
 }
 
+// ── System prompt tier cache (Hermes-style prefix cache warmth) ────────────
+// stable+context built once at session start, volatile rebuilt per turn.
+let _cachedStable = '';
+let _cachedContext = '';
+let _cachedTierOpts = null; // opts snapshot for volatile-only rebuilds
+
+function rebuildSystemPrompt(opts) {
+  // If stable/context opts changed, rebuild them too
+  const needsFullRebuild = !_cachedTierOpts ||
+    _cachedTierOpts.botName !== opts.botName ||
+    _cachedTierOpts.soulSummary !== opts.soulSummary ||
+    _cachedTierOpts.skillsIndexBlock !== opts.skillsIndexBlock ||
+    _cachedTierOpts.crossSessionContext !== opts.crossSessionContext;
+  
+  if (needsFullRebuild || !_cachedStable) {
+    const tiers = buildTiers(opts);
+    _cachedStable = tiers.stable;
+    _cachedContext = tiers.context;
+    _cachedTierOpts = {
+      botName: opts.botName,
+      soulSummary: opts.soulSummary,
+      skillsIndexBlock: opts.skillsIndexBlock,
+      crossSessionContext: opts.crossSessionContext,
+    };
+  }
+  // Volatile always rebuilt fresh
+  const volatileOnly = buildTiers({
+    ...opts,
+    // Pass empty strings for stable/context fields so buildTiers only builds volatile
+    botName: '',
+    soulSummary: '',
+    skillsIndexBlock: '',
+    crossSessionContext: '',
+  });
+  return assemble(_cachedStable, _cachedContext, volatileOnly.volatile);
+}
+
+// ── Tool Guardrails instance (Hermes-style) ─────────────────────────────
+const guardrails = new ToolGuardrails();
+
 // CLI komutları (REPL içinden çalıştırılabilir)
 const CLI_COMMANDS = {
   '/doctor':    { desc: 'Sistem sağlığı kontrolü', run: ['doctor'] },
@@ -233,6 +274,7 @@ async function sendStreaming(providerUrl, providerApiKey, messages, model, onChu
   const isMM = isMiniMax(providerUrl);
   const toolDefs = getToolDefs();
   const toolParam = toOpenAIFormat(toolDefs);
+  guardrails.reset();
 
   let currentMessages = messages;
   let fullText = '';
@@ -268,17 +310,18 @@ async function sendStreaming(providerUrl, providerApiKey, messages, model, onChu
 
   while (iterations < MAX_TOOL_ITERATIONS) {
     iterations++;
+    const shouldStream = !isMM; // MiniMax streaming endpoint doesn't support tool_calls
     const body = {
       model,
       messages: currentMessages,
-      stream: false,  // v5.4.18: tum cevap bekle, sonra fix et
+      stream: shouldStream,
       temperature: 0.3,
       max_tokens: 2048,
     };
     if (toolParam) body.tools = toolParam;
     if (isMM) body.tool_choice = 'auto'; // MiniMax için explicit
 
-    if (!body.stream) {
+    if (!shouldStream) {
       // MiniMax (non-stream) — tool_calls desteklemiyor varsayalım
       const res = await apiRequest(providerUrl, providerApiKey, body, false);
       const msg = res.choices?.[0]?.message || {};
@@ -408,12 +451,25 @@ async function processToolCalls(toolCalls, onToolCall) {
     return { name, args, id };
   });
 
-  // Separate parallel-safe and sequential tools
-  const parallelBatch = parsed.filter(p => PARALLEL_SAFE_TOOLS.has(p.name));
-  const sequentialBatch = parsed.filter(p => !PARALLEL_SAFE_TOOLS.has(p.name));
+  // Filter out blocked tools via guardrails
+  guardrails.startIteration();
+  const blocked = parsed.filter(p => {
+    const check = guardrails.check(p.name, p.args);
+    if (check.blocked) {
+      if (onToolCall) onToolCall({ name: p.name, args: p.args, status: 'done', result: { error: check.reason } });
+      results.push({ ...p, result: { error: check.reason }, _blocked: true });
+      return false;
+    }
+    return true;
+  });
+  const allowed = parsed.filter(p => !results.some(r => r.id === p.id && r._blocked));
+
+  // Separate parallel-safe and sequential tools (over allowed only)
+  const parallelBatch = allowed.filter(p => PARALLEL_SAFE_TOOLS.has(p.name));
+  const sequentialBatch = allowed.filter(p => !PARALLEL_SAFE_TOOLS.has(p.name));
 
-  // Notify UI for all
-  for (const p of parsed) {
+  // Notify UI for all non-blocked
+  for (const p of allowed) {
     if (onToolCall) onToolCall({ name: p.name, args: p.args, status: 'running' });
   }
 
@@ -421,6 +477,8 @@ async function processToolCalls(toolCalls, onToolCall) {
   if (parallelBatch.length > 0) {
     const parallelResults = await Promise.all(parallelBatch.map(async (p) => {
       const result = await executeTool(p.name, p.args, toolDefs);
+      const success = result?.success !== false;
+      guardrails.record(p.name, p.args, success);
       return { ...p, result };
     }));
     results.push(...parallelResults);
@@ -429,9 +487,16 @@ async function processToolCalls(toolCalls, onToolCall) {
   // Run sequential batch one at a time
   for (const p of sequentialBatch) {
     const result = await executeTool(p.name, p.args, toolDefs);
+    const success = result?.success !== false;
+    guardrails.record(p.name, p.args, success);
     results.push({ ...p, result });
   }
 
+  // No-progress check: if all tools failed, inject warning
+  if (guardrails.isNoProgress()) {
+    if (onToolCall) onToolCall({ name: '_no_progress', args: null, status: 'done', result: { error: 'All tools failed this iteration' } });
+  }
+
   // Notify UI done + build messages
   const messages = [];
   for (const { name, id, result } of results) {
@@ -575,26 +640,23 @@ async function startRepl(args) {
   }
 
   // System prompt oluştur (memory + identity + persistent bağlam)
-  // v5.4.6: Bot adı zorlaması EN GÜÇLÜ + SOUL.md EN BAŞTA
+  // v5.6.5: Kucuk model tespiti (Groq, Mistral Small, Ollama) - SOUL injection skip
   const botName = memory.botName || 'Asistan';
   const userName = memory.name || memory.nickname || 'kanka';
-  // v5.6.5: Kucuk model tespiti (Groq, Mistral Small, Ollama) - SOUL injection skip
   const isSmallModel = (cfg.providerUrl || '').includes('groq.com') || 
                        (cfg.providerUrl || '').includes('mistral.ai') ||
                        (cfg.providerUrl || '').includes('localhost') ||
                        (cfg.providerUrl || '').includes('ollama');
-  // `let` (not `const`) because /system <text> reassigns it at line ~796.
-  // Before this fix, /system would throw "Assignment to constant variable"
-  // and tear down the REPL session mid-conversation.
-  const tiers = buildTiers({
+  // Build system prompt with tier caching (stable+context cached, volatile fresh)
+  const promptOpts = {
     botName, userName, soulSummary, isSmallModel,
     memorySnapshotBlock, skillsIndexBlock,
     crossSessionContext: crossSessionContext || '',
     userHome: cfg.userHome || '',
     hasHistory: messages.length > 0,
     memoryFacts: memory.facts || [],
-  });
-  let systemPrompt = assemble(tiers.stable, tiers.context, tiers.volatile);
+  };
+  let systemPrompt = rebuildSystemPrompt(promptOpts);
 
   if (messages.length === 0) {
     messages.push({ role: 'system', content: systemPrompt, _internal: true });
@@ -790,9 +852,12 @@ async function startRepl(args) {
               fs.unlinkSync(path.join(MEMORY_DIR, `${(cfg.userName || 'default').toLowerCase()}.json`));
             }
             memory = { name: cfg.userName, nickname: null, botName: 'Asistan', facts: [], preferences: [], history: [] };
-            // System prompt'u sıfırla
-            const newSysPrompt = systemPrompt.replace(/Kullanıcı hakkında bildiklerin:.*$/, '').trim();
-            messages[0] = { role: 'system', content: newSysPrompt, _internal: true };
+            // System prompt'u rebuild with cleared memory
+            promptOpts.memoryFacts = [];
+            memoryStore.clear();
+            promptOpts.memorySnapshotBlock = memoryStore.getSystemPromptBlock();
+            systemPrompt = rebuildSystemPrompt(promptOpts);
+            messages[0] = { role: 'system', content: systemPrompt, _internal: true };
             console.log(chalk.green('  ✓ Memory temizlendi'));
           } catch (e) {
             console.log(chalk.red('  ❌ ' + e.message));
@@ -822,7 +887,15 @@ async function startRepl(args) {
           break;
         case 'system':
           if (!arg) { console.log(chalk.yellow('  Kullanım: /system <text>')); break; }
-          systemPrompt = arg;
+          // Override stable tier directly (user's custom text)
+          _cachedStable = arg;
+          // Rebuild volatile only (context stays unchanged)
+          memoryStore.load();
+          promptOpts.memorySnapshotBlock = memoryStore.getSystemPromptBlock();
+          promptOpts.memoryFacts = memory.facts || [];
+          const volOpts = { ...promptOpts, botName: '', soulSummary: '', skillsIndexBlock: '', crossSessionContext: '' };
+          const volTiers = buildTiers(volOpts);
+          systemPrompt = assemble(_cachedStable, _cachedContext, volTiers.volatile);
           messages[0] = { role: 'system', content: systemPrompt, _internal: true };
           console.log(chalk.green('  ✓ System prompt güncellendi'));
           break;
@@ -835,8 +908,14 @@ async function startRepl(args) {
           if (!arg) { console.log(chalk.yellow(`  Mevcut: ${memory.botName || 'Asistan'}`)); break; }
           memory.botName = arg;
           saveMemory(cfg.userName, memory);
-          const newSys = systemPrompt.replace(/Sen \w+ adında/, `Sen ${arg} adında`);
-          messages[0] = { role: 'system', content: newSys, _internal: true };
+          // Rebuild stable tier with new botName
+          promptOpts.botName = arg;
+          _cachedTierOpts = null; // force full rebuild
+          memoryStore.load();
+          promptOpts.memorySnapshotBlock = memoryStore.getSystemPromptBlock();
+          promptOpts.memoryFacts = memory.facts || [];
+          systemPrompt = rebuildSystemPrompt(promptOpts);
+          messages[0] = { role: 'system', content: systemPrompt, _internal: true };
           console.log(chalk.green('  ✓ Bot adı: ') + chalk.cyan(arg));
           break;
         case 'tokens':
@@ -891,6 +970,14 @@ async function startRepl(args) {
     // AI cevabı
     process.stdout.write(tui.styled('\n  AI   ', { color: tui.PALETTE.secondary, bold: true }));
     try {
+      // Per-turn: rebuild volatile tier with current memory snapshot (Hermes frozen snapshot)
+      guardrails.reset();
+      memory = loadMemory(cfg.userName);
+      memoryStore.load();
+      promptOpts.memorySnapshotBlock = memoryStore.getSystemPromptBlock();
+      promptOpts.memoryFacts = memory.facts || [];
+      systemPrompt = rebuildSystemPrompt(promptOpts);
+      messages[0] = { role: 'system', content: systemPrompt, _internal: true };
       const apiMessages = messages.filter(m => !m._internal);
       const reply = await sendStreaming(
         providerUrl,
@@ -899,19 +986,19 @@ async function startRepl(args) {
         model,
         // v5.6.12: Callback bos - tam metin 'reply' olarak gelecek (non-stream mode)
         () => {},
-        // Tool call callback — minimal Hermes-style one-liner
-        (toolEvent) => {
+        // Tool call callback — Hermes-style per-tool status line
+        ((toolEvent) => {
+          const name = toolEvent.name;
           if (toolEvent.status === 'running') {
-            process.stdout.write(tui.styled('\r  🔧 ' + toolEvent.name + '...  ', { color: tui.PALETTE.muted }));
+            process.stdout.write(tui.styled('\r  🔧 ' + name + '...  ', { color: tui.PALETTE.muted }));
           } else if (toolEvent.status === 'done') {
-            if (toolEvent.result.error) {
-              process.stdout.write(tui.styled('\r  ✗ ' + toolEvent.name + ': ' + toolEvent.result.error.slice(0, 80) + '\n', { color: tui.PALETTE.danger }));
+            if (toolEvent.result?.error) {
+              process.stdout.write(tui.styled('  ✗ ' + name + ': ' + String(toolEvent.result.error).slice(0, 80) + '\n', { color: tui.PALETTE.danger }));
             } else {
-              process.stdout.write('\r' + tui.styled('  ✓ ' + toolEvent.name + '    ', { color: tui.PALETTE.success }) + '\r');
+              process.stdout.write(tui.styled('  ✓ ' + name + '\n', { color: tui.PALETTE.success }));
             }
-            process.stdout.write(tui.styled('  AI   ', { color: tui.PALETTE.secondary, bold: true }));
           }
-        }
+        })
       );
       // v5.6.12: Tam metin 'reply' olarak zaten geldi (non-stream mode)
       const fullReply = String(reply || '');

package/src/utils/api.js

@@ -10,6 +10,8 @@ const { getToolDefinitions, executeToolCalls } = require('./tool-runner');
 const { MCPClient } = require('./mcp-client');
 const TB = require('./token-budget');
 const { accumulateToolCallDeltas } = require('./streaming-tools');
+const { ToolGuardrails } = require('./tool-guardrails');
+const guardrails = new ToolGuardrails();
 
 /**
  * v5.5.0: Provider-specific format detection
@@ -756,44 +758,59 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
         input: JSON.parse(tc.function.arguments)
       }));
 
-      const toolResults = [];
-      const SPINNER_FRAMES = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
-
-      for (const toolCall of toolCalls) {
-        // Spinner başlat
-        let frameIdx = 0;
-        const inputPreview = JSON.stringify(toolCall.input).slice(0, 50);
-        const spinner = setInterval(() => {
-          process.stdout.write(`\r  ${chalk.cyan(SPINNER_FRAMES[frameIdx++ % SPINNER_FRAMES.length])} ${chalk.gray(toolCall.name + ' — ' + inputPreview)}`);
-        }, 80);
-
-        // Check if this is an MCP tool
-        const mcpTools = getMcpTools();
-        const isMcpTool = mcpTools.find(t => t.name === toolCall.name);
-        let result;
-
-        if (isMcpTool) {
-          debugLog(`[MCP] Executing tool: ${toolCall.name}`);
-          result = await executeMcpTool(toolCall.name, toolCall.input);
-          toolResults.push({ id: toolCall.id, name: toolCall.name, result });
-        } else {
-          debugLog(`[Local] Executing tool: ${toolCall.name}`);
-          const localResults = await executeToolCalls([toolCall]);
-          toolResults.push(...localResults);
-          result = localResults[0]?.result;
+      // Group MCP and local tools
+      const mcpTools = getMcpTools();
+      const mcpCalls = toolCalls.filter(tc => mcpTools.find(t => t.name === tc.name));
+      const localCalls = toolCalls.filter(tc => !mcpTools.find(t => t.name === tc.name));
+
+      // Guardrails: filter blocked tools
+      guardrails.reset();
+      guardrails.startIteration();
+      const blockedMcp = mcpCalls.filter(tc => {
+        const check = guardrails.check(tc.name, tc.input);
+        return check.blocked;
+      });
+      const blockedLocal = localCalls.filter(tc => {
+        const check = guardrails.check(tc.name, tc.input);
+        return check.blocked;
+      });
+
+      // Execute local tools in parallel (tool-runner already parallelizes safe tools)
+      let localResults = [];
+      if (localCalls.filter(tc => !blockedLocal.includes(tc)).length > 0) {
+        debugLog(`[Local] Executing ${localCalls.length} tool(s) concurrently`);
+        localResults = await executeToolCalls(
+          localCalls.filter(tc => !blockedLocal.includes(tc)),
+          { toolDefinitions: getToolDefinitions() }
+        );
+        for (const r of localResults) {
+          guardrails.record(r.name, {}, r.result?.success !== false);
         }
+      }
 
-        // Spinner durdur, sonucu göster
-        clearInterval(spinner);
-        const success = result?.success !== false;
-        process.stdout.write(`\r  ${success ? chalk.green('✓') : chalk.red('✗')} ${chalk.cyan(toolCall.name)} ${chalk.gray('— ' + inputPreview)}\n`);
+      // Execute MCP tools in parallel (they're independent by nature)
+      let mcpResults = [];
+      if (mcpCalls.filter(tc => !blockedMcp.includes(tc)).length > 0) {
+        debugLog(`[MCP] Executing ${mcpCalls.length} tool(s) concurrently`);
+        mcpResults = await Promise.all(
+          mcpCalls.filter(tc => !blockedMcp.includes(tc)).map(async (tc) => {
+            const result = await executeMcpTool(tc.name, tc.input);
+            guardrails.record(tc.name, tc.input, result?.success !== false);
+            return { id: tc.id, name: tc.name, result };
+          })
+        );
       }
 
-      // Add tool results to messages (base64 encoded for safety)
-      for (const result of toolResults) {
-        // Encode tool result (works for both MCP and local tools)
+      // Add blocked tool results as errors
+      const allResults = [
+        ...blockedMcp.map(tc => ({ id: tc.id, name: tc.name, result: { error: `blocked_by_guardrails: ${tc.name}` } })),
+        ...blockedLocal.map(tc => ({ id: tc.id, name: tc.name, result: { error: `blocked_by_guardrails: ${tc.name}` } })),
+        ...localResults,
+        ...mcpResults,
+      ];
+
+      for (const result of allResults) {
         const encodedContent = encodeToolResult(result.result);
-        
         messages.push({
           role: 'tool',
           tool_call_id: result.id,

package/src/utils/memory-store.js

@@ -120,6 +120,15 @@ class MemoryStore {
     return JSON.stringify({ success: true, message: 'Memory entry removed.', removed: removed[0] });
   }
 
+  clear(target) {
+    const path = this._pathFor(target);
+    this._ensureDir();
+    fs.writeFileSync(path, '', 'utf8');
+    const entries = target === 'user' ? this._userEntries : this._memoryEntries;
+    entries.length = 0;
+    return JSON.stringify({ success: true, message: `Memory ${target} cleared.` });
+  }
+
   replace(target, oldContent, newContent) {
     if (!oldContent || !newContent) {
       return JSON.stringify({ success: false, error: 'Both old and new content required.' });

package/src/utils/tool-guardrails.js

@@ -0,0 +1,85 @@
+/**
+ * Tool Guardrails — Hermes-style ToolCallGuardrailController
+ *
+ * Tracks per-iteration:
+ *   - failure count per tool
+ *   - repeated identical calls (same name + same args)
+ *   - no-progress detection (all tools failing)
+ */
+
+class ToolGuardrails {
+  constructor() {
+    this.reset();
+  }
+
+  reset() {
+    this.callLog = [];         // [{ name, argsKey, iteration, success }]
+    this.failureCounts = {};   // { toolName: count }
+    this.iteration = 0;
+    this.blockedTools = new Set();
+    this.consecutiveFailures = {};
+  }
+
+  startIteration() {
+    this.iteration++;
+    // Decay consecutive failures each iteration (Hermes: decay factor 0.5)
+    for (const name of Object.keys(this.consecutiveFailures)) {
+      this.consecutiveFailures[name] = Math.floor(this.consecutiveFailures[name] * 0.5);
+      if (this.consecutiveFailures[name] <= 0) {
+        delete this.consecutiveFailures[name];
+        this.blockedTools.delete(name);
+      }
+    }
+  }
+
+  /**
+   * Returns blocked tool names if guardrails trigger.
+   */
+  check(toolName, toolArgs) {
+    const argsKey = JSON.stringify(toolArgs || {});
+
+    // 1. Too many repeated identical calls (Hermes: same name+args in last 3 calls)
+    const identicalCount = this.callLog.filter(
+      c => c.name === toolName && c.argsKey === argsKey && c.iteration >= this.iteration - 2
+    ).length;
+    if (identicalCount >= 2) {
+      return { blocked: true, reason: `repeated_call: ${toolName} called ${identicalCount + 1}x with same args` };
+    }
+
+    // 2. Too many failures (Hermes: 2+ failures = blocked for this iteration)
+    const recentFailures = this.callLog.filter(
+      c => c.name === toolName && !c.success && c.iteration >= this.iteration - 1
+    ).length;
+    if (recentFailures >= 2 || (this.consecutiveFailures[toolName] || 0) >= 2) {
+      this.blockedTools.add(toolName);
+      return { blocked: true, reason: `too_many_failures: ${toolName} failed ${recentFailures + 1}x` };
+    }
+
+    return { blocked: false };
+  }
+
+  /**
+   * Record a tool call result.
+   */
+  record(toolName, toolArgs, success) {
+    const argsKey = JSON.stringify(toolArgs || {});
+    this.callLog.push({ name: toolName, argsKey, iteration: this.iteration, success });
+
+    if (!success) {
+      this.failureCounts[toolName] = (this.failureCounts[toolName] || 0) + 1;
+      this.consecutiveFailures[toolName] = (this.consecutiveFailures[toolName] || 0) + 1;
+    } else {
+      this.consecutiveFailures[toolName] = 0;
+    }
+  }
+
+  /**
+   * Returns true if no tool has succeeded this iteration (no-progress).
+   */
+  isNoProgress() {
+    const thisIter = this.callLog.filter(c => c.iteration === this.iteration);
+    return thisIter.length > 0 && thisIter.every(c => !c.success);
+  }
+}
+
+module.exports = { ToolGuardrails };

package/src/utils/tool-runner.js

@@ -146,13 +146,33 @@ async function executeTool(toolName, params, opts = {}) {
   }
 }
 
-// ── Execute multiple tool calls ───────────────────────────────────────────────
+// ── Execute multiple tool calls (parallel for independent, sequential for others) ──
+const PARALLEL_SAFE_TOOLS = new Set(['read_file', 'file_search', 'grep_search', 'web_search', 'web_readability', 'duckduckgo_search', 'exa_search', 'searxng_search', 'firecrawl', 'memory_search', 'memory']);
+
 async function executeToolCalls(toolCalls, opts = {}) {
+  if (!toolCalls || toolCalls.length === 0) return [];
+
+  // Group: parallel-safe vs sequential
+  const safe = toolCalls.filter(c => PARALLEL_SAFE_TOOLS.has(c.name));
+  const sequential = toolCalls.filter(c => !PARALLEL_SAFE_TOOLS.has(c.name));
+
   const results = [];
-  for (const call of toolCalls) {
+
+  // Run parallel-safe tools concurrently
+  if (safe.length > 0) {
+    const safeResults = await Promise.all(safe.map(async (call) => {
+      const result = await executeTool(call.name, call.input, opts);
+      return { id: call.id, name: call.name, result };
+    }));
+    results.push(...safeResults);
+  }
+
+  // Run sequential tools one at a time
+  for (const call of sequential) {
     const result = await executeTool(call.name, call.input, opts);
     results.push({ id: call.id, name: call.name, result });
   }
+
   return results;
 }