natureco-cli 5.18.3 → 5.20.0

package/src/tools/search_provider.js

@@ -0,0 +1,79 @@
+const loadConfig = () => {
+  try { return JSON.parse(require('fs').readFileSync(require('path').join(require('os').homedir(), '.natureco', 'config.json'), 'utf8')); } catch { return {}; }
+};
+
+require('../providers/search/tavily');
+require('../providers/search/duckduckgo');
+require('../providers/search/searxng');
+require('../providers/search/exa');
+
+const name = 'search_provider';
+const description = 'Unified search backend with pluggable providers. search/status/switch/list. Supports Tavily, DuckDuckGo, SearXNG, Exa. Switch via NATURECO_SEARCH_PROVIDER env or config.searchProvider. Default: tavily (falls back to others if no API key).';
+const parameters = {
+  type: 'object',
+  properties: {
+    action: {
+      type: 'string',
+      enum: ['search', 'status', 'list', 'switch'],
+      description: 'Operation: search, status, list, or switch',
+    },
+    query: { type: 'string', description: '(search) Search query' },
+    maxResults: { type: 'number', description: '(search) Max results (default: 5)' },
+    provider: { type: 'string', description: '(search/switch) Provider name to use or switch to' },
+  },
+  required: ['action'],
+};
+
+async function execute(params) {
+  const cfg = loadConfig();
+  const { getActiveProvider, getProviderNames, resolveProviderConfig, getProvider } = require('../utils/search-provider');
+
+  switch (params.action) {
+    case 'search': {
+      if (!params.query) return { success: false, error: 'query gerekli' };
+      const providerName = params.provider || process.env.NATURECO_SEARCH_PROVIDER || cfg.searchProvider;
+      let Provider;
+      if (providerName) Provider = getProvider(providerName);
+      if (!Provider) Provider = getActiveProvider(cfg);
+      const provider = new Provider(cfg);
+      return provider.search(params.query, { maxResults: params.maxResults || 5 });
+    }
+
+    case 'status': {
+      const active = resolveProviderConfig(cfg);
+      const avail = getProviderNames().sort();
+      return {
+        active,
+        available: avail,
+        config: cfg.searchProvider || '(not set, using default)',
+        env: process.env.NATURECO_SEARCH_PROVIDER || '(not set)',
+        default: 'tavily',
+      };
+    }
+
+    case 'list': {
+      const avail = getProviderNames().sort();
+      return {
+        success: true,
+        providers: avail.map(name => {
+          const Provider = getProvider(name);
+          const inst = new Provider(cfg);
+          const hasKey = name === 'duckduckgo' || name === 'searxng' || !!(cfg[name + 'ApiKey'] || process.env[name.toUpperCase() + '_API_KEY']);
+          return { name, available: hasKey };
+        }),
+      };
+    }
+
+    case 'switch': {
+      if (!params.provider) return { success: false, error: 'provider (name) gerekli' };
+      const { setConfigValue } = require('../utils/config');
+      setConfigValue('searchProvider', params.provider);
+      return { success: true, message: `Search provider switched to: ${params.provider}` };
+    }
+
+    default:
+      return { success: false, error: `Unknown action: ${params.action}` };
+  }
+}
+
+module.exports = { name, description, parameters, execute };

package/src/tools/skills_download.js

@@ -0,0 +1,217 @@
+/**
+ * skills_download — Download skills from skills.sh ecosystem or GitHub repos
+ *
+ * Bulk-imports Agent Skills from the open ecosystem into natureco's skill system.
+ * Skills are SKILL.md files following the Agent Skills standard (agentskills.io).
+ *
+ * Sources:
+ *   - GitHub repos (anthropics/skills, vercel-labs/agent-skills, etc.)
+ *   - skills.sh registry
+ *   - Direct SKILL.md URLs
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BUILTIN_SKILLS_DIR = path.join(__dirname, '..', '..', 'skills');
+const USER_SKILLS_DIR = path.join(os.homedir(), '.natureco', 'skills');
+
+// Known skill repos with high-quality skills
+const KNOWN_REPOS = [
+  { owner: 'anthropics', repo: 'skills', topic: 'general' },
+  { owner: 'mattpocock', repo: 'skills', topic: 'typescript' },
+  { owner: 'vercel-labs', repo: 'agent-skills', topic: 'vercel' },
+  { owner: 'supabase', repo: 'agent-skills', topic: 'database' },
+  { owner: 'xixu-me', repo: 'skills', topic: 'devops' },
+  { owner: 'microsoft', repo: 'azure-skills', topic: 'cloud' },
+  { owner: 'shadcn', repo: 'ui', topic: 'design' },
+  { owner: 'nrwl', repo: 'nx-ai-agents-config', topic: 'nx' },
+  { owner: 'remotion-dev', repo: 'skills', topic: 'video' },
+  { owner: 'mcollina', repo: 'skills', topic: 'nodejs' },
+  { owner: 'spillwavesolutions', repo: 'design-doc-mermaid', topic: 'design' },
+  { owner: 'nextlevelbuilder', repo: 'ui-ux-pro-max-skill', topic: 'design' },
+  { owner: 'browser-act', repo: 'skills', topic: 'browser' },
+  { owner: 'obra', repo: 'superpowers', topic: 'workflow' },
+];
+
+function httpsGet(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, { timeout: 15000 }, (res) => {
+      let data = '';
+      res.on('data', c => data += c);
+      res.on('end', () => resolve(data));
+    }).on('error', reject).on('timeout', function() { this.destroy(); reject(new Error('Timeout')); });
+  });
+}
+
+function getGithubContentsUrl(owner, repo, path) {
+  return `https://api.github.com/repos/${owner}/${repo}/contents/${path}`;
+}
+
+async function listRepos() {
+  return KNOWN_REPOS.map(r => ({
+    id: `${r.owner}/${r.repo}`,
+    owner: r.owner,
+    repo: r.repo,
+    topic: r.topic,
+  }));
+}
+
+function parseFrontmatter(content) {
+  const m = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!m) return { metadata: {}, body: content };
+  const fm = {};
+  for (const line of m[1].split('\n')) {
+    const kv = line.match(/^(\w+):\s*(.+)$/);
+    if (kv) fm[kv[1]] = kv[2].replace(/^["']|["']$/g, '');
+  }
+  return { metadata: fm, body: (m[2] || '').trim() };
+}
+
+async function fetchGithubRepo(owner, repo) {
+  // Use GitHub API to list contents of /skills directory
+  const url = `https://api.github.com/repos/${owner}/${repo}/git/trees/HEAD?recursive=1`;
+  const data = await httpsGet(url, { headers: { 'User-Agent': 'natureco-cli', 'Accept': 'application/vnd.github.v3+json' } });
+  const tree = JSON.parse(data).tree || [];
+
+  // Find all SKILL.md files
+  const skillFiles = tree.filter(f => f.path.endsWith('SKILL.md'));
+  const skills = [];
+
+  for (const file of skillFiles) {
+    const skillDir = path.dirname(file.path);
+    const skillName = path.basename(skillDir);
+
+    // Fetch SKILL.md content
+    const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/main/${file.path}`;
+    let content;
+    try {
+      content = await httpsGet(rawUrl);
+    } catch { continue; }
+
+    const { metadata, body } = parseFrontmatter(content);
+    const name = metadata.name || skillName;
+    const description = metadata.description || '';
+
+    // Find additional files in the skill directory
+    const additionalFiles = tree
+      .filter(f => f.path.startsWith(skillDir + '/') && f.path !== file.path)
+      .map(f => ({ path: f.path.replace(skillDir + '/', ''), url: `https://raw.githubusercontent.com/${owner}/${repo}/main/${f.path}` }));
+
+    skills.push({
+      name,
+      description: description.length > 200 ? description.slice(0, 200) + '...' : description,
+      fullDescription: description,
+      content: body,
+      source: `${owner}/${repo}/${skillDir}`,
+      metadata,
+      additionalFiles,
+    });
+  }
+
+  return skills;
+}
+
+async function downloadSkill(skill, targetDir) {
+  const skillDir = path.join(targetDir, skill.name);
+  if (fs.existsSync(skillDir)) {
+    return { success: false, error: 'Already exists', path: skillDir };
+  }
+
+  fs.mkdirSync(skillDir, { recursive: true });
+
+  // Write SKILL.md
+  const frontmatter = [
+    '---',
+    `name: ${skill.name}`,
+    `description: ${skill.description}`,
+    skill.metadata.license ? `license: ${skill.metadata.license}` : null,
+    skill.source ? `metadata:\n  source: ${skill.source}` : null,
+    '---',
+    '',
+    skill.content,
+  ].filter(Boolean).join('\n');
+
+  fs.writeFileSync(path.join(skillDir, 'SKILL.md'), frontmatter, 'utf8');
+
+  // Download additional files
+  for (const af of (skill.additionalFiles || [])) {
+    try {
+      const data = await httpsGet(af.url);
+      const afDir = path.dirname(path.join(skillDir, af.path));
+      fs.mkdirSync(afDir, { recursive: true });
+      fs.writeFileSync(path.join(skillDir, af.path), data, 'utf8');
+    } catch {}
+  }
+
+  return { success: true, path: skillDir, name: skill.name };
+}
+
+async function execute(params) {
+  const { action, source, name, target } = params;
+  const targetDir = target === 'user' ? USER_SKILLS_DIR : BUILTIN_SKILLS_DIR;
+
+  if (action === 'list_sources') {
+    const repos = await listRepos();
+    return JSON.stringify({ success: true, sources: repos });
+  }
+
+  if (action === 'list_skills') {
+    const [owner, repo] = (source || '').split('/');
+    if (!owner || !repo) return JSON.stringify({ success: false, error: 'source must be owner/repo (e.g. anthropics/skills)' });
+    const skills = await fetchGithubRepo(owner, repo);
+    return JSON.stringify({ success: true, source, count: skills.length, skills: skills.map(s => ({ name: s.name, description: s.description })) });
+  }
+
+  if (action === 'download') {
+    const [owner, repo] = (source || '').split('/');
+    if (!owner || !repo) return JSON.stringify({ success: false, error: 'source must be owner/repo' });
+    const skills = await fetchGithubRepo(owner, repo);
+    const targetSkill = name ? skills.find(s => s.name === name) : null;
+    const toDownload = targetSkill ? [targetSkill] : skills;
+    const results = [];
+    for (const skill of toDownload) {
+      const result = await downloadSkill(skill, targetDir);
+      results.push({ name: skill.name, ...result });
+    }
+    const succeeded = results.filter(r => r.success).length;
+    return JSON.stringify({ success: true, source, total: results.length, succeeded, failed: results.length - succeeded, results });
+  }
+
+  if (action === 'download_all') {
+    const repos = await listRepos();
+    const allResults = [];
+    for (const repo of repos) {
+      try {
+        const skills = await fetchGithubRepo(repo.owner, repo.repo);
+        for (const skill of skills) {
+          const result = await downloadSkill(skill, targetDir);
+          allResults.push({ repo: repo.id, name: skill.name, ...result });
+        }
+      } catch (e) {
+        allResults.push({ repo: repo.id, error: e.message });
+      }
+    }
+    const succeeded = allResults.filter(r => r.success).length;
+    return JSON.stringify({ success: true, total: allResults.length, succeeded, failed: allResults.length - succeeded, results: allResults });
+  }
+
+  return JSON.stringify({ success: false, error: 'Unknown action. Use: list_sources, list_skills, download, download_all' });
+}
+
+const name = 'skills_download';
+const description = 'Download skills from skills.sh ecosystem or GitHub repos. Bulk-import Agent Skills from anthropics/skills, vercel-labs/agent-skills, supabase/agent-skills and more. Actions: list_sources, list_skills, download, download_all.';
+const parameters = {
+  type: 'object',
+  properties: {
+    action: { type: 'string', enum: ['list_sources', 'list_skills', 'download', 'download_all'] },
+    source: { type: 'string', description: 'Source repo in owner/repo format (e.g. anthropics/skills)' },
+    name: { type: 'string', description: 'Specific skill name to download (optional, downloads all if not set)' },
+    target: { type: 'string', enum: ['builtin', 'user'], description: 'Target directory: builtin (project) or user (~/.natureco)' },
+  },
+  required: ['action'],
+};
+
+module.exports = { name, description, parameters, execute };

package/src/tools/web_search.js

@@ -1,82 +1,62 @@
 const { getConfig } = require('../utils/config');
+const { getActiveProvider, getProviderNames, DEFAULT_PROVIDER } = require('../utils/search-provider');
+require('../providers/search/tavily');
+require('../providers/search/duckduckgo');
+require('../providers/search/searxng');
+require('../providers/search/exa');
 
 module.exports = {
   name: 'web_search',
-  description: 'Search the web for current information using Tavily',
+  description: 'Search the web for current information using the configured search provider (Tavily, DuckDuckGo, SearXNG, Exa). Switch via NATURECO_SEARCH_PROVIDER env or config.searchProvider.',
   inputSchema: {
     type: 'object',
     properties: {
-      query: {
-        type: 'string',
-        description: 'Search query'
-      }
+      query: { type: 'string', description: 'Search query' },
+      maxResults: { type: 'number', description: 'Maximum results (default: 5)' },
+      provider: { type: 'string', description: 'Override provider: tavily, duckduckgo, searxng, exa (default: configured or tavily)' },
     },
     required: ['query']
   },
-  
+
   async execute(params) {
     try {
       const config = getConfig();
-      const apiKey = config.tavilyApiKey || process.env.TAVILY_API_KEY;
-      
-      if (!apiKey) {
-        return {
-          success: false,
-          error: 'Tavily API key gerekli. Kur: natureco config set tavilyApiKey tvly_xxx\nÜcretsiz key: https://tavily.com'
-        };
-      }
-      
-      const response = await fetch('https://api.tavily.com/search', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          api_key: apiKey,
-          query: params.query,
-          search_depth: 'basic',
-          max_results: 5
-        })
-      });
-      
-      if (!response.ok) {
-        return {
-          success: false,
-          error: `Tavily API error: ${response.status} ${response.statusText}`
-        };
+      const providerName = params.provider || process.env.NATURECO_SEARCH_PROVIDER || config.searchProvider;
+      let Provider;
+
+      if (providerName) {
+        const { getProvider } = require('../utils/search-provider');
+        Provider = getProvider(providerName);
       }
-      
-      const data = await response.json();
-      
-      if (data.error) {
-        return {
-          success: false,
-          error: data.error
-        };
+      if (!Provider) {
+        Provider = getActiveProvider(config);
       }
-      
-      if (!data.results || data.results.length === 0) {
-        return {
-          success: true,
-          message: 'Sonuç bulunamadı',
-          query: params.query,
-          results: []
-        };
+
+      const provider = new Provider(config);
+      const result = await provider.search(params.query, {
+        maxResults: params.maxResults || 5,
+      });
+
+      if (!result.success && providerName && !params.provider) {
+        const allProviders = getProviderNames();
+        for (const name of allProviders) {
+          if (name === providerName) continue;
+          const { getProvider } = require('../utils/search-provider');
+          const FallbackProvider = getProvider(name);
+          if (!FallbackProvider) continue;
+          const fallback = new FallbackProvider(config);
+          const fallbackResult = await fallback.search(params.query, { maxResults: params.maxResults || 5 });
+          if (fallbackResult.success) {
+            fallbackResult.fallback = true;
+            fallbackResult.fallbackReason = result.error;
+            return fallbackResult;
+          }
+        }
       }
-      
-      return {
-        success: true,
-        query: params.query,
-        results: data.results.map(r => ({
-          title: r.title,
-          snippet: r.content,
-          url: r.url
-        })),
-        count: data.results.length
-      };
+
+      return result;
     } catch (error) {
-      return {
-        success: false,
-        error: error.message
-      };
+      return { success: false, error: error.message };
     }
   }
 };

package/src/tools/workflow.js

@@ -6,6 +6,8 @@ const os = require('os');
 const WORKFLOW_DIR = path.join(os.homedir(), '.natureco', 'workflows');
 const WORKFLOW_HISTORY = path.join(os.homedir(), '.natureco', 'workflow-history.json');
 
+const { buildSkillIndex } = require('../utils/skill-index');
+
 function ensureDir(dir) { try { fs.mkdirSync(dir, { recursive: true }); } catch {} }
 function loadConfig() {
   try { return JSON.parse(fs.readFileSync(path.join(os.homedir(), '.natureco', 'config.json'), 'utf8')); } catch { return {}; }
@@ -94,6 +96,8 @@ async function workflow(params) {
     return { success: false, error: 'Provider ayarli degil. Once: natureco setup' };
   }
 
+  const skillsIndexBlock = buildSkillIndex();
+
   // ── RUN: Execute a complete workflow ──────────────────────────────────
   if (action === 'run') {
     if (!task) return { success: false, error: 'task gerekli' };
@@ -114,7 +118,7 @@ async function workflow(params) {
     if (isSimple) {
       // Passthrough: just chat with LLM, no tools — include user memory
       const memCtx = memoryContext();
-      const sysMsg = 'Sen yardimci bir asistansin. Kisa ve oz yanit ver.' + (memCtx ? '\n\nKullanici bilgisi:\n' + memCtx : '');
+      const sysMsg = 'Sen yardimci bir asistansin. Kisa ve oz yanit ver.' + (memCtx ? '\n\nKullanici bilgisi:\n' + memCtx : '') + '\n\n' + skillsIndexBlock;
       const chatBody = { model, stream: false, messages: [{ role: 'system', content: sysMsg }, { role: 'user', content: task }], temperature: 0.7, max_tokens: 1000 };
       try {
         const chatResult = await apiCall(providerUrl, providerApiKey, chatBody);
@@ -127,12 +131,13 @@ async function workflow(params) {
 
     // Phase 1: LLM plans the workflow
     const memCtx = memoryContext();
-    const planPrompt = {
-      role: 'system',
-      content: 'Sen bir workflow planlama asistanisin. Verilen gorev icin hangi tool\'larin kullanilacagini ve hangi sirayla calisacagini belirle. SADECE JSON formatinda yanit ver, baska bir sey yazma.\n\nKullanilabilir tool\'lar:\n' +
-        tools.map(t => '- ' + t).join('\n') +
-        (memCtx ? '\n\nKullanici bilgisi:\n' + memCtx : '') +
-        '\n\nJSON format:\n{\n  "workflowName": "...",\n  "description": "...",\n  "steps": [\n    { "step": 1, "tool": "tool_name", "purpose": "...", "params": { ... } }\n  ]\n}\n\nHer adim icin params kismina tool\'un gerektirdigi parametreleri ekle. Adimlar birbirine bagimli olabilir, onceki adimin outputu sonraki adimin inputu olarak kullanilabilir.'
+      const planPrompt = {
+        role: 'system',
+        content: 'Sen bir workflow planlama asistanisin. Verilen gorev icin hangi tool\'larin kullanilacagini ve hangi sirayla calisacagini belirle. SADECE JSON formatinda yanit ver, baska bir sey yazma.\n\nKullanilabilir tool\'lar:\n' +
+          tools.map(t => '- ' + t).join('\n') +
+          '\n\nKullanilabilir skill\'ler (gorevle ilgili skill varsa plana skill_view adimi olarak ekle):\n' + skillsIndexBlock +
+          (memCtx ? '\n\nKullanici bilgisi:\n' + memCtx : '') +
+          '\n\nJSON format:\n{\n  "workflowName": "...",\n  "description": "...",\n  "skillsLoaded": ["..."],\n  "steps": [\n    { "step": 1, "tool": "tool_name", "purpose": "...", "params": { ... } }\n  ]\n}\n\nHer adim icin params kismina tool\'un gerektirdigi parametreleri ekle. Adimlar birbirine bagimli olabilir, onceki adimin outputu sonraki adimin inputu olarak kullanilabilir.\n\nGorevle ilgili skill varsa ILK adim olarak skill_view ile yukle, ardindan diger adimlara gec.'
     };
     const planBody = {
       model, stream: false,
@@ -203,7 +208,8 @@ async function workflow(params) {
         role: 'system',
         content: 'Bir sonraki adimi calistiriyorsun. Sana verilen tool\'u ve parametreleri kullanarak islemi gerceklestir. Tool cagrisini dogru formatta yap.\n\nTool: ' + step.tool + '\nAmac: ' + (step.purpose || '') + '\nPlanlanan parametreler: ' + JSON.stringify(step.params || {}) +
           '\n\nOnceki adim sonuclari:\n' + stepResults.map(r => 'Adim ' + r.step + ' (' + r.tool + '): ' + (r.status === 'done' ? JSON.stringify(r.result).slice(0, 300) : r.status)).join('\n') +
-          '\n\nTek bir tool cagrisi yap ve sonucu bekle. Tool cagrisi yaparken Onceki adim sonuclarindaki gerekli verileri parametre olarak kullan.'
+          '\n\nKullanilabilir skill\'ler:\n' + skillsIndexBlock +
+          '\n\nTek bir tool cagrisi yap ve sonucu bekle. Tool cagrisi yaparken Onceki adim sonuclarindaki gerekli verileri parametre olarak kullan. Ilgili skill varsa once skill_view ile yukle, sonra asil tool\'u cagir.'
       };
       const executeBody = {
         model, stream: false,
@@ -251,6 +257,10 @@ async function workflow(params) {
     history.unshift({ id: wfId, name: plan.workflowName || task.slice(0, 50), task, status: wfEntry.status, steps: plan.steps.length, completedAt: wfEntry.completedAt });
     fs.writeFileSync(WORKFLOW_HISTORY, JSON.stringify(history.slice(0, 50), null, 2));
 
+    const skillsLoaded = stepResults
+      .filter(r => r.tool === 'skill_view' && r.status === 'done')
+      .map(r => r.args?.name || 'bilinmeyen-skill');
+
     return {
       success: true,
       workflowId: wfId,
@@ -260,6 +270,7 @@ async function workflow(params) {
       completedSteps: stepResults.filter(r => r.status === 'done').length,
       failedSteps: stepResults.filter(r => r.status === 'error' || r.status === 'skipped').length,
       status: wfEntry.status,
+      skillsLoaded: skillsLoaded.length > 0 ? skillsLoaded : undefined,
       plan: plan.steps.map(s => ({ step: s.step, tool: s.tool, purpose: s.purpose })),
       results: stepResults.map(r => ({
         step: r.step, tool: r.tool, status: r.status,
@@ -276,7 +287,8 @@ async function workflow(params) {
     const planPrompt = {
       role: 'system',
       content: 'Kullanilabilir tool\'lar:\n' + tools.map(t => '- ' + t).join('\n') +
-        '\n\nGorev icin bir workflow plani JSON formatinda olustur. JSON disinda hicbir sey yazma.\nFormat: { "workflowName": "...", "description": "...", "estimatedSteps": N, "steps": [{ "step": 1, "tool": "...", "purpose": "...", "params": {...}, "expectedOutput": "..." }] }'
+        '\n\nKullanilabilir skill\'ler:\n' + skillsIndexBlock +
+        '\n\nGorev icin bir workflow plani JSON formatinda olustur. JSON disinda hicbir sey yazma.\nFormat: { "workflowName": "...", "description": "...", "estimatedSteps": N, "skillsLoaded": ["..."], "steps": [{ "step": 1, "tool": "...", "purpose": "...", "params": {...}, "expectedOutput": "..." }] }\n\nGorevle ilgili skill varsa plana skill_view adimi olarak ekle.'
     };
     const planBody = {
       model, stream: false,