natureco-cli 5.7.0 → 5.7.2

package/src/utils/process-errors.js

@@ -0,0 +1,115 @@
+/**
+ * Top-level process error handlers.
+ *
+ * Node's default behavior for unhandled rejections is to print a deprecated
+ * warning and (since Node 15) exit with code 1. The default for uncaught
+ * exceptions is to print the stack and exit 1. Both bypass natureco's audit
+ * trail and dump raw Node output that's useless to a CLI user.
+ *
+ * `install({ audit, exit, stderr })` registers handlers that:
+ *   1. Append a structured entry to the audit log (synchronous — the
+ *      process is about to die, async fire-and-forget would race),
+ *   2. Print a single friendly Turkish line + log path to stderr,
+ *   3. Exit with code 1 (configurable via `exit` for tests).
+ *
+ * Idempotent: a second call replaces the previous handlers (so the test
+ * suite can re-install with fresh spies).
+ */
+const path = require('path');
+const os = require('os');
+
+const ERROR_LOG_PATH = path.join(os.homedir(), '.natureco', 'logs', 'crash.log');
+
+let _installed = false;
+let _registered = { rejection: null, exception: null, warning: null };
+
+function _defaultAudit() {
+  try {
+    return require('./audit');
+  } catch {
+    return null;
+  }
+}
+
+function _serializeError(err) {
+  if (!err) return { type: 'unknown', message: 'null' };
+  if (err instanceof Error) {
+    return {
+      type: err.constructor.name,
+      message: err.message,
+      stack: err.stack ? err.stack.split('\n').slice(0, 20).join('\n') : null,
+      code: err.code,
+    };
+  }
+  if (typeof err === 'object') {
+    try { return { type: 'object', message: JSON.stringify(err).slice(0, 1000) }; }
+    catch { return { type: 'object', message: String(err) }; }
+  }
+  return { type: typeof err, message: String(err) };
+}
+
+/**
+ * Install global handlers. Returns an `uninstall()` function.
+ *
+ * @param {{
+ *   audit?: { logSync: Function, ACTIONS?: Record<string,string> } | null,
+ *   exit?: (code: number) => void,
+ *   stderr?: (msg: string) => void,
+ * }} [opts]
+ */
+function install(opts = {}) {
+  const audit = opts.audit === undefined ? _defaultAudit() : opts.audit;
+  const exit = opts.exit || ((code) => process.exit(code));
+  const stderr = opts.stderr || ((msg) => process.stderr.write(msg));
+
+  // Replace any previous handlers (idempotency for tests).
+  if (_registered.rejection) process.off('unhandledRejection', _registered.rejection);
+  if (_registered.exception) process.off('uncaughtException', _registered.exception);
+
+  const onRejection = (reason) => {
+    const payload = { kind: 'unhandledRejection', error: _serializeError(reason) };
+    try { audit?.logSync('error', payload); } catch { /* ignore */ }
+    stderr(
+      `\n  ✗ Beklenmedik bir hata oluştu (unhandled promise rejection).\n` +
+      `    Detay: ${payload.error.message}\n` +
+      `    Log: ${ERROR_LOG_PATH}\n` +
+      `    Hata raporu için: github.com/natureco-official/natureco-cli/issues\n\n`,
+    );
+    exit(1);
+  };
+
+  const onException = (err) => {
+    const payload = { kind: 'uncaughtException', error: _serializeError(err) };
+    try { audit?.logSync('error', payload); } catch { /* ignore */ }
+    stderr(
+      `\n  ✗ Beklenmedik bir hata oluştu (uncaught exception).\n` +
+      `    Detay: ${payload.error.message}\n` +
+      `    Log: ${ERROR_LOG_PATH}\n` +
+      `    Hata raporu için: github.com/natureco-official/natureco-cli/issues\n\n`,
+    );
+    exit(1);
+  };
+
+  process.on('unhandledRejection', onRejection);
+  process.on('uncaughtException', onException);
+  _registered = { rejection: onRejection, exception: onException, warning: null };
+  _installed = true;
+
+  return function uninstall() {
+    if (_registered.rejection) process.off('unhandledRejection', _registered.rejection);
+    if (_registered.exception) process.off('uncaughtException', _registered.exception);
+    _registered = { rejection: null, exception: null, warning: null };
+    _installed = false;
+  };
+}
+
+function isInstalled() {
+  return _installed;
+}
+
+module.exports = {
+  install,
+  isInstalled,
+  ERROR_LOG_PATH,
+  _internals: { _serializeError },
+};

package/src/utils/provider-detect.js

@@ -0,0 +1,78 @@
+/**
+ * Provider detection — single source of truth for "given a base URL
+ * (and optionally a model name) which provider family is this?"
+ *
+ * Previously this logic lived inline in three places:
+ *   - src/utils/api.js  (the canonical detectProvider, exported only
+ *     informally via its module surface)
+ *   - src/commands/setup.js  (string contains checks against minimax /
+ *     anthropic / groq, scattered through the OAuth + test flows)
+ *   - src/utils/api.js  again, with `const isMiniMax = baseUrl.includes(
+ *     'minimax.io') || baseUrl.includes('minimaxi.com') || baseUrl.includes(
+ *     'minimax.cn')` repeated twice (lines 560 + 1017)
+ *
+ * Refactoring opportunity from the v5.7 audit. This module preserves
+ * EXACTLY the same detection rules as the original detectProvider so
+ * the migration is a behavioral no-op verifiable by tests.
+ */
+
+/**
+ * Family of an inference provider.
+ *
+ * @typedef {'openai'|'anthropic'|'groq'|'openrouter'|'deepseek'|'mistral'
+ *           |'together'|'fireworks'|'perplexity'|'ollama'|'minimax'} ProviderName
+ */
+
+/**
+ * @param {string} providerUrl
+ * @param {string} [model]
+ * @returns {ProviderName}
+ */
+function detectProvider(providerUrl, model) {
+  const url = (providerUrl || '').toLowerCase();
+  const m = (model || '').toLowerCase();
+  if (url.includes('anthropic.com') || m.includes('claude')) return 'anthropic';
+  if (url.includes('groq.com') || m.includes('groq') || m.includes('llama-3') || m.includes('mixtral')) return 'groq';
+  if (url.includes('openrouter.ai')) return 'openrouter';
+  if (url.includes('api.deepseek.com') || m.includes('deepseek')) return 'deepseek';
+  if (url.includes('mistral.ai') || m.includes('mistral') || m.includes('codestral')) return 'mistral';
+  if (url.includes('together.xyz') || m.includes('together')) return 'together';
+  if (url.includes('fireworks.ai') || m.includes('fireworks')) return 'fireworks';
+  if (url.includes('perplexity.ai') || m.includes('pplx') || m.includes('sonar')) return 'perplexity';
+  if (url.includes('localhost') || url.includes('127.0.0.1') || url.includes('ollama')) return 'ollama';
+  if (url.includes('minimax.io') || url.includes('minimax')) return 'minimax';
+  return 'openai';
+}
+
+/** Convenience predicates — each one short-circuits on hostname only. */
+function isAnthropic(url) {
+  return (url || '').toLowerCase().includes('anthropic.com');
+}
+
+function isGroq(url) {
+  return (url || '').toLowerCase().includes('groq.com');
+}
+
+/**
+ * MiniMax has three known production hosts:
+ *   api.minimax.io    — global English-facing
+ *   api.minimaxi.com  — China-facing
+ *   api.minimax.cn    — legacy CN domain seen in some auth tokens
+ */
+function isMiniMax(url) {
+  const u = (url || '').toLowerCase();
+  return u.includes('minimax.io') || u.includes('minimaxi.com') || u.includes('minimax.cn');
+}
+
+function isOllama(url) {
+  const u = (url || '').toLowerCase();
+  return u.includes('localhost') || u.includes('127.0.0.1') || u.includes('ollama');
+}
+
+module.exports = {
+  detectProvider,
+  isAnthropic,
+  isGroq,
+  isMiniMax,
+  isOllama,
+};

package/src/utils/sessions.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { writeJsonAtomicSync, readJsonSafeSync } = require('./atomic-file');
 
 // ── Legacy botId-based sessions ─────────────────────────────────────────────────
 
@@ -36,20 +37,12 @@ function createSession(botId, botName) {
 function _saveBotSession(botId, session) {
   ensureSessionsDir(botId);
   const sessionFile = path.join(getSessionsDir(botId), `${session.id}.json`);
-  fs.writeFileSync(sessionFile, JSON.stringify(session, null, 2), 'utf-8');
+  writeJsonAtomicSync(sessionFile, session);
 }
 
 function loadSession(botId, sessionId) {
   const sessionFile = path.join(getSessionsDir(botId), `${sessionId}.json`);
-  if (!fs.existsSync(sessionFile)) {
-    return null;
-  }
-  try {
-    const data = fs.readFileSync(sessionFile, 'utf-8');
-    return JSON.parse(data);
-  } catch {
-    return null;
-  }
+  return readJsonSafeSync(sessionFile, null);
 }
 
 function getLatestSession(botId) {
@@ -110,10 +103,10 @@ function saveSession(commandName, messages, metadata = {}) {
   }
   const id = Date.now().toString(36);
   const filename = path.join(SESSIONS_DIR, `${commandName}-${id}.json`);
-  fs.writeFileSync(filename, JSON.stringify({
+  writeJsonAtomicSync(filename, {
     id, commandName, messages, metadata,
-    savedAt: new Date().toISOString()
-  }, null, 2));
+    savedAt: new Date().toISOString(),
+  });
   return filename;
 }
 

package/src/utils/streaming-tools.js

@@ -0,0 +1,97 @@
+/**
+ * Streaming tool-call delta accumulator.
+ *
+ * OpenAI-compatible providers stream tool calls as a sequence of partial
+ * `delta.tool_calls` chunks. Each chunk carries an `index`, optionally an
+ * `id`, and pieces of `function.name` / `function.arguments` that must be
+ * concatenated per index before the JSON arguments can be parsed.
+ *
+ * Broken (do-not-do) pattern, which crashes on multi-chunk arguments:
+ *
+ *   const tc = delta.tool_calls[0];
+ *   JSON.parse(tc.function.arguments); // SyntaxError on incomplete JSON
+ *
+ * Correct pattern (this module): keep a per-index buffer keyed on `index`,
+ * concat `name` and `arguments` as strings, JSON-parse only after `[DONE]`.
+ *
+ * See `~/.hermes/skills/llm-provider-integration/references/
+ * minimax-401-tool-calling-lessons.md` Lesson 2 for the failure-mode that
+ * motivated this. Both `src/utils/api.js` (non-REPL stream path) and
+ * `src/commands/repl.js` (REPL stream path) use this helper so the two
+ * implementations cannot drift.
+ */
+
+/**
+ * Apply one streaming delta chunk to the per-index buffer.
+ * Mutates `buffer` in place and returns it for chaining.
+ *
+ * @param {Array<object>} buffer  per-index accumulator (created externally,
+ *                                index = position; sparse entries fine)
+ * @param {Array<object>} deltas  `parsed.choices[0].delta.tool_calls`
+ * @returns {Array<object>} the same buffer
+ */
+function accumulateToolCallDeltas(buffer, deltas) {
+  if (!Array.isArray(deltas)) return buffer;
+  for (const tcDelta of deltas) {
+    if (!tcDelta || typeof tcDelta.index !== 'number') continue;
+    const idx = tcDelta.index;
+    if (!buffer[idx]) {
+      buffer[idx] = {
+        index: idx,
+        id: '',
+        type: 'function',
+        function: { name: '', arguments: '' },
+      };
+    }
+    const slot = buffer[idx];
+    if (tcDelta.id) slot.id = tcDelta.id;
+    if (tcDelta.type) slot.type = tcDelta.type;
+    if (tcDelta.function?.name) slot.function.name += tcDelta.function.name;
+    if (tcDelta.function?.arguments) slot.function.arguments += tcDelta.function.arguments;
+  }
+  return buffer;
+}
+
+/**
+ * Finalize accumulated buffer into the shape an OpenAI-compatible
+ * `assistant.tool_calls` array expects. Filters incomplete entries
+ * (missing name or id) and synthesizes ids when absent.
+ *
+ * @param {Array<object>} buffer  from accumulateToolCallDeltas
+ * @returns {Array<{id:string,type:string,function:{name:string,arguments:string}}>}
+ */
+function finalizeToolCalls(buffer) {
+  const out = [];
+  for (let i = 0; i < buffer.length; i++) {
+    const slot = buffer[i];
+    if (!slot || !slot.function.name) continue;
+    out.push({
+      id: slot.id || `call_${Date.now()}_${i}`,
+      type: slot.type || 'function',
+      function: { name: slot.function.name, arguments: slot.function.arguments || '' },
+    });
+  }
+  return out;
+}
+
+/**
+ * Parse the JSON arguments of a finalized tool call, returning {} on
+ * failure so callers don't have to repeat the try/catch.
+ *
+ * @param {string} argsJson
+ * @returns {object}
+ */
+function parseToolArgs(argsJson) {
+  if (!argsJson || typeof argsJson !== 'string') return {};
+  try {
+    return JSON.parse(argsJson);
+  } catch {
+    return {};
+  }
+}
+
+module.exports = {
+  accumulateToolCallDeltas,
+  finalizeToolCalls,
+  parseToolArgs,
+};

package/src/utils/tools.js

@@ -105,10 +105,12 @@ function toOpenAIFormat(toolDefs) {
   return toolDefs
     .filter(t => !['brave_search','brave-web-search','google_search','web_search','browse','open','search','shell','bash_command','execute_command','run_command','sql','query','lookup'].includes(t.name))
     .map(t => {
-      // Alias varsa degistir
+      // Alias varsa degistir. Önceki kod ALIAS_MAP'i declare ediyordu ama
+      // değiştirmek için TOOL_ALIASES kullanıyordu (undefined) — alias hit
+      // olduğunda ReferenceError ile çöküyordu. ALIAS_MAP'e döndürüldü.
       const ALIAS_MAP = { 'brave_search':'duckduckgo_search','brave-web-search':'duckduckgo_search','google_search':'duckduckgo_search','web_search':'duckduckgo_search','browse':'browser','shell':'bash','bash_command':'bash','execute_command':'bash','run_command':'bash' };
       if (ALIAS_MAP[t.name]) {
-        t = { ...t, name: TOOL_ALIASES[t.name] };
+        t = { ...t, name: ALIAS_MAP[t.name] };
       }
     // v5.4.21: Groq uyumluluk - additionalProperties: false kaldirildi
     // ve gereksiz kisitlamalar temizlendi