natureco-cli 2.23.30 → 2.23.32

package/src/utils/agents-md.js

@@ -0,0 +1,85 @@
+const fs = require('fs');
+const path = require('path');
+
+const cache = new Map();
+
+const AGENTS_MD_FILENAMES = [
+  'AGENTS.md',
+  '.natureco/AGENTS.md',
+  '.natureco/INSTRUCTIONS.md',
+];
+
+function isRoot(dir) {
+  const parsed = path.parse(dir);
+  return parsed.root === dir;
+}
+
+function hasGit(dir) {
+  return fs.existsSync(path.join(dir, '.git'));
+}
+
+function findAgentsMd(cwd) {
+  let current = path.resolve(cwd || process.cwd());
+
+  while (true) {
+    for (const relPath of AGENTS_MD_FILENAMES) {
+      const candidate = path.join(current, relPath);
+      if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+        return candidate;
+      }
+    }
+
+    if (isRoot(current) || hasGit(current)) {
+      break;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+
+  return null;
+}
+
+function loadInstructions(cwd) {
+  const resolvedCwd = path.resolve(cwd || process.cwd());
+
+  if (cache.has(resolvedCwd)) {
+    return cache.get(resolvedCwd);
+  }
+
+  const filePath = findAgentsMd(resolvedCwd);
+  if (!filePath) {
+    cache.set(resolvedCwd, null);
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    cache.set(resolvedCwd, content);
+    return content;
+  } catch {
+    cache.set(resolvedCwd, null);
+    return null;
+  }
+}
+
+function injectIntoPrompt(systemPrompt, cwd) {
+  const instructions = loadInstructions(cwd);
+  if (!instructions) {
+    return systemPrompt;
+  }
+
+  const header = '\n\n## Project Instructions (from AGENTS.md)\n\n';
+  return systemPrompt + header + instructions.trim();
+}
+
+function clearCache() {
+  cache.clear();
+}
+
+module.exports = {
+  loadInstructions,
+  injectIntoPrompt,
+  clearCache,
+};

package/src/utils/api.js

@@ -8,6 +8,7 @@ const chalk = require('chalk');
 const { getConfig } = require('./config');
 const { getToolDefinitions, executeToolCalls } = require('./tool-runner');
 const { MCPClient } = require('./mcp-client');
+const TB = require('./token-budget');
 
 // Persistent conversation directory
 const CONV_DIR = path.join(os.homedir(), '.natureco', 'conversations');
@@ -60,7 +61,7 @@ function saveConversation(convId, messages) {
   try {
     fs.mkdirSync(CONV_DIR, { recursive: true });
     // Keep only last 10 messages
-    fs.writeFileSync(file, JSON.stringify(messages.slice(-10), null, 2));
+    fs.writeFileSync(file, JSON.stringify(messages.slice(-(TB.load().conversationOnDisk)), null, 2));
   } catch (e) {
     // Silently fail
   }
@@ -188,7 +189,7 @@ function normalizeMcpToolSchema(tool) {
 function minimizeMcpTool(tool) {
   return {
     name: tool.name,
-    description: (tool.description || '').slice(0, 100),
+    description: TB.capMcpDesc(tool.description),
     inputSchema: {
       type: tool.inputSchema?.type || 'object',
       properties: Object.fromEntries(
@@ -265,9 +266,10 @@ async function executeMcpTool(toolName, toolArgs) {
           if (textContents.length > 0) {
             let output = textContents.join('\n');
             
-            // Truncate MCP result to max 1500 characters
-            if (output.length > 1500) {
-              output = output.slice(0, 1500) + '... (truncated)';
+            // Truncate MCP result
+            const maxChars = TB.load().toolMaxChars;
+            if (output.length > maxChars) {
+              output = output.slice(0, maxChars) + '... (truncated)';
             }
             
             return {
@@ -281,8 +283,9 @@ async function executeMcpTool(toolName, toolArgs) {
         let fallbackOutput = JSON.stringify(result, null, 2);
         
         // Truncate fallback output too
-        if (fallbackOutput.length > 1500) {
-          fallbackOutput = fallbackOutput.slice(0, 1500) + '... (truncated)';
+        const maxChars = TB.load().toolMaxChars;
+        if (fallbackOutput.length > maxChars) {
+          fallbackOutput = fallbackOutput.slice(0, maxChars) + '... (truncated)';
         }
         
         return {
@@ -467,6 +470,7 @@ async function sendMessageOpenAICompatible(providerConfig, messages, tools) {
     role: 'assistant',
     content,
     tool_calls: data.choices?.[0]?.message?.tool_calls || undefined,
+    usage: data.usage || undefined,
   };
 }
 
@@ -519,7 +523,8 @@ async function sendMessageAnthropic(providerConfig, messages, tools) {
   return {
     role: 'assistant',
     content: content,
-    tool_calls: toolCalls.length > 0 ? toolCalls : undefined
+    tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+    usage: data.usage || undefined,
   };
 }
 
@@ -548,18 +553,22 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
   const convId = conversationId || generateDefaultConvId();
   const history = loadConversation(convId);
 
+  // Augment system prompt with project AGENTS.md instructions
+  const agentsMd = require('./agents-md');
+  const augmentedPrompt = agentsMd.injectIntoPrompt(systemPrompt || '', options?.cwd || process.cwd());
+
   // Build messages
-  const messages = [];
-  if (systemPrompt) {
-    messages.push({ role: 'system', content: systemPrompt });
+  let messages = [];
+  if (augmentedPrompt) {
+    messages.push({ role: 'system', content: augmentedPrompt });
   }
   messages.push(...history);
   messages.push({ role: 'user', content: message });
 
-  // Get tool definitions (local + MCP)
-  const tools = providerConfig.isAnthropic 
-    ? formatToolsForAnthropic() 
-    : formatToolsForOpenAI();
+  // Get tool definitions (local + MCP) — skip if noTools flag set (chat mode)
+  const tools = options.noTools 
+    ? [] 
+    : (providerConfig.isAnthropic ? formatToolsForAnthropic() : formatToolsForOpenAI());
 
   debugLog('\n[Provider] Sending request...');
   debugLog('[Provider] URL:', providerConfig.url);
@@ -572,7 +581,7 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
   let iteration = 0;
   const maxIterations = 10;
   let finalResponse = null;
-  const stream = options.stream !== false && 
+  const stream = (options.stream ?? options.noStream === undefined) !== false && 
     !providerConfig.url.includes('api.natureco.me');
 
   while (iteration < maxIterations) {
@@ -604,6 +613,14 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
       };
     }
 
+    // Track token usage if available
+    if (assistantMessage.usage) {
+      TB.trackUsage(convId, {
+        input: assistantMessage.usage.prompt_tokens || assistantMessage.usage.input_tokens || 0,
+        output: assistantMessage.usage.completion_tokens || assistantMessage.usage.output_tokens || 0
+      });
+    }
+
     debugLog('[Provider] Response type:', assistantMessage?.tool_calls ? 'tool_calls' : 'text');
 
     // Add assistant message to history
@@ -681,6 +698,9 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
     finalResponse = finalResponse || 'Max tool execution iterations reached.';
   }
 
+  // Apply token budget trimming
+  messages = TB.trimMessages(messages);
+
   // Save to conversation history (only user and final assistant message)
   history.push({ role: 'user', content: message });
   history.push({ role: 'assistant', content: finalResponse });
@@ -755,35 +775,14 @@ async function sendMessage(apiKey, botId, message, conversationId = null, chatSy
     return sendMessageToProvider(apiKey, message, conversationId, prompt, options);
   }
 
-  // Base system prompt — kısa (~3000 token max)
+  // Minimal base prompt (~200 token)
   const toolDefs = getToolDefinitions();
   const toolsDesc = toolDefs.map(t => t.name).join(', ');
-  let baseSystemPrompt = `Terminal assistant. Use tools when needed.
-Home: ${homeDir}
-Tools: ${toolsDesc}`;
+  let systemPrompt = `Assistant. Tools: ${toolsDesc}. Home: ${homeDir}.`;
 
-  // MCP sayı parametresi uyarısı — sadece MCP aktifse
-  if (config.mcpEnabled !== false) {
-    baseSystemPrompt += `\nMCP: send number params as numbers, not strings.`;
-  }
-
-  // Prepend botName
-  if (mem.botName) {
-    baseSystemPrompt = `Adın ${mem.botName}. Sen ${mem.botName}'sun. Adın sorulduğunda her zaman "${mem.botName}" de.\n\n` + baseSystemPrompt;
-  }
-
-  let systemPrompt = baseSystemPrompt;
-
-  // Append chat.js system prompt (memory + skills + agents) — max 3000 chars
+  // Skill prompts only, max 500 chars
   if (chatSystemPrompt) {
-    systemPrompt += '\n\n' + chatSystemPrompt.slice(0, 3000);
-  }
-
-  // Add MCP server names if enabled and loaded
-  const mcpTools = getMcpTools();
-  if (config.mcpEnabled !== false && mcpTools.length > 0) {
-    const mcpServerNames = Object.keys(mcpClients);
-    systemPrompt += `\n\nMCP SERVERS: ${mcpServerNames.join(', ')}`;
+    systemPrompt += '\n' + chatSystemPrompt.slice(0, TB.load().systemPromptMaxChars);
   }
   
   return sendMessageToProvider(apiKey, message, conversationId, systemPrompt, options);

package/src/utils/format.js

@@ -0,0 +1,144 @@
+const chalk = require('chalk');
+
+const W = () => Math.min(process.stdout.columns || 100, 100);
+
+function header(text) {
+  const w = W();
+  const line = chalk.dim('┌' + '─'.repeat(w - 2) + '┐');
+  const padding = Math.max(0, w - text.length - 4);
+  const leftPad = Math.floor(padding / 2);
+  const rightPad = padding - leftPad;
+  console.log('');
+  console.log(line);
+  console.log(chalk.dim('│') + ' '.repeat(leftPad) + chalk.bold.cyan(text) + ' '.repeat(rightPad) + chalk.dim('│'));
+  console.log(chalk.dim('└' + '─'.repeat(w - 2) + '┘'));
+}
+
+function section(text) {
+  const w = W();
+  console.log('');
+  console.log(chalk.dim('▔').repeat(Math.min(w - 4, 48)));
+  console.log(chalk.bold.cyan('  ' + text));
+}
+
+function divider() {
+  const w = W();
+  console.log(chalk.dim('─').repeat(Math.min(w - 4, 48)));
+}
+
+function label(key, value, options = {}) {
+  const { indent = 2, keyWidth = 14, valueColor = 'white' } = options;
+  const pad = ' '.repeat(indent);
+  const coloredKey = chalk.dim(key.padEnd(keyWidth));
+  const coloredValue = chalk[valueColor] ? chalk[valueColor](value) : chalk.white(value);
+  console.log(pad + coloredKey + coloredValue);
+}
+
+function kv(key, value) {
+  if (value === undefined || value === null) value = chalk.dim('—');
+  const keyStr = chalk.dim(key.padEnd(14));
+  console.log('  ' + keyStr + chalk.white(value));
+}
+
+function badge(text, color = 'cyan') {
+  const c = chalk[color] || chalk.cyan;
+  return c.bold(' ' + text + ' ');
+}
+
+function cmd(text) {
+  return chalk.cyan(text);
+}
+
+function flag(text) {
+  return chalk.yellow(text);
+}
+
+function success(text) {
+  console.log(chalk.green('  ✓ ' + text));
+}
+
+function error(text) {
+  console.log(chalk.red('  ✗ ' + text));
+}
+
+function warning(text) {
+  console.log(chalk.yellow('  ⚠ ' + text));
+}
+
+function info(text) {
+  console.log(chalk.blue('  ℹ ' + text));
+}
+
+function list(items, options = {}) {
+  const { indent = 2, bullet = '•' } = options;
+  const pad = ' '.repeat(indent);
+  for (const item of items) {
+    if (typeof item === 'string') {
+      console.log(pad + chalk.dim(bullet + ' ') + chalk.white(item));
+    } else if (item.label && item.value) {
+      console.log(pad + chalk.dim(bullet + ' ') + chalk.white(item.label + ': ') + chalk.dim(item.value));
+    } else if (item.label) {
+      console.log(pad + chalk.dim(bullet + ' ') + chalk.white(item.label));
+      if (item.desc) console.log(pad + '  ' + chalk.dim(item.desc));
+    }
+  }
+}
+
+function table(headers, rows, options = {}) {
+  const { indent = 2, headerColor = 'bold.cyan' } = options;
+  const pad = ' '.repeat(indent);
+
+  if (rows.length === 0) {
+    console.log(pad + chalk.dim('(empty)'));
+    return;
+  }
+
+  const colCount = headers.length;
+  const colWidths = headers.map((h, i) => {
+    const maxData = rows.reduce((max, row) => Math.max(max, String(row[i] || '').length), 0);
+    return Math.max(h.length, maxData) + 2;
+  });
+
+  const totalWidth = colWidths.reduce((a, b) => a + b, 0) + colCount - 1;
+  if (totalWidth > W() - indent) {
+    const ratio = (W() - indent - colCount + 1) / (totalWidth - colCount + 1);
+    for (let i = 0; i < colWidths.length; i++) {
+      colWidths[i] = Math.max(3, Math.floor((colWidths[i] - 2) * ratio) + 2);
+    }
+  }
+
+  const hdr = headers.map((h, i) => {
+    const w = colWidths[i];
+    const text = h.length > w - 1 ? h.slice(0, w - 2) + '…' : h.padEnd(w);
+    return chalk.bold.cyan(text);
+  }).join(' ');
+  console.log(pad + chalk.dim('┌' + '─'.repeat(totalWidth) + '┐'));
+  console.log(pad + chalk.dim('│') + hdr + chalk.dim('│'));
+  console.log(pad + chalk.dim('├' + '─'.repeat(totalWidth) + '┤'));
+
+  for (const row of rows) {
+    const cells = row.map((cell, i) => {
+      const w = colWidths[i];
+      const text = String(cell || '');
+      return (text.length > w - 1 ? text.slice(0, w - 2) + '…' : text.padEnd(w));
+    }).join(' ');
+    console.log(pad + chalk.dim('│') + cells + chalk.dim('│'));
+  }
+
+  console.log(pad + chalk.dim('└' + '─'.repeat(totalWidth) + '┘'));
+}
+
+function dot(enabled, label) {
+  const d = enabled ? chalk.green('●') : chalk.dim('○');
+  console.log('  ' + d + ' ' + chalk.white(label));
+}
+
+function meta(text) {
+  console.log(chalk.dim('  ' + text));
+}
+
+function json(obj) {
+  console.log(chalk.dim('  ') + chalk.white(JSON.stringify(obj, null, 2).replace(/\n/g, '\n  ')));
+}
+
+module.exports = { header, section, divider, label, kv, badge, cmd, flag, success, error, warning, info, list, table, dot, meta, json };

package/src/utils/headless.js

@@ -6,6 +6,7 @@
 const fs = require('fs');
 const path = require('path');
 const { getProviderConfig } = require('./config');
+const TB = require('./token-budget');
 const { getToolDefinitions, executeTool } = require('./tool-runner');
 
 // ── Proje indexing (code.js'den paylaşılan) ───────────────────────────────────
@@ -169,7 +170,7 @@ Dosyalar: ${projectIndex.files.slice(0, 25).join(', ')}`;
         role: 'tool',
         tool_call_id: assistantMsg.tool_calls?.find(tc => tc.function.name === toolCall.name)?.id || toolCall.id,
         name: toolCall.name,
-        content: resultStr.slice(0, 3000),
+        content: resultStr.slice(0, TB.load().toolMaxChars),
       });
     }
   }

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