natureco-cli 2.23.28 → 2.23.30

package/src/tools/text_to_speech.js

@@ -0,0 +1,105 @@
+const { getConfig } = require('../utils/config');
+
+module.exports = {
+  name: 'text_to_speech',
+  description: 'Convert text to speech using ElevenLabs, OpenAI TTS, or local CLI TTS',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      text: { type: 'string', description: 'Text to convert to speech' },
+      provider: { type: 'string', description: 'TTS provider: elevenlabs, openai, local (default: elevenlabs)', enum: ['elevenlabs', 'openai', 'local'] },
+      voice: { type: 'string', description: 'Voice ID or name (ElevenLabs: Rachel, Adam, etc; OpenAI: alloy, echo, fable, nova, shimmer)' },
+      outputPath: { type: 'string', description: 'Save audio to file path (optional)' }
+    },
+    required: ['text']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const provider = params.provider || config.ttsProvider || 'elevenlabs';
+      const outputPath = params.outputPath;
+
+      if (provider === 'elevenlabs') {
+        const apiKey = params.apiKey || config.elevenlabsApiKey || process.env.ELEVENLABS_API_KEY;
+        if (!apiKey) {
+          return { success: false, error: 'ElevenLabs API key gerekli.\nKur: natureco config set elevenlabsApiKey <key>' };
+        }
+
+        const voice = params.voice || config.elevenlabsVoice || '21m00Tcm4TlvDq8ikWAM';
+        const response = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voice}`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'xi-api-key': apiKey },
+          body: JSON.stringify({
+            text: params.text,
+            model_id: 'eleven_monolingual_v1',
+            voice_settings: { stability: 0.5, similarity_boost: 0.5 }
+          })
+        });
+
+        if (!response.ok) throw new Error(`ElevenLabs error ${response.status}`);
+
+        const audioBuffer = await response.arrayBuffer();
+        if (outputPath) {
+          require('fs').writeFileSync(outputPath, Buffer.from(audioBuffer));
+          return { success: true, provider: 'elevenlabs', outputPath, size: audioBuffer.byteLength };
+        }
+
+        return {
+          success: true,
+          provider: 'elevenlabs',
+          audioData: Buffer.from(audioBuffer).toString('base64'),
+          format: 'mp3',
+          message: 'Audio generated. Use outputPath to save to file.'
+        };
+      }
+
+      if (provider === 'openai') {
+        const apiKey = params.apiKey || config.openaiApiKey || process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+          return { success: false, error: 'OpenAI API key gerekli.' };
+        }
+
+        const voice = params.voice || 'alloy';
+        const response = await fetch('https://api.openai.com/v1/audio/speech', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+          body: JSON.stringify({ model: 'tts-1', input: params.text, voice })
+        });
+
+        if (!response.ok) throw new Error(`OpenAI TTS error ${response.status}`);
+
+        const audioBuffer = await response.arrayBuffer();
+        if (outputPath) {
+          require('fs').writeFileSync(outputPath, Buffer.from(audioBuffer));
+          return { success: true, provider: 'openai', outputPath, size: audioBuffer.byteLength };
+        }
+
+        return {
+          success: true, provider: 'openai',
+          audioData: Buffer.from(audioBuffer).toString('base64'), format: 'mp3'
+        };
+      }
+
+      if (provider === 'local') {
+        const { execSync } = require('child_process');
+        try {
+          execSync('which say || which espeak || which festival', { stdio: 'ignore' });
+        } catch {
+          return { success: false, error: 'Local TTS aracı bulunamadı. macOS: "say", Linux: "espeak"' };
+        }
+
+        const cmd = process.platform === 'darwin'
+          ? `say "${params.text.replace(/"/g, '\\"')}"${outputPath ? ` -o "${outputPath}"` : ''}`
+          : `espeak "${params.text.replace(/"/g, '\\"')}"${outputPath ? ` -w "${outputPath}"` : ''}`;
+
+        execSync(cmd, { timeout: 30000 });
+        return { success: true, provider: 'local', outputPath: outputPath || 'played via speakers', message: 'Text spoken via local TTS' };
+      }
+
+      return { success: false, error: `Unknown provider: ${provider}` };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/thread_ownership.js

@@ -0,0 +1,88 @@
+const { getConfig, saveConfig } = require('../utils/config');
+
+module.exports = {
+  name: 'thread_ownership',
+  description: 'Manage message thread ownership — assign threads to specific agents/bots',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      action: { type: 'string', description: 'Action: assign, release, status, list', enum: ['assign', 'release', 'status', 'list'] },
+      threadId: { type: 'string', description: 'Thread/channel/conversation ID' },
+      agentName: { type: 'string', description: 'Agent name to assign (for assign action)' },
+      channel: { type: 'string', description: 'Channel type: telegram, whatsapp, signal, irc, mattermost, discord, slack' }
+    },
+    required: ['action']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const ownership = config.threadOwnership || {};
+
+      if (params.action === 'list') {
+        const entries = Object.entries(ownership);
+        if (entries.length === 0) {
+          return { success: true, action: 'list', message: 'Atanmış thread yok.', threads: [] };
+        }
+        return {
+          success: true,
+          action: 'list',
+          threads: entries.map(([id, agent]) => ({
+            threadId: id,
+            assignedAgent: agent
+          })),
+          count: entries.length
+        };
+      }
+
+      if (params.action === 'status') {
+        if (!params.threadId) {
+          return { success: false, error: 'threadId gerekli' };
+        }
+        const assigned = ownership[params.threadId];
+        return {
+          success: true,
+          action: 'status',
+          threadId: params.threadId,
+          assignedAgent: assigned || null,
+          isAssigned: !!assigned
+        };
+      }
+
+      if (params.action === 'assign') {
+        if (!params.threadId || !params.agentName) {
+          return { success: false, error: 'threadId ve agentName gerekli' };
+        }
+        ownership[params.threadId] = params.agentName;
+        config.threadOwnership = ownership;
+        saveConfig(config);
+        return {
+          success: true,
+          action: 'assign',
+          threadId: params.threadId,
+          agentName: params.agentName,
+          message: `Thread ${params.threadId} → ${params.agentName}`
+        };
+      }
+
+      if (params.action === 'release') {
+        if (!params.threadId) {
+          return { success: false, error: 'threadId gerekli' };
+        }
+        delete ownership[params.threadId];
+        config.threadOwnership = ownership;
+        saveConfig(config);
+        return {
+          success: true,
+          action: 'release',
+          threadId: params.threadId,
+          message: `Thread ${params.threadId} serbest bırakıldı`
+        };
+      }
+
+      return { success: false, error: `Bilinmeyen aksiyon: ${params.action}` };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/video_generation.js

@@ -0,0 +1,72 @@
+const { getConfig } = require('../utils/config');
+
+const PROVIDERS = {
+  runway: {
+    name: 'RunwayML',
+    async generate({ prompt, apiKey, model }) {
+      const response = await fetch('https://api.runwayml.com/v1/text_to_video', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        body: JSON.stringify({
+          model: model || 'gen3a_turbo',
+          prompt_text: prompt,
+          prompt_image: null,
+          duration: 5
+        })
+      });
+      if (!response.ok) throw new Error(`Runway error ${response.status}: ${await response.text()}`);
+      const data = await response.json();
+      return [{ url: data.video?.url || data.url, id: data.id }];
+    }
+  }
+};
+
+module.exports = {
+  name: 'video_generation',
+  description: 'Generate videos using AI. Supports RunwayML provider.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      prompt: { type: 'string', description: 'Text description of the video to generate' },
+      provider: { type: 'string', description: 'Video provider: runway (default: runway)', enum: ['runway'] },
+      model: { type: 'string', description: 'Model override (default: gen3a_turbo)' }
+    },
+    required: ['prompt']
+  },
+
+  async execute(params) {
+    try {
+      const config = getConfig();
+      const provider = params.provider || 'runway';
+
+      const providerConfig = PROVIDERS[provider];
+      if (!providerConfig) {
+        return { success: false, error: `Desteklenmeyen provider: ${provider}` };
+      }
+
+      const apiKey = params.apiKey || config.runwayApiKey || process.env.RUNWAY_API_KEY;
+      if (!apiKey) {
+        return {
+          success: false,
+          error: `${providerConfig.name} API key gerekli.\nKur: natureco config set runwayApiKey <key>`
+        };
+      }
+
+      const videos = await providerConfig.generate({
+        prompt: params.prompt,
+        apiKey,
+        model: params.model
+      });
+
+      return {
+        success: true,
+        prompt: params.prompt,
+        provider,
+        videos,
+        count: videos.length
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/tools/web_readability.js

@@ -0,0 +1,104 @@
+const { getConfig } = require('../utils/config');
+
+module.exports = {
+  name: 'web_readability',
+  description: 'Extract readable content from any web page (Mozilla Readability algorithm, no API key needed)',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      url: { type: 'string', description: 'URL to extract readable content from' },
+      maxChars: { type: 'number', description: 'Maximum characters to return (default: 10000)', default: 10000 }
+    },
+    required: ['url']
+  },
+
+  async execute(params) {
+    try {
+      const maxChars = params.maxChars || 10000;
+
+      const response = await fetch(params.url, {
+        headers: { 'User-Agent': 'Mozilla/5.0 (compatible; NatureCo-CLI/2.0; +https://natureco.me)' },
+        signal: AbortSignal.timeout(15000)
+      });
+
+      if (!response.ok) {
+        return { success: false, error: `HTTP ${response.status}: ${response.statusText}` };
+      }
+
+      const html = await response.text();
+      const contentType = response.headers.get('content-type') || '';
+      const isHtml = contentType.includes('text/html') || contentType.includes('text/plain') || html.trim().startsWith('<');
+
+      if (!isHtml) {
+        return { success: false, error: 'URL does not contain HTML content' };
+      }
+
+      // Extract title
+      const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+      const title = titleMatch ? titleMatch[1].trim() : '';
+
+      // Extract meta description
+      const descMatch = html.match(/<meta[^>]+name=["']description["'][^>]+content=["']([^"']*)["']/i);
+      const description = descMatch ? descMatch[1] : '';
+
+      // Strip HTML tags for readable text
+      let text = html
+        // Remove scripts and styles
+        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, ' ')
+        .replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, ' ')
+        .replace(/<header[^>]*>[\s\S]*?<\/header>/gi, ' ')
+        // Remove all HTML tags
+        .replace(/<[^>]+>/g, ' ')
+        // Decode HTML entities
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#x27;/g, "'")
+        .replace(/&#x2F;/g, '/')
+        .replace(/&#\d+;/g, ' ')
+        // Normalize whitespace
+        .replace(/&nbsp;/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+
+      // Extract meaningful paragraphs
+      const paragraphs = [];
+      const pRegex = /<p[^>]*>([\s\S]*?)<\/p>/gi;
+      let pMatch;
+      while ((pMatch = pRegex.exec(html)) !== null) {
+        const pText = pMatch[1]
+          .replace(/<[^>]+>/g, '')
+          .replace(/&nbsp;/g, ' ')
+          .replace(/\s+/g, ' ')
+          .trim();
+        if (pText.length > 20) paragraphs.push(pText);
+      }
+
+      // Prefer paragraph extraction, fall back to full text
+      const content = paragraphs.length > 0
+        ? paragraphs.join('\n\n')
+        : text;
+
+      const truncated = content.length > maxChars
+        ? content.slice(0, maxChars) + '...'
+        : content;
+
+      return {
+        success: true,
+        url: params.url,
+        title,
+        description,
+        content: truncated,
+        wordCount: content.split(/\s+/).length,
+        totalChars: content.length,
+        truncated: content.length > maxChars,
+        source: 'readability'
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+};

package/src/utils/api.js

@@ -317,8 +317,6 @@ function encodeToolResult(toolResult) {
     content = toolResult;
   } else if (toolResult.output) {
     content = toolResult.output;
-  /* DEAD CODE */ } else if (toolResult.data) {
-    content = JSON.stringify(toolResult.data); /* DEAD CODE */
   } else if (toolResult.success !== undefined) {
     // Handle { success: true/false, output/error: ... } format
     content = toolResult.success ? (toolResult.output || JSON.stringify(toolResult)) : (toolResult.error || 'Unknown error');
@@ -429,9 +427,7 @@ function formatToolsForAnthropic() {
  */
 async function sendMessageOpenAICompatible(providerConfig, messages, tools) {
   const baseUrl = providerConfig.url.replace(/\/+$/, '');
-  const endpoint = baseUrl.includes('api.natureco.me')
-    ? 'https://api.natureco.me/api/v1/chat/completions'
-    : `${baseUrl}/chat/completions`;
+  const endpoint = `${baseUrl}/chat/completions`;
   const requestBody = {
     model: providerConfig.model,
     messages: messages,
@@ -859,16 +855,8 @@ async function getBots(apiKey) {
       }
     } catch (e) {
       debugLog('[getBots] NatureCo API error:', e.message);
+      return { bots: [], error: e.message };
     }
-    // Fallback — API'den bot gelmezse universal provider döndür
-    return {
-      bots: [{
-        id: 'universal-provider',
-        name: 'Universal Provider (NatureCo)',
-        ai_provider: 'natureco',
-        model: 'natureco-default',
-      }]
-    };
   }
 
   // Diğer provider'lar — universal provider döndür
@@ -889,9 +877,6 @@ async function getBots(apiKey) {
 // ── Streaming Support ────────────────────────────────────────────────────────────
 
 async function streamProviderCompletion(providerConfig, messages, tools) {
-  if (providerConfig.url.includes('api.natureco.me')) {
-    return sendMessageOpenAICompatible(providerConfig, messages, tools);
-  }
   if (providerConfig.isAnthropic) {
     return streamAnthropicCompletion(providerConfig, messages);
   }
@@ -900,9 +885,7 @@ async function streamProviderCompletion(providerConfig, messages, tools) {
 
 async function streamOpenAICompletion(providerConfig, messages, tools) {
   const baseUrl = providerConfig.url.replace(/\/+$/, '');
-  const endpoint = baseUrl.includes('api.natureco.me')
-    ? 'https://api.natureco.me/api/v1/chat/completions'
-    : `${baseUrl}/chat/completions`;
+  const endpoint = `${baseUrl}/chat/completions`;
 
   const requestBody = {
     model: providerConfig.model,