natureco-cli 5.44.1 → 5.45.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to NatureCo CLI will be documented in this file.
 
+## [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.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/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;
+  }
+  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 + ']') : ''}`);
+    }
+  }
+  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 + ']') : ''}`);
+    }
+  }
+  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/utils/memory-lint.js

@@ -0,0 +1,131 @@
+/**
+ * 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)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const MEMORY_DIR = path.join(os.homedir(), '.natureco', 'memory');
+const DUP = 0.85;
+const CONFLICT = 0.5;
+
+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) {
+  return new Set(
+    String(text || '').toLowerCase()
+      .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.
+ * @returns {Array<{level:'duplicate'|'conflict', sim:number, a:string, b: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 findings = [];
+  for (let i = 0; i < vals.length; i++) {
+    for (let j = i + 1; j < vals.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] });
+    }
+  }
+  return findings.sort((x, y) => y.sim - x.sim);
+}
+
+/** 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 (!t || t.startsWith('<!--') || t.startsWith('#') || t === '---' || /^_no entries yet\._$/i.test(t) || t.startsWith('>')) continue;
+    leaves.push({ value: 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|kök|kok)-)?\d[-_].*\.md$/i.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.
+ * @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'); }
+  let files;
+  try { files = fs.readdirSync(treeDir).filter((f) => /^(?:(?:root|kök|kok)-)?\d[-_].*\.md$/i.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 (!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; }
+    }
+  }
+  return out;
+}
+
+module.exports = { lintFacts, lintTreeFile, lintUser, searchTree, tokens, jaccard };