natureco-cli 5.23.0 → 5.26.0

package/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 All notable changes to NatureCo CLI will be documented in this file.
 
+## [5.26.0] - 2026-07-04 — "CANLI STREAMING + KEŞFET→DÜZENLE→DOĞRULA"
+
+### ✨ Yeni
+- **Canlı streaming (TTY)**: yanit artik token token akarak gelir (Hermes/Claude Code hissi). SSE → tool-call/skill XML'ini gizleyen filtre → model-adi sanitizer ("Ben MiniMax"→"Ben {bot}") zinciri; kelime chunk sinirinda bolunse bile sizinti yok. Non-TTY (pipe/CI) bloklu yola duser. `makeStreamFilter` + `makeSanitizeStream` (birim testli).
+- **Keşfet→düzenle→doğrula**: ajana `file_search` (glob), `list_dir` ve MEVCUT dosyayi hedefli degistiren `edit_file` eklendi; sistem prompt'u "once oku, sonra edit_file ile duzenle, sonra calistirip dogrula" akisini ogretir. E2E dogrulandi (dosyayi oku→edit→node ile calistir→sonucu raporla).
+
+### 🐛 Düzeltme
+- **Okuma araclari icerigi modele donmuyordu**: `read_file`/`list_dir`/`file_search`/`bash` sonucu ajana sadece "OK" olarak donuyordu → model icerigi goremeyip "okudum ama bos" diye takiliyordu. Feedback artik gercek ciktiyi (content/output/results) modele verir.
+
+Doğrulama: MiniMax ile E2E (oku→edit→calistir; streaming XML/model-adi sizintisiz); **484 test yeşil**, ESLint temiz.
+
+## [5.25.0] - 2026-07-04 — "PROVIDER-AGNOSTİK + STREAMING ALTYAPISI"
+
+### ✨ İyileştirme
+- **Provider-agnostik**: agentic düzeltmeler MiniMax'e özel DEĞİL — `workflow.js`'in paylaşılan non-tool-calling dalında çalışır (MiniMax, Groq, Ollama, yerel modeller). Tool-calling sağlayıcıları (OpenAI, Anthropic, Gemini) kendi native `tool_calls` yolunu kullanır (dokunulmadı). `agentic-runner` hem native `tool_calls` hem native XML parse eder → sağlayıcıdan bağımsız çalışır.
+- **Streaming altyapısı**: canlı akışta tool-call/skill protokol jetonlarını (`<minimax:tool_call>`, `<invoke>`, `<skill>`) gizleyip düz metni gösteren, chunk sınırında bölünen tag'leri doğru işleyen akış filtresi (`makeStreamFilter`, 4 test). Tam devreye alma (streaming-güvenli model-adı temizleme ile birlikte) sonraki adım.
+
+> Not: v5.24.0'daki büyük düzeltmeler (MiniMax dosya yazma, komut çalıştırma, memory recall) bu sürümde de yer alır.
+
+## [5.24.0] - 2026-07-04 — "AGENTIC SERTLEŞTİRME" (MiniMax native tool-call + komut çalıştırma)
+
+Kök neden: **MiniMax M2.5 agentic bir model** — tool call'ları OpenAI `tool_calls` JSON'u yerine metin içinde native XML olarak üretir (`<minimax:tool_call><invoke name="write_file">...`) ve skill'i `<skill>ad</skill>` ile yükler. 5.23.0'ın tek-atış JSON planı bunu yakalayamıyordu; `JSON.parse` patlayıp boş `catch{}` yutunca dosya sessizce yazılmıyordu ("masaüstünde yarış oyunu yapamadı").
+
+### ✨ Yeni
+- **`src/tools/agentic-runner.js`**: MiniMax'in native XML/skill protokolünü parse edip gerçek araçları çalıştıran bounded agentic döngü (parse→execute→sonucu geri besle→dur, max 15 iterasyon). `workflow.js`'in non-tool-calling dalı buna bağlandı. 13 yeni birim testi.
+- **Komut çalıştırma (onaylı)**: ajan artık `bash` ile npm/git/node/test çalıştırıp çıktıya göre devam edebilir — gerçek **yaz→çalıştır→test→düzelt** döngüsü.
+
+### 🐛 Düzeltme
+- **MiniMax dosya yazma**: native `<invoke>`/`<skill>` parse edilip gerçek araçlara yönlendiriliyor; büyük içerikteki JSON-kaçış sorunu ortadan kalktı.
+- **Memory recall split-brain**: hafıza `default.json`'da tutulurken okuyucular `<userName>.json` arıyordu → chat/code kullanıcıyı hiç hatırlamıyordu ("adım ne?"→"bilmiyorum"). `loadUserMemory` + `repl.loadMemory` artık `<user>.json` + legacy `default.json`'ı birleştirir (isim-eşleşme guard'ı).
+- **Bot personası**: jenerik "Asistan" placeholder'ı gerçek persona (örn. "Hinata") ile eziliyor.
+
+### 🔒 Güvenlik
+- **Ajan modunda yıkıcı komut guard'ı**: varsayılan 'full' politika `rm -rf /`'i bile geçiriyordu (insan için bilinçli olabilir, model için değil). Agentic-runner artık `isDangerousCommand`'ı politikadan bağımsız uygular — yıkıcı komutlar ajan tarafından **çalıştırılmaz**. Diğer ~85 araç allowlist dışı (yalnızca write_file/read_file/edit_file/skill_view/bash).
+
+Doğrulama: gerçek MiniMax API ile uçtan uca (yarış oyunu + "node script yaz&çalıştır"→42); **474 test yeşil**.
+
 ## [5.23.0] - 2026-07-02 — "NON-TOOL-CALLING FIX" (MiniMax dosya yazma)
 
 ### 🐛 Düzeltme

package/package.json

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

@@ -145,11 +145,36 @@ function getConfig() {
 const { isMiniMax, isGemini, buildChatEndpoint } = require('../utils/provider-detect');
 
 function loadMemory(username) {
-  const file = path.join(MEMORY_DIR, `${(username || 'default').toLowerCase()}.json`);
-  try {
-    if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {}
-  return { name: username || 'Kullanıcı', nickname: null, botName: 'Asistan', facts: [], preferences: [], history: [] };
+  const uname = (username || 'default').toLowerCase();
+  const base = { name: username || 'Kullanıcı', nickname: null, botName: null, facts: [], preferences: [], history: [] };
+  const readJson = (f) => { try { return fs.existsSync(f) ? JSON.parse(fs.readFileSync(f, 'utf8')) : null; } catch { return null; } };
+
+  const userMem = readJson(path.join(MEMORY_DIR, `${uname}.json`));
+  const merged = userMem
+    ? { ...base, ...userMem, facts: [...(userMem.facts || [])], preferences: [...(userMem.preferences || [])], history: [...(userMem.history || [])] }
+    : { ...base };
+
+  // Legacy default.json'i birlestir (isim eslesiyorsa ya da isimsizse): eski kurulumlarda
+  // hafiza + bot personasi default.json'da kalmis olabiliyordu; <user>.json ile split-brain
+  // olusuyordu. Birlestirince recall calisir ve ilk kayitta konsolide olur.
+  if (uname !== 'default') {
+    const def = readJson(path.join(MEMORY_DIR, 'default.json'));
+    if (def && (!def.name || String(def.name).toLowerCase() === uname)) {
+      // Jenerik "Asistan" placeholder'ini gercek persona (orn. Hinata) ile ez
+      const isGeneric = (b) => !b || /^asistan$/i.test(String(b));
+      if (isGeneric(merged.botName) && def.botName && !isGeneric(def.botName)) merged.botName = def.botName;
+      if ((!merged.name || merged.name === 'Kullanıcı') && def.name) merged.name = def.name;
+      const factVal = (f) => ((f && (f.value != null ? f.value : f)) || '').toString().trim();
+      const seen = new Set(merged.facts.map(f => factVal(f).toLowerCase()));
+      for (const f of (def.facts || [])) {
+        const v = factVal(f);
+        if (v && !seen.has(v.toLowerCase())) { seen.add(v.toLowerCase()); merged.facts.push(f); }
+      }
+    }
+  }
+
+  if (!merged.botName) merged.botName = 'Asistan';
+  return merged;
 }
 
 function saveMemory(username, memory) {
@@ -1468,16 +1493,20 @@ async function startRepl(args) {
       messages[0] = { role: 'system', content: systemPrompt, _internal: true };
 
       // v5.13.0: Run workflow FIRST for every request
-      process.stdout.write(tui.styled('\r  🔧 workflow...  ', { color: tui.PALETTE.muted }));
+      // v5.26: TTY'de canli streaming — spinner yerine yanit akarak gelir (workflow stdout'a akitir)
+      const wantStream = !!(process.stdout && process.stdout.isTTY);
+      if (!wantStream) process.stdout.write(tui.styled('\r  🔧 workflow...  ', { color: tui.PALETTE.muted }));
       const wfToolDefs = getToolDefs();
       const recentHistory = messages.length > 1 ? messages.slice(-10) : [];
-      const wfResult = await executeTool('workflow', { action: 'run', task: line, conversationHistory: recentHistory }, wfToolDefs);
+      const wfResult = await executeTool('workflow', { action: 'run', task: line, conversationHistory: recentHistory, stream: wantStream }, wfToolDefs);
       const wf = wfResult?.result || {};
-      if (wf.success !== false) {
-        const loaded = wf.skillsLoaded && wf.skillsLoaded.length > 0 ? ` [skill: ${wf.skillsLoaded.join(', ')}]` : '';
-        process.stdout.write(tui.styled(`  ✓ workflow${loaded}\n`, { color: tui.PALETTE.success }));
-      } else {
-        process.stdout.write(tui.styled('  ✗ workflow\n', { color: tui.PALETTE.danger }));
+      if (!wf.streamed) {
+        if (wf.success !== false) {
+          const loaded = wf.skillsLoaded && wf.skillsLoaded.length > 0 ? ` [skill: ${wf.skillsLoaded.join(', ')}]` : '';
+          process.stdout.write(tui.styled(`  ✓ workflow${loaded}\n`, { color: tui.PALETTE.success }));
+        } else {
+          process.stdout.write(tui.styled('  ✗ workflow\n', { color: tui.PALETTE.danger }));
+        }
       }
 
       if (wf.passthrough && wf.reply !== undefined && wf.reply !== null) {
@@ -1497,7 +1526,9 @@ async function startRepl(args) {
         fixedReply = fixedReply.replace(/Ben\s+GPT[^.!?,;:\n]*/gi, 'Ben ' + displayBotName);
         fixedReply = fixedReply.replace(/Ben\s+Asistan[\s\w\.]*/gi, 'Ben ' + displayBotName);
         fixedReply = fixedReply.replace(/\*\*(?:MiniMax|Claude|GPT|M2\.5|M2)[^\*]*\*\*/gi, '**' + displayBotName + '**');
-        process.stdout.write('\n' + fixedReply + '\n');
+        // streamed ise yanit zaten canli basildi (sanitize edilerek) — tekrar basma
+        if (wf.streamed) process.stdout.write('\n');
+        else process.stdout.write('\n' + fixedReply + '\n');
         messages.push({ role: 'assistant', content: fixedReply });
         totalInputTokens += Math.ceil(line.length / 4);
         totalOutputTokens += Math.ceil(fullReply.length / 4);

package/src/tools/agentic-runner.js

@@ -0,0 +1,322 @@
+/**
+ * agentic-runner — "agentic-text" modeller (MiniMax M2.x gibi) icin bounded tool döngüsü.
+ *
+ * Neden: MiniMax M2.5 tool call'larini OpenAI tarzi `message.tool_calls` JSON'u yerine
+ * dogrudan metin icinde native XML olarak uretir:
+ *   <minimax:tool_call><invoke name="write_file"><parameter name="path">...</parameter>
+ *   <parameter name="content">...</parameter></invoke></minimax:tool_call>
+ * Ayrica skill'leri <skill>ad</skill> ile yuklemek ister. Eski passthrough bunlari
+ * hic islemedigi icin (JSON.parse patliyor, bos catch yutuyor) dosya asla yazilmiyordu.
+ *
+ * Bu modul o XML'i parse eder, gercek araclari (write_file/read_file/edit_file/skill_view)
+ * calistirir, sonuclari modele geri besler ve is bitene kadar (ya da MAX adima kadar) doner.
+ *
+ * Guvenlik: sadece allowlist'teki araclar calisir. bash/shell gibi keyfi komut calistirma
+ * bu modda KAPALIDIR (onay katmanini atlamamak icin).
+ */
+const path = require('path');
+const os = require('os');
+
+// Agentic dongude izin verilen araclar. bash BURADA ama guvenli: bash.js kendi
+// icinde approvals politikasini uyguluyor (isSafeCommand → direkt; tehlikeli → red;
+// digerleri → allowlist/full moda gore). Yani keyfi/yikici komut calismaz.
+// Diger ~85 arac (discord, telegram, cron, browser...) bilerek DISARIDA.
+const DEFAULT_ALLOWED = ['write_file', 'read_file', 'edit_file', 'skill_view', 'bash', 'file_search', 'list_dir'];
+
+const TOOL_ALIASES = {
+  write_file: 'write_file', create_file: 'write_file', writefile: 'write_file', write: 'write_file', create: 'write_file', save_file: 'write_file', new_file: 'write_file',
+  read_file: 'read_file', readfile: 'read_file', view_file: 'read_file', open_file: 'read_file', cat: 'read_file',
+  edit_file: 'edit_file', editfile: 'edit_file', str_replace: 'edit_file', str_replace_editor: 'edit_file', replace_in_file: 'edit_file',
+  skill_view: 'skill_view', skillview: 'skill_view', load_skill: 'skill_view', view_skill: 'skill_view', skill: 'skill_view',
+  bash: 'bash', run_command: 'bash', shell: 'bash', shell_command: 'bash', exec: 'bash', run_terminal: 'bash', terminal: 'bash', run: 'bash', command: 'bash',
+  file_search: 'file_search', glob: 'file_search', find_files: 'file_search', search_files: 'file_search', find: 'file_search',
+  list_dir: 'list_dir', ls: 'list_dir', dir: 'list_dir', list_directory: 'list_dir', filesystem: 'list_dir',
+};
+
+function expandHome(p) {
+  if (!p || typeof p !== 'string') return p;
+  if (p.startsWith('~')) return path.join(os.homedir(), p.slice(1));
+  return p;
+}
+
+// Ajanin urettigi komutlar icin ekstra koruma. bash.js kendi politikasini uygular
+// ama varsayilan 'full' mod yikici komutlari (rm -rf gibi) bile gecirir — bu insan
+// icin bilincli olabilir, ama MODELIN urettigi komut icin degil. Bu yuzden agentic
+// yolda yikici komutlari politikadan BAGIMSIZ olarak engelliyoruz.
+function defaultIsDangerous(cmd) {
+  try { return require('../utils/approvals').isDangerousCommand(cmd); } catch { return false; }
+}
+
+/**
+ * Model metninden agentic tool cagrilarini cikar.
+ * Destekler: <invoke name><parameter name> (opsiyonel <minimax:tool_call> sarmali),
+ * <skill>ad</skill> kisayolu, ve yan yana gelen native OpenAI tool_calls.
+ */
+function parseAgenticCalls(content, nativeToolCalls) {
+  const calls = [];
+  content = content || '';
+
+  for (const tc of nativeToolCalls || []) {
+    const fn = tc.function || {};
+    if (!fn.name) continue;
+    let args = {};
+    try { args = typeof fn.arguments === 'string' ? JSON.parse(fn.arguments || '{}') : (fn.arguments || {}); } catch {}
+    calls.push({ tool: fn.name, args });
+  }
+
+  const invokeRe = /<invoke\s+name=["']([^"']+)["']\s*>([\s\S]*?)<\/invoke>/g;
+  let m;
+  while ((m = invokeRe.exec(content)) !== null) {
+    const tool = m[1].trim();
+    const body = m[2];
+    const args = {};
+    const paramRe = /<parameter\s+name=["']([^"']+)["']\s*>([\s\S]*?)<\/parameter>/g;
+    let pm;
+    while ((pm = paramRe.exec(body)) !== null) {
+      args[pm[1].trim()] = pm[2];
+    }
+    calls.push({ tool, args });
+  }
+
+  const skillRe = /<skill>\s*([^<>\n]+?)\s*<\/skill>/g;
+  while ((m = skillRe.exec(content)) !== null) {
+    const name = m[1].trim();
+    if (!calls.some(c => /skill/i.test(c.tool || '') && c.args && c.args.name === name)) {
+      calls.push({ tool: 'skill_view', args: { name } });
+    }
+  }
+
+  return calls;
+}
+
+/** Final yanittan protokol jetonlarini temizle (kullaniciya gosterim icin). */
+function stripProtocolTokens(s) {
+  return (s || '')
+    .replace(/<minimax:tool_call>[\s\S]*?<\/minimax:tool_call>/g, '')
+    .replace(/<invoke[\s\S]*?<\/invoke>/g, '')
+    .replace(/<skill>[\s\S]*?<\/skill>/g, '')
+    .replace(/<available_skills>[\s\S]*?<\/available_skills>/g, '')
+    .replace(/<\/?(minimax:tool_call|available_skills|available_skins)>/g, '')
+    .trim();
+}
+
+/**
+ * Streaming ekran filtresi: model canli akarken duz metni goster, ama tool-call/skill
+ * protokol bloklarini (<minimax:tool_call>, <invoke>, <skill>, <available_skills>)
+ * kullaniciya HAM gosterme. Bir protokol jetonu gorunce o tur icin gostermeyi keser
+ * (icerik yine tam biriktirilir; parse sonra yapilir). Kismi tag chunk sinirinda
+ * bolunebilir — sonda olasi kismi-tag kuyrugunu tutar.
+ *
+ *   const f = makeStreamFilter(t => process.stdout.write(t), () => process.stdout.write(' 🔧'));
+ *   f.push(deltaChunk); ... ; f.end();
+ */
+function makeStreamFilter(onText, onTool) {
+  const MARKERS = ['<minimax:tool_call', '<invoke', '<skill>', '<available_skills'];
+  let buf = '';
+  let suppressed = false;
+  return {
+    push(chunk) {
+      if (suppressed) return;
+      buf += (chunk || '');
+      let idx = -1;
+      for (const mk of MARKERS) { const i = buf.indexOf(mk); if (i !== -1 && (idx === -1 || i < idx)) idx = i; }
+      if (idx !== -1) {
+        if (idx > 0 && onText) onText(buf.slice(0, idx));
+        buf = '';
+        suppressed = true;
+        if (onTool) onTool();
+        return;
+      }
+      const lastLt = buf.lastIndexOf('<');
+      if (lastLt === -1) { if (buf && onText) onText(buf); buf = ''; return; }
+      if (lastLt > 0 && onText) onText(buf.slice(0, lastLt));
+      buf = buf.slice(lastLt);
+      // buf artik '<' ile basliyor; bir marker'a buyuyebilecekse tut, degilse yaz (orn. literal <div>)
+      if (!MARKERS.some(mk => mk.startsWith(buf))) { if (onText) onText(buf); buf = ''; }
+    },
+    end() { if (!suppressed && buf && onText) onText(buf); buf = ''; return suppressed; },
+  };
+}
+
+/**
+ * Streaming model-adi temizleyici: canli akarken model kendi adini soylerse
+ * (MiniMax/Claude/GPT...) persona adiyla degistir. Kelime sinirinda (bosluk)
+ * emit eder — boylece bir chunk'ta "Mini", digerinde "Max" gelse bile kelime
+ * tam olusmadan gonderilmez, sizinti olmaz. onText'e temizlenmis metin gider.
+ */
+function makeSanitizeStream(botName, onText) {
+  const name = botName || 'Asistan';
+  let buf = '';
+  const clean = (s) => s
+    .replace(/\bMiniMaxi?\b/gi, name)
+    .replace(/\bChatGPT\b/gi, name)
+    .replace(/\bGPT-?[0-9.]*\b/gi, name)
+    .replace(/\bClaude(?:\s*[0-9.]+)?\b/gi, name)
+    .replace(/\bM2\.5\b/gi, name);
+  return {
+    push(chunk) {
+      buf += (chunk || '');
+      const lastWs = Math.max(buf.lastIndexOf(' '), buf.lastIndexOf('\n'), buf.lastIndexOf('\t'));
+      if (lastWs >= 0) {
+        const safe = buf.slice(0, lastWs + 1);
+        buf = buf.slice(lastWs + 1);
+        if (onText) onText(clean(safe));
+      }
+    },
+    end() { if (buf && onText) onText(clean(buf)); buf = ''; },
+  };
+}
+
+function sanitizeArgs(args) {
+  const a = { ...args };
+  if (typeof a.content === 'string' && a.content.length > 160) a.content = `[${a.content.length} chars]`;
+  if (typeof a.new_string === 'string' && a.new_string.length > 160) a.new_string = `[${a.new_string.length} chars]`;
+  return a;
+}
+
+// Modele geri beslenecek metin. KRITIK: read_file/list_dir/file_search/bash gibi
+// araclarda modelin GORMESI gereken asil cikti (content/output/results/items) geri
+// verilmeli — yoksa model "okudum ama icerik yok" diye takilir.
+function buildFeedback(norm, res) {
+  if (typeof res === 'string') return `${norm} sonucu:\n` + res.slice(0, 2500);
+  const ok = res && res.success !== false;
+  if (!ok) return `${norm} HATA: ${(res && res.error) || 'bilinmeyen hata'}`;
+  if (norm === 'write_file') return `write_file OK: ${res.path || ''} (${res.size != null ? res.size : '?'} bytes)`;
+  let body = '';
+  if (res.content != null) body = String(res.content).slice(0, 2500);
+  else if (res.output != null) body = String(res.output).slice(0, 2000);
+  else if (res.stdout != null) body = String(res.stdout).slice(0, 2000);
+  else if (res.results != null) body = JSON.stringify(res.results).slice(0, 2000);
+  else if (res.items != null) body = JSON.stringify(res.items).slice(0, 2000);
+  const head = `${norm} OK` + (res.path ? ` (${res.path})` : '');
+  return body ? `${head}:\n${body}` : head;
+}
+
+/**
+ * Tek bir parse edilmis cagriyi calistir.
+ * Donus: { records: [...], feedback: '...' }
+ */
+async function executeCall(call, opts = {}) {
+  const toolsDir = opts.toolsDir || __dirname;
+  const loadTool = opts.loadTool || ((n) => require(path.join(toolsDir, n + '.js')));
+  const allowed = opts.allowed || new Set(DEFAULT_ALLOWED);
+  const rawTool = (call.tool || '').trim();
+  const norm = TOOL_ALIASES[rawTool.toLowerCase()] || rawTool;
+  const records = [];
+  const feedbacks = [];
+
+  // "files" JSON dizisi (bulk-file-operations veya files parametresi) → coklu write_file
+  let files = call.args && call.args.files;
+  if (typeof files === 'string') { try { files = JSON.parse(files); } catch { files = null; } }
+  if (Array.isArray(files) && (/bulk/i.test(rawTool) || /file/i.test(rawTool) || norm === 'write_file')) {
+    let wf;
+    try { wf = loadTool('write_file'); } catch { wf = null; }
+    for (const f of files) {
+      if (!wf || !f || !f.path) { records.push({ tool: 'write_file', status: 'error', error: 'gecersiz dosya girisi' }); feedbacks.push('write_file HATA: gecersiz giris'); continue; }
+      try {
+        const res = await wf.execute({ path: expandHome(f.path), content: f.content != null ? String(f.content) : '' });
+        const ok = res && res.success !== false;
+        records.push({ tool: 'write_file', status: ok ? 'done' : 'error', args: { path: f.path }, result: res, error: ok ? undefined : (res && res.error) });
+        feedbacks.push(ok ? `write_file OK: ${res.path || f.path} (${res.size != null ? res.size : '?'} bytes)` : `write_file HATA: ${res && res.error}`);
+      } catch (e) {
+        records.push({ tool: 'write_file', status: 'error', args: { path: f.path }, error: e.message });
+        feedbacks.push(`write_file HATA: ${e.message}`);
+      }
+    }
+    return { records, feedback: feedbacks.join('\n') };
+  }
+
+  if (!allowed.has(norm)) {
+    records.push({ tool: rawTool, status: 'error', error: 'Bu modda kullanilamayan arac: ' + rawTool });
+    return { records, feedback: `${rawTool}: bu arac bu modda kullanilamaz (izin verilenler: ${[...allowed].join(', ')})` };
+  }
+
+  const args = { ...(call.args || {}) };
+  for (const k of ['path', 'name', 'command', 'old_string', 'new_string']) {
+    if (typeof args[k] === 'string') args[k] = args[k].trim();
+  }
+  if (args.path) args.path = expandHome(args.path);
+
+  // Ajan modu guvenlik guard'i: yikici/tehlikeli kabuk komutlarini calistirmadan engelle
+  if (norm === 'bash') {
+    const cmd = (args.command || args.cmd || '').toString();
+    if (!cmd.trim()) {
+      records.push({ tool: 'bash', status: 'error', error: 'Bos komut' });
+      return { records, feedback: 'bash HATA: bos komut' };
+    }
+    const isDangerous = opts.isDangerous || defaultIsDangerous;
+    if (isDangerous(cmd)) {
+      records.push({ tool: 'bash', status: 'error', args: { command: cmd }, error: 'Yikici/tehlikeli komut ajan modunda engellendi' });
+      return { records, feedback: `bash: "${cmd.slice(0, 80)}" yikici/tehlikeli goruldugu icin ajan tarafindan CALISTIRILMADI. Gerekirse kullanici komutu kendisi calistirabilir.` };
+    }
+  }
+
+  let mod;
+  try { mod = loadTool(norm); } catch {
+    records.push({ tool: rawTool, status: 'error', error: 'Bilinmeyen arac: ' + rawTool });
+    return { records, feedback: `${rawTool} HATA: bilinmeyen arac` };
+  }
+  const fn = mod.execute || (mod.default && mod.default.execute);
+  if (typeof fn !== 'function') {
+    records.push({ tool: norm, status: 'error', error: 'execute yok' });
+    return { records, feedback: `${norm} HATA: execute fonksiyonu yok` };
+  }
+  try {
+    const res = await fn(args);
+    const ok = typeof res === 'string' ? true : (res && res.success !== false);
+    const status = ok ? 'done' : 'error';
+    const feedback = buildFeedback(norm, res);
+    records.push({ tool: norm, status, args: sanitizeArgs(args), result: res });
+    return { records, feedback };
+  } catch (e) {
+    records.push({ tool: norm, status: 'error', args: sanitizeArgs(args), error: e.message });
+    return { records, feedback: `${norm} HATA: ${e.message}` };
+  }
+}
+
+/**
+ * Ana agentic dongu.
+ * callModel(messages) => Promise<{ content, toolCalls }>
+ * Donus: { records, reply, iterations }
+ */
+async function runAgentic({ callModel, systemPrompt, historyMessages, task, toolsDir, loadTool, allowed, maxIterations = 15 }) {
+  const messages = [{ role: 'system', content: systemPrompt }];
+  for (const mm of historyMessages || []) messages.push({ role: mm.role, content: mm.content || '' });
+  messages.push({ role: 'user', content: task });
+
+  const allowedSet = allowed ? new Set(allowed) : new Set(DEFAULT_ALLOWED);
+  const allRecords = [];
+  let finalReply = '';
+  let iterations = 0;
+
+  for (let i = 0; i < maxIterations; i++) {
+    iterations++;
+    const { content, toolCalls } = await callModel(messages);
+    const calls = parseAgenticCalls(content, toolCalls);
+
+    if (calls.length === 0) {
+      finalReply = stripProtocolTokens(content);
+      break;
+    }
+
+    messages.push({ role: 'assistant', content: content || '' });
+    const feedbacks = [];
+    for (const call of calls) {
+      const { records, feedback } = await executeCall(call, { toolsDir, loadTool, allowed: allowedSet });
+      allRecords.push(...records);
+      feedbacks.push(feedback);
+    }
+    messages.push({
+      role: 'user',
+      content: '<tool_results>\n' + feedbacks.join('\n') + '\n</tool_results>\nGorev tamamlandiysa ARAC CAGIRMADAN tek cumlelik ozet yaz. Devam gerekiyorsa sonraki araci cagir.',
+    });
+
+    if (i === maxIterations - 1) {
+      finalReply = stripProtocolTokens(content) || 'Islem maksimum adima ulasti.';
+    }
+  }
+
+  return { records: allRecords, reply: finalReply, iterations };
+}
+
+module.exports = { parseAgenticCalls, stripProtocolTokens, executeCall, runAgentic, expandHome, makeStreamFilter, makeSanitizeStream, TOOL_ALIASES, DEFAULT_ALLOWED };

package/src/tools/workflow.js

@@ -24,23 +24,58 @@ function allToolNames() {
 
 function loadUserMemory(username) {
   try {
-    const file = path.join(os.homedir(), '.natureco', 'memory', `${(username || 'default').toLowerCase()}.json`);
-    if (fs.existsSync(file)) {
-      const mem = JSON.parse(fs.readFileSync(file, 'utf8'));
-      const facts = (mem.facts || []).map(f => f.value || f).filter(Boolean);
-      let name = mem.name || '';
-      // Extract name from facts if not saved as memory.name
-      if (!name) {
-        for (const f of facts) {
-          const match = f.toLowerCase().match(/(?:kullanici\s*adi?|kullanıcı\s*adı?|isim|name)\s*:?\s*(.+)/);
-          if (match && match[1].trim().length > 2) { name = match[1].trim(); break; }
-        }
+    const dir = path.join(os.homedir(), '.natureco', 'memory');
+    const uname = (username || 'default').toLowerCase();
+    // Kullanici-ozel dosya (`<user>.json`) + legacy `default.json`'i birlestir.
+    // Eski kurulumlarda hafiza default.json'a yazilmis olabilir; okuyucu sadece
+    // <user>.json'a bakinca eski kayitlar (ve bot personasi) hic yuklenmiyordu.
+    // default.json'i yalnizca ismi aktif kullaniciyla eslesiyorsa (ya da isimsizse)
+    // katariz — coklu kullanicida baska birinin hafizasini sizdirmamak icin.
+    const files = [];
+    const userFile = path.join(dir, `${uname}.json`);
+    if (fs.existsSync(userFile)) files.push(userFile);
+    if (uname !== 'default') {
+      const defFile = path.join(dir, 'default.json');
+      if (fs.existsSync(defFile)) {
+        try {
+          const dm = JSON.parse(fs.readFileSync(defFile, 'utf8'));
+          const dn = (dm.name || '').toLowerCase();
+          if (!dn || dn === uname) files.push(defFile);
+        } catch {}
       }
-      const parts = [];
-      if (name) parts.push(`Kullanici adi: ${name}`);
-      if (facts.length > 0) parts.push(`Bilinenler: ${facts.slice(0, 10).join('; ')}`);
-      return parts.join('\n');
     }
+    if (files.length === 0) return '';
+
+    const seen = new Set();
+    const facts = [];
+    let name = '', botName = '';
+    for (const file of files) {
+      let mem;
+      try { mem = JSON.parse(fs.readFileSync(file, 'utf8')); } catch { continue; }
+      if (!name && mem.name) name = mem.name;
+      // Jenerik "Asistan" placeholder yerine gercek persona adini tercih et
+      if ((!botName || /^asistan$/i.test(botName)) && mem.botName && !/^asistan$/i.test(mem.botName)) botName = mem.botName;
+      for (const f of (mem.facts || [])) {
+        const v = (f && (f.value != null ? f.value : f));
+        if (!v || typeof v !== 'string') continue;
+        const key = v.trim().toLowerCase();
+        if (!key || seen.has(key)) continue;
+        seen.add(key);
+        facts.push(v.trim());
+      }
+    }
+    // isim memory.name'de yoksa fact'lerden cikar
+    if (!name) {
+      for (const f of facts) {
+        const match = f.toLowerCase().match(/(?:kullanici\s*adi?|kullanıcı\s*adı?|isim|name)\s*:?\s*(.+)/);
+        if (match && match[1].trim().length > 2) { name = match[1].trim(); break; }
+      }
+    }
+    const parts = [];
+    if (name) parts.push(`Kullanici adi: ${name}`);
+    if (botName) parts.push(`Bot adi: ${botName}`);
+    if (facts.length > 0) parts.push(`Bilinenler: ${facts.slice(0, 15).join('; ')}`);
+    return parts.join('\n');
   } catch {}
   return '';
 }
@@ -82,6 +117,58 @@ function apiCall(providerUrl, apiKey, body) {
   });
 }
 
+// Streaming (SSE) varyanti — onDelta(token) canli cagirilir; sonunda {content, toolCalls} doner.
+// OpenAI-uyumlu delta formati (MiniMax chatcompletion_v2, Gemini /openai, OpenAI, ...).
+function apiCallStream(providerUrl, apiKey, body, onDelta) {
+  return new Promise((resolve, reject) => {
+    const base = providerUrl.replace(/\/+$/, '');
+    const endpoint = isMiniMax(base)
+      ? base + '/v1/text/chatcompletion_v2'
+      : isGemini(base)
+        ? base + '/openai/chat/completions'
+        : base + '/chat/completions';
+    const req = https.request(endpoint, {
+      method: 'POST',
+      headers: { 'Authorization': 'Bearer ' + apiKey, 'Content-Type': 'application/json' },
+      timeout: 120000,
+    }, (res) => {
+      if (res.statusCode < 200 || res.statusCode >= 300) {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => reject(new Error('HTTP ' + res.statusCode + ': ' + data.slice(0, 300))));
+        return;
+      }
+      res.setEncoding('utf8');
+      let sseBuf = '';
+      let content = '';
+      const toolCalls = [];
+      res.on('data', (chunk) => {
+        sseBuf += chunk;
+        const parts = sseBuf.split('\n');
+        sseBuf = parts.pop(); // eksik son satiri buffer'da tut
+        for (const line of parts) {
+          const l = line.trim();
+          if (!l.startsWith('data:')) continue;
+          const payload = l.slice(5).trim();
+          if (!payload || payload === '[DONE]') continue;
+          try {
+            const parsed = JSON.parse(payload);
+            const delta = parsed.choices?.[0]?.delta;
+            if (!delta) continue;
+            if (delta.content) { content += delta.content; if (onDelta) onDelta(delta.content); }
+            if (Array.isArray(delta.tool_calls)) { for (const tc of delta.tool_calls) toolCalls.push(tc); }
+          } catch { /* eksik/parcali JSON — atla */ }
+        }
+      });
+      res.on('end', () => resolve({ content, toolCalls }));
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+    req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
 async function workflow(params) {
   const { action, task, steps, name, workflowId, regenerateStep, conversationHistory } = params;
   const cfg = loadConfig();
@@ -126,89 +213,90 @@ async function workflow(params) {
   if (action === 'run') {
     if (!task) return { success: false, error: 'task gerekli' };
 
-    // Non-tool-calling modellerde once simple/complex kontrolu yap
+    // Non-tool-calling / agentic-text modeller (MiniMax M2.x): model tool call'larini
+    // native XML olarak (<invoke> / <minimax:tool_call>) ve skill yuklemeyi <skill> ile
+    // uretir. Bounded agentic dongu ile parse edip gercek araclari calistir.
     if (!supportsToolCalls()) {
+      const { runAgentic } = require('./agentic-runner');
       const memCtx = memoryContext();
-      // Phase 0: Check if simple chat or complex task
-      const simpleCheckPrompt = {
-        role: 'system',
-        content: 'Gorevin basit bir selamlasma/sohbet mi yoksa arac gerektiren bir islem mi oldugunu belirle. Sadece "simple" veya "complex" yaz, kesinlikle baska bir sey yazma.\n\nSimple: selamlasma, nasilsin, bugun ne yaptin, havadan sudan, genel bilgi sorusu, ben kimim, adim ne, kullanici bilgisi sorgulama, hatirlatma talebi\nComplex: dosya islemleri, kod yazma, arastirma, karsilastirma, duzenleme, otomasyon'
-      };
-      let isComplex = true;
-      try {
-        const checkBody = { model, stream: false, messages: [simpleCheckPrompt, { role: 'user', content: task }], temperature: 0, max_tokens: 20 };
-        const checkResult = await apiCall(providerUrl, providerApiKey, checkBody);
-        const raw = (checkResult.choices?.[0]?.message?.content || '').trim().toLowerCase().replace(/[^a-z]/g, '');
-        isComplex = raw !== 'simple';
-      } catch {}
-
-      if (!isComplex) {
-        // Simple chat — passthrough
-        const sysMsg = 'Sen yardimci bir asistansin. Kisa ve oz yanit ver. Konusma gecmisi varsa onceki mesajlari dikkate al.' + (memCtx ? '\n\nKullanici bilgisi:\n' + memCtx : '') + '\n\n' + skillsIndexBlock;
-        const chatBody = { model, stream: false, messages: chatMessages(sysMsg, task), temperature: 0.7, max_tokens: 1000 };
-        try {
-          const chatResult = await apiCall(providerUrl, providerApiKey, chatBody);
-          const reply = chatResult.choices?.[0]?.message?.content || '';
-          return { success: true, workflowId: 'passthrough', name: 'Direct Chat', status: 'completed', totalSteps: 0, completedSteps: 0, results: [], passthrough: true, reply };
-        } catch (e) {
-          return { success: false, error: 'Sohbet yaniti alinamadi: ' + e.message };
-        }
+      const desktop = path.join(os.homedir(), 'Desktop');
+      const sysMsg = [
+        'Sen NatureCo adli, arac kullanabilen bir yapay zeka ajanisin. Kullanicinin istegini SADECE anlatarak degil, ARACLARI cagirarak fiilen gerceklestir.',
+        memCtx ? '\nKullanici bilgisi:\n' + memCtx : '',
+        '\n\nOrtam:\n- Isletim sistemi: ' + process.platform + '\n- Kullanici home: ' + os.homedir() + '\n- Masaustu: ' + desktop + '\n- Calisma dizini: ' + process.cwd(),
+        '\n\nArac cagirmak icin TAM olarak su formati kullan:\n<minimax:tool_call>\n<invoke name="ARAC_ADI">\n<parameter name="PARAM">DEGER</parameter>\n</invoke>\n</minimax:tool_call>',
+        '\n\nKullanabilecegin araclar:',
+        '- write_file: dosya olustur/uzerine yaz. parametreler: path (TAM yol), content (dosyanin TAM icerigi). Kod/oyun/site isteniyorsa TUM icerigi content icine yaz, kisaltma.',
+        '- read_file: dosya oku. parametre: path',
+        '- edit_file: MEVCUT dosyada metin degistir. parametreler: path, old_string (birebir mevcut metin), new_string. Bir dosyanin bir kismini degistirirken write_file yerine bunu kullan (tum dosyayi yeniden yazma).',
+        '- file_search: glob ile dosya bul. parametre: pattern (orn. "**/*.js", "src/**/*.json").',
+        '- list_dir: dizin icerigini listele. parametre: path',
+        '- bash: kabuk komutu calistir (npm, git, node, python, test, ls, grep/findstr, mkdir...). parametre: command. Guvenli komutlar dogrudan calisir; yikici/tehlikeli komutlar guvenlik politikasiyla engellenir. Icerik aramasi icin grep/findstr kullan.',
+        '- skill_view: gorevle ilgili bir skill yukle. parametre: name',
+        '\nKurallar:',
+        '- MEVCUT bir dosyayi degistirmeden ONCE read_file ile oku; sonra edit_file ile hedefli degisiklik yap (tum dosyayi write_file ile ezme).',
+        '- Bir seyi nerede oldugunu bilmiyorsan once file_search/list_dir/bash(grep) ile kesfet.',
+        '- Kod yazdiktan/degistirdikten sonra gerektiginde bash ile calistir/test et (orn. "node dosya.js", "npm test"); hata cikarsa duzelt.',
+        '- Birden fazla dosya gerekiyorsa her biri icin AYRI write_file cagir.',
+        '- Kullanici "masaustu"/"desktop" dediyse ve tam yol vermediyse dosyayi buraya yaz: ' + desktop,
+        '- Goreceli yol yerine TAM yol kullan.',
+        '- Arac sonuclari <tool_results> icinde geri gelir; gorev bitince ARAC CAGIRMADAN tek cumlelik ozet yaz.',
+        '- Basit sohbet/selamlasma ise arac cagirma, dogrudan kisa yanit ver.',
+        skillsIndexBlock ? '\n\n' + skillsIndexBlock : '',
+      ].filter(Boolean).join('\n');
+
+      const historyMessages = [];
+      if (conversationHistory && Array.isArray(conversationHistory)) {
+        for (const hm of conversationHistory) { if (hm._internal) continue; historyMessages.push({ role: hm.role, content: hm.content || '' }); }
       }
 
-      // Complex task for non-tool-calling model: ask LLM for structured file ops
-      const execSysMsg = 'Gorevi tamamlamak icin hangi dosyalarin olusturulacagini JSON olarak belirt. SADECE JSON yaz.\n\n' +
-        'Kullanici bilgisi:\n' + (memCtx || '') +
-        '\n\nMasaustu yolu: ' + require('path').join(require('os').homedir(), 'Desktop') +
-        '\n\nKullanici home: ' + require('os').homedir() +
-        '\n\nJSON format:\n{"files": [{"path": "/tam/dosya/yolu/dosya.html", "content": "dosya icerigi buraya"}]}\n\nHer dosya icin path ve content zorunlu. path TAM yol olmali (~ veya goreceli degil). Birden fazla dosya olusturulabilir.' +
-        '\n\n' + skillsIndexBlock;
-      const execBody = { model, stream: false, messages: chatMessages(execSysMsg, task), temperature: 0.3, max_tokens: 8000 };
-      try {
-        const execResult = await apiCall(providerUrl, providerApiKey, execBody);
-        const reply = execResult.choices?.[0]?.message?.content || '';
-
-        // Try to extract JSON with file operations
-        const jsonStart = reply.indexOf('{');
-        const jsonEnd = reply.lastIndexOf('}');
-        let stepResults = [];
-        let fileWriteSuccess = false;
-
-        if (jsonStart !== -1 && jsonEnd > jsonStart) {
-          try {
-            const plan = JSON.parse(reply.slice(jsonStart, jsonEnd + 1));
-            if (plan.files && Array.isArray(plan.files)) {
-              // Execute file writes locally
-              for (const f of plan.files) {
-                try {
-                  const wfPath = f.path ? require('path').resolve(f.path.replace(/^~/, require('os').homedir())) : '';
-                  if (!wfPath) continue;
-                  require('fs').mkdirSync(require('path').dirname(wfPath), { recursive: true });
-                  require('fs').writeFileSync(wfPath, f.content || '', 'utf-8');
-                  const stats = require('fs').statSync(wfPath);
-                  stepResults.push({ step: 1, tool: 'write_file', status: 'done', args: { path: wfPath }, result: { success: true, path: wfPath, size: stats.size } });
-                  fileWriteSuccess = true;
-                } catch (wfErr) {
-                  stepResults.push({ step: 1, tool: 'write_file', status: 'error', error: wfErr.message });
-                }
-              }
-            }
-          } catch {}
+      // Streaming: yalnizca TTY'de ve caller (repl) stream:true gecince. SSE token'lari
+      // XML-gizleyen filtre + model-adi sanitizer zincirinden gecip stdout'a canli akar.
+      const streamOn = params.stream === true && !!(process.stdout && process.stdout.isTTY);
+      const botName = cfg.botName || 'Asistan';
+      const { makeStreamFilter, makeSanitizeStream } = require('./agentic-runner');
+
+      async function callModel(msgs) {
+        if (streamOn) {
+          const sani = makeSanitizeStream(botName, t => process.stdout.write(t));
+          const filter = makeStreamFilter(t => sani.push(t), null);
+          const body = { model, stream: true, messages: msgs, temperature: 0.3, max_tokens: 16000 };
+          const out = await apiCallStream(providerUrl, providerApiKey, body, d => filter.push(d));
+          filter.end(); sani.end();
+          return { content: out.content || '', toolCalls: out.toolCalls || [] };
         }
+        const body = { model, stream: false, messages: msgs, temperature: 0.3, max_tokens: 16000 };
+        const r = await apiCall(providerUrl, providerApiKey, body);
+        const msg = r.choices?.[0]?.message || {};
+        return { content: msg.content || '', toolCalls: msg.tool_calls || [] };
+      }
 
-        if (fileWriteSuccess) {
-          const lines = stepResults.map(r => { const p = r.result?.path || ''; const s = r.result?.size || 0; const name = require('path').basename(p); return `  ✓ ${name} oluşturuldu (${s} bytes)`; }).join('\n');
-          const reply = `Dosya(lar) başarıyla oluşturuldu:\n${lines}`;
-          return {
-            success: true, workflowId: 'file_write_' + Date.now().toString(36),
-            name: 'File Operations', status: 'completed',
-            totalSteps: stepResults.length, completedSteps: stepResults.length,
-            results: stepResults,
-            passthrough: true, reply,
-          };
+      try {
+        const { records, reply } = await runAgentic({
+          callModel, systemPrompt: sysMsg, historyMessages, task,
+          toolsDir: __dirname, maxIterations: 15,
+        });
+        const fileWrites = records.filter(r => r.tool === 'write_file' && r.status === 'done');
+        let finalReply = reply || '';
+        if (fileWrites.length > 0) {
+          const lines = fileWrites.map(r => `  ✓ ${path.basename((r.result && r.result.path) || (r.args && r.args.path) || '')} olusturuldu (${(r.result && r.result.size != null) ? r.result.size : '?'} bytes)`).join('\n');
+          const fileSummary = 'Dosya(lar):\n' + lines;
+          finalReply = (finalReply ? finalReply + '\n\n' : '') + fileSummary;
+          if (streamOn) process.stdout.write('\n\n' + fileSummary + '\n');
         }
-
-        // If no structured file ops detected, return LLM reply as passthrough
-        return { success: true, workflowId: 'passthrough', name: 'Direct Generation', status: 'completed', totalSteps: 0, completedSteps: 0, results: [{ step: 0, tool: 'chat', status: 'done', result: { reply } }], passthrough: true, reply };
+        const done = records.filter(r => r.status === 'done').length;
+        return {
+          success: true,
+          workflowId: (records.length ? 'agentic_' : 'passthrough_') + Date.now().toString(36),
+          name: records.length ? 'Agentic Run' : 'Direct Chat',
+          status: 'completed',
+          totalSteps: records.length,
+          completedSteps: done,
+          results: records.map((r, i) => ({ step: i + 1, ...r })),
+          passthrough: true,
+          streamed: streamOn,
+          reply: finalReply || 'Tamamlandi.',
+        };
       } catch (e) {
         return { success: false, error: 'Yanit alinamadi: ' + e.message };
       }