natureco-cli 5.14.7 → 5.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "5.14.7",
+  "version": "5.15.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/providers/file-memory.js

@@ -0,0 +1,138 @@
+/**
+ * file-memory.js — File-based memory provider (default)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { MemoryProvider, registerProvider } = require('../utils/memory-provider');
+
+const BASE_DIR = path.join(os.homedir(), '.natureco', 'memory');
+
+class FileMemoryProvider extends MemoryProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'file';
+  }
+
+  _ensureDir() {
+    if (!fs.existsSync(BASE_DIR)) fs.mkdirSync(BASE_DIR, { recursive: true });
+  }
+
+  _fileFor(userId) {
+    return path.join(BASE_DIR, `${(userId || 'default').toLowerCase()}.json`);
+  }
+
+  _load(userId) {
+    this._ensureDir();
+    const file = this._fileFor(userId);
+    try {
+      if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {}
+    return { name: userId || 'User', nickname: null, botName: null, facts: [], preferences: [] };
+  }
+
+  _save(userId, data) {
+    this._ensureDir();
+    data.lastUpdated = new Date().toISOString();
+    fs.writeFileSync(this._fileFor(userId), JSON.stringify(data, null, 2));
+  }
+
+  async add(userId, content, metadata = {}) {
+    const uid = userId || 'default';
+    const mem = this._load(uid);
+    const now = new Date().toISOString();
+    const existing = mem.facts.find(f => (f.value || '').toLowerCase() === content.toLowerCase());
+    if (existing) {
+      existing.score = Math.min(10, (existing.score || 5) + 2);
+      existing.updatedAt = now;
+    } else {
+      mem.facts.push({
+        value: content,
+        score: metadata.score || 5,
+        category: metadata.category || 'general',
+        createdAt: now,
+        updatedAt: now,
+      });
+    }
+    if (metadata.name) mem.name = metadata.name;
+    if (metadata.botName) mem.botName = metadata.botName;
+    if (metadata.nickname !== undefined) mem.nickname = metadata.nickname;
+    this._save(uid, mem);
+    return { success: true, id: content, message: 'Memory added', totalFacts: mem.facts.length };
+  }
+
+  async search(query, options = {}) {
+    const uid = options.userId;
+    const results = [];
+    if (uid) {
+      const mem = this._load(uid);
+      for (const f of mem.facts || []) {
+        const v = f.value || '';
+        if (v.toLowerCase().includes(query.toLowerCase())) {
+          results.push({ id: v, content: v, score: f.score || 5, metadata: { category: f.category } });
+        }
+      }
+    } else {
+      this._ensureDir();
+      const files = fs.readdirSync(BASE_DIR).filter(f => f.endsWith('.json'));
+      for (const file of files) {
+        try {
+          const mem = JSON.parse(fs.readFileSync(path.join(BASE_DIR, file), 'utf8'));
+          for (const f of mem.facts || []) {
+            const v = f.value || '';
+            if (v.toLowerCase().includes(query.toLowerCase())) {
+              results.push({ id: v, content: v, score: f.score || 5, metadata: { userId: file.replace('.json', ''), category: f.category } });
+            }
+          }
+        } catch {}
+      }
+    }
+    results.sort((a, b) => (b.score || 0) - (a.score || 0));
+    const limit = options.limit || 20;
+    return { success: true, results: results.slice(0, limit) };
+  }
+
+  async list(userId) {
+    const uid = userId || 'default';
+    const mem = this._load(uid);
+    return {
+      success: true,
+      memories: (mem.facts || []).map(f => ({
+        id: f.value,
+        content: f.value,
+        score: f.score,
+        metadata: { category: f.category, createdAt: f.createdAt, updatedAt: f.updatedAt },
+      })),
+      name: mem.name,
+      nickname: mem.nickname,
+      botName: mem.botName,
+    };
+  }
+
+  async remove(id) {
+    const files = fs.readdirSync(BASE_DIR).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+      try {
+        const mem = JSON.parse(fs.readFileSync(path.join(BASE_DIR, file), 'utf8'));
+        const before = mem.facts.length;
+        mem.facts = mem.facts.filter(f => (f.value || '').toLowerCase() !== id.toLowerCase());
+        if (mem.facts.length !== before) {
+          this._save(file.replace('.json', ''), mem);
+          return { success: true, message: 'Memory removed' };
+        }
+      } catch {}
+    }
+    return { success: false, message: 'Memory not found' };
+  }
+
+  async clear(userId) {
+    const uid = userId || 'default';
+    const file = this._fileFor(uid);
+    if (fs.existsSync(file)) fs.unlinkSync(file);
+    return { success: true, message: `Memory cleared for ${uid}` };
+  }
+}
+
+registerProvider('file', FileMemoryProvider);
+module.exports = FileMemoryProvider;

package/src/providers/mem0-memory.js

@@ -0,0 +1,121 @@
+/**
+ * mem0-memory.js — Mem0 memory provider
+ *
+ * Uses the mem0ai npm package (platform API) or local OSS Memory class.
+ * Requires MEM0_API_KEY env var or config.mem0.apiKey.
+ * npm install mem0ai
+ */
+
+const { MemoryProvider, registerProvider } = require('../utils/memory-provider');
+
+class Mem0MemoryProvider extends MemoryProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'mem0';
+    this._client = null;
+    this._mode = 'platform'; // or 'oss'
+  }
+
+  _getConfig() {
+    return this.config.mem0 || this.config.Mem0 || {};
+  }
+
+  _apiKey() {
+    return process.env.MEM0_API_KEY || this._getConfig().apiKey || '';
+  }
+
+  async _ensureClient() {
+    if (this._client) return;
+    try {
+      const apiKey = this._apiKey();
+      if (apiKey) {
+        const { MemoryClient } = await import('mem0ai');
+        this._client = new MemoryClient({ apiKey });
+        this._mode = 'platform';
+      } else {
+        const { Memory } = await import('mem0ai/oss');
+        this._client = new Memory(this._getConfig().oss || {});
+        this._mode = 'oss';
+      }
+    } catch (e) {
+      throw new Error('mem0ai paketi yuklu degil. npm install mem0ai');
+    }
+  }
+
+  async add(userId, content, metadata = {}) {
+    await this._ensureClient();
+    const uid = userId || 'default';
+    if (this._mode === 'platform') {
+      const messages = [{ role: 'user', content }];
+      await this._client.add(messages, { userId: uid, metadata });
+    } else {
+      const messages = [
+        { role: 'user', content },
+        { role: 'assistant', content: 'Bilgi kaydedildi.' },
+      ];
+      await this._client.add(messages, { userId: uid, metadata });
+    }
+    return { success: true, id: content, message: 'Mem0 memory added', provider: 'mem0' };
+  }
+
+  async search(query, options = {}) {
+    await this._ensureClient();
+    const uid = options.userId;
+    const filters = uid ? { userId: uid } : {};
+    if (options.limit) filters.limit = options.limit;
+    try {
+      const results = await this._client.search(query, { filters });
+      return { success: true, results: (results.results || results || []).map(r => ({
+        id: r.id || r.memory,
+        content: r.memory || r.content || '',
+        score: r.score || 0,
+        metadata: r.metadata || {},
+      })) };
+    } catch (e) {
+      return { success: false, error: e.message, results: [] };
+    }
+  }
+
+  async list(userId) {
+    await this._ensureClient();
+    const uid = userId || 'default';
+    try {
+      const memories = await this._client.getAll({ userId: uid });
+      return {
+        success: true,
+        memories: (memories || []).map(r => ({
+          id: r.id || r.memory,
+          content: r.memory || r.content || '',
+          score: r.score || 0,
+          metadata: r.metadata || {},
+        })),
+      };
+    } catch (e) {
+      return { success: false, error: e.message, memories: [] };
+    }
+  }
+
+  async remove(id) {
+    await this._ensureClient();
+    try {
+      await this._client.delete(id);
+      return { success: true, message: 'Mem0 memory removed' };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  async clear(userId) {
+    await this._ensureClient();
+    const uid = userId || 'default';
+    try {
+      await this._client.deleteAll({ userId: uid });
+      return { success: true, message: `Mem0 memory cleared for ${uid}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+}
+
+registerProvider('mem0', Mem0MemoryProvider);
+module.exports = Mem0MemoryProvider;

package/src/providers/rest-memory.js

@@ -0,0 +1,141 @@
+/**
+ * rest-memory.js — Generic REST API memory provider
+ *
+ * Configure via config:
+ *   memoryProvider: "holographic" | "hindsight" | "honcho" | "openviking" | "retaindb" | "byterover"
+ *   <providerName>: { baseUrl: "...", apiKey: "...", ... }
+ *
+ * Expects REST endpoints:
+ *   POST   /memories        — add { userId, content, metadata }
+ *   POST   /memories/search — search { query, userId, limit }
+ *   GET    /memories/:userId — list
+ *   DELETE /memories/:id    — remove
+ *   DELETE /memories/:userId/clear — clear
+ */
+
+const https = require('https');
+const http = require('http');
+const { MemoryProvider, registerProvider } = require('../utils/memory-provider');
+
+const PROVIDERS = ['holographic', 'hindsight', 'honcho', 'openviking', 'retaindb', 'byterover'];
+
+class RestMemoryProvider extends MemoryProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = config._providerName || 'rest';
+    this._providerConfig = config[this.name] || {};
+  }
+
+  _baseUrl() {
+    return this._providerConfig.baseUrl || process.env[`${this.name.toUpperCase()}_URL`] || `http://localhost:3000`;
+  }
+
+  _apiKey() {
+    return this._providerConfig.apiKey || process.env[`${this.name.toUpperCase()}_API_KEY`] || '';
+  }
+
+  _headers() {
+    const h = { 'Content-Type': 'application/json' };
+    const key = this._apiKey();
+    if (key) h['Authorization'] = 'Bearer ' + key;
+    return h;
+  }
+
+  _request(method, path, body) {
+    return new Promise((resolve, reject) => {
+      const base = this._baseUrl().replace(/\/+$/, '');
+      const url = new URL(base + path);
+      const mod = url.protocol === 'https:' ? https : http;
+      const opts = {
+        method,
+        hostname: url.hostname,
+        port: url.port || (url.protocol === 'https:' ? 443 : 80),
+        path: url.pathname + url.search,
+        headers: this._headers(),
+        timeout: 15000,
+      };
+      const req = mod.request(opts, (res) => {
+        let data = '';
+        res.on('data', c => data += c);
+        res.on('end', () => {
+          try { resolve(JSON.parse(data)); } catch { resolve(data); }
+        });
+      });
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+      if (body) req.write(JSON.stringify(body));
+      req.end();
+    });
+  }
+
+  async add(userId, content, metadata = {}) {
+    try {
+      const res = await this._request('POST', '/memories', { userId: userId || 'default', content, metadata });
+      return { success: true, id: res.id || content, message: `${this.name} memory added`, provider: this.name };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  async search(query, options = {}) {
+    try {
+      const res = await this._request('POST', '/memories/search', { query, userId: options.userId, limit: options.limit || 10 });
+      const results = (res.results || res || []).map(r => ({
+        id: r.id,
+        content: r.content || r.memory || '',
+        score: r.score || 0,
+        metadata: r.metadata || {},
+      }));
+      return { success: true, results };
+    } catch (e) {
+      return { success: false, error: e.message, results: [] };
+    }
+  }
+
+  async list(userId) {
+    try {
+      const uid = userId || 'default';
+      const res = await this._request('GET', `/memories/${encodeURIComponent(uid)}`);
+      const memories = (res.memories || res.results || res || []).map(r => ({
+        id: r.id,
+        content: r.content || r.memory || '',
+        score: r.score || 0,
+        metadata: r.metadata || {},
+      }));
+      return { success: true, memories };
+    } catch (e) {
+      return { success: false, error: e.message, memories: [] };
+    }
+  }
+
+  async remove(id) {
+    try {
+      await this._request('DELETE', `/memories/${encodeURIComponent(id)}`);
+      return { success: true, message: `${this.name} memory removed` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  async clear(userId) {
+    try {
+      const uid = userId || 'default';
+      await this._request('DELETE', `/memories/${encodeURIComponent(uid)}/clear`);
+      return { success: true, message: `${this.name} memory cleared for ${uid}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+}
+
+// Register all 6 provider names with the same RestMemoryProvider class
+for (const name of PROVIDERS) {
+  const factory = class extends RestMemoryProvider {
+    constructor(config) {
+      super({ ...config, _providerName: name });
+    }
+  };
+  registerProvider(name, factory);
+}
+
+module.exports = RestMemoryProvider;

package/src/providers/supermemory-memory.js

@@ -0,0 +1,117 @@
+/**
+ * supermemory-memory.js — Supermemory memory provider
+ *
+ * Uses the supermemory npm package.
+ * Requires SUPERMEMORY_API_KEY env var or config.supermemory.apiKey.
+ * npm install supermemory
+ */
+
+const { MemoryProvider, registerProvider } = require('../utils/memory-provider');
+
+class SupermemoryMemoryProvider extends MemoryProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'supermemory';
+    this._client = null;
+  }
+
+  _getConfig() {
+    return this.config.supermemory || this.config.Supermemory || {};
+  }
+
+  _apiKey() {
+    return process.env.SUPERMEMORY_API_KEY || this._getConfig().apiKey || '';
+  }
+
+  async _ensureClient() {
+    if (this._client) return;
+    try {
+      const Supermemory = (await import('supermemory')).default;
+      this._client = new Supermemory({
+        apiKey: this._apiKey() || undefined,
+        ...this._getConfig().options,
+      });
+    } catch (e) {
+      throw new Error('supermemory paketi yuklu degil. npm install supermemory');
+    }
+  }
+
+  async add(userId, content, metadata = {}) {
+    await this._ensureClient();
+    const tag = `user_${(userId || 'default').toLowerCase()}`;
+    await this._client.add({
+      content,
+      containerTags: [tag],
+      ...metadata,
+    });
+    return { success: true, id: content, message: 'Supermemory added', provider: 'supermemory' };
+  }
+
+  async search(query, options = {}) {
+    await this._ensureClient();
+    const tag = options.userId ? `user_${options.userId.toLowerCase()}` : undefined;
+    try {
+      const response = await this._client.search.documents({
+        q: query,
+        ...(tag ? { containerTags: [tag] } : {}),
+        limit: options.limit || 10,
+      });
+      return {
+        success: true,
+        results: (response.results || []).map(r => ({
+          id: r.id,
+          content: r.content || '',
+          score: r.score || 0,
+          metadata: r.metadata || {},
+        })),
+      };
+    } catch (e) {
+      return { success: false, error: e.message, results: [] };
+    }
+  }
+
+  async list(userId) {
+    await this._ensureClient();
+    const tag = `user_${(userId || 'default').toLowerCase()}`;
+    try {
+      const docs = await this._client.documents.list({ containerTags: [tag] });
+      return {
+        success: true,
+        memories: (docs.results || docs || []).map(r => ({
+          id: r.id,
+          content: r.content || '',
+          score: 0,
+          metadata: r.metadata || {},
+        })),
+      };
+    } catch (e) {
+      return { success: false, error: e.message, memories: [] };
+    }
+  }
+
+  async remove(id) {
+    await this._ensureClient();
+    try {
+      await this._client.documents.delete({ docId: id });
+      return { success: true, message: 'Supermemory removed' };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+
+  async clear(userId) {
+    const tag = `user_${(userId || 'default').toLowerCase()}`;
+    try {
+      const listed = await this.list(userId);
+      for (const mem of listed.memories || []) {
+        try { await this.remove(mem.id); } catch {}
+      }
+      return { success: true, message: `Supermemory cleared for ${tag}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+}
+
+registerProvider('supermemory', SupermemoryMemoryProvider);
+module.exports = SupermemoryMemoryProvider;

package/src/tools/memory_provider.js

@@ -0,0 +1,91 @@
+/**
+ * memory_provider — Switchable memory backend tool
+ *
+ * Uses the memory provider abstraction. Default: file (same as memory_write).
+ * Switch provider via config: memoryProvider: "mem0" | "supermemory" | ...
+ * Or env: NATURECO_MEMORY_PROVIDER=mem0
+ *
+ * Actions:
+ *   add    — save a memory
+ *   search — semantic/keyword search
+ *   list   — list all memories for a user
+ *   remove — delete a memory
+ *   clear  — clear all memories for a user
+ *   status — show active provider info
+ */
+
+const { getActiveProvider, getProviderNames } = require('../utils/memory-provider');
+const loadConfig = () => {
+  try { return JSON.parse(require('fs').readFileSync(require('path').join(require('os').homedir(), '.natureco', 'config.json'), 'utf8')); } catch { return {}; }
+};
+
+const name = 'memory_provider';
+const description = 'Unified memory backend with pluggable providers. add/search/list/remove/clear/status. Default is file-based. Switch via NATURECO_MEMORY_PROVIDER env or config.memoryProvider.';
+const parameters = {
+  type: 'object',
+  properties: {
+    action: {
+      type: 'string',
+      enum: ['add', 'search', 'list', 'remove', 'clear', 'status'],
+      description: 'Operation: add, search, list, remove, clear, or status',
+    },
+    content: { type: 'string', description: 'Memory content to add, or query for search' },
+    userId: { type: 'string', description: 'User identifier' },
+    metadata: { type: 'object', description: 'Additional metadata (category, score, etc.)' },
+    limit: { type: 'number', description: 'Max results for search/list' },
+    provider: { type: 'string', description: 'Override provider name (default: config or file)' },
+  },
+  required: ['action'],
+};
+
+async function execute(params) {
+  const cfg = loadConfig();
+  const providerName = params.provider || process.env.NATURECO_MEMORY_PROVIDER || cfg.memoryProvider;
+  let Provider;
+  if (providerName) {
+    const { getProvider } = require('../utils/memory-provider');
+    Provider = getProvider(providerName);
+  }
+  if (!Provider) {
+    // Load default (file)
+    Provider = getActiveProvider(cfg);
+  }
+  const provider = new Provider(cfg);
+  const userId = params.userId || cfg.userName || 'default';
+
+  switch (params.action) {
+    case 'add':
+      if (!params.content) return JSON.stringify({ success: false, error: 'content required for add' });
+      return provider.add(userId, params.content, params.metadata || {});
+
+    case 'search':
+      if (!params.content) return JSON.stringify({ success: false, error: 'content (query) required for search' });
+      return provider.search(params.content, { userId, limit: params.limit || 10 });
+
+    case 'list':
+      return provider.list(userId);
+
+    case 'remove':
+      if (!params.content) return JSON.stringify({ success: false, error: 'content (id) required for remove' });
+      return provider.remove(params.content);
+
+    case 'clear':
+      return provider.clear(userId);
+
+    case 'status': {
+      const avail = getProviderNames().sort();
+      return {
+        active: provider.name,
+        available: avail,
+        userId,
+        config: cfg.memoryProvider || '(not set, using default)',
+        env: process.env.NATURECO_MEMORY_PROVIDER || '(not set)',
+      };
+    }
+
+    default:
+      return JSON.stringify({ success: false, error: `Unknown action: ${params.action}` });
+  }
+}
+
+module.exports = { name, description, parameters, execute };

package/src/utils/memory-provider.js

@@ -0,0 +1,109 @@
+/**
+ * memory-provider.js — Abstract memory backend interface + registry
+ *
+ * All memory providers extend the MemoryProvider base class.
+ * Register a provider via registerProvider(name, class) and
+ * switch with memory config or environment variable.
+ */
+
+const path = require('path');
+const os = require('os');
+
+const PROVIDER_CONFIG_KEY = 'memoryProvider';
+const DEFAULT_PROVIDER = 'file';
+
+// Registry: name -> class
+const _registry = new Map();
+
+function registerProvider(name, providerClass) {
+  _registry.set(name, providerClass);
+}
+
+function getProviderNames() {
+  return Array.from(_registry.keys());
+}
+
+function getProvider(name) {
+  const Cls = _registry.get(name);
+  if (!Cls) return null;
+  return Cls;
+}
+
+/**
+ * Resolve active provider from config + env + defaults.
+ * Priority: env NATURECO_MEMORY_PROVIDER > config.memoryProvider > 'file'
+ */
+function resolveProviderConfig(cfg) {
+  const env = process.env.NATURECO_MEMORY_PROVIDER || '';
+  if (env && _registry.has(env)) return env;
+  if (cfg && cfg[PROVIDER_CONFIG_KEY] && _registry.has(cfg[PROVIDER_CONFIG_KEY])) {
+    return cfg[PROVIDER_CONFIG_KEY];
+  }
+  return DEFAULT_PROVIDER;
+}
+
+/**
+ * Get an instance of the active memory provider.
+ * Provider classes should be singletons — call this once, cache the result.
+ */
+function getActiveProvider(cfg) {
+  const name = resolveProviderConfig(cfg);
+  const Cls = getProvider(name);
+  if (!Cls) return getProvider(DEFAULT_PROVIDER);
+  return Cls;
+}
+
+/**
+ * MemoryProvider base class.
+ *
+ * Subclasses must implement:
+ *   add(userId, content, metadata)   → { success, id, message }
+ *   search(query, options)            → { success, results: [{id, content, score, metadata}] }
+ *   list(userId)                      → { success, memories: [{id, content, metadata}] }
+ *   remove(id)                        → { success, message }
+ *   clear(userId)                     → { success, message }
+ */
+class MemoryProvider {
+  constructor(config = {}) {
+    this.config = config;
+    this.name = 'base';
+  }
+
+  async add(userId, content, metadata = {}) {
+    throw new Error('Not implemented: add');
+  }
+
+  async search(query, options = {}) {
+    throw new Error('Not implemented: search');
+  }
+
+  async list(userId) {
+    throw new Error('Not implemented: list');
+  }
+
+  async remove(id) {
+    throw new Error('Not implemented: remove');
+  }
+
+  async clear(userId) {
+    throw new Error('Not implemented: clear');
+  }
+
+  /**
+   * Extract a user ID from args or config
+   */
+  _userId(args) {
+    return args?.userId || args?.username || args?.user || this.config?.defaultUserId || 'default';
+  }
+}
+
+module.exports = {
+  MemoryProvider,
+  registerProvider,
+  getProviderNames,
+  getProvider,
+  resolveProviderConfig,
+  getActiveProvider,
+  PROVIDER_CONFIG_KEY,
+  DEFAULT_PROVIDER,
+};