natureco-cli 2.23.29 → 2.23.30

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/memory.js

@@ -282,11 +282,211 @@ function clearMemory(botId) {
   }
 }
 
+// ── Memory Wiki (structured pages) ──────────────────────────────────────────────
+
+const MEMORY_WIKI_DIR = path.join(CONFIG_DIR, 'memory-wiki');
+
+function ensureWikiDir() {
+  if (!fs.existsSync(MEMORY_WIKI_DIR)) {
+    fs.mkdirSync(MEMORY_WIKI_DIR, { recursive: true });
+  }
+}
+
+function getWikiPage(slug) {
+  ensureWikiDir();
+  const file = path.join(MEMORY_WIKI_DIR, `${slug.replace(/[^a-z0-9_-]/gi, '_')}.json`);
+  if (!fs.existsSync(file)) return null;
+  try { return JSON.parse(fs.readFileSync(file, 'utf-8')); } catch { return null; }
+}
+
+function saveWikiPage(slug, content) {
+  ensureWikiDir();
+  const file = path.join(MEMORY_WIKI_DIR, `${slug.replace(/[^a-z0-9_-]/gi, '_')}.json`);
+  fs.writeFileSync(file, JSON.stringify({ slug, content, updatedAt: new Date().toISOString() }, null, 2));
+}
+
+function listWikiPages() {
+  ensureWikiDir();
+  return fs.readdirSync(MEMORY_WIKI_DIR)
+    .filter(f => f.endsWith('.json'))
+    .map(f => {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(MEMORY_WIKI_DIR, f), 'utf-8'));
+        return { slug: data.slug || f.replace('.json', ''), content: data.content || '', updatedAt: data.updatedAt };
+      } catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+function searchWikiPages(query) {
+  const pages = listWikiPages();
+  const q = query.toLowerCase();
+  return pages.filter(p =>
+    p.slug.toLowerCase().includes(q) ||
+    p.content.toLowerCase().includes(q)
+  );
+}
+
+// ── Semantic Memory Search ─────────────────────────────────────────────────────
+
+function semanticSearchMemory(query, limit = 5) {
+  const results = [];
+  const q = query.toLowerCase();
+
+  if (!fs.existsSync(MEMORY_DIR)) return results;
+
+  const files = fs.readdirSync(MEMORY_DIR).filter(f => f.endsWith('.json'));
+  for (const file of files) {
+    const botId = file.replace('.json', '');
+    const mem = loadMemory(botId);
+
+    // Score each fact by relevance
+    const scored = (mem.facts || [])
+      .map(f => {
+        const val = typeof f === 'string' ? f : f.value || '';
+        const words = q.split(/\s+/).filter(Boolean);
+        const matches = words.filter(w => val.toLowerCase().includes(w)).length;
+        const score = words.length > 0 ? matches / words.length : 0;
+        const boost = typeof f === 'object' ? (f.score || 5) / 10 : 0.5;
+        return { bot: mem.botName || botId, value: val, score: score * 0.7 + boost * 0.3 };
+      })
+      .filter(f => f.score > 0.1)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, limit);
+
+    results.push(...scored);
+  }
+
+  return results.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+
+// ── Memory Categories ──────────────────────────────────────────────────────────
+
+const MEMORY_CATEGORIES = {
+  personal: { label: 'Kişisel Bilgiler', icon: '👤' },
+  work: { label: 'İş/Okul', icon: '💼' },
+  preferences: { label: 'Tercihler', icon: '⭐' },
+  health: { label: 'Sağlık', icon: '❤️' },
+  social: { label: 'Sosyal', icon: '👥' },
+  goals: { label: 'Hedefler', icon: '🎯' },
+  projects: { label: 'Projeler', icon: '📁' },
+  general: { label: 'Genel', icon: '📝' }
+};
+
+function addMemoryEntryWithCategory(botId, key, value, category = 'general') {
+  const memory = loadMemory(botId);
+  const now = new Date().toISOString();
+  const validCategory = MEMORY_CATEGORIES[category] ? category : 'general';
+
+  if (key === 'name') { memory.name = value; }
+  else if (key === 'nickname') { memory.nickname = value; }
+  else if (key === 'botName') { memory.botName = value; }
+  else if (key === 'preference') {
+    const existing = memory.preferences.find(p => p.value.toLowerCase() === value.toLowerCase());
+    if (existing) {
+      existing.score = Math.min(existing.score + 1, 10);
+      existing.updatedAt = now;
+    } else {
+      memory.preferences.push({ value, score: 5, updatedAt: now, category: validCategory });
+    }
+  } else {
+    const existing = memory.facts.find(f => f.value.toLowerCase() === value.toLowerCase());
+    if (existing) {
+      existing.score = Math.min(existing.score + 1, 10);
+      existing.updatedAt = now;
+      if (!existing.category) existing.category = validCategory;
+    } else {
+      memory.facts.push({ value, score: 5, updatedAt: now, category: validCategory });
+    }
+  }
+
+  // Decay old entries
+  const sixMonthsAgo = new Date();
+  sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 6);
+
+  memory.preferences = memory.preferences.map(p => {
+    const age = new Date(p.updatedAt);
+    if (age < sixMonthsAgo) p.score = Math.max(p.score - 1, 1);
+    return p;
+  }).filter(p => p.score > 0);
+
+  memory.facts = memory.facts.map(f => {
+    const age = new Date(f.updatedAt);
+    if (age < sixMonthsAgo) f.score = Math.max(f.score - 1, 1);
+    return f;
+  }).filter(f => f.score > 0);
+
+  saveMemory(botId, memory);
+}
+
+// ── Memory Import/Export ───────────────────────────────────────────────────────
+
+function exportMemory(botId) {
+  return loadMemory(botId);
+}
+
+function importMemory(botId, data) {
+  const current = loadMemory(botId);
+  const merged = {
+    name: data.name || current.name,
+    nickname: data.nickname || current.nickname,
+    botName: data.botName || current.botName,
+    preferences: [...(current.preferences || []), ...(data.preferences || [])],
+    facts: [...(current.facts || []), ...(data.facts || [])],
+    lastSeen: current.lastSeen
+  };
+  saveMemory(botId, merged);
+}
+
+// ── Active Memory (pre-prompt injection) ──────────────────────────────────────
+
+function getActiveMemoryPrompt(botId, messageContext = '') {
+  const memory = loadMemory(botId);
+  const facts = memory.facts || [];
+  const prefs = memory.preferences || [];
+
+  if (facts.length === 0 && prefs.length === 0 && !memory.name) return '';
+
+  // Score facts by relevance to current context
+  const contextWords = messageContext.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+  const scored = facts
+    .map(f => {
+      let relevance = 0;
+      if (contextWords.length > 0) {
+        const val = (f.value || '').toLowerCase();
+        relevance = contextWords.filter(w => val.includes(w)).length / contextWords.length;
+      }
+      return { ...f, relevance };
+    })
+    .sort((a, b) => (b.score || 0) + b.relevance - (a.score || 0) - a.relevance)
+    .slice(0, 5);
+
+  const parts = [];
+  if (memory.name) parts.push(`👤 ${memory.name}`);
+  if (memory.nickname) parts.push(`🏷 ${memory.nickname}`);
+  if (scored.length > 0) {
+    parts.push('📌 ' + scored.map(f => f.value).join(' | '));
+  }
+
+  return parts.length > 0 ? `<active_memory>\n${parts.join('\n')}\n</active_memory>` : '';
+}
+
 module.exports = {
   loadMemory,
   saveMemory,
   addMemoryEntry,
+  addMemoryEntryWithCategory,
   extractMemoryFromMessage,
   getMemoryPrompt,
+  getActiveMemoryPrompt,
   clearMemory,
+  semanticSearchMemory,
+  exportMemory,
+  importMemory,
+  // Wiki
+  getWikiPage,
+  saveWikiPage,
+  listWikiPages,
+  searchWikiPages,
+  MEMORY_CATEGORIES,
 };