natureco-cli 2.23.29 → 2.23.31

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,
 };

package/src/utils/parallel-tools.js

@@ -0,0 +1,106 @@
+// Parallel Tool Runner — run multiple independent tool/MCP calls in parallel
+
+async function executeSingle(tool, options = {}) {
+  const { type, name, params } = tool;
+  const executeTool = options.executeTool || defaultExecuteTool;
+
+  if (type === 'mcp') {
+    return executeMcpCall(tool, options);
+  }
+  if (type === 'function') {
+    return executeTool(name, params);
+  }
+  throw new Error(`Unknown tool type: ${type}`);
+}
+
+async function defaultExecuteTool(toolName, params) {
+  const { executeTool } = require('./tool-runner');
+  return executeTool(toolName, params);
+}
+
+async function executeMcpCall(tool, options = {}) {
+  const { name, params } = tool;
+  const getClient = options.getMcpClient;
+
+  if (!getClient) {
+    return { success: false, error: 'No MCP client lookup provided (options.getMcpClient)' };
+  }
+
+  const client = getClient(name);
+  if (!client) {
+    return { success: false, error: `MCP client not found for tool: ${name}` };
+  }
+
+  try {
+    const result = await client.callTool(name, params);
+    if (result.content && result.content.length > 0) {
+      const textContents = result.content
+        .filter(c => c.type === 'text')
+        .map(c => c.text);
+      if (textContents.length > 0) {
+        return { success: true, output: textContents.join('\n') };
+      }
+    }
+    return { success: true, output: JSON.stringify(result, null, 2) };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+// Run multiple independent tool calls in parallel
+// tools: [{ name, params, type: 'mcp' | 'function' }]
+async function runParallel(tools, options = {}) {
+  if (!tools || tools.length === 0) return [];
+
+  const results = await Promise.allSettled(
+    tools.map(t => executeSingle(t, options))
+  );
+
+  return results.map((r, i) => ({
+    tool: tools[i].name,
+    status: r.status === 'fulfilled' ? 'success' : 'error',
+    result: r.status === 'fulfilled' ? r.value : r.reason.message,
+  }));
+}
+
+// Group tool calls by independence
+// dependencyMap: { inputKeys?: string[], outputKeys?: string[] }
+// Tools that don't share input/output keys are independent
+function groupIndependent(tools, dependencyMap = {}) {
+  if (!tools || tools.length === 0) return [];
+
+  const maps = tools.map(t => ({
+    tool: t,
+    inputs: dependencyMap[t.name]?.inputKeys || Object.keys(t.params || {}),
+    outputs: dependencyMap[t.name]?.outputKeys || [],
+  }));
+
+  const groups = [];
+
+  for (const item of maps) {
+    const allKeys = [...item.inputs, ...item.outputs];
+    let placed = false;
+
+    for (const group of groups) {
+      const overlap = allKeys.some(k => group.keys.includes(k));
+      if (!overlap) {
+        group.items.push(item.tool);
+        group.keys.push(...allKeys);
+        placed = true;
+        break;
+      }
+    }
+
+    if (!placed) {
+      groups.push({ items: [item.tool], keys: allKeys });
+    }
+  }
+
+  return groups.map(g => g.items);
+}
+
+module.exports = {
+  executeSingle,
+  runParallel,
+  groupIndependent,
+};

package/src/utils/sub-agent.js

@@ -0,0 +1,148 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { getProviderConfig } = require('./api');
+
+const SUB_AGENTS_FILE = path.join(os.homedir(), '.natureco', 'sub-agents.json');
+
+const SYSTEM_PROMPTS = {
+  explore: 'You are a research agent. Find information, explore codebases, search files. Be concise.',
+  general: 'You are a general-purpose implementation agent. Write code, fix bugs, refactor.',
+  review: 'You are a code review agent. Analyze code for bugs, security, performance, style.',
+};
+
+function ensureDir() {
+  const dir = path.dirname(SUB_AGENTS_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function loadAgents() {
+  ensureDir();
+  if (!fs.existsSync(SUB_AGENTS_FILE)) return [];
+  try {
+    return JSON.parse(fs.readFileSync(SUB_AGENTS_FILE, 'utf8'));
+  } catch {
+    return [];
+  }
+}
+
+function saveAgents(agents) {
+  ensureDir();
+  fs.writeFileSync(SUB_AGENTS_FILE, JSON.stringify(agents, null, 2), 'utf8');
+}
+
+function generateId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
+}
+
+async function spawnSubAgent(type, task, options = {}) {
+  const validTypes = Object.keys(SYSTEM_PROMPTS);
+  if (!validTypes.includes(type)) {
+    throw new Error(`Invalid sub-agent type: ${type}. Valid: ${validTypes.join(', ')}`);
+  }
+
+  console.log(`  [Sub-agent ${type}] Spawned for: ${task.slice(0, 80)}`);
+
+  const entry = {
+    id: generateId(),
+    type,
+    task,
+    status: 'running',
+    result: null,
+    startedAt: new Date().toISOString(),
+    completedAt: null,
+  };
+
+  const agents = loadAgents();
+  agents.push(entry);
+  saveAgents(agents);
+
+  try {
+    const providerConfig = getProviderConfig();
+    if (!providerConfig) {
+      throw new Error('Provider not configured. Run: natureco configure');
+    }
+
+    const systemPrompt = options.systemPrompt || SYSTEM_PROMPTS[type];
+
+    const baseUrl = providerConfig.url.replace(/\/+$/, '');
+    const endpoint = `${baseUrl}/chat/completions`;
+
+    const maxTokens = options.maxTokens || 512;
+
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${providerConfig.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: providerConfig.model,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: task },
+        ],
+        temperature: 0.3,
+        max_tokens: maxTokens,
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Provider API error: ${response.status} - ${errorText}`);
+    }
+
+    const data = await response.json();
+    const content = data.choices?.[0]?.message?.content || data.choices?.[0]?.text || '';
+
+    entry.status = 'completed';
+    entry.result = content;
+    entry.completedAt = new Date().toISOString();
+    saveAgents(loadAgents().map(a => a.id === entry.id ? entry : a));
+
+    const usage = data.usage || {};
+    const duration = new Date(entry.completedAt) - new Date(entry.startedAt);
+
+    return { result: content, usage, duration };
+  } catch (err) {
+    entry.status = 'failed';
+    entry.result = err.message;
+    entry.completedAt = new Date().toISOString();
+    saveAgents(loadAgents().map(a => a.id === entry.id ? entry : a));
+
+    throw err;
+  }
+}
+
+async function spawnParallel(agents) {
+  const promises = agents.map(a =>
+    spawnSubAgent(a.type, a.task, a.options || {}).then(
+      result => ({ status: 'fulfilled', result }),
+      error => ({ status: 'rejected', reason: error.message })
+    )
+  );
+
+  const results = await Promise.allSettled(promises);
+
+  const failed = results.filter(r => r.status === 'rejected');
+  return { results, failed };
+}
+
+function getStatus() {
+  const agents = loadAgents();
+  const last20 = agents.slice(-20).reverse();
+  return {
+    total: agents.length,
+    running: agents.filter(a => a.status === 'running').length,
+    completed: agents.filter(a => a.status === 'completed').length,
+    failed: agents.filter(a => a.status === 'failed').length,
+    agents: last20,
+  };
+}
+
+module.exports = {
+  spawnSubAgent,
+  spawnParallel,
+  getStatus,
+  SYSTEM_PROMPTS,
+};