natureco-cli 4.8.4 → 4.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "4.8.4",
+  "version": "4.9.1",
   "description": "OpenClaw'dan daha güvenli, daha hızlı, daha ucuz AI agent CLI. Multi-agent, self-evolving skills, audit log, maliyet optimizasyonu ve NatureCo platform-native.",
   "bin": {
     "natureco": "bin/natureco.js"

package/src/tools/calendar_add.js

@@ -0,0 +1,94 @@
+/**
+ * calendar_add - macOS Calendar'a etkinlik ekle (v4.9.1)
+ *
+ * Parton'un OS-level kontrol vizyonu için.
+ * "Yarin saat 14:00 toplantim var" -> Takvime ekler.
+ */
+
+const { spawn } = require("child_process");
+const os = require("os");
+
+const IS_MAC = os.platform() === "darwin";
+
+function runAppleScript(script) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("osascript", ["-e", script]);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", d => stdout += d);
+    proc.stderr.on("data", d => stderr += d);
+    proc.on("close", code => {
+      if (code === 0) resolve(stdout.trim());
+      else reject(new Error(stderr.trim() || `osascript exit ${code}`));
+    });
+  });
+}
+
+async function calendarAdd(params) {
+  if (!IS_MAC) return { success: false, error: "Calendar sadece macOS'ta desteklenir" };
+  const { title, startDate = "now", duration = 60, calendar = null, notes = "", location = "" } = params;
+  if (!title) return { success: false, error: "title gerekli" };
+
+  let startScript;
+  if (startDate === "now") startScript = "current date";
+  else if (typeof startDate === "string" && startDate.startsWith("+")) {
+    const m = startDate.match(/\+(\d+)\s*(hour|day|minute)/i);
+    if (m) startScript = `(current date) + ${m[1]} * ${m[2].toLowerCase()}s`;
+    else startScript = "current date";
+  } else {
+    startScript = `date "${startDate}"`;
+  }
+
+  const calScript = calendar ? `calendar "${calendar}"` : `first calendar whose writable is true`;
+
+  const script = `
+    tell application "Calendar"
+      set targetCal to ${calScript}
+      set startDate to ${startScript}
+      set endDate to startDate + (${duration} * minutes)
+      set newEvent to make new event at end of events of targetCal with properties {summary:"${title.replace(/"/g, "'")}", start date:startDate, end date:endDate${location ? `, location:"${location.replace(/"/g, "'")}"` : ""}${notes ? `, description:"${notes.replace(/"/g, "'")}"` : ""}}
+      save
+      return id of newEvent
+    end tell
+  `;
+
+  try {
+    const eventId = await runAppleScript(script);
+    return {
+      success: true,
+      eventId,
+      title,
+      startDate,
+      duration,
+      message: `Takvime eklendi: "${title}" (${startDate} + ${duration}dk)`,
+    };
+  } catch (e) {
+    if (e.message.includes("-1728") || e.message.includes("not authorized")) {
+      return {
+        success: false,
+        error: "Calendar erisim izni yok.\n\nIzin vermek icin:\n1. System Preferences -> Security & Privacy -> Privacy -> Automation\n2. natureco (veya Terminal) -> Calendar -> ON\n3. Tekrar dene",
+      };
+    }
+    return { success: false, error: e.message };
+  }
+}
+
+module.exports = {
+  name: "calendar_add",
+  description: "macOS Calendar'a etkinlik ekle. 'Yarin 14:00 toplanti' gibi.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      title: { type: "string", description: "Etkinlik basligi" },
+      startDate: { type: "string", description: 'Baslangic: "now", "+1 hour", "+2 days", veya ISO "2026-06-23 14:00"' },
+      duration: { type: "number", description: "Dakika (default 60)" },
+      calendar: { type: "string", description: "Takvim adi (default: ilk yazilabilir)" },
+      notes: { type: "string", description: "Notlar" },
+      location: { type: "string", description: "Konum" },
+    },
+    required: ["title"],
+  },
+  async execute(params) {
+    return await calendarAdd(params);
+  },
+};

package/src/tools/code_execution.js

@@ -0,0 +1,86 @@
+/**
+ * Code Execution — Python/Node kodu sandbox'ta çalıştır (v4.9.0)
+ *
+ * Hermes'ın execute_code'una benzer.
+ * Kullanıcı "Python ile X yap" derse çalıştırır.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+/**
+ * Kod çalıştır, çıktıyı ve hataları döndür.
+ * @param code - Çalıştırılacak kod
+ * @param language - 'python', 'node', 'bash' (default: otomatik tespit)
+ * @param timeoutMs - Timeout (default 30s)
+ */
+async function runCode({ code, language = 'auto', timeoutMs = 30000, cwd = null }) {
+  if (!code) return { success: false, error: 'code gerekli' };
+
+  // Dil tespiti
+  let cmd, args;
+  if (language === 'auto') {
+    if (/^import |^from |def |print\(/m.test(code) || code.includes('python')) {
+      language = 'python';
+    } else if (/require\(|^const |^let |^var |console\./m.test(code)) {
+      language = 'node';
+    } else if (/^(ls|cat|echo|grep|find|cd|mkdir)/m.test(code)) {
+      language = 'bash';
+    } else {
+      language = 'bash';
+    }
+  }
+
+  if (language === 'python') { cmd = 'python3'; args = ['-c', code]; }
+  else if (language === 'node') { cmd = 'node'; args = ['-e', code]; }
+  else if (language === 'bash' || language === 'shell') { cmd = 'bash'; args = ['-c', code]; }
+  else return { success: false, error: `Desteklenmeyen dil: ${language}` };
+
+  return new Promise((resolve) => {
+    const proc = spawn(cmd, args, {
+      cwd: cwd || os.homedir(),
+      timeout: timeoutMs,
+      env: { ...process.env, FORCE_COLOR: '0' },
+    });
+
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', d => stdout += d.toString());
+    proc.stderr.on('data', d => stderr += d.toString());
+
+    proc.on('close', (code) => {
+      const truncated = (s) => s.length > 8000 ? s.slice(0, 8000) + '\n... (kesildi, ' + (s.length - 8000) + ' karakter daha)' : s;
+      resolve({
+        success: code === 0,
+        language,
+        exitCode: code,
+        stdout: truncated(stdout).trim(),
+        stderr: truncated(stderr).trim(),
+        output: truncated(stdout + (stderr ? '\n[STDERR]: ' + stderr : '')).trim(),
+      });
+    });
+    proc.on('error', (e) => {
+      resolve({ success: false, error: e.message, language });
+    });
+  });
+}
+
+module.exports = {
+  name: 'code_execution',
+  description: 'Python/Node/Bash kodu sandbox\'ta çalıştır. Çıktıyı ve hataları döndürür.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      code: { type: 'string', description: 'Çalıştırılacak kod' },
+      language: { type: 'string', description: 'Dil: python, node, bash (default: otomatik tespit)', enum: ['auto', 'python', 'node', 'bash'] },
+      timeoutMs: { type: 'number', description: 'Timeout ms (default 30000)' },
+      cwd: { type: 'string', description: 'Çalışma dizini (default: home)' },
+    },
+    required: ['code'],
+  },
+  async execute(params) {
+    return await runCode(params);
+  },
+};

package/src/tools/cron_create.js

@@ -0,0 +1,105 @@
+/**
+ * cron_create - Zamanlanmis gorev (v4.9.0)
+ *
+ * Hermes cronjob'una benzer. "Her gun 09:00'da calistir" gibi.
+ * NatureCo CLI mevcut cron sistemine yazar (cron.js zaten var).
+ */
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execSync } = require("child_process");
+
+const CRON_FILE = path.join(os.homedir(), ".natureco", "crons.json");
+
+function loadCrons() {
+  try {
+    if (!fs.existsSync(CRON_FILE)) return [];
+    return JSON.parse(fs.readFileSync(CRON_FILE, "utf8"));
+  } catch { return []; }
+}
+
+function saveCrons(crons) {
+  fs.mkdirSync(path.dirname(CRON_FILE), { recursive: true });
+  fs.writeFileSync(CRON_FILE, JSON.stringify(crons, null, 2), "utf8");
+}
+
+function genId() {
+  return "cron-" + Date.now().toString(36);
+}
+
+// Yaygin zamanlama ifadeleri
+const SCHEDULE_PRESETS = {
+  "every minute": "* * * * *",
+  "every 5 minutes": "*/5 * * * *",
+  "every 15 minutes": "*/15 * * * *",
+  "every hour": "0 * * * *",
+  "every day 9am": "0 9 * * *",
+  "every day midnight": "0 0 * * *",
+  "every monday 9am": "0 9 * * 1",
+  "every sunday": "0 9 * * 0",
+};
+
+async function createCron({ name, schedule, command, description = "" }) {
+  if (!name) return { success: false, error: "name gerekli" };
+  if (!schedule) return { success: false, error: "schedule gerekli (cron expression veya preset)" };
+  if (!command) return { success: false, error: "command gerekli (calistirilacak komut)" };
+
+  // Preset kontrolu
+  const resolvedSchedule = SCHEDULE_PRESETS[schedule.toLowerCase()] || schedule;
+
+  // Cron expression dogrulama (basit)
+  if (!/^[\d*/\s,-]+$/.test(resolvedSchedule)) {
+    return { success: false, error: `Gecersiz cron expression: ${resolvedSchedule}` };
+  }
+
+  const crons = loadCrons();
+  const newCron = {
+    id: genId(),
+    name,
+    schedule: resolvedSchedule,
+    command,
+    description,
+    enabled: true,
+    createdAt: new Date().toISOString(),
+  };
+  crons.push(newCron);
+  saveCrons(crons);
+
+  // İstege bagli: gercek crontab'a da ekle (sistem cron)
+  // Bu tehlikeli olabilir, sadece bilgi veriyoruz
+  let systemCrontabInstalled = false;
+  try {
+    const crontabLine = `${resolvedSchedule} ${command} # natureco:${name}`;
+    const current = execSync("crontab -l 2>/dev/null || echo ''", { encoding: "utf8" });
+    if (!current.includes(`# natureco:${name}`)) {
+      // Kullaniciya soru sormadan eklemiyoruz - sadece komutu gosteriyoruz
+      systemCrontabInstalled = false;
+    }
+  } catch {}
+
+  return {
+    success: true,
+    cron: newCron,
+    message: `Cron olusturuldu: ${name} (${resolvedSchedule})`,
+    hint: systemCrontabInstalled ? undefined : `Sistem crontab'a eklemek icin: crontab -e ve ekleyin: ${resolvedSchedule} ${command}`,
+  };
+}
+
+module.exports = {
+  name: "cron_create",
+  description: "Zamanlanmis gorev olustur. Schedule: cron expression veya preset ('every day 9am', 'every hour').",
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "Gorev adi" },
+      schedule: { type: "string", description: "Cron expression (ornek: '0 9 * * *') veya preset" },
+      command: { type: "string", description: "Calistirilacak komut" },
+      description: { type: "string", description: "Aciklama" },
+    },
+    required: ["name", "schedule", "command"],
+  },
+  async execute(params) {
+    return await createCron(params);
+  },
+};

package/src/tools/delegate_task.js

@@ -0,0 +1,61 @@
+/**
+ * delegate_task - Alt-agent'a gorev devret (v4.9.0)
+ *
+ * Hermes delegate_task'ina benzer. Bir alt-agent baslatip ozel bir gorev verir.
+ * Not: Bu basitlestirilmis versiyon - async sub-process olarak agent calistirir.
+ */
+
+const { spawn } = require("child_process");
+const path = require("path");
+const os = require("os");
+
+async function delegate({ task, agent = "general", timeoutMs = 60000 }) {
+  if (!task) return { success: false, error: "task gerekli" };
+
+  // Bu basitlestirilmis versiyon: kendi agent sistemi yerine
+  // natureco'nun REPL'ini sub-process olarak baslatip gorev verir
+  return new Promise((resolve) => {
+    const cliPath = path.resolve(__dirname, "..", "..", "bin", "natureco.js");
+    const args = ["ask", `"${task.replace(/"/g, '\\"')}"`];
+
+    let stdout = "";
+    let stderr = "";
+    const proc = spawn("node", [cliPath, ...args], {
+      timeout: timeoutMs,
+      env: { ...process.env },
+    });
+
+    proc.stdout.on("data", d => stdout += d.toString());
+    proc.stderr.on("data", d => stderr += d.toString());
+
+    proc.on("close", code => {
+      // natureco ask komutu genelde cevabi stdout'a yazar
+      const output = stdout.split("\n").filter(l => !l.startsWith("[") && l.trim()).join("\n").trim();
+      resolve({
+        success: code === 0,
+        task,
+        agent,
+        output: output || stderr,
+        exitCode: code,
+      });
+    });
+    proc.on("error", e => resolve({ success: false, error: e.message, task }));
+  });
+}
+
+module.exports = {
+  name: "delegate_task",
+  description: "Alt-agent'a ozel gorev devret. Sub-process olarak REPL calistirip gorev verir, cevabi dondurur.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      task: { type: "string", description: "Alt-agent'in yapacagi gorev (ornek: 'README.md dosyasinin ilk 100 satirini ozetle')" },
+      agent: { type: "string", description: "Agent tipi (default: general)", enum: ["general", "explore", "review", "seo", "content", "security", "debugger", "translator"] },
+      timeoutMs: { type: "number", description: "Timeout ms (default 60000)" },
+    },
+    required: ["task"],
+  },
+  async execute(params) {
+    return await delegate(params);
+  },
+};

package/src/tools/file_search.js

@@ -0,0 +1,85 @@
+/**
+ * file_search - Glob pattern ile dosya arama (v4.9.0)
+ *
+ * Hermes dosya arama motoruna benzer.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+/**
+ * Recursive glob search
+ * @param pattern - Glob pattern (ornek: "glob" ile "glob" arasi)
+ * @param basePath - Aranacak dizin (default: cwd)
+ * @param maxResults - Max sonuc sayisi (default 100)
+ */
+async function searchFiles({ pattern, basePath = null, maxResults = 100 }) {
+  if (!pattern) return { success: false, error: "pattern gerekli" };
+
+  const cwd = basePath || process.cwd();
+  const results = [];
+
+  // Basit glob regex donusumu (glob deseni)
+  const regexPattern = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\\\*\\\*/g, ".*")
+    .replace(/\\\*/g, "[^/]*")
+    .replace(/\\\?/g, "[^/]");
+
+  const regex = new RegExp("^" + regexPattern + "$");
+
+  function walk(dir, depth) {
+    if (depth > 8 || results.length >= maxResults) return;
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+
+    for (const entry of entries) {
+      if (results.length >= maxResults) return;
+      if (entry.name.startsWith(".") && entry.name !== ".gitignore") continue;
+      if (entry.name === "node_modules") continue;
+
+      const fullPath = path.join(dir, entry.name);
+      const relative = path.relative(cwd, fullPath);
+
+      if (regex.test(relative) || regex.test(entry.name)) {
+        results.push({
+          path: fullPath,
+          relative,
+          name: entry.name,
+          type: entry.isDirectory() ? "directory" : "file",
+          size: entry.isFile() ? fs.statSync(fullPath).size : null,
+        });
+      }
+
+      if (entry.isDirectory()) {
+        walk(fullPath, depth + 1);
+      }
+    }
+  }
+
+  try {
+    walk(cwd, 0);
+    return { success: true, pattern, count: results.length, results };
+  } catch (e) {
+    return { success: false, error: e.message, pattern };
+  }
+}
+
+module.exports = {
+  name: "file_search",
+  description: "Glob pattern ile dosya/klasor arama. Hermes dosya arama motoru gibi. Default cwd arar.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      pattern: { type: "string", description: "Glob pattern (ornek: glob)" },
+      basePath: { type: "string", description: "Aranacak dizin (default: cwd)" },
+      maxResults: { type: "number", description: "Max sonuc (default 100)" },
+    },
+    required: ["pattern"],
+  },
+  async execute(params) {
+    return await searchFiles(params);
+  },
+};

package/src/tools/grep_search.js

@@ -0,0 +1,127 @@
+/**
+ * grep_search — İçerik araması (ripgrep tarzı) (v4.9.0)
+ *
+ * Hermes'ın search_files'ine benzer ama içerik arar.
+ * "TODO" kelimesini tüm src/ içinde ara gibi.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+/**
+ * Dosya içinde pattern ara
+ * @param pattern - Aranacak metin veya regex
+ * @param path - Aranacak dosya/klasör yolu
+ * @param caseSensitive - Case sensitive (default false)
+ * @param maxResults - Max sonuç (default 50)
+ */
+async function grepSearch({ pattern, path: searchPath = null, caseSensitive = false, includePattern = null, maxResults = 50 }) {
+  if (!pattern) return { success: false, error: 'pattern gerekli' };
+
+  const cwd = searchPath || process.cwd();
+  // ripgrep varsa onu kullan, yoksa fallback grep
+  const useRipgrep = await checkCommand('rg');
+
+  if (useRipgrep) {
+    return await grepWithRipgrep(pattern, cwd, caseSensitive, includePattern, maxResults);
+  }
+  return await grepWithFallback(pattern, cwd, caseSensitive, maxResults);
+}
+
+async function checkCommand(cmd) {
+  return new Promise((resolve) => {
+    const proc = spawn('which', [cmd]);
+    proc.on('close', code => resolve(code === 0));
+    proc.on('error', () => resolve(false));
+  });
+}
+
+async function grepWithRipgrep(pattern, cwd, caseSensitive, includePattern, maxResults) {
+  return new Promise((resolve) => {
+    const args = [
+      '--json',
+      '--line-number',
+      caseSensitive ? '' : '--ignore-case',
+      includePattern ? `-g "${includePattern}"` : '',
+      '--no-heading',
+    ].filter(Boolean);
+    args.push(pattern);
+    args.push(cwd);
+
+    const proc = spawn('rg', args, { cwd });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', d => stdout += d.toString());
+    proc.stderr.on('data', d => stderr += d.toString());
+
+    proc.on('close', (code) => {
+      const results = [];
+      const lines = stdout.split('\n').filter(Boolean);
+      for (const line of lines) {
+        if (results.length >= maxResults) break;
+        try {
+          const obj = JSON.parse(line);
+          if (obj.type === 'match') {
+            results.push({
+              file: obj.data.path.text,
+              line: obj.data.line_number,
+              text: obj.data.lines.text.trim(),
+            });
+          }
+        } catch {}
+      }
+      resolve({ success: true, pattern, tool: 'ripgrep', count: results.length, results });
+    });
+    proc.on('error', (e) => resolve({ success: false, error: e.message }));
+  });
+}
+
+async function grepWithFallback(pattern, cwd, caseSensitive, maxResults) {
+  return new Promise((resolve) => {
+    const args = ['-r', '-n', caseSensitive ? '' : '-i'];
+    if (process.platform === 'darwin') args.push('-E');
+    else args.push('-E');
+    args.push(pattern);
+    args.push(cwd);
+
+    const proc = spawn('grep', args);
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', d => stdout += d.toString());
+    proc.stderr.on('data', d => stderr += d.toString());
+
+    proc.on('close', (code) => {
+      const results = [];
+      const lines = stdout.split('\n').filter(Boolean);
+      for (const line of lines) {
+        if (results.length >= maxResults) break;
+        const match = line.match(/^(.+?):(\d+):(.*)$/);
+        if (match) {
+          results.push({ file: match[1], line: parseInt(match[2]), text: match[3] });
+        }
+      }
+      resolve({ success: true, pattern, tool: 'grep', count: results.length, results });
+    });
+    proc.on('error', (e) => resolve({ success: false, error: e.message }));
+  });
+}
+
+module.exports = {
+  name: 'grep_search',
+  description: 'Dosya içeriklerinde pattern ara (ripgrep veya grep). Örn: pattern="TODO", path="~/projects".',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      pattern: { type: 'string', description: 'Aranacak metin veya regex' },
+      path: { type: 'string', description: 'Aranacak dosya/klasör yolu (default: cwd)' },
+      caseSensitive: { type: 'boolean', description: 'Büyük/küçük harf duyarlı (default: false)' },
+      includePattern: { type: 'string', description: 'Glob filter (örn: "*.js")' },
+      maxResults: { type: 'number', description: 'Max sonuç (default 50)' },
+    },
+    required: ['pattern'],
+  },
+  async execute(params) {
+    return await grepSearch(params);
+  },
+};

package/src/tools/http_request.js

@@ -0,0 +1,77 @@
+/**
+ * http_request — HTTP GET/POST/PUT/DELETE isteği (v4.9.0)
+ *
+ * Hermes'ın http_request'ine benzer. API çağrıları için.
+ */
+
+async function httpRequest({ url, method = 'GET', headers = {}, body = null, timeoutMs = 30000 }) {
+  if (!url) return { success: false, error: 'url gerekli' };
+
+  // fetch global olarak Node 18+'da var
+  if (typeof fetch !== 'function') {
+    return { success: false, error: 'fetch() Node 18+ gerektirir' };
+  }
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const options = {
+      method: method.toUpperCase(),
+      headers: { 'User-Agent': 'NatureCo-CLI/4.9.0', ...headers },
+      signal: controller.signal,
+    };
+    if (body && ['POST', 'PUT', 'PATCH'].includes(options.method)) {
+      if (typeof body === 'string') options.body = body;
+      else {
+        options.body = JSON.stringify(body);
+        if (!headers['Content-Type']) options.headers['Content-Type'] = 'application/json';
+      }
+    }
+
+    const response = await fetch(url, options);
+    clearTimeout(timeout);
+
+    const contentType = response.headers.get('content-type') || '';
+    let responseBody;
+    if (contentType.includes('application/json')) {
+      responseBody = await response.json();
+    } else {
+      responseBody = await response.text();
+      if (responseBody.length > 10000) {
+        responseBody = responseBody.slice(0, 10000) + '\n... (kesildi)';
+      }
+    }
+
+    return {
+      success: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      headers: Object.fromEntries(response.headers.entries()),
+      body: responseBody,
+    };
+  } catch (e) {
+    clearTimeout(timeout);
+    if (e.name === 'AbortError') return { success: false, error: `Timeout (${timeoutMs}ms)` };
+    return { success: false, error: e.message, url, method };
+  }
+}
+
+module.exports = {
+  name: 'http_request',
+  description: 'HTTP GET/POST/PUT/DELETE isteği. JSON veya text response döndürür. Örn: API\'lerden veri çekmek için.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      url: { type: 'string', description: 'Hedef URL (https://api.example.com/data)' },
+      method: { type: 'string', description: 'HTTP metodu', enum: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'] },
+      headers: { type: 'object', description: 'HTTP header\'ları (Auth, Content-Type, vs.)' },
+      body: { type: 'string', description: 'Request body (JSON string veya object)' },
+      timeoutMs: { type: 'number', description: 'Timeout ms (default 30000)' },
+    },
+    required: ['url'],
+  },
+  async execute(params) {
+    return await httpRequest(params);
+  },
+};