natureco-cli 2.23.28 → 2.23.30

package/src/utils/config.js

@@ -1,11 +1,24 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const crypto = require('crypto');
+const { ConfigParseError, ConfigMutationConflictError, ConfigValidationError, handleError } = require('./errors');
+
+let json5;
+try {
+  json5 = require('json5');
+} catch {
+  json5 = null;
+}
 
 const CONFIG_DIR = path.join(os.homedir(), '.natureco');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const CONFIG_BACKUP_DIR = path.join(CONFIG_DIR, 'backups');
+const MAX_BACKUPS = 10;
+
+let _configCache = null;
+let _configHash = null;
 
-// --profile flag desteği: ~/.natureco-<profile>/
 function getProfileDir() {
   const profileArg = process.argv.find(a => a.startsWith('--profile='));
   const profileIdx = process.argv.indexOf('--profile');
@@ -27,50 +40,134 @@ function ensureConfigDir() {
   }
 }
 
-function saveConfig(data) {
+function computeHash(data) {
+  return crypto.createHash('sha256').update(JSON.stringify(data)).digest('hex');
+}
+
+function createBackup() {
+  if (!fs.existsSync(ACTIVE_CONFIG_FILE)) return;
   ensureConfigDir();
-  fs.writeFileSync(ACTIVE_CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8');
+  if (!fs.existsSync(CONFIG_BACKUP_DIR)) {
+    fs.mkdirSync(CONFIG_BACKUP_DIR, { recursive: true });
+  }
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupFile = path.join(CONFIG_BACKUP_DIR, `config-${timestamp}.json`);
+  fs.copyFileSync(ACTIVE_CONFIG_FILE, backupFile);
+  const backups = fs.readdirSync(CONFIG_BACKUP_DIR)
+    .filter(f => f.startsWith('config-') && f.endsWith('.json'))
+    .sort()
+    .reverse();
+  if (backups.length > MAX_BACKUPS) {
+    backups.slice(MAX_BACKUPS).forEach(f => {
+      try { fs.unlinkSync(path.join(CONFIG_BACKUP_DIR, f)); } catch {}
+    });
+  }
+}
+
+function parseConfigContent(content) {
+  if (!content || !content.trim()) return {};
+  const trimmed = content.trim();
+  if (trimmed.startsWith('{')) {
+    if (json5) {
+      try { return json5.parse(trimmed); } catch {}
+    }
+    return JSON.parse(trimmed);
+  }
+  return JSON.parse(trimmed);
+}
+
+function validateConfig(data) {
+  if (data === null || data === undefined) throw new ConfigValidationError('Config cannot be null', { field: 'root' });
+  if (typeof data !== 'object' || Array.isArray(data)) throw new ConfigValidationError('Config must be a JSON object', { field: 'root' });
+  if (data.apiKey !== undefined && typeof data.apiKey !== 'string') throw new ConfigValidationError('apiKey must be a string', { field: 'apiKey' });
+  if (data.providerUrl !== undefined && typeof data.providerUrl !== 'string') throw new ConfigValidationError('providerUrl must be a string', { field: 'providerUrl' });
+  if (data.providerModel !== undefined && typeof data.providerModel !== 'string') throw new ConfigValidationError('providerModel must be a string', { field: 'providerModel' });
+  return true;
+}
+
+function saveConfig(data, options = {}) {
+  const { skipBackup = false, skipValidation = false } = options;
+  ensureConfigDir();
+  if (!skipValidation) validateConfig(data);
+  if (!skipBackup) createBackup();
+  const content = JSON.stringify(data, null, 2);
+  fs.writeFileSync(ACTIVE_CONFIG_FILE, content, 'utf8');
+  _configCache = data;
+  _configHash = computeHash(data);
 }
 
-function loadConfig() {
+function loadConfig(options = {}) {
+  const { useCache = true, skipValidation = false } = options;
+  if (useCache && _configCache) return _configCache;
   if (!fs.existsSync(ACTIVE_CONFIG_FILE)) {
+    _configCache = null;
+    _configHash = null;
     return null;
   }
   try {
     const content = fs.readFileSync(ACTIVE_CONFIG_FILE, 'utf8');
-    return JSON.parse(content);
+    const data = parseConfigContent(content);
+    if (!skipValidation) validateConfig(data);
+    _configCache = data;
+    _configHash = computeHash(data);
+    return data;
   } catch (err) {
+    _configCache = null;
+    _configHash = null;
+    if (err instanceof ConfigValidationError || err instanceof ConfigParseError) throw err;
     return null;
   }
 }
 
+function loadConfigWithRetry(maxRetries = 3) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      return loadConfig({ useCache: false });
+    } catch (err) {
+      if (i === maxRetries - 1) throw err;
+    }
+  }
+  return null;
+}
+
 function deleteConfig() {
   if (fs.existsSync(ACTIVE_CONFIG_FILE)) {
+    createBackup();
     fs.unlinkSync(ACTIVE_CONFIG_FILE);
   }
+  _configCache = null;
+  _configHash = null;
 }
 
 function getApiKey() {
   const config = loadConfig();
-  return config?.apiKey || null;
+  return config?.apiKey ?? null;
 }
 
 function saveApiKey(apiKey) {
-  const config = loadConfig() || {};
+  const config = loadConfig() ?? {};
   config.apiKey = apiKey;
   saveConfig(config);
 }
 
 function getConfig() {
-  return loadConfig() || {};
+  try {
+    return loadConfig() ?? {};
+  } catch {
+    return {};
+  }
 }
 
 function getAllConfig() {
-  return loadConfig() || {};
+  try {
+    return loadConfig() ?? {};
+  } catch {
+    return {};
+  }
 }
 
 function setConfigValue(key, value) {
-  const config = loadConfig() || {};
+  const config = loadConfig() ?? {};
   const keys = key.split('.');
   let current = config;
   for (let i = 0; i < keys.length - 1; i++) {
@@ -83,15 +180,49 @@ function setConfigValue(key, value) {
   saveConfig(config);
 }
 
+function getConfigHash() {
+  return _configHash;
+}
+
+function listBackups() {
+  if (!fs.existsSync(CONFIG_BACKUP_DIR)) return [];
+  return fs.readdirSync(CONFIG_BACKUP_DIR)
+    .filter(f => f.startsWith('config-') && f.endsWith('.json'))
+    .sort()
+    .reverse();
+}
+
+function restoreConfig(backupFile) {
+  const backupPath = path.isAbsolute(backupFile)
+    ? backupFile
+    : path.join(CONFIG_BACKUP_DIR, backupFile);
+  if (!fs.existsSync(backupPath)) {
+    throw new ConfigValidationError(`Yedek dosyası bulunamadı: ${backupPath}`, { field: 'backupFile' });
+  }
+  const content = fs.readFileSync(backupPath, 'utf8');
+  const data = parseConfigContent(content);
+  validateConfig(data);
+  createBackup();
+  fs.writeFileSync(ACTIVE_CONFIG_FILE, JSON.stringify(data, null, 2), 'utf8');
+  _configCache = data;
+  _configHash = computeHash(data);
+  return { path: backupPath, timestamp: path.basename(backupPath).replace(/^config-|\.json$/g, '') };
+}
+
 module.exports = {
   saveConfig,
   loadConfig,
+  loadConfigWithRetry,
   deleteConfig,
   getApiKey,
   saveApiKey,
   getConfig,
   getAllConfig,
   setConfigValue,
+  getConfigHash,
+  listBackups,
+  restoreConfig,
   CONFIG_FILE: ACTIVE_CONFIG_FILE,
   CONFIG_DIR: ACTIVE_CONFIG_DIR,
+  CONFIG_BACKUP_DIR,
 };

package/src/utils/errors.js

@@ -0,0 +1,148 @@
+const chalk = require('chalk');
+
+class NatureCoError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.cause = options.cause || null;
+    this.exitCode = options.exitCode || 1;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+class ConfigError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.configPath = options.configPath || null;
+  }
+}
+
+class ConfigParseError extends ConfigError {
+  constructor(message, options = {}) {
+    super(`Config parse error: ${message}`, options);
+  }
+}
+
+class ConfigMutationConflictError extends ConfigError {
+  constructor(message, options = {}) {
+    super(`Config conflict: ${message}`, options);
+    this.currentHash = options.currentHash || null;
+  }
+}
+
+class ConfigValidationError extends ConfigError {
+  constructor(message, options = {}) {
+    super(`Config validation error: ${message}`, options);
+    this.field = options.field || null;
+  }
+}
+
+class ApiError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.statusCode = options.statusCode || null;
+    this.provider = options.provider || null;
+  }
+}
+
+class ProviderError extends ApiError {
+  constructor(message, options = {}) {
+    super(`Provider error (${options.provider || 'unknown'}): ${message}`, options);
+  }
+}
+
+class AuthenticationError extends ApiError {
+  constructor(message, options = {}) {
+    super(`Authentication error: ${message}`, options);
+  }
+}
+
+class ToolError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.toolName = options.toolName || null;
+  }
+}
+
+class ToolInputError extends ToolError {
+  constructor(message, options = {}) {
+    super(`Invalid tool input: ${message}`, options);
+  }
+}
+
+class ToolExecutionError extends ToolError {
+  constructor(message, options = {}) {
+    super(`Tool execution failed: ${message}`, options);
+  }
+}
+
+class ChannelError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.channel = options.channel || null;
+  }
+}
+
+class GatewayError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+  }
+}
+
+class PluginError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.plugin = options.plugin || null;
+  }
+}
+
+class SkillError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.skill = options.skill || null;
+  }
+}
+
+class MigrationError extends NatureCoError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.step = options.step || null;
+  }
+}
+
+function handleError(err, options = {}) {
+  const { prefix = '', exit = true, log = true } = options;
+  
+  if (log) {
+    const message = err instanceof NatureCoError
+      ? `${prefix}${err.message}`
+      : `${prefix}${err.message || 'An unknown error occurred'}`;
+    console.log(chalk.red(`\n${message}\n`));
+  }
+  
+  if (exit) {
+    process.exit(err instanceof NatureCoError ? err.exitCode : 1);
+  }
+}
+
+module.exports = {
+  NatureCoError,
+  ConfigError,
+  ConfigParseError,
+  ConfigMutationConflictError,
+  ConfigValidationError,
+  ApiError,
+  ProviderError,
+  AuthenticationError,
+  ToolError,
+  ToolInputError,
+  ToolExecutionError,
+  ChannelError,
+  GatewayError,
+  PluginError,
+  SkillError,
+  MigrationError,
+  handleError,
+};

package/src/utils/inquirer-wrapper.js

@@ -1,4 +1,4 @@
-const { select, input, password, confirm } = require('@inquirer/prompts');
+const { select, input, password, confirm, checkbox } = require('@inquirer/prompts');
 
 module.exports = {
   async prompt(questions) {
@@ -14,7 +14,6 @@ module.exports = {
       } else if (q.type === 'password') {
         results[q.name] = await password({ message: q.message, mask: q.mask });
       } else if (q.type === 'checkbox') {
-        const { checkbox } = require('@inquirer/prompts');
         results[q.name] = await checkbox({
           message: q.message,
           choices: q.choices.map(c =>

package/src/utils/memory.js

@@ -282,11 +282,211 @@ function clearMemory(botId) {
   }
 }
 
+// ── Memory Wiki (structured pages) ──────────────────────────────────────────────
+
+const MEMORY_WIKI_DIR = path.join(CONFIG_DIR, 'memory-wiki');
+
+function ensureWikiDir() {
+  if (!fs.existsSync(MEMORY_WIKI_DIR)) {
+    fs.mkdirSync(MEMORY_WIKI_DIR, { recursive: true });
+  }
+}
+
+function getWikiPage(slug) {
+  ensureWikiDir();
+  const file = path.join(MEMORY_WIKI_DIR, `${slug.replace(/[^a-z0-9_-]/gi, '_')}.json`);
+  if (!fs.existsSync(file)) return null;
+  try { return JSON.parse(fs.readFileSync(file, 'utf-8')); } catch { return null; }
+}
+
+function saveWikiPage(slug, content) {
+  ensureWikiDir();
+  const file = path.join(MEMORY_WIKI_DIR, `${slug.replace(/[^a-z0-9_-]/gi, '_')}.json`);
+  fs.writeFileSync(file, JSON.stringify({ slug, content, updatedAt: new Date().toISOString() }, null, 2));
+}
+
+function listWikiPages() {
+  ensureWikiDir();
+  return fs.readdirSync(MEMORY_WIKI_DIR)
+    .filter(f => f.endsWith('.json'))
+    .map(f => {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(MEMORY_WIKI_DIR, f), 'utf-8'));
+        return { slug: data.slug || f.replace('.json', ''), content: data.content || '', updatedAt: data.updatedAt };
+      } catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+function searchWikiPages(query) {
+  const pages = listWikiPages();
+  const q = query.toLowerCase();
+  return pages.filter(p =>
+    p.slug.toLowerCase().includes(q) ||
+    p.content.toLowerCase().includes(q)
+  );
+}
+
+// ── Semantic Memory Search ─────────────────────────────────────────────────────
+
+function semanticSearchMemory(query, limit = 5) {
+  const results = [];
+  const q = query.toLowerCase();
+
+  if (!fs.existsSync(MEMORY_DIR)) return results;
+
+  const files = fs.readdirSync(MEMORY_DIR).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    const botId = file.replace('.json', '');
+    const mem = loadMemory(botId);
+
+    // Score each fact by relevance
+    const scored = (mem.facts || [])
+      .map(f => {
+        const val = typeof f === 'string' ? f : f.value || '';
+        const words = q.split(/\s+/).filter(Boolean);
+        const matches = words.filter(w => val.toLowerCase().includes(w)).length;
+        const score = words.length > 0 ? matches / words.length : 0;
+        const boost = typeof f === 'object' ? (f.score || 5) / 10 : 0.5;
+        return { bot: mem.botName || botId, value: val, score: score * 0.7 + boost * 0.3 };
+      })
+      .filter(f => f.score > 0.1)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, limit);
+
+    results.push(...scored);
+  }
+
+  return results.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+
+// ── Memory Categories ──────────────────────────────────────────────────────────
+
+const MEMORY_CATEGORIES = {
+  personal: { label: 'Kişisel Bilgiler', icon: '👤' },
+  work: { label: 'İş/Okul', icon: '💼' },
+  preferences: { label: 'Tercihler', icon: '⭐' },
+  health: { label: 'Sağlık', icon: '❤️' },
+  social: { label: 'Sosyal', icon: '👥' },
+  goals: { label: 'Hedefler', icon: '🎯' },
+  projects: { label: 'Projeler', icon: '📁' },
+  general: { label: 'Genel', icon: '📝' }
+};
+
+function addMemoryEntryWithCategory(botId, key, value, category = 'general') {
+  const memory = loadMemory(botId);
+  const now = new Date().toISOString();
+  const validCategory = MEMORY_CATEGORIES[category] ? category : 'general';
+
+  if (key === 'name') { memory.name = value; }
+  else if (key === 'nickname') { memory.nickname = value; }
+  else if (key === 'botName') { memory.botName = value; }
+  else if (key === 'preference') {
+    const existing = memory.preferences.find(p => p.value.toLowerCase() === value.toLowerCase());
+    if (existing) {
+      existing.score = Math.min(existing.score + 1, 10);
+      existing.updatedAt = now;
+    } else {
+      memory.preferences.push({ value, score: 5, updatedAt: now, category: validCategory });
+    }
+  } else {
+    const existing = memory.facts.find(f => f.value.toLowerCase() === value.toLowerCase());
+    if (existing) {
+      existing.score = Math.min(existing.score + 1, 10);
+      existing.updatedAt = now;
+      if (!existing.category) existing.category = validCategory;
+    } else {
+      memory.facts.push({ value, score: 5, updatedAt: now, category: validCategory });
+    }
+  }
+
+  // Decay old entries
+  const sixMonthsAgo = new Date();
+  sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 6);
+
+  memory.preferences = memory.preferences.map(p => {
+    const age = new Date(p.updatedAt);
+    if (age < sixMonthsAgo) p.score = Math.max(p.score - 1, 1);
+    return p;
+  }).filter(p => p.score > 0);
+
+  memory.facts = memory.facts.map(f => {
+    const age = new Date(f.updatedAt);
+    if (age < sixMonthsAgo) f.score = Math.max(f.score - 1, 1);
+    return f;
+  }).filter(f => f.score > 0);
+
+  saveMemory(botId, memory);
+}
+
+// ── Memory Import/Export ───────────────────────────────────────────────────────
+
+function exportMemory(botId) {
+  return loadMemory(botId);
+}
+
+function importMemory(botId, data) {
+  const current = loadMemory(botId);
+  const merged = {
+    name: data.name || current.name,
+    nickname: data.nickname || current.nickname,
+    botName: data.botName || current.botName,
+    preferences: [...(current.preferences || []), ...(data.preferences || [])],
+    facts: [...(current.facts || []), ...(data.facts || [])],
+    lastSeen: current.lastSeen
+  };
+  saveMemory(botId, merged);
+}
+
+// ── Active Memory (pre-prompt injection) ──────────────────────────────────────
+
+function getActiveMemoryPrompt(botId, messageContext = '') {
+  const memory = loadMemory(botId);
+  const facts = memory.facts || [];
+  const prefs = memory.preferences || [];
+
+  if (facts.length === 0 && prefs.length === 0 && !memory.name) return '';
+
+  // Score facts by relevance to current context
+  const contextWords = messageContext.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+  const scored = facts
+    .map(f => {
+      let relevance = 0;
+      if (contextWords.length > 0) {
+        const val = (f.value || '').toLowerCase();
+        relevance = contextWords.filter(w => val.includes(w)).length / contextWords.length;
+      }
+      return { ...f, relevance };
+    })
+    .sort((a, b) => (b.score || 0) + b.relevance - (a.score || 0) - a.relevance)
+    .slice(0, 5);
+
+  const parts = [];
+  if (memory.name) parts.push(`👤 ${memory.name}`);
+  if (memory.nickname) parts.push(`🏷 ${memory.nickname}`);
+  if (scored.length > 0) {
+    parts.push('📌 ' + scored.map(f => f.value).join(' | '));
+  }
+
+  return parts.length > 0 ? `<active_memory>\n${parts.join('\n')}\n</active_memory>` : '';
+}
+
 module.exports = {
   loadMemory,
   saveMemory,
   addMemoryEntry,
+  addMemoryEntryWithCategory,
   extractMemoryFromMessage,
   getMemoryPrompt,
+  getActiveMemoryPrompt,
   clearMemory,
+  semanticSearchMemory,
+  exportMemory,
+  importMemory,
+  // Wiki
+  getWikiPage,
+  saveWikiPage,
+  listWikiPages,
+  searchWikiPages,
+  MEMORY_CATEGORIES,
 };

package/src/utils/path-utils.js

@@ -3,19 +3,19 @@ const os = require('os');
 function normalizeWindowsPaths(str) {
   let result = str.replace(/\\/g, '/');
 
-  result = result
-    .replace(/C:\/\/\/\/Users\/\/\/\/user\/\/\/\//g, `${os.homedir()}/`)
-    .replace(/C:\/Users\/user\//g, `${os.homedir()}/`)
-    .replace(/C:\/Users\/user\//g, `${os.homedir()}/`)
-    .replace(/C:\/\/Users\/\/user\/\/\.natureco\/\//g, `${os.homedir()}/.natureco/`)
-    .replace(/C:\/\/Users\/\/user\/\//g, `${os.homedir()}/`)
-    .replace(/E:\/\/\.natureco\/\//g, `${os.homedir()}/.natureco/`)
-    .replace(/'C:\/Users\/user\/\.natureco\//g, `'${os.homedir()}/.natureco/`)
-    .replace(/"C:\/Users\/user\/\.natureco\//g, `"${os.homedir()}/.natureco/`)
-    .replace(/'C:\/\/\/\/Users\/\/\/\/user\/\/\/\/\.natureco\/\/\/\//g, `'${os.homedir()}/.natureco/`)
-    .replace(/E:\/\.openclaw\//g, `${os.homedir()}/.natureco/`)
-    .replace(/\.openclaw\//g, '.natureco/')
-    .replace(/workspace\/scripts\\/g, 'workspace/scripts/');
+  const homeDir = os.homedir().replace(/\\/g, '/');
+
+  // Replace any Windows user profile path with actual homedir
+  result = result.replace(/[A-Za-z]:\/Users\/[^/]+\//g, `${homeDir}/`);
+
+  // Replace bare drive-letter references pointing to .openclaw
+  result = result.replace(/[A-Za-z]:\/\.openclaw\//g, `${homeDir}/.natureco/`);
+
+  // Migrate .openclaw paths to .natureco
+  result = result.replace(/\.openclaw\//g, '.natureco/');
+
+  // Normalize mixed path separators
+  result = result.replace(/workspace\/scripts\\/g, 'workspace/scripts/');
 
   return result;
 }