natureco-cli 5.6.16 → 5.6.18

package/package.json

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

@@ -2,6 +2,7 @@ const chalk = require('chalk');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const memoryStore = require('../utils/memory-store');
 const { loadMemory, saveMemory, clearMemory } = require('../utils/memory');
 const { getConfig } = require('../utils/config');
 
@@ -213,7 +214,7 @@ function indexMemory() {
 // ── Export Memory ──────────────────────────────────────────────────────────────
 function exportMemoryCmd(botId, outputFile) {
   const id = botId || 'universal-provider';
-  const mem = exportMemory(id);
+  const mem = memoryStore.loadMemory(id);
   const filePath = outputFile || path.join(process.cwd(), `memory-${id}.json`);
   fs.writeFileSync(filePath, JSON.stringify(mem, null, 2));
   console.log(chalk.green(`\n  ✓ Hafıza dışa aktarıldı: ${filePath}\n`));
@@ -233,8 +234,11 @@ function importMemoryCmd(botId, sourceFile) {
   }
   try {
     const data = JSON.parse(fs.readFileSync(resolvedPath, 'utf-8'));
-    importMemory(botId || 'universal-provider', data);
-    console.log(chalk.green(`\n  ✓ Hafıza içe aktarıldı: ${botId || 'universal-provider'}\n`));
+    // v5.6.16: memoryStore.saveMemory kullan
+    const importId = botId || 'universal-provider';
+    memoryStore.saveMemory(importId, data);
+    console.log(chalk.green(`\n  ✓ Hafıza içe aktarıldı: ${importId}\n`));
+    console.log(chalk.green(`\n  ✓ Hafıza içe aktarıldı: ${id}\n`));
   } catch (err) {
     console.log(chalk.red(`\n  ❌ Hata: ${err.message}\n`));
   }
@@ -335,4 +339,70 @@ function wikiSearchCmd(query) {
   });
 }
 
+// ── Wiki Page Functions (v5.6.16 inline) ─────────────────────────────
+function listWikiPages() {
+  const WIKI_DIR = path.join(os.homedir(), '.natureco', 'wiki');
+  if (!fs.existsSync(WIKI_DIR)) {
+    console.log(chalk.gray('\n  Wiki bos.\n'));
+    return;
+  }
+  const files = fs.readdirSync(WIKI_DIR).filter(f => f.endsWith('.md'));
+  console.log(chalk.cyan(`\n  Wiki Sayfalari (${files.length}):\n`));
+  files.forEach(f => console.log(`  ${chalk.white(f.replace('.md',''))}`));
+  console.log();
+}
+
+function getWikiPage(slug) {
+  if (!slug) return;
+  const WIKI_DIR = path.join(os.homedir(), '.natureco', 'wiki');
+  const filePath = path.join(WIKI_DIR, `${slug}.md`);
+  if (!fs.existsSync(filePath)) {
+    console.log(chalk.red(`\n  ❌ Wiki sayfasi bulunamadi: ${slug}\n`));
+    return;
+  }
+  console.log(chalk.cyan(`\n  ${slug}\n`));
+  console.log(chalk.gray('  ' + '─'.repeat(60)));
+  console.log(fs.readFileSync(filePath, 'utf-8'));
+}
+
+function saveWikiPage(slug, content) {
+  if (!slug) return;
+  const WIKI_DIR = path.join(os.homedir(), '.natureco', 'wiki');
+  if (!fs.existsSync(WIKI_DIR)) fs.mkdirSync(WIKI_DIR, { recursive: true });
+  const filePath = path.join(WIKI_DIR, `${slug}.md`);
+  fs.writeFileSync(filePath, content);
+  console.log(chalk.green(`\n  ✓ Wiki sayfasi kaydedildi: ${slug}\n`));
+}
+
+function searchWikiPages(query) {
+  if (!query) return [];
+  const WIKI_DIR = path.join(os.homedir(), '.natureco', 'wiki');
+  if (!fs.existsSync(WIKI_DIR)) return [];
+  const lower = query.toLowerCase();
+  return fs.readdirSync(WIKI_DIR)
+    .filter(f => f.endsWith('.md'))
+    .map(f => ({
+      slug: f.replace('.md', ''),
+      content: fs.readFileSync(path.join(WIKI_DIR, f), 'utf-8'),
+    }))
+    .filter(p => p.content.toLowerCase().includes(lower));
+}
+
+// ── Semantic Search (v5.6.16 inline - basit keyword-based) ───────────
+function semanticSearchMemory(query, botId) {
+  const id = botId || 'universal-provider';
+  const mem = memoryStore.loadMemory(id);
+  if (!query) return [];
+  const lower = query.toLowerCase();
+  const results = [];
+  // facts icinde ara
+  (mem.facts || []).forEach(f => {
+    const text = (typeof f === 'string' ? f : f.value) || '';
+    if (text.toLowerCase().includes(lower)) {
+      results.push({ type: 'fact', value: text, score: f.score || 5 });
+    }
+  });
+  return results;
+}
+
 module.exports = memoryCmd;

package/src/commands/uninstall.js

@@ -4,6 +4,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 const readline = require('readline');
+const { requireApproval, RISK } = require('../utils/dangerous');
 
 const BASE_DIR = path.join(os.homedir(), '.natureco');
 
@@ -46,12 +47,16 @@ function cmdDryRun() {
 async function cmdRun() {
   console.log(chalk.cyan('\n  Uninstall NatureCo\n'));
 
-  const answer = await rlQuestion(chalk.red('  This will remove all NatureCo data. Continue? [y/N]: '));
-  if (answer !== 'y' && answer !== 'yes') {
+  // v5.6.16: Dangerous approval (CRITICAL)
+  const approved = await requireApproval('natureco uninstall', {}, RISK.CRITICAL,
+    'NatureCo CLI ve tum kisisel veriler silinecek (geri alinamaz)');
+  if (!approved) {
     console.log(chalk.gray('\n  Cancelled.\n'));
     return;
   }
 
+  // Eski onay mekanizmasini kaldirdik, dangerous approval yeterli
+
   if (fs.existsSync(BASE_DIR)) {
     console.log(chalk.gray('  Removing ~/.natureco/...'));
     fs.rmSync(BASE_DIR, { recursive: true, force: true });

package/src/utils/memory-store.js

@@ -0,0 +1,185 @@
+/**
+ * memory_write - Memory'ye fact/kayit yaz (v5.1.1)
+ *
+ * REPL'in extractMemoryFromMessage ozelligini tool olarak expose eder.
+ * Parton'un vizyonu: "Benim asistanim, her seyimi hatirlayacak"
+ */
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const MEMORY_DIR = path.join(os.homedir(), ".natureco", "memory");
+
+function getMemoryFile(username) {
+  const name = (username || "default").toLowerCase();
+  return path.join(MEMORY_DIR, `${name}.json`);
+}
+
+function loadMemory(username) {
+  const file = getMemoryFile(username);
+  try {
+    if (!fs.existsSync(file)) {
+      return { name: username || "User", nickname: null, botName: null, facts: [], preferences: [] };
+    }
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return { name: username || "User", nickname: null, botName: null, facts: [], preferences: [] };
+  }
+}
+
+function saveMemory(username, memory) {
+  if (!fs.existsSync(MEMORY_DIR)) fs.mkdirSync(MEMORY_DIR, { recursive: true });
+  memory.lastUpdated = new Date().toISOString();
+  fs.writeFileSync(getMemoryFile(username), JSON.stringify(memory, null, 2), "utf8");
+  return memory;
+}
+
+/**
+ * Score azalt (eski fact'ler zamanla unutuluyor)
+ */
+function decayFacts(memory) {
+  if (!memory.facts) return memory;
+  const now = Date.now();
+  memory.facts = memory.facts.map(f => {
+    if (!f.score) f.score = 5;
+    // 1 haftadan eski -1, 1 aydan eski -3
+    const ageMs = now - new Date(f.updatedAt || f.createdAt || now).getTime();
+    const ageDays = ageMs / (1000 * 60 * 60 * 24);
+    if (ageDays > 30) f.score = Math.max(0, f.score - 3);
+    else if (ageDays > 7) f.score = Math.max(0, f.score - 1);
+    return f;
+  });
+  // score 0 olanlari sil
+  memory.facts = memory.facts.filter(f => (f.score || 0) > 0);
+  // max 15 fact tut
+  memory.facts.sort((a, b) => (b.score || 0) - (a.score || 0));
+  memory.facts = memory.facts.slice(0, 15);
+  return memory;
+}
+
+
+/**
+ * v5.4.9: Memory yazma sonrasi verification — geri oku ve gercekten yazildigini dogrula
+ * Self-validation mekanizmasi: tool cagirip "success" demesine ragmen dosya bos olabilir
+ */
+function verifyMemoryWrite(username, expectedFact, expectedBotName) {
+  try {
+    const memFile = getMemoryFile(username);
+    if (!fs.existsSync(memFile)) {
+      return { success: false, error: "Memory dosyasi olusturulamadi: " + memFile };
+    }
+    const mem = JSON.parse(fs.readFileSync(memFile, "utf8"));
+
+    // Fact verification
+    if (expectedFact) {
+      const found = (mem.facts || []).some(f => f.value === expectedFact);
+      if (!found) {
+        return { success: false, error: "Fact memory'de bulunamadi: " + expectedFact };
+      }
+    }
+
+    // BotName verification
+    if (expectedBotName && mem.botName !== expectedBotName) {
+      return { success: false, error: "BotName guncellenmedi: " + mem.botName };
+    }
+
+    return { success: true, message: "Memory dogrulandi" };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+
+function addMemory({ username, fact, score = 5, category = "general", botName, nickname, name }) {
+  // Username yoksa ve 'name' parametresi varsa, onu username olarak kullan
+  // (Parton'un "patron" diye hitap etmesi durumu icin)
+  const effectiveUsername = username || (name && name.toLowerCase()) || 'default';
+  if (!effectiveUsername || effectiveUsername === 'default') {
+    // Hicbir username yok, default.json'a yaz
+  }
+
+  let memory = loadMemory(effectiveUsername);
+  memory = decayFacts(memory);
+
+  // identity updates (botName, nickname, name) — name sadece memory.name, username degil
+  if (botName) memory.botName = botName;
+  if (nickname !== undefined) memory.nickname = nickname;
+  if (name) memory.name = name; // Bu memory.name (kullanici gercek adi), username degil
+
+  if (fact) {
+    // duplicate kontrol
+    const existing = memory.facts.find(f => (f.value || f).toLowerCase() === fact.toLowerCase());
+    if (existing) {
+      existing.score = Math.min(10, (existing.score || 5) + 2);
+      existing.updatedAt = new Date().toISOString();
+    } else {
+      memory.facts.push({
+        value: fact,
+        score,
+        category,
+        updatedAt: new Date().toISOString(),
+        createdAt: new Date().toISOString(),
+      });
+    }
+  }
+
+  if (!memory.preferences) memory.preferences = [];
+  memory = saveMemory(effectiveUsername, memory);
+
+  // v5.4.9: Verification - geri oku ve dogrula
+  const verifyResult = verifyMemoryWrite(effectiveUsername, fact, botName);
+  if (!verifyResult.success) {
+    return {
+      success: false,
+      error: "Memory yazildi ama dogrulanamadi: " + verifyResult.error,
+      username: effectiveUsername,
+    };
+  }
+
+  return {
+    success: true,
+    message: "Memory guncellendi ve dogrulandi",
+    username: effectiveUsername,
+    verified: true,
+    totalFacts: memory.facts.length,
+    facts: memory.facts.map(f => ({ value: f.value, score: f.score, category: f.category })),
+    botName: memory.botName,
+    nickname: memory.nickname,
+    name: memory.name,
+  };
+}
+
+function clearMemory({ username }) {
+  if (!username) return { success: false, error: "username gerekli" };
+  const file = getMemoryFile(username);
+  if (fs.existsSync(file)) fs.unlinkSync(file);
+  return { success: true, message: `Memory temizlendi: ${username}` };
+}
+
+function showMemory({ username }) {
+  if (!username) return { success: false, error: "username gerekli" };
+  const memory = loadMemory(username);
+  return {
+    success: true,
+    username,
+    name: memory.name,
+    nickname: memory.nickname,
+    botName: memory.botName,
+    totalFacts: (memory.facts || []).length,
+    facts: memory.facts || [],
+    preferences: memory.preferences || [],
+  };
+}
+
+
+module.exports = {
+  getMemoryFile,
+  loadMemory,
+  saveMemory,
+  decayFacts,
+  verifyMemoryWrite,
+  addMemory,
+  clearMemory,
+  showMemory,
+};