natureco-cli 5.45.0 → 5.45.1

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 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

package/package.json

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

@@ -435,19 +435,19 @@ function lintMemoryCmd(user) {
     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)) {
-      console.log(`     ${chalk.gray(`(%${Math.round(f.sim * 100)})`)} ${f.a}`);
-      console.log(`     ${chalk.gray('           ≈')} ${f.b}${f.file ? chalk.gray(' [' + f.file + ']') : ''}`);
-    }
+    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)) {
-      console.log(`     ${chalk.gray(`(%${Math.round(f.sim * 100)})`)} ${f.a}`);
-      console.log(`     ${chalk.gray('           ↔')} ${f.b}${f.file ? chalk.gray(' [' + f.file + ']') : ''}`);
-    }
+    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`));
 }

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

@@ -10,22 +10,30 @@
  *
  * 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(
-    String(text || '').toLowerCase()
+    foldTr(text)
       .replace(/[*_`|]/g, ' ')
       .replace(/\b\d{2}\.\d{2}\.\d{4}\b/g, ' ')
       .split(/[^a-z0-9çğıöşü-]+/i)
@@ -42,22 +50,48 @@ function jaccard(a, b) {
 
 /**
  * Lint an array of fact objects/strings. Returns findings, most-similar first.
- * @returns {Array<{level:'duplicate'|'conflict', sim:number, a:string, b:string}>}
+ * 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 vals = (facts || []).map((f) => (f && f.value != null ? f.value : f)).filter((v) => typeof v === 'string' && v.trim());
-  const toks = vals.map(tokens);
+  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 < vals.length; i++) {
-    for (let j = i + 1; j < vals.length; j++) {
+  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 >= DUP) findings.push({ level: 'duplicate', sim, a: vals[i], b: vals[j] });
-      else if (sim >= CONFLICT) findings.push({ level: 'conflict', sim, a: vals[i], b: vals[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;
@@ -68,8 +102,8 @@ function lintTreeFile(file) {
     const h = line.match(/^##\s+(.+?)\s*$/);
     if (h) { branch = h[1]; continue; }
     const t = line.trim();
-    if (!t || t.startsWith('<!--') || t.startsWith('#') || t === '---' || /^_no entries yet\._$/i.test(t) || t.startsWith('>')) continue;
-    leaves.push({ value: t, branch });
+    if (!isLeaf(t)) continue;
+    leaves.push({ value: leafText(t), branch });
   }
   return lintFacts(leaves).map((f) => ({ ...f, file: path.basename(file) }));
 }
@@ -89,7 +123,7 @@ function lintUser(user) {
   const treeFindings = [];
   try {
     for (const f of fs.readdirSync(treeDir)) {
-      if (/^(?:(?:root|kök|kok)-)?\d[-_].*\.md$/i.test(f)) treeFindings.push(...lintTreeFile(path.join(treeDir, f)));
+      if (ROOT_RE.test(f)) treeFindings.push(...lintTreeFile(path.join(treeDir, f)));
     }
   } catch {}
 
@@ -100,17 +134,22 @@ function lintUser(user) {
  * 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 = path.join(MEMORY_DIR, 'tree', (user || 'default').toLowerCase());
-  if (!query || !String(query).trim()) return [];
-  let re;
-  try { re = new RegExp(query, 'i'); }
-  catch { re = new RegExp(String(query).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i'); }
+  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|kök|kok)-)?\d[-_].*\.md$/i.test(f)); }
+  try { files = fs.readdirSync(treeDir).filter((f) => ROOT_RE.test(f)); }
   catch { return []; }
   const out = [];
   for (const file of files.sort()) {
@@ -121,8 +160,12 @@ function searchTree(user, query, opts = {}) {
       const h = line.match(/^##\s+(.+?)\s*$/);
       if (h) { branch = h[1]; continue; }
       const t = line.trim();
-      if (!t || t.startsWith('<!--') || t.startsWith('#') || t === '---' || /^_no entries yet\._$/i.test(t) || t.startsWith('>')) continue;
-      if (re.test(line)) { out.push({ file, branch, text: t.slice(0, 300) }); if (out.length >= max) return out; }
+      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;

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 };