natureco-cli 5.44.1 → 5.45.1

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable changes to NatureCo CLI will be documented in this file.
 
+## [5.45.1] - 2026-07-08 — "FIX: Türkçe İ/i recall hatası — büyük-harfli her Türkçe kelime sessizce kaçıyordu"
+
+### Fixed
+- **Ajanın canlı hafıza recall'ı büyük-harfli Türkçe kelimeleri BULAMIYORDU (kritik, doğrulandı).** `memory_tree` search/remove eşleşmeyi `line.toLowerCase().includes(q)` ile yapıyordu; ama JS'in `toLowerCase()`'i locale-duyarsız: `"İstanbul".toLowerCase()` → `"i̇stanbul"` (ASCII i + U+0307 BİRLEŞİK NOKTA) olur ve `"istanbul"` sorgusuyla **EŞLEŞMEZ**. Sonuç: her konuşmada İstanbul, İzmir, İş, İletişim gibi büyük-harfli Türkçe kelimeler recall'da görünmez şekilde kaçıyordu — Türkçe-öncelikli bir üründe milyonlarca kullanıcı için sessiz veri kaybı. Artık ortak `src/utils/tr-text.js` **`foldTr`** helper'ı dört Türkçe i-varyantını (İ/I/ı/i → i) tek forma indiriyor; `{İstanbul, istanbul, ISTANBUL, ıstanbul}` hepsi `"istanbul"` sorgusuyla eşleşiyor, İngilizce bozulmuyor (`FILE`→`file`), anlam taşıyan ş/ç/ğ/ö/ü korunuyor (`şık`≠`sık`). Hem ajan recall'ı (`memory_tree`) hem insan CLI araması (`memory-lint searchTree`) aynı folding'i kullanıyor.
+- **`memory search` regex-özel-karakter tuzağı.** Fallback arama `new RegExp(query, 'i')` kullanıyordu; `"proje kod adı (v2)"` gibi doğal bir sorguda parantezler yakalama-grubu sayılıp literal metinle **eşleşmiyordu**. Artık regex yok: sorgu boşluklardan kelimelere ayrılıp **AND** mantığıyla literal aranıyor — özel karakterler `()[]*?` literal alınır, çok-kelimeli sorgular daha isabetli.
+
+### Added
+- `src/utils/tr-text.js` (`foldTr`, `foldIncludes`) — Türkçe-güvenli case folding, tek kaynak.
+- Lint bulgularında **dal (branch) bağlamı** gösterilir (`(## Projeler)` / `(## Kararlar)`) — kullanıcı çelişen kaydın hangisinin nerede olduğunu görür.
+- 22 yeni regresyon testi (İ/i folding, regex-özel-karakter literal, çok-kelime AND, branch koruma, dosya-yok güvenliği). **596 test yeşil** (593 + 3 skip).
+
+## [5.45.0] - 2026-07-08 — "MEMORY: Urðr lint + fallback search entegre edildi"
+
+### Added
+- **`natureco memory lint`** — Urðr standardından (natureco-official/urdr) türetilen, LLM'siz sağlık denetimi. Düz hafızada (`<user>.json`) ve ağaç hafızada (`tree/<user>/`) **YİNELENEN** (aynı bilgi iki kez) ve **ÇELİŞEN** (aynı konu, farklı değer — ör. iki farklı favori renk ya da iki farklı proje kod adı) kayıtları Jaccard benzerliğiyle yakalar. Bu, recall'ın "yanlış hatırlanan değeri" döndürmesinin kök nedeni. Gerçek kullanıcı hafızasında test edildi (çelişki yakalandı).
+- **`natureco memory search`'e ağaç fallback'i** — düz hafızada bulunamazsa, ağaç hafızada branch-aware tam tarama yapar (Urðr `search.mjs` portu). Yanlış-kök tahmini yüzünden bilgi "erişilemez" kalmaz. LLM'siz, cross-platform. Sonuçlar `dosya › ## dal › yaprak` biçiminde.
+- `src/utils/memory-lint.js` — `lintFacts`/`lintUser`/`searchTree` (5 regresyon testi). 576 test yeşil.
+
+Bu, Urðr'nin kanıtlanmış hafıza-güvenilirlik araçlarını NatureCo'nun gerçek memory-tree'sine bağlar; native root isimleri (`0-index.md`, `1-kisisel.md` …) zaten tanınıyor.
+
 ## [5.44.1] - 2026-07-08 — "MEMORY: açık 'hatırla' komutu HAM kaydedilir (kayıp önlenir)"
 
 ### Added

package/bin/natureco.js

@@ -130,7 +130,7 @@ ${chalk.yellow('💻 Geliştirici Araçları')}
 
 ${chalk.yellow('📊 Yönetim & Sistem')}
   ${chalk.cyan('dashboard')}     Web kontrol paneli (open|status|url)
-  ${chalk.cyan('memory')}        Hafıza yönetimi (status|list|search|show|clear|index|export|import|semantic|wiki)
+  ${chalk.cyan('memory')}        Hafıza yönetimi (status|list|search|lint|show|clear|index|export|import|semantic|wiki)
   ${chalk.cyan('logs')}          Log yönetimi (tail|show|search|clear|path)
   ${chalk.cyan('status')}        Sistem durumu (run|simple|usage)
   ${chalk.cyan('plugins')}       Plugin yönetimi (list|install|uninstall|enable|disable|info|update|search|doctor|registry|marketplace)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "5.44.1",
+  "version": "5.45.1",
   "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/memory-cmd.js

@@ -19,6 +19,7 @@ async function memoryCmd(args) {
   if (action === 'index') return indexMemory();
   if (action === 'export') return exportMemoryCmd(params[0], params[1]);
   if (action === 'import') return importMemoryCmd(params[0], params[1]);
+  if (action === 'lint') return lintMemoryCmd(params[0]);
   if (action === 'semantic') return semanticSearchCmd(params.join(' '));
   // Wiki pages
   if (action === 'wiki') return wikiCmd(params[0], params.slice(1));
@@ -141,14 +142,24 @@ function searchMemory(query) {
     });
   });
 
-  console.log(chalk.cyan.bold(`\n  "${query}" için ${results.length} sonuç\n`));
-  if (results.length === 0) {
-    console.log(chalk.gray('  Sonuç bulunamadı.\n'));
-    return;
-  }
+  console.log(chalk.cyan.bold(`\n  "${query}" için ${results.length} sonuç (düz hafıza)\n`));
   results.forEach(r => {
     console.log(chalk.white(`  [${r.bot}] `) + chalk.gray(`${r.field}: `) + chalk.white(r.value));
   });
+
+  // v5.45: ağaç hafızada branch-aware FALLBACK (Urðr) — düz hafızada bulunamasa bile
+  // bilgi "erişilemez" kalmasın (yanlış-kök tahmini kurtarma ağı). LLM'siz.
+  try {
+    const { searchTree } = require('../utils/memory-lint');
+    let u; try { u = require('../utils/config').getConfig().userName; } catch {}
+    const treeHits = searchTree(u || 'default', query);
+    if (treeHits.length) {
+      console.log(chalk.cyan(`\n  Ağaç hafızada ${treeHits.length} sonuç:`));
+      treeHits.slice(0, 15).forEach(h => console.log(chalk.gray(`  ${h.file} › ## ${h.branch} › `) + chalk.white(h.text)));
+    } else if (results.length === 0) {
+      console.log(chalk.gray('  Sonuç bulunamadı (düz + ağaç hafıza).'));
+    }
+  } catch { if (results.length === 0) console.log(chalk.gray('  Sonuç bulunamadı.')); }
   console.log('');
 }
 
@@ -404,4 +415,41 @@ function semanticSearchMemory(query, botId) {
   return results;
 }
 
+// v5.45: memory lint — Urðr-derived duplicate/conflict audit (flat + tree).
+// Catches "same fact stored twice" and "same subject, different value" (the drift that
+// makes recall return the wrong remembered value, e.g. two different project code names).
+function lintMemoryCmd(user) {
+  const { lintUser } = require('../utils/memory-lint');
+  let u = user;
+  if (!u) { try { u = require('../utils/config').getConfig().userName; } catch {} }
+  const { flatFile, flatCount, flatFindings, treeFindings } = lintUser(u || 'default');
+
+  console.log(chalk.cyan(`\n  🧠 Memory Lint · ${u || 'default'}\n`) + chalk.gray('  ' + '─'.repeat(52)));
+  console.log(chalk.gray(`  flat: ${flatCount} fact · ${path.basename(flatFile)}`));
+
+  const all = [...flatFindings, ...treeFindings];
+  const dups = all.filter((f) => f.level === 'duplicate');
+  const conflicts = all.filter((f) => f.level === 'conflict');
+
+  if (all.length === 0) {
+    console.log(chalk.green('\n  ✓ Temiz — yinelenen veya çelişen kayıt yok.\n'));
+    return;
+  }
+  // Tree bulgularında dal (branch) bağlamını da göster ki kullanıcı "hangisi nerede" bilsin.
+  const br = (b) => (b ? chalk.gray(` (## ${b})`) : '');
+  const printFinding = (f, sym) => {
+    console.log(`     ${chalk.gray(`(%${Math.round(f.sim * 100)})`)} ${f.a}${br(f.aBranch)}`);
+    console.log(`     ${chalk.gray('           ' + sym)} ${f.b}${br(f.bBranch)}${f.file ? chalk.gray(' [' + f.file + ']') : ''}`);
+  };
+  if (dups.length) {
+    console.log(chalk.yellow(`\n  ⚠ ${dups.length} olası YİNELENEN (aynı bilgi iki kez):`));
+    for (const f of dups.slice(0, 10)) printFinding(f, '≈');
+  }
+  if (conflicts.length) {
+    console.log(chalk.red(`\n  ⚠ ${conflicts.length} olası ÇELİŞKİ (aynı konu, farklı değer):`));
+    for (const f of conflicts.slice(0, 10)) printFinding(f, '↔');
+  }
+  console.log(chalk.gray(`\n  Öneri: eskiyen/yanlış kaydı düzeltin — "natureco memory clear" veya elle. Tek doğru kalsın.\n`));
+}
+
 module.exports = memoryCmd;

package/src/tools/memory_tree.js

@@ -17,6 +17,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { foldTr } = require('../utils/tr-text');
 
 const ROOTS = [
   { id: '1-kisisel', title: 'Kişisel & Tercihler', branches: ['Kimlik', 'Tercihler', 'İletişim Kalıpları'] },
@@ -91,7 +92,10 @@ function buildDigest(username, maxChars = 2600) {
 
 function search(username, query) {
   ensureTree(username);
-  const q = String(query || '').toLowerCase().trim();
+  // v5.45.1: Türkçe-güvenli eşleşme (foldTr). Eski `line.toLowerCase().includes(q)` locale
+  // duyarsızdı → "İstanbul" .toLowerCase() = "i̇stanbul" olur ve "istanbul" sorgusuyla EŞLEŞMEZDİ;
+  // her büyük-harfli Türkçe kelime (İzmir, İş, İletişim…) canlı recall'da sessizce kaçıyordu.
+  const q = foldTr(query).trim();
   if (!q) return [];
   const hits = [];
   for (const r of ROOTS) {
@@ -99,7 +103,7 @@ function search(username, query) {
     let branch = '';
     for (const line of txt.split('\n')) {
       if (line.startsWith('## ')) branch = line.slice(3).trim();
-      else if (line.trim() && !line.startsWith('#') && line.toLowerCase().includes(q)) hits.push(`${r.id}/${branch}: ${line.trim()}`);
+      else if (line.trim() && !line.startsWith('#') && foldTr(line).includes(q)) hits.push(`${r.id}/${branch}: ${line.trim()}`);
     }
   }
   return hits;
@@ -121,13 +125,13 @@ function getPending(username) {
 function remove(username, root, query) {
   ensureTree(username);
   const r = resolveRoot(root || '3-kararlar');
-  const q = String(query || '').toLowerCase().trim();
+  const q = foldTr(query).trim(); // v5.45.1: Türkçe-güvenli (bkz: search)
   if (!q) return { success: false, error: 'query gerekli' };
   const txt = readSafe(username, r.id);
   const kept = [];
   let removed = 0;
   for (const line of txt.split('\n')) {
-    if (/^\s*-\s+/.test(line) && line.toLowerCase().includes(q)) { removed++; continue; }
+    if (/^\s*-\s+/.test(line) && foldTr(line).includes(q)) { removed++; continue; }
     kept.push(line);
   }
   if (removed) fs.writeFileSync(rootPath(username, r.id), kept.join('\n'), 'utf8');

package/src/utils/memory-lint.js

@@ -0,0 +1,174 @@
+/**
+ * memory-lint — flat + tree memory health audit (Urðr-derived, LLM-free)
+ *
+ * Ported from the Urðr standard (natureco-official/urdr scripts/lint.mjs) into NatureCo's
+ * real memory layout so users are protected from the drift that erodes recall:
+ *   - DUPLICATE facts (Jaccard ≥ 0.85) — the same thing stored twice, slightly reworded.
+ *   - CONFLICTING facts (Jaccard 0.5–0.85) — same subject, different value, e.g.
+ *     "favori rengi kırmızı" vs "Favori rengi mavidir", or two different project code names.
+ *     This is exactly why recall can return the "wrong" remembered value.
+ *
+ * Flat memory:  ~/.natureco/memory/<user>.json  (facts: [{value, ...}])
+ * Tree memory:  ~/.natureco/memory/tree/<user>/*.md  (## branch → leaves)
+ *
+ * v5.45.1: matching is Turkish-aware (tr-text foldTr) and searchTree is regex-free so a
+ * natural query like "proje kod adı (v2)" is matched literally, not as a regex.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { foldTr } = require('./tr-text');
+
+const MEMORY_DIR = path.join(os.homedir(), '.natureco', 'memory');
+const DUP = 0.85;
+const CONFLICT = 0.5;
+// Root files: Urðr "root-N-name.md" / "kök-N-…" and NatureCo native "N-name.md".
+const ROOT_RE = /^(?:(?:root|kök|kok)-)?\d[-_].*\.md$/i;
+
+const STOP = new Set(['ve', 'ile', 'için', 'icin', 'bir', 'bu', 'da', 'de', 'the', 'and', 'for',
+  'kullanici', 'kullanıcı', 'kullanicinin', 'kullanıcının', 'benim', 'onun', 'çok', 'cok']);
+
+function tokens(text) {
+  // foldTr lowercases and normalizes the four Turkish i-variants so "İstanbul" and
+  // "istanbul" tokenize identically (better duplicate/conflict detection for TR facts).
+  return new Set(
+    foldTr(text)
+      .replace(/[*_`|]/g, ' ')
+      .replace(/\b\d{2}\.\d{2}\.\d{4}\b/g, ' ')
+      .split(/[^a-z0-9çğıöşü-]+/i)
+      .filter((w) => w.length > 2 && !STOP.has(w))
+  );
+}
+
+function jaccard(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let inter = 0;
+  for (const x of a) if (b.has(x)) inter++;
+  return inter / (a.size + b.size - inter);
+}
+
+/**
+ * Lint an array of fact objects/strings. Returns findings, most-similar first.
+ * Each fact may carry an optional `branch` (tree memory) which is propagated into the
+ * finding as aBranch/bBranch so the caller can tell the user WHERE each side lives.
+ * @returns {Array<{level:'duplicate'|'conflict', sim:number, a:string, b:string, aBranch?:string, bBranch?:string}>}
+ */
+function lintFacts(facts) {
+  const items = (facts || [])
+    .map((f) => ({ value: f && f.value != null ? f.value : f, branch: f && f.branch }))
+    .filter((x) => typeof x.value === 'string' && x.value.trim());
+  const toks = items.map((x) => tokens(x.value));
+  const findings = [];
+  for (let i = 0; i < items.length; i++) {
+    for (let j = i + 1; j < items.length; j++) {
+      const sim = jaccard(toks[i], toks[j]);
+      if (sim < CONFLICT) continue;
+      findings.push({
+        level: sim >= DUP ? 'duplicate' : 'conflict',
+        sim,
+        a: items[i].value,
+        b: items[j].value,
+        aBranch: items[i].branch,
+        bBranch: items[j].branch,
+      });
+    }
+  }
+  return findings.sort((x, y) => y.sim - x.sim);
+}
+
+/** Is this a real leaf line (not a heading/comment/separator/placeholder/quote)? */
+function isLeaf(trimmed) {
+  return !!trimmed
+    && !trimmed.startsWith('<!--')
+    && !trimmed.startsWith('#')
+    && trimmed !== '---'
+    && !/^_no entries yet\._$/i.test(trimmed)
+    && !trimmed.startsWith('>');
+}
+
+/** Strip a leading list marker ("- ", "* ", "+ ") for clean display/tokenization. */
+function leafText(trimmed) {
+  return trimmed.replace(/^[-*+]\s+/, '');
+}
+
+/** Parse a tree root file into branches → leaves and lint for duplicates/conflicts within it. */
+function lintTreeFile(file) {
+  let content;
+  try { content = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  const leaves = [];
+  let branch = '(root)';
+  for (const line of content.split(/\r?\n/)) {
+    const h = line.match(/^##\s+(.+?)\s*$/);
+    if (h) { branch = h[1]; continue; }
+    const t = line.trim();
+    if (!isLeaf(t)) continue;
+    leaves.push({ value: leafText(t), branch });
+  }
+  return lintFacts(leaves).map((f) => ({ ...f, file: path.basename(file) }));
+}
+
+/** Full audit for a user: flat facts + every tree root file. */
+function lintUser(user) {
+  const uname = (user || 'default').toLowerCase();
+  const flatFile = path.join(MEMORY_DIR, `${uname}.json`);
+  let flatFindings = [], flatCount = 0;
+  try {
+    const facts = (JSON.parse(fs.readFileSync(flatFile, 'utf8')).facts) || [];
+    flatCount = facts.length;
+    flatFindings = lintFacts(facts);
+  } catch {}
+
+  const treeDir = path.join(MEMORY_DIR, 'tree', uname);
+  const treeFindings = [];
+  try {
+    for (const f of fs.readdirSync(treeDir)) {
+      if (ROOT_RE.test(f)) treeFindings.push(...lintTreeFile(path.join(treeDir, f)));
+    }
+  } catch {}
+
+  return { flatFile, flatCount, flatFindings, treeFindings };
+}
+
+/**
+ * v5.45: Branch-aware fallback search over a user's memory tree (Urðr search.mjs port).
+ * The hierarchical 4-step lookup is primary; this is the safety net so a wrong-root guess
+ * never makes stored info read as "forgotten". LLM-free, cross-platform.
+ *
+ * v5.45.1: Turkish-aware (foldTr) and REGEX-FREE. The query is split into whitespace terms
+ * and a leaf matches only if it contains ALL terms (AND) — so multi-word queries are useful
+ * and special characters like ()[]*? are matched literally instead of breaking the search.
+ * @param {string} user
+ * @param {string} query
+ * @param {{max?:number, dir?:string}} opts  dir overrides the tree directory (testing).
+ * @returns {Array<{file, branch, text}>}
+ */
+function searchTree(user, query, opts = {}) {
+  const max = opts.max || 25;
+  const treeDir = opts.dir || path.join(MEMORY_DIR, 'tree', (user || 'default').toLowerCase());
+  const terms = String(query == null ? '' : query).split(/\s+/).map(foldTr).filter(Boolean);
+  if (!terms.length) return [];
+  let files;
+  try { files = fs.readdirSync(treeDir).filter((f) => ROOT_RE.test(f)); }
+  catch { return []; }
+  const out = [];
+  for (const file of files.sort()) {
+    let content;
+    try { content = fs.readFileSync(path.join(treeDir, file), 'utf8'); } catch { continue; }
+    let branch = '(root)';
+    for (const line of content.split(/\r?\n/)) {
+      const h = line.match(/^##\s+(.+?)\s*$/);
+      if (h) { branch = h[1]; continue; }
+      const t = line.trim();
+      if (!isLeaf(t)) continue;
+      const folded = foldTr(line);
+      if (terms.every((term) => folded.includes(term))) {
+        out.push({ file, branch, text: leafText(t).slice(0, 300) });
+        if (out.length >= max) return out;
+      }
+    }
+  }
+  return out;
+}
+
+module.exports = { lintFacts, lintTreeFile, lintUser, searchTree, tokens, jaccard };

package/src/utils/tr-text.js

@@ -0,0 +1,50 @@
+/**
+ * tr-text — Turkish-aware text folding for case-insensitive, robust substring matching.
+ *
+ * WHY THIS EXISTS (real bug, verified):
+ *   JavaScript's String.prototype.toLowerCase() is locale-INSENSITIVE. On the dotted
+ *   capital "İ" (U+0130) it produces "i̇" (ASCII i + COMBINING DOT ABOVE U+0307), which
+ *   does NOT equal a plain "i". So the naive `text.toLowerCase().includes(query)` used by
+ *   memory recall silently MISSES every capitalized Turkish word:
+ *     "İstanbul".toLowerCase() -> "i̇stanbul"  (query "istanbul" → NO MATCH)
+ *     "ISPARTA".toLowerCase()  -> "isparta"    (Turkish query "ısparta" → NO MATCH)
+ *   For a Turkish-first product this breaks recall for İstanbul, İzmir, İş, İletişim, …
+ *   on every conversation — invisible data loss for millions of users.
+ *
+ * THE FIX:
+ *   Fold all four Turkish "i" letters — İ (dotted upper), I (dotless upper), ı (dotless
+ *   lower), i (dotted lower) — to a single canonical 'i' BEFORE lowercasing. This makes
+ *   {İstanbul, istanbul, ISTANBUL, ıstanbul} all match query "istanbul", while English
+ *   stays intact ("FILE" -> "file", not the Turkish "fıle").
+ *
+ *   We deliberately do NOT fold ş/ç/ğ/ö/ü — those carry meaning ("şık" elegant ≠ "sık"
+ *   frequent), and collapsing them would create wrong matches. Only the notorious
+ *   i-dot case-folding trap is normalized.
+ *
+ * Used by both the agent's live recall (memory_tree search/remove) and the human CLI
+ * search (memory-lint searchTree) so matching behaves identically everywhere.
+ */
+
+/**
+ * Fold text for case-insensitive Turkish-safe comparison. Never throws.
+ * @param {*} s
+ * @returns {string}
+ */
+function foldTr(s) {
+  return String(s == null ? '' : s)
+    .replace(/İ/g, 'i') // U+0130 dotted capital  → i  (avoids the U+0307 combining-dot trap)
+    .replace(/I/g, 'i') // U+0049 dotless capital → i
+    .replace(/ı/g, 'i') // U+0131 dotless lower   → i
+    .toLowerCase();
+}
+
+/**
+ * Turkish-aware, case-insensitive "does haystack contain needle?". Substring — no regex,
+ * so query text with (), [], *, ? etc. is matched literally (never interpreted).
+ * @returns {boolean}
+ */
+function foldIncludes(haystack, needle) {
+  return foldTr(haystack).includes(foldTr(needle));
+}
+
+module.exports = { foldTr, foldIncludes };