natureco-cli 5.19.0 → 5.20.0

package/src/providers/model/anthropic.js

@@ -0,0 +1,84 @@
+const { ModelProvider, registerProvider, DEFAULT_ANTHROPIC_SYSTEM } = require('../../utils/model-provider');
+
+class AnthropicProvider extends ModelProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'anthropic';
+  }
+
+  getEndpoint() {
+    const base = (this.config.providerUrl || '').replace(/\/+$/, '');
+    return `${base}/v1/messages`;
+  }
+
+  extractSystem(messages) {
+    const systemMsg = messages.find(m => m.role === 'system');
+    if (!systemMsg) return DEFAULT_ANTHROPIC_SYSTEM;
+    const content = systemMsg.content;
+    if (typeof content === 'string' && content.trim()) return content;
+    if (Array.isArray(content) && content.length > 0) return content;
+    return DEFAULT_ANTHROPIC_SYSTEM;
+  }
+
+  buildRequest(messages, options = {}) {
+    const userMsgs = messages.filter(m => m.role !== 'system');
+    return {
+      model: this.config.providerModel || 'claude-3-5-haiku-20241022',
+      messages: userMsgs.map(m => ({ role: m.role, content: m.content })),
+      system: this.extractSystem(messages),
+      max_tokens: options.max_tokens || 4096,
+      temperature: options.temperature ?? 0.7,
+      stream: options.stream || false,
+      ...(options.tools?.length > 0 ? { tools: options.tools } : {}),
+    };
+  }
+
+  parseResponse(data) {
+    const textContent = data.content?.find(c => c.type === 'text')?.text || '';
+    const toolCalls = data.content
+      ?.filter(c => c.type === 'tool_use')
+      ?.map(c => ({
+        id: c.id,
+        type: 'function',
+        function: { name: c.name, arguments: JSON.stringify(c.input || {}) },
+      })) || [];
+    return {
+      role: 'assistant',
+      content: textContent,
+      tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+      usage: data.usage || undefined,
+    };
+  }
+
+  normalizeTools(tools) {
+    return (tools || []).map(t => ({
+      name: t.name || t.function?.name,
+      description: t.description || t.function?.description || '',
+      input_schema: t.inputSchema || t.input_schema || t.function?.parameters || { type: 'object', properties: {} },
+    }));
+  }
+
+  parseToolCalls(message) {
+    if (Array.isArray(message.content)) {
+      return message.content
+        .filter(c => c.type === 'tool_use')
+        .map(c => ({
+          id: c.id,
+          type: 'function',
+          function: { name: c.name, arguments: JSON.stringify(c.input || {}) },
+        }));
+    }
+    return [];
+  }
+
+  getAuthHeaders() {
+    return {
+      'x-api-key': this.config.providerApiKey || '',
+      'anthropic-version': '2023-06-01',
+      'Content-Type': 'application/json',
+    };
+  }
+}
+
+registerProvider('anthropic', AnthropicProvider);
+module.exports = AnthropicProvider;

package/src/providers/model/gemini.js

@@ -0,0 +1,49 @@
+const { ModelProvider, registerProvider } = require('../../utils/model-provider');
+
+class GeminiProvider extends ModelProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'gemini';
+  }
+
+  getEndpoint() {
+    const base = (this.config.providerUrl || '').replace(/\/+$/, '');
+    return `${base}/openai/chat/completions`;
+  }
+
+  buildRequest(messages, options = {}) {
+    return {
+      model: this.config.providerModel || 'gemini-2.0-flash',
+      messages,
+      max_tokens: options.max_tokens || 4096,
+      temperature: options.temperature ?? 0.7,
+      stream: options.stream || false,
+      ...(options.tools?.length > 0 ? { tools: options.tools, tool_choice: 'auto' } : {}),
+    };
+  }
+
+  parseResponse(data) {
+    const choice = data.choices?.[0];
+    if (!choice) return { role: 'assistant', content: '' };
+    return {
+      role: 'assistant',
+      content: choice.message?.content || choice.text || '',
+      tool_calls: choice.message?.tool_calls || undefined,
+      usage: data.usage || undefined,
+    };
+  }
+
+  normalizeTools(tools) {
+    return (tools || []).map(t => ({
+      type: 'function',
+      function: {
+        name: t.name || t.function?.name,
+        description: t.description || t.function?.description || '',
+        parameters: t.inputSchema || t.input_schema || t.function?.parameters || { type: 'object', properties: {} },
+      },
+    }));
+  }
+}
+
+registerProvider('gemini', GeminiProvider);
+module.exports = GeminiProvider;

package/src/providers/model/minimax.js

@@ -0,0 +1,48 @@
+const { ModelProvider, registerProvider } = require('../../utils/model-provider');
+
+class MiniMaxProvider extends ModelProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'minimax';
+  }
+
+  getEndpoint() {
+    const base = (this.config.providerUrl || '').replace(/\/+$/, '');
+    return `${base}/v1/text/chatcompletion_v2`;
+  }
+
+  buildRequest(messages, options = {}) {
+    return {
+      model: this.config.providerModel || 'minimax-m2.5',
+      messages,
+      max_tokens: options.max_tokens || 4096,
+      temperature: options.temperature ?? 0.7,
+      stream: options.stream || false,
+      ...(options.tools?.length > 0 ? { tools: options.tools, tool_choice: 'auto' } : {}),
+    };
+  }
+
+  parseResponse(data) {
+    const choice = data.choices?.[0] || data.base_resp || {};
+    return {
+      role: 'assistant',
+      content: choice.message?.content || choice.text || data.reply || '',
+      tool_calls: choice.message?.tool_calls || undefined,
+      usage: data.usage || undefined,
+    };
+  }
+
+  normalizeTools(tools) {
+    return (tools || []).map(t => ({
+      type: 'function',
+      function: {
+        name: t.name || t.function?.name,
+        description: t.description || t.function?.description || '',
+        parameters: t.inputSchema || t.input_schema || t.function?.parameters || { type: 'object', properties: {} },
+      },
+    }));
+  }
+}
+
+registerProvider('minimax', MiniMaxProvider);
+module.exports = MiniMaxProvider;

package/src/providers/model/ollama.js

@@ -0,0 +1,42 @@
+const { ModelProvider, registerProvider } = require('../../utils/model-provider');
+
+class OllamaProvider extends ModelProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'ollama';
+  }
+
+  getEndpoint() {
+    const base = (this.config.providerUrl || '').replace(/\/+$/, '');
+    return `${base}/chat/completions`;
+  }
+
+  buildRequest(messages, options = {}) {
+    return {
+      model: this.config.providerModel || 'llama3.2',
+      messages,
+      max_tokens: options.max_tokens || 4096,
+      temperature: options.temperature ?? 0.7,
+      stream: options.stream || false,
+      ...(options.tools?.length > 0 ? { tools: options.tools, tool_choice: 'auto' } : {}),
+    };
+  }
+
+  parseResponse(data) {
+    const choice = data.choices?.[0];
+    if (!choice) return { role: 'assistant', content: data.response || '' };
+    return {
+      role: 'assistant',
+      content: choice.message?.content || choice.text || data.response || '',
+      tool_calls: choice.message?.tool_calls || undefined,
+      usage: data.usage || undefined,
+    };
+  }
+
+  normalizeTools(tools) {
+    return [];
+  }
+}
+
+registerProvider('ollama', OllamaProvider);
+module.exports = OllamaProvider;

package/src/providers/model/openai.js

@@ -0,0 +1,49 @@
+const { ModelProvider, registerProvider, DEFAULT_ANTHROPIC_SYSTEM } = require('../../utils/model-provider');
+
+class OpenAIProvider extends ModelProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'openai';
+  }
+
+  getEndpoint() {
+    const base = (this.config.providerUrl || '').replace(/\/+$/, '');
+    return `${base}/chat/completions`;
+  }
+
+  buildRequest(messages, options = {}) {
+    return {
+      model: this.config.providerModel || 'gpt-4o-mini',
+      messages,
+      max_tokens: options.max_tokens || 4096,
+      temperature: options.temperature ?? 0.7,
+      stream: options.stream || false,
+      ...(options.tools?.length > 0 ? { tools: options.tools, tool_choice: 'auto' } : {}),
+    };
+  }
+
+  parseResponse(data) {
+    const choice = data.choices?.[0];
+    if (!choice) return { role: 'assistant', content: data.response || data.content || '' };
+    return {
+      role: 'assistant',
+      content: choice.message?.content || choice.text || '',
+      tool_calls: choice.message?.tool_calls || undefined,
+      usage: data.usage || undefined,
+    };
+  }
+
+  normalizeTools(tools) {
+    return (tools || []).map(t => ({
+      type: 'function',
+      function: {
+        name: t.name || t.function?.name,
+        description: t.description || t.function?.description || '',
+        parameters: t.inputSchema || t.input_schema || t.function?.parameters || { type: 'object', properties: {} },
+      },
+    }));
+  }
+}
+
+registerProvider('openai', OpenAIProvider);
+module.exports = OpenAIProvider;

package/src/providers/search/duckduckgo.js

@@ -0,0 +1,45 @@
+const { SearchProvider, registerProvider } = require('../../utils/search-provider');
+
+class DuckDuckGoProvider extends SearchProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'duckduckgo';
+  }
+
+  async search(query, options = {}) {
+    const maxResults = options.maxResults || 5;
+    const encoded = encodeURIComponent(query);
+
+    const response = await fetch(
+      `https://html.duckduckgo.com/html/?q=${encoded}`,
+      { headers: { 'User-Agent': 'NatureCo-CLI/2.0' } }
+    );
+
+    if (!response.ok) {
+      return { success: false, error: `DuckDuckGo error: ${response.status}`, provider: this.name };
+    }
+
+    const html = await response.text();
+    const results = [];
+    const resultRegex = /<a rel="nofollow" class="result__a" href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+    let match;
+    while ((match = resultRegex.exec(html)) !== null && results.length < maxResults) {
+      results.push({
+        title: match[2].replace(/<[^>]+>/g, '').trim(),
+        snippet: match[3].replace(/<[^>]+>/g, '').trim(),
+        url: match[1],
+      });
+    }
+
+    return {
+      success: true,
+      query,
+      results,
+      count: results.length,
+      provider: this.name,
+    };
+  }
+}
+
+registerProvider('duckduckgo', DuckDuckGoProvider);
+module.exports = DuckDuckGoProvider;

package/src/providers/search/exa.js

@@ -0,0 +1,52 @@
+const { SearchProvider, registerProvider } = require('../../utils/search-provider');
+
+class ExaProvider extends SearchProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'exa';
+  }
+
+  async search(query, options = {}) {
+    const apiKey = this.config.exaApiKey || process.env.EXA_API_KEY;
+    if (!apiKey) {
+      return { success: false, error: 'Exa API key gerekli. Kur: natureco config set exaApiKey <key>', provider: this.name };
+    }
+
+    const response = await fetch('https://api.exa.ai/search', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey },
+      body: JSON.stringify({
+        query,
+        type: options.type || 'auto',
+        numResults: options.maxResults || 5,
+        includeTerms: options.includeTerms,
+        excludeTerms: options.excludeTerms,
+      }),
+    });
+
+    if (!response.ok) {
+      const err = await response.text().catch(() => '');
+      return { success: false, error: `Exa error ${response.status}: ${err}`, provider: this.name };
+    }
+
+    const data = await response.json();
+    const results = (data.results || []).map(r => ({
+      title: r.title,
+      snippet: r.text,
+      url: r.url,
+      score: r.score,
+      publishedDate: r.publishedDate,
+    }));
+
+    return {
+      success: true,
+      query,
+      results,
+      count: results.length,
+      provider: this.name,
+    };
+  }
+}
+
+registerProvider('exa', ExaProvider);
+module.exports = ExaProvider;

package/src/providers/search/searxng.js

@@ -0,0 +1,51 @@
+const { SearchProvider, registerProvider } = require('../../utils/search-provider');
+
+class SearXNGProvider extends SearchProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'searxng';
+  }
+
+  async search(query, options = {}) {
+    const instanceUrl = (options.instanceUrl || this.config.searxngInstanceUrl || 'https://search.sapti.me').replace(/\/+$/, '');
+    const maxResults = options.maxResults || 5;
+
+    const searchParams = new URLSearchParams({
+      q: query,
+      format: 'json',
+      language: 'en',
+      categories: options.categories || 'general',
+      pageno: 1,
+    });
+
+    const response = await fetch(`${instanceUrl}/search?${searchParams}`, {
+      headers: { 'User-Agent': 'NatureCo-CLI/2.0', 'Accept': 'application/json' },
+    });
+
+    if (!response.ok) {
+      return { success: false, error: `SearXNG error: ${response.status}`, provider: this.name };
+    }
+
+    const data = await response.json();
+    const raw = (data.results || []).slice(0, maxResults);
+    const results = raw.map(r => ({
+      title: r.title,
+      snippet: r.content,
+      url: r.url,
+      engine: r.engine,
+      category: r.category,
+    }));
+
+    return {
+      success: true,
+      query,
+      instance: instanceUrl,
+      results,
+      count: results.length,
+      provider: this.name,
+    };
+  }
+}
+
+registerProvider('searxng', SearXNGProvider);
+module.exports = SearXNGProvider;

package/src/providers/search/tavily.js

@@ -0,0 +1,47 @@
+const { SearchProvider, registerProvider } = require('../../utils/search-provider');
+
+class TavilyProvider extends SearchProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'tavily';
+  }
+
+  async search(query, options = {}) {
+    const apiKey = this.config.tavilyApiKey || process.env.TAVILY_API_KEY;
+    if (!apiKey) {
+      return { success: false, error: 'Tavily API key gerekli. Kur: natureco config set tavilyApiKey tvly_xxx', provider: this.name };
+    }
+
+    const response = await fetch('https://api.tavily.com/search', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        api_key: apiKey,
+        query,
+        search_depth: options.searchDepth || 'basic',
+        max_results: options.maxResults || 5,
+      }),
+    });
+
+    if (!response.ok) {
+      return { success: false, error: `Tavily API error: ${response.status}`, provider: this.name };
+    }
+
+    const data = await response.json();
+    if (data.error) {
+      return { success: false, error: data.error, provider: this.name };
+    }
+
+    const results = this.normalizeResults(data.results || []);
+    return {
+      success: true,
+      query,
+      results,
+      count: results.length,
+      provider: this.name,
+    };
+  }
+}
+
+registerProvider('tavily', TavilyProvider);
+module.exports = TavilyProvider;

package/src/tools/model_provider.js

@@ -0,0 +1,71 @@
+require('../providers/model/openai');
+require('../providers/model/anthropic');
+require('../providers/model/gemini');
+require('../providers/model/minimax');
+require('../providers/model/ollama');
+
+const name = 'model_provider';
+const description = 'Model provider management. status/switch/list — view or switch between model providers (openai, anthropic, gemini, minimax, ollama). Also supports model-specific queries.';
+const parameters = {
+  type: 'object',
+  properties: {
+    action: {
+      type: 'string',
+      enum: ['status', 'list', 'switch'],
+      description: 'Operation: status, list, or switch',
+    },
+    provider: { type: 'string', description: '(switch) Provider name to switch to' },
+    model: { type: 'string', description: '(switch) Model to use with provider' },
+  },
+  required: ['action'],
+};
+
+async function execute(params) {
+  const fs = require('fs');
+  const path = require('path');
+  const os = require('os');
+  const cfg = (() => { try { return JSON.parse(fs.readFileSync(path.join(os.homedir(), '.natureco', 'config.json'), 'utf8')); } catch { return {}; } })();
+  const { getProviderNames, getProvider, resolveProviderConfig, detectFamily } = require('../utils/model-provider');
+
+  switch (params.action) {
+    case 'status': {
+      const active = resolveProviderConfig(cfg);
+      const family = detectFamily(cfg.providerUrl, cfg.providerModel);
+      const avail = getProviderNames().sort();
+      return {
+        activeProvider: active,
+        detectedFamily: family,
+        available: avail,
+        url: (cfg.providerUrl || '').replace(/\/\/.*@/, '//***@'),
+        model: cfg.providerModel || '(not set)',
+        env: process.env.NATURECO_MODEL_PROVIDER || '(not set)',
+        configValue: cfg.modelProvider || '(not set, using auto-detect)',
+      };
+    }
+
+    case 'list': {
+      const avail = getProviderNames().sort();
+      return {
+        success: true,
+        providers: avail.map(name => {
+          const Provider = getProvider(name);
+          const inst = new Provider(cfg);
+          return { name, endpoint: inst.getEndpoint() };
+        }),
+      };
+    }
+
+    case 'switch': {
+      if (!params.provider) return { success: false, error: 'provider name gerekli' };
+      const { setConfigValue } = require('../utils/config');
+      setConfigValue('modelProvider', params.provider);
+      if (params.model) setConfigValue('providerModel', params.model);
+      return { success: true, message: `Model provider switched to: ${params.provider}${params.model ? ' (model: ' + params.model + ')' : ''}` };
+    }
+
+    default:
+      return { success: false, error: `Unknown action: ${params.action}` };
+  }
+}
+
+module.exports = { name, description, parameters, execute };

package/src/tools/parallel_search.js

@@ -1,77 +1,68 @@
 const { getConfig } = require('../utils/config');
+const { getProviderNames, getProvider } = require('../utils/search-provider');
+require('../providers/search/tavily');
+require('../providers/search/duckduckgo');
+require('../providers/search/searxng');
+require('../providers/search/exa');
 
 module.exports = {
   name: 'parallel_search',
-  description: 'Free web search using Parallel (no API key required)',
+  description: 'Run search across multiple search providers in parallel and merge results. Uses configured providers (DuckDuckGo, SearXNG, Exa, Tavily).',
   inputSchema: {
     type: 'object',
     properties: {
       query: { type: 'string', description: 'Search query' },
-      maxResults: { type: 'number', description: 'Maximum results (default: 5)', default: 5 }
+      maxResults: { type: 'number', description: 'Maximum results per provider (default: 3)' },
+      providers: { type: 'array', items: { type: 'string' }, description: 'Providers to use (default: all available, except Tavily which needs API key)' },
     },
-    required: ['query']
+    required: ['query'],
   },
 
   async execute(params) {
     try {
-      const query = encodeURIComponent(params.query);
-      const maxResults = params.maxResults || 5;
+      const config = getConfig();
+      const query = params.query;
+      const maxResults = params.maxResults || 3;
+      const allProviders = getProviderNames();
 
-      const response = await fetch(
-        `https://api.duckduckgo.com/?q=${query}&format=json&no_html=1&skip_disambig=1`,
-        { headers: { 'User-Agent': 'NatureCo-CLI/2.0' } }
-      );
+      let providersToUse = params.providers || allProviders;
+      providersToUse = providersToUse.filter(name => allProviders.includes(name));
 
-      if (!response.ok) {
-        return { success: false, error: `Parallel search error: ${response.status}` };
+      if (providersToUse.length === 0) {
+        return { success: false, error: 'Kullanilabilir search provider bulunamadi' };
       }
 
-      const data = await response.json();
-      const results = [];
-
-      if (data.AbstractText) {
-        results.push({
-          title: data.Heading || 'Summary',
-          snippet: data.AbstractText,
-          url: data.AbstractURL || ''
-        });
-      }
-
-      if (data.Results && Array.isArray(data.Results)) {
-        for (const r of data.Results) {
-          if (results.length >= maxResults) break;
-          if (r.Text && r.FirstURL) {
-            results.push({ title: r.Text.split(' - ')[0] || r.Text, snippet: r.Text, url: r.FirstURL });
-          }
-        }
-      }
+      const results = await Promise.allSettled(
+        providersToUse.map(async (name) => {
+          const Provider = getProvider(name);
+          if (!Provider) throw new Error(`Provider bulunamadi: ${name}`);
+          const provider = new Provider(config);
+          const result = await provider.search(query, { maxResults });
+          return { provider: name, result };
+        })
+      );
 
-      if (data.RelatedTopics && Array.isArray(data.RelatedTopics)) {
-        for (const r of data.RelatedTopics) {
-          if (results.length >= maxResults) break;
-          if (r.Text && r.FirstURL) {
-            results.push({ title: r.Text.split(' - ')[0] || r.Text, snippet: r.Text, url: r.FirstURL });
-          }
-          if (r.Topics && Array.isArray(r.Topics)) {
-            for (const t of r.Topics) {
-              if (results.length >= maxResults) break;
-              if (t.Text && t.FirstURL) {
-                results.push({ title: t.Text.split(' - ')[0] || t.Text, snippet: t.Text, url: t.FirstURL });
-              }
-            }
+      const merged = [];
+      for (const r of results) {
+        if (r.status === 'fulfilled' && r.value.result.success) {
+          for (const item of r.value.result.results || []) {
+            merged.push({
+              ...item,
+              _provider: r.value.provider,
+            });
           }
         }
       }
 
       return {
         success: true,
-        query: params.query,
-        results,
-        count: results.length,
-        source: 'parallel'
+        query,
+        results: merged.slice(0, maxResults * providersToUse.length),
+        count: merged.length,
+        providersUsed: providersToUse,
       };
     } catch (error) {
       return { success: false, error: error.message };
     }
-  }
-};
+  },
+};