natureco-cli 5.6.15 → 5.6.17

package/src/commands/reset.js

@@ -17,12 +17,34 @@ const path = require('path');
 const os = require('os');
 const inquirer = require('../utils/inquirer-wrapper');
 const chalk = require('chalk');
+const { requireApproval, RISK } = require('../utils/dangerous');
 
 async function reset() {
   const args = process.argv.slice(3);
   const home = os.homedir();
   const baseDir = path.join(home, '.natureco');
 
+  // v5.6.16: Dangerous command approval
+  const isFullReset = args.includes('--all') || args.includes('--personal');
+  const risk = isFullReset ? RISK.CRITICAL : RISK.HIGH;
+  const reason = isFullReset
+    ? 'Tum kisisel veriler ve ayarlar silinecek (geri alinamaz)'
+    : 'Secili kapsamdaki veriler silinecek';
+
+  // --yes/-y bypass (eski davranis)
+  const skipApproval = args.includes('--yes') || args.includes('-y');
+
+  if (!skipApproval) {
+    const argsObj = {
+      flags: args.filter(a => a.startsWith('--') || a.startsWith('-'))
+    };
+    const approved = await requireApproval('natureco reset', argsObj, risk, reason);
+    if (!approved) {
+      console.log(chalk.gray('\nIptal edildi.\n'));
+      return;
+    }
+  }
+
   console.log(chalk.yellow('\n\u26a0  RESET - Tum veriler silinecek!\n'));
 
   const whatToReset = {
@@ -48,18 +70,7 @@ async function reset() {
   if (whatToReset.soul) console.log('  - soul/ (generic default doner)');
   if (whatToReset.personal) console.log('  - personal/');
 
-  // Onay
-  const ans = await inquirer.prompt([{
-    type: 'confirm',
-    name: 'confirm',
-    message: 'Tum verileri silmek istediginize emin misiniz?',
-    default: false,
-  }]);
-
-  if (!ans.confirm) {
-    console.log(chalk.gray('\nIptal edildi.'));
-    return;
-  }
+
 
   // Sil
   if (whatToReset.config) {

package/src/utils/dangerous.js

@@ -0,0 +1,110 @@
+/**
+ * Dangerous Command Approval (v5.6.16)
+ *
+ * Hermes Agent'taki "Command required approval" mekanizmasinin
+ * NatureCo CLI versiyonu. Riskli komutlari calistirmadan once
+ * kullanici onayi alir.
+ *
+ * Kullanim:
+ *   const { requireApproval, RISK } = require('../utils/dangerous');
+ *   if (!await requireApproval('reset', { scope: 'full' }, RISK.CRITICAL)) return;
+ */
+
+const inquirer = require('../utils/inquirer-wrapper');
+const chalk = require('chalk');
+
+const RISK = {
+  LOW: 'low',          // Otomatik onay
+  MEDIUM: 'medium',    // Basit onay mesaji
+  HIGH: 'high',        // Acik onay gerekli
+  CRITICAL: 'critical', // Tam yazim onay gerekli
+};
+
+const RISK_LABELS = {
+  low: { color: 'gray', icon: '⚪', label: 'DUSUK RISK' },
+  medium: { color: 'yellow', icon: '🟡', label: 'ORTA RISK' },
+  high: { color: 'red', icon: '🔴', label: 'YUKSEK RISK' },
+  critical: { color: 'magenta', icon: '⛔', label: 'KRITIK - GERI ALINAMAZ' },
+};
+
+const RISK_RANK = { low: 0, medium: 1, high: 2, critical: 3 };
+
+/**
+ * Komut calistirmadan once risk seviyesi goster, onay iste
+ * @param {string} command - komut adi ('reset', 'uninstall', 'memory clear', vs.)
+ * @param {object} args - komutun parametreleri
+ * @param {string} risk - RISK enum degeri
+ * @param {string} reason - neden tehlikeli
+ * @returns {Promise<boolean>} - onay verildi mi
+ */
+async function requireApproval(command, args = {}, risk = RISK.HIGH, reason = '') {
+  // --force veya --yes flag kontrolu (CLI tarafinda eklenir)
+  if (process.env.NATURECO_FORCE === '1' || args.force || args.yes) {
+    return true;
+  }
+
+  const label = RISK_LABELS[risk] || RISK_LABELS.high;
+
+  console.log();
+  console.log(chalk[label.color](`  ${label.icon} ${label.label}: ${command}`));
+  console.log(chalk.gray('  ' + '─'.repeat(60)));
+  console.log(chalk.white(`  Komut: ${command}`));
+  if (Object.keys(args).length > 0) {
+    console.log(chalk.gray(`  Argumanlar: ${JSON.stringify(args)}`));
+  }
+  if (reason) {
+    console.log(chalk[label.color](`  Neden: ${reason}`));
+  }
+  console.log(chalk.gray('  ' + '─'.repeat(60)));
+
+  // Dusuk risk - otomatik onay, sadece mesaj goster
+  if (risk === RISK.LOW) {
+    console.log(chalk.gray('  Otomatik onaylandi (dusuk risk)'));
+    console.log();
+    return true;
+  }
+
+  // Kritik risk - tam yazim gerekli
+  if (risk === RISK.CRITICAL) {
+    console.log(chalk.red('  Bu islem geri alinamaz!'));
+    const { confirm } = await inquirer.prompt([{
+      type: 'input',
+      name: 'confirm',
+      message: chalk.red('  Devam etmek icin "EVET SIL" yazin (veya Enter ile iptal):'),
+      validate: (input) => input === 'EVET SIL' || input === ''
+    }]);
+    console.log();
+    return confirm === 'EVET SIL';
+  }
+
+  // Yuksek ve orta risk - basit onay
+  const promptType = risk === RISK.HIGH ? 'confirm' : 'confirm';
+  const { ok } = await inquirer.prompt([{
+    type: promptType,
+    name: 'ok',
+    message: chalk[label.color](`  Bu komutu calistirmak istediginize emin misiniz?`),
+    default: false,
+  }]);
+  console.log();
+  return ok;
+}
+
+/**
+ * Komutun risk seviyesini goster, hizli onay al
+ * (sync versiyon, sadece mesaj gosterir)
+ */
+function showRisk(command, args = {}, risk = RISK.MEDIUM, reason = '') {
+  const label = RISK_LABELS[risk] || RISK_LABELS.medium;
+  console.log();
+  console.log(chalk[label.color](`  ${label.icon} ${label.label}: ${command}`));
+  if (reason) console.log(chalk.gray(`  ${reason}`));
+  console.log();
+}
+
+module.exports = {
+  RISK,
+  RISK_LABELS,
+  RISK_RANK,
+  requireApproval,
+  showRisk,
+};

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