natureco-cli 5.7.16 → 5.7.17

package/bin/natureco.js

@@ -67,6 +67,7 @@ const terminal = require('../src/commands/terminal');
 const transcripts = require('../src/commands/transcripts');
 const wiki = require('../src/commands/wiki');
 const browser = require('../src/commands/browser');
+const tools = require('../src/commands/tools');
 
 const program = new Command();
 
@@ -623,6 +624,13 @@ program
     xp(action ? [action] : []);
   });
 
+program
+  .command('tools [action] [name]')
+  .description('Tool registry (list|enable|disable)')
+  .action((action, name) => {
+    tools(action ? [action, name].filter(Boolean) : []);
+  });
+
 program
   .command('team [action] [params...]')
   .description('Multi-agent orkestrasyon (list|status|spawn|parallel)')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "5.7.16",
+  "version": "5.7.17",
   "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/tools.js

@@ -0,0 +1,95 @@
+/**
+ * natureco tools — Tool registry management (Hermes-style)
+ *
+ * Kullanım:
+ *   natureco tools            List toolset groups
+ *   natureco tools list       Detailed tool list
+ *   natureco tools enable <name>    Enable a tool
+ *   natureco tools disable <name>   Disable a tool
+ */
+
+const chalk = require('chalk');
+const tui = require('../utils/tui');
+const { loadToolDefinitions, EMOJI_MAP, TOOLSET_MAP } = require('../utils/tools');
+const { getConfig, setConfigValue } = require('../utils/config');
+
+function main(args) {
+  const action = args[0] || 'list';
+
+  switch (action) {
+    case 'list':
+      return cmdList();
+    case 'enable':
+      return cmdEnable(args[1]);
+    case 'disable':
+      return cmdDisable(args[1]);
+    default:
+      console.log(chalk.yellow('Kullanım:'));
+      console.log(chalk.gray('  natureco tools                Grup listesi'));
+      console.log(chalk.gray('  natureco tools list           Detaylı liste'));
+      console.log(chalk.gray('  natureco tools enable <name>  Tool etkinleştir'));
+      console.log(chalk.gray('  natureco tools disable <name> Tool devre dışı'));
+      console.log('');
+  }
+}
+
+function cmdList() {
+  const allTools = loadToolDefinitions();
+  const disabled = getDisabledTools();
+
+  const byToolset = {};
+  for (const t of allTools) {
+    const ts = t.toolset || 'general';
+    if (!byToolset[ts]) byToolset[ts] = [];
+    byToolset[ts].push(t);
+  }
+
+  let total = 0;
+  for (const [ts, tools] of Object.entries(byToolset).sort()) {
+    const active = tools.filter(t => !disabled.has(t.name));
+    total += active.length;
+    const line = tools.map(t => {
+      const d = disabled.has(t.name);
+      return (d ? chalk.gray.dim : chalk.white)((t.emoji || '  ') + ' ' + t.name);
+    }).join('  ');
+    console.log(chalk.cyan.bold('\n  ' + ts + ' (' + active.length + '/' + tools.length + ')'));
+    console.log('    ' + line);
+  }
+
+  console.log(chalk.gray('\n  Toplam: ' + total + ' aktif tool'));
+  if (disabled.size > 0) {
+    console.log(chalk.yellow('  Devre dışı: ' + [...disabled].join(', ')));
+  }
+  console.log('');
+}
+
+function getDisabledTools() {
+  const cfg = getConfig();
+  return new Set(cfg.disabledTools || []);
+}
+
+function cmdEnable(name) {
+  if (!name) return console.log(chalk.red('Tool adı gerekli: natureco tools enable <name>'));
+  const disabled = getDisabledTools();
+  if (!disabled.has(name)) return console.log(chalk.yellow(name + ' zaten etkin.'));
+  disabled.delete(name);
+  setConfigValue('disabledTools', [...disabled]);
+  console.log(chalk.green('✅ ' + name + ' etkinleştirildi.'));
+}
+
+function cmdDisable(name) {
+  if (!name) return console.log(chalk.red('Tool adı gerekli: natureco tools disable <name>'));
+  const allTools = loadToolDefinitions();
+  const tool = allTools.find(t => t.name === name);
+  if (!tool) return console.log(chalk.red('Tool bulunamadı: ' + name));
+  const disabled = getDisabledTools();
+  if (disabled.has(name)) return console.log(chalk.yellow(name + ' zaten devre dışı.'));
+  disabled.add(name);
+  setConfigValue('disabledTools', [...disabled]);
+  console.log(chalk.yellow('⛔ ' + name + ' devre dışı bırakıldı.'));
+}
+
+// Diğer modüllerden çağrılabilir
+main.getDisabledTools = getDisabledTools;
+
+module.exports = main;

package/src/tools/memory.js

@@ -1,23 +1,26 @@
 /**
- * memory — Unified memory tool (Hermes-style)
+ * memory — Unified memory tool (Hermes-style, merged with memory_write + memory_search)
  *
- * Single tool with action=add|remove|replace|list, target=memory|user
+ * Single tool with action=add|remove|replace|list|search, target=memory|user
  *
- * Coexists with existing memory_write / memory_search tools.
- * New system prompt uses memory-store snapshot; this tool mutates live state.
+ * Uses memory-store (MEMORY.md / USER.md) for add/remove/replace/list.
+ * Search action uses the legacy memory_write/search JSON files for cross-session query.
  */
 
 const { getMemoryStore } = require('../utils/memory-store');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 
 const name = 'memory';
-const description = 'Persistent memory across sessions. Use action=add to save facts, action=list to see everything, action=remove to delete by substring match. target=memory for environment facts, target=user for user preferences and traits.';
+const description = 'Persistent memory across sessions. action=add to save facts, action=list to see everything, action=remove to delete by substring, action=search to query all past sessions and memory files. target=memory for environment facts, target=user for user preferences.';
 const parameters = {
   type: 'object',
   properties: {
     action: {
       type: 'string',
-      enum: ['add', 'remove', 'replace', 'list'],
-      description: 'Operation: add (append entry), remove (by substring match), replace (find by substring, replace), list (show all)',
+      enum: ['add', 'remove', 'replace', 'list', 'search'],
+      description: 'Operation: add (append entry), remove (by substring match), replace (find by substring, replace), list (show all), search (query all memory + sessions)',
     },
     target: {
       type: 'string',
@@ -26,19 +29,99 @@ const parameters = {
     },
     content: {
       type: 'string',
-      description: 'Content to add/remove/replace. For replace, this is the new content.',
+      description: 'Content to add/remove/replace. For replace, this is the new content. For search, the query string.',
     },
     oldContent: {
       type: 'string',
       description: 'For replace: substring to match existing entry.',
     },
+    scope: {
+      type: 'string',
+      enum: ['all', 'memory', 'sessions'],
+      description: 'For search: scope to search (all=memory files + sessions, memory=only memory files, sessions=only session history)',
+    },
+    maxResults: {
+      type: 'number',
+      description: 'For search: max results (default 10)',
+    },
   },
-  required: ['action', 'target'],
+  required: ['action'],
 };
 
+// ── Legacy search helpers (from memory_search.js) ────────────────────────
+
+const MEMORY_DIR = path.join(os.homedir(), '.natureco', 'memory');
+const SESSION_DIR = path.join(os.homedir(), '.natureco', 'sessions');
+
+function _searchInObject(obj, query, pathStr) {
+  const results = [];
+  if (!obj || typeof obj !== 'object') return results;
+  if (typeof obj === 'string' && obj.toLowerCase().includes(query)) {
+    return [{ path: pathStr, content: obj.slice(0, 200) }];
+  }
+  for (const [key, val] of Object.entries(obj)) {
+    const newPath = pathStr ? pathStr + '.' + key : key;
+    if (typeof val === 'string' && val.toLowerCase().includes(query)) {
+      results.push({ path: newPath, content: val.slice(0, 200) });
+    } else if (Array.isArray(val)) {
+      val.forEach((item, i) => {
+        const ip = newPath + '[' + i + ']';
+        if (typeof item === 'string' && item.toLowerCase().includes(query)) {
+          results.push({ path: ip, content: item.slice(0, 200) });
+        } else if (typeof item === 'object') {
+          results.push(..._searchInObject(item, query, ip));
+        }
+      });
+    } else if (typeof val === 'object' && val !== null) {
+      results.push(..._searchInObject(val, query, newPath));
+    }
+  }
+  return results;
+}
+
+function _searchFiles(dir, query, sourceLabel) {
+  const results = [];
+  if (!fs.existsSync(dir)) return results;
+  const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'));
+      const hits = _searchInObject(data, query.toLowerCase(), '');
+      for (const h of hits) {
+        results.push({ source: sourceLabel, file, path: h.path, content: h.content });
+      }
+    } catch { /* skip corrupt files */ }
+  }
+  return results;
+}
+
+function _searchSessions(query, maxResults) {
+  const results = [];
+  if (!fs.existsSync(SESSION_DIR)) return results;
+  const files = fs.readdirSync(SESSION_DIR).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    if (results.length >= maxResults) break;
+    try {
+      const session = JSON.parse(fs.readFileSync(path.join(SESSION_DIR, file), 'utf8'));
+      const msgs = session.messages || [];
+      for (const msg of msgs) {
+        const text = msg.content || '';
+        if (typeof text === 'string' && text.toLowerCase().includes(query)) {
+          results.push({
+            source: 'session', file, role: msg.role || '?',
+            preview: text.slice(0, 200),
+          });
+          if (results.length >= maxResults) break;
+        }
+      }
+    } catch { /* skip corrupt */ }
+  }
+  return results;
+}
+
 async function execute(args) {
   const store = getMemoryStore();
-  const { action, target = 'memory', content, oldContent } = args;
+  const { action, target = 'memory', content, oldContent, scope, maxResults = 10 } = args;
 
   switch (action) {
     case 'add':
@@ -52,6 +135,20 @@ async function execute(args) {
       return store.replace(target, oldContent, content);
     case 'list':
       return store.list(target);
+    case 'search': {
+      if (!content) return JSON.stringify({ success: false, error: 'content (query) required for search' });
+      const s = scope || 'all';
+      const results = [];
+      if (s === 'all' || s === 'memory') {
+        const memHits = _searchFiles(MEMORY_DIR, content, 'memory');
+        results.push(...memHits);
+      }
+      if (s === 'all' || s === 'sessions') {
+        const sessHits = _searchSessions(content, maxResults);
+        results.push(...sessHits);
+      }
+      return JSON.stringify({ success: true, query: content, count: results.length, results: results.slice(0, maxResults) });
+    }
     default:
       return JSON.stringify({ success: false, error: `Unknown action: ${action}` });
   }

package/src/tools/skill_manage.js

@@ -0,0 +1,104 @@
+/**
+ * skill_manage — Create, patch, or delete skills (Hermes-style)
+ *
+ * Model can create new skills, patch existing ones, or delete them.
+ * Skills are SKILL.md files in ~/.natureco/skills/<name>/SKILL.md
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const USER_SKILLS_DIR = path.join(os.homedir(), '.natureco', 'skills');
+
+const name = 'skill_manage';
+const description = 'Create, update (patch), or delete skills. Use skill_view(name) to read skill content first, then skill_manage to create/patch it. Skills contain reusable workflows, instructions, and conventions.';
+const parameters = {
+  type: 'object',
+  properties: {
+    action: {
+      type: 'string',
+      enum: ['create', 'patch', 'delete'],
+      description: 'create: make a new skill. patch: update an existing one. delete: remove a skill.',
+    },
+    name: {
+      type: 'string',
+      description: 'Skill name (lowercase, hyphen-separated, e.g. "my-workflow"). For patch/delete, must match an existing skill.',
+    },
+    description: {
+      type: 'string',
+      description: 'Short one-line description shown in the skills index.',
+    },
+    content: {
+      type: 'string',
+      description: 'Full SKILL.md body (including YAML frontmatter). For patch: the new content to write. For create: must include --- frontmatter with name + description.',
+    },
+  },
+  required: ['action', 'name'],
+};
+
+function _ensureUserSkillsDir() {
+  if (!fs.existsSync(USER_SKILLS_DIR)) {
+    fs.mkdirSync(USER_SKILLS_DIR, { recursive: true });
+  }
+}
+
+function _skillPath(name) {
+  return path.join(USER_SKILLS_DIR, name, 'SKILL.md');
+}
+
+async function execute(args) {
+  const { action, name: skillName, description, content } = args;
+
+  switch (action) {
+    case 'create': {
+      if (!content) {
+        return JSON.stringify({ success: false, error: 'content (full SKILL.md with frontmatter) required for create' });
+      }
+      if (!content.startsWith('---')) {
+        return JSON.stringify({ success: false, error: 'content must start with YAML frontmatter (---)' });
+      }
+      _ensureUserSkillsDir();
+      const skillDir = path.join(USER_SKILLS_DIR, skillName);
+      if (fs.existsSync(skillDir)) {
+        return JSON.stringify({ success: false, error: `Skill "${skillName}" already exists. Use action=patch to update.` });
+      }
+      fs.mkdirSync(skillDir, { recursive: true });
+      fs.writeFileSync(_skillPath(skillName), content, 'utf8');
+      return JSON.stringify({ success: true, message: `Skill "${skillName}" created.`, path: _skillPath(skillName) });
+    }
+    case 'patch': {
+      const sp = _skillPath(skillName);
+      if (!fs.existsSync(sp)) {
+        return JSON.stringify({ success: false, error: `Skill "${skillName}" not found. Use action=create first.` });
+      }
+      let newContent = content;
+      if (!newContent) {
+        return JSON.stringify({ success: false, error: 'content required for patch' });
+      }
+      if (!newContent.startsWith('---') && description) {
+        const existing = fs.readFileSync(sp, 'utf8');
+        const frontmatterEnd = existing.indexOf('\n---', 3);
+        if (frontmatterEnd !== -1) {
+          const fm = existing.slice(0, frontmatterEnd + 4);
+          const body = existing.slice(frontmatterEnd + 4);
+          newContent = fm + '\n\n' + content + body;
+        }
+      }
+      fs.writeFileSync(sp, newContent, 'utf8');
+      return JSON.stringify({ success: true, message: `Skill "${skillName}" updated.` });
+    }
+    case 'delete': {
+      const sp = _skillPath(skillName);
+      if (!fs.existsSync(sp)) {
+        return JSON.stringify({ success: false, error: `Skill "${skillName}" not found.` });
+      }
+      fs.rmSync(path.dirname(sp), { recursive: true, force: true });
+      return JSON.stringify({ success: true, message: `Skill "${skillName}" deleted.` });
+    }
+    default:
+      return JSON.stringify({ success: false, error: `Unknown action: ${action}` });
+  }
+}
+
+module.exports = { name, description, parameters, execute };

package/src/utils/tools.js

@@ -2,42 +2,145 @@
  * NatureCo CLI — Tool Definitions for OpenAI-compatible APIs
  *
  * src/tools/*.js dosyalarını OpenAI uyumlu function calling format'ına dönüştürür.
- * Her tool'un:
- *   - name: tool adı
- *   - description: ne yaptığı
- *   - parameters: JSON schema
- *
- * REPL bu listeyi API'ye gönderir, model tool çağrısı yapar,
- * biz tool'u çalıştırır, sonucu modele geri veririz.
+ * v5.7.17: Emoji + toolset + check_fn + registry entegrasyonu.
  */
 
 const fs = require('fs');
 const path = require('path');
+const { globalRegistry } = require('./registry');
 
 const TOOLS_DIR = path.join(__dirname, '..', 'tools');
 
-/**
- * src/tools/*.js dosyalarını oku, her birinin export'ladığı
- * tool metadata'sını topla. Eğer tool'un export'unda
- * { name, description, parameters, execute } varsa kullan,
- * yoksa dosya adından otomatik üret.
- */
+// ── Emoji map (central, tek kaynak) ──────────────────────────────────────
+const EMOJI_MAP = {
+  // File operations
+  read_file: '📖', write_file: '✏️', edit_file: '🖊️', list_dir: '📂', file_search: '🔍', grep_search: '🔎', filesystem: '🗄️',
+  // Terminal
+  bash: '💻', shell_command: '⌨️',
+  // Web
+  duckduckgo: '🦆', duckduckgo_search: '🦆', web_search: '🌐', web_readability: '📄', firecrawl: '🔥', searxng: '🔬', searxng_search: '🔬', http_request: '🌍', http: '🌍', exa_search: '🔬', parallel_search: '⚡',
+  // Browser
+  browser: '🖥️',
+  // Memory
+  memory: '🧠', memory_write: '🧠', memory_search: '🔍',
+  // Skills
+  skill_view: '📚', skills_list: '📋', skill_generate: '✨', skills_autoload: '🔄', skills_marketplace: '🏪', skill_manage: '🛠️',
+  // Agent
+  delegate_task: '👥', llm_task: '🤖', sub_agent: '👤',
+  // Documents
+  document_extract: '📄', notebook_edit: '📓', notes_add: '📝',
+  // Git
+  git: '🔀',
+  // Plan / Todo
+  plan: '📋', todo_write: '✅',
+  // Media
+  image_generation: '🎨', video_generation: '🎬', music_generation: '🎵', media_understanding: '📺', text_to_speech: '🔊', speech_to_text: '🎤', voice_chat: '🗣️',
+  // macOS
+  mac_alarm: '⏰', mac_app_open: '🚀', mac_app_quit: '⏹️', mac_notify: '🔔', macos_screenshot: '📸', phone_control: '📱', phone_control_enhanced: '📱',
+  // Calendar
+  calendar_add: '📅',
+  // Reminder
+  reminder_add: '⏰',
+  // Dashboard
+  dashboard: '📊',
+  kanban: '📋',
+  // Canvas
+  canvas: '🎨',
+  // Plugin
+  plugin: '🔌',
+  // Soul
+  soul: '💫',
+  // Cron
+  cron_create: '⏱️',
+  // Thread
+  thread_ownership: '🔗',
+  // Audio understanding
+  audio_understanding: '🎵',
+  // Code execution
+  code_execution: '⚡',
+  // Cross-session
+  cross_session_memory: '🔗',
+};
 
-/**
- * v5.6.1: Provider'a gore tool filtrele
- * Groq validator cok kati — sadece basit tool'lar
- * Anthropic, OpenAI tam tool seti kullanir
- */
+// ── Toolset grouping ─────────────────────────────────────────────────────
+const TOOLSET_MAP = {
+  // File
+  read_file: 'file', write_file: 'file', edit_file: 'file', list_dir: 'file',
+  file_search: 'file', grep_search: 'file', filesystem: 'file',
+  // Terminal
+  bash: 'terminal', shell_command: 'terminal',
+  // Web
+  duckduckgo: 'web', web_search: 'web', web_readability: 'web', firecrawl: 'web',
+  searxng: 'web', http_request: 'web', http: 'web', exa_search: 'web',
+  parallel_search: 'web',
+  duckduckgo_search: 'web', searxng_search: 'web',
+  // Browser
+  browser: 'browser',
+  // Memory
+  memory: 'memory', memory_write: 'memory', memory_search: 'memory',
+  // Skills
+  skill_view: 'skills', skills_list: 'skills', skill_generate: 'skills',
+  skills_autoload: 'skills', skills_marketplace: 'skills', skill_manage: 'skills',
+  // Agent
+  delegate_task: 'agent', llm_task: 'agent',
+  // Documents
+  document_extract: 'documents', notebook_edit: 'documents', notes_add: 'documents',
+  // Git
+  git: 'git',
+  // Plan / Todo
+  plan: 'planning', todo_write: 'planning',
+  // Media
+  image_generation: 'media', video_generation: 'media', music_generation: 'media',
+  media_understanding: 'media', text_to_speech: 'media', speech_to_text: 'media',
+  voice_chat: 'media', audio_understanding: 'media',
+  // macOS
+  mac_alarm: 'macos', mac_app_open: 'macos', mac_app_quit: 'macos', mac_notify: 'macos',
+  macos_screenshot: 'macos', phone_control: 'macos', phone_control_enhanced: 'macos',
+  // Calendar
+  calendar_add: 'calendar',
+  // Reminder
+  reminder_add: 'reminders',
+  // Other
+  dashboard: 'dashboard', canvas: 'canvas', plugin: 'plugins', soul: 'soul',
+  kanban: 'planning',
+  cron_create: 'cron', thread_ownership: 'threads', code_execution: 'sandbox',
+  cross_session_memory: 'memory',
+};
+
+// ── check_fn'ler (tool availability kontrolleri) ────────────────────────
+function _checkBrowser() {
+  try {
+    require.resolve('playwright');
+    return true;
+  } catch { return false; }
+}
+
+function _checkDuckDuckGo() {
+  return true; // API-based, always available
+}
+
+function _checkMacOSTools() {
+  return process.platform === 'darwin';
+}
+
+const CHECK_FN_MAP = {
+  browser: _checkBrowser,
+  mac_alarm: _checkMacOSTools,
+  mac_app_open: _checkMacOSTools,
+  mac_app_quit: _checkMacOSTools,
+  mac_notify: _checkMacOSTools,
+  macos_screenshot: _checkMacOSTools,
+  phone_control: _checkMacOSTools,
+  phone_control_enhanced: _checkMacOSTools,
+};
+
+// ── Provider filtering ───────────────────────────────────────────────────
 function getToolsForProvider(allTools, providerUrl) {
   const url = (providerUrl || '').toLowerCase();
-
-  // Groq icin minimum tool seti
   if (url.includes('groq.com')) {
-    const allowed = ['read_file', 'write_file', 'bash', 'shell_command', 'list_dir', 'soul', 'memory_write', 'memory_search'];
+    const allowed = ['read_file', 'write_file', 'bash', 'shell_command', 'list_dir', 'soul', 'memory', 'memory_write', 'memory_search', 'filesystem', 'grep_search'];
     return allTools.filter(t => allowed.includes(t.name));
   }
-
-  // Anthropic, OpenAI, MiniMax tam set
   return allTools;
 }
 
@@ -45,7 +148,6 @@ function loadToolDefinitions() {
   const tools = [];
   const files = fs.readdirSync(TOOLS_DIR).filter(f => f.endsWith('.js'));
 
-  // v5.6.1: Provider tespiti - Groq icin sadece temel tool'lar
   let isGroq = false;
   try {
     const { getConfig } = require('./config');
@@ -55,105 +157,109 @@ function loadToolDefinitions() {
     }
   } catch (e) {}
 
+  let disabledTools = new Set();
+  try {
+    const { getConfig } = require('./config');
+    const cfg = getConfig();
+    if (Array.isArray(cfg.disabledTools)) disabledTools = new Set(cfg.disabledTools);
+  } catch (e) {}
+
   const GROQ_ALLOWED = new Set([
     'read_file', 'write_file', 'list_dir', 'bash', 'shell_command',
-    'soul', 'memory_write', 'memory_search', 'filesystem', 'grep_search'
+    'soul', 'memory', 'memory_write', 'memory_search', 'filesystem', 'grep_search'
   ]);
 
   for (const file of files) {
     try {
       const toolPath = path.join(TOOLS_DIR, file);
       const mod = require(toolPath);
+      const toolName = mod.name || path.basename(file, '.js');
 
-      // Groq icin sadece temel tool'lar
-      if (isGroq) {
-        const toolName = mod.name || path.basename(file, '.js');
-        if (!GROQ_ALLOWED.has(toolName)) continue;
-      }
+      if (isGroq && !GROQ_ALLOWED.has(toolName)) continue;
+      if (disabledTools.has(toolName)) continue;
 
-      // Tool metadata çıkar
       const meta = {
-        name: mod.name || path.basename(file, '.js'),
+        name: toolName,
         description: mod.description || `${path.basename(file, '.js')} tool`,
         parameters: mod.parameters || mod.inputSchema || { type: 'object', properties: {} },
         execute: mod.execute || (mod.default && mod.default.execute) || null,
+        emoji: EMOJI_MAP[toolName] || '',
+        toolset: TOOLSET_MAP[toolName] || 'general',
+        checkFn: CHECK_FN_MAP[toolName] || null,
       };
 
-      // Eğer execute fonksiyonu varsa ekle (CLI'da çalıştırmak için)
       if (meta.execute) {
         tools.push(meta);
+        // Registry'ye kaydet
+        globalRegistry.register({
+          name: meta.name,
+          toolset: meta.toolset,
+          schema: { name: meta.name, description: meta.description, parameters: meta.parameters },
+          handler: meta.execute,
+          checkFn: meta.checkFn,
+          emoji: meta.emoji,
+        });
       }
     } catch (e) {
-      // Sessizce atla — bozuk tool dosyaları kritik değil
+      // Sessizce atla
     }
   }
-
   return tools;
 }
 
-/**
- * OpenAI uyumlu API'ye gönderilecek format:
- *   [{ type: "function", function: { name, description, parameters } }]
- */
-function toOpenAIFormat(toolDefs) {
-  // v5.6.6: Yasakli tool'lari filtrele, alias'lari cozumle
-  // v5.6.6: Inline tool filtre - model halusinasyonla cagirabilecegi tool'lari engelle
-  toolDefs = toolDefs.filter(t => 
-    !['brave_search','brave-web-search','google_search','web_search','browse','open','search','shell','bash_command','execute_command','run_command','sql','query','lookup'].includes(t.name)
-  );
+const ALIAS_MAP = {
+  'brave_search': 'duckduckgo', 'brave-web-search': 'duckduckgo',
+  'google_search': 'duckduckgo', 'web_search': 'duckduckgo',
+  'browse': 'browser', 'shell': 'bash', 'bash_command': 'bash',
+  'execute_command': 'bash', 'run_command': 'bash',
+};
 
+const BLOCKED_NAMES = new Set([
+  'brave_search', 'brave-web-search', 'google_search', 'web_search',
+  'browse', 'open', 'search', 'shell', 'bash_command', 'execute_command',
+  'run_command', 'sql', 'query', 'lookup',
+]);
+
+function toOpenAIFormat(toolDefs) {
   return toolDefs
-    .filter(t => !['brave_search','brave-web-search','google_search','web_search','browse','open','search','shell','bash_command','execute_command','run_command','sql','query','lookup'].includes(t.name))
+    .filter(t => !BLOCKED_NAMES.has(t.name))
+    .filter(t => {
+      if (t.checkFn) {
+        try { return t.checkFn() !== false; } catch { return false; }
+      }
+      return true;
+    })
     .map(t => {
-      // Alias varsa degistir. Önceki kod ALIAS_MAP'i declare ediyordu ama
-      // değiştirmek için TOOL_ALIASES kullanıyordu (undefined) — alias hit
-      // olduğunda ReferenceError ile çöküyordu. ALIAS_MAP'e döndürüldü.
-      const ALIAS_MAP = { 'brave_search':'duckduckgo_search','brave-web-search':'duckduckgo_search','google_search':'duckduckgo_search','web_search':'duckduckgo_search','browse':'browser','shell':'bash','bash_command':'bash','execute_command':'bash','run_command':'bash' };
-      if (ALIAS_MAP[t.name]) {
-        t = { ...t, name: ALIAS_MAP[t.name] };
+      let name = t.name;
+      if (ALIAS_MAP[name]) name = ALIAS_MAP[name];
+
+      const cleanParams = JSON.parse(JSON.stringify(t.parameters || {}));
+      if (cleanParams.properties) {
+        Object.keys(cleanParams.properties).forEach(key => {
+          const prop = cleanParams.properties[key];
+          if (Array.isArray(prop.type)) prop.type = prop.type[0];
+          delete prop.additionalProperties;
+        });
       }
-    // v5.4.21: Groq uyumluluk - additionalProperties: false kaldirildi
-    // ve gereksiz kisitlamalar temizlendi
-    const cleanParams = JSON.parse(JSON.stringify(t.parameters || {}));
-    if (cleanParams.properties) {
-      Object.keys(cleanParams.properties).forEach(key => {
-        const prop = cleanParams.properties[key];
-        // "type": ["number", "string"] union types Groq'da hata verir
-        // Sadece ilk tipi al
-        if (Array.isArray(prop.type)) {
-          prop.type = prop.type[0];
-        }
-        // additionalProperties kaldir
-        delete prop.additionalProperties;
-      });
-    }
-    // Groq icin required kismi bazen sorun cikarir - olduugu gibi birak
-    // ama type validation'u gevset
-    return {
-      type: 'function',
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: cleanParams,
-      },
-    };
-  });
+
+      return {
+        type: 'function',
+        function: { name, description: t.description, parameters: cleanParams },
+      };
+    });
 }
 
-/**
- * Tool çağrısını çalıştır
- * @param toolName - tool adı
- * @param args - tool argümanları (object)
- * @param toolDefs - loadToolDefinitions() sonucu
- * @returns { result, error }
- */
 async function executeTool(toolName, args, toolDefs) {
   const tool = toolDefs.find(t => t.name === toolName);
-  if (!tool) {
-    return { error: `Tool bulunamadı: ${toolName}` };
-  }
-  if (!tool.execute) {
-    return { error: `Tool execute fonksiyonu yok: ${toolName}` };
+  if (!tool) return { error: `Tool bulunamadı: ${toolName}` };
+  if (!tool.execute) return { error: `Tool execute fonksiyonu yok: ${toolName}` };
+  // checkFn — tool disabled? (re-check at runtime)
+  if (tool.checkFn) {
+    try {
+      if (tool.checkFn() === false) return { error: `${toolName} şu anda kullanılamıyor (check_fn engelledi)` };
+    } catch {
+      return { error: `${toolName} kontrol hatası` };
+    }
   }
   try {
     const result = await tool.execute(args || {});
@@ -164,7 +270,6 @@ async function executeTool(toolName, args, toolDefs) {
 }
 
 module.exports = {
-  loadToolDefinitions,
-  toOpenAIFormat,
-  executeTool,
+  loadToolDefinitions, toOpenAIFormat, executeTool, getToolsForProvider,
+  EMOJI_MAP, TOOLSET_MAP, CHECK_FN_MAP,
 };

package/src/tools/http.js

@@ -1,78 +0,0 @@
-module.exports = {
-  name: 'http_request',
-  description: 'Make HTTP requests to any URL (GET, POST, PUT, DELETE, PATCH)',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      method: {
-        type: 'string',
-        description: 'HTTP method: GET, POST, PUT, DELETE, PATCH',
-        enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
-        default: 'GET'
-      },
-      url: {
-        type: 'string',
-        description: 'Full URL to request'
-      },
-      headers: {
-        type: 'object',
-        description: 'Optional headers (key-value pairs)'
-      },
-      body: {
-        type: 'object',
-        description: 'Optional request body (for POST/PUT/PATCH)'
-      }
-    },
-    required: ['url']
-  },
-  
-  async execute(params) {
-    try {
-      const method = (params.method || 'GET').toUpperCase();
-      
-      const options = {
-        method,
-        headers: {
-          'Content-Type': 'application/json',
-          'User-Agent': 'NatureCo-CLI/2.7.0',
-          ...(params.headers || {})
-        }
-      };
-      
-      // Add body for POST/PUT/PATCH
-      if (params.body && ['POST', 'PUT', 'PATCH'].includes(method)) {
-        options.body = JSON.stringify(params.body);
-      }
-      
-      const response = await fetch(params.url, options);
-      const text = await response.text();
-      
-      // Try to parse as JSON
-      let data;
-      try {
-        data = JSON.parse(text);
-      } catch {
-        data = text;
-      }
-      
-      // Truncate large responses
-      if (typeof data === 'string' && data.length > 2000) {
-        data = data.slice(0, 2000) + '... (truncated)';
-      }
-      
-      return {
-        success: true,
-        status: response.status,
-        ok: response.ok,
-        statusText: response.statusText,
-        headers: Object.fromEntries(response.headers.entries()),
-        data: data
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      };
-    }
-  }
-};