natureco-cli 5.18.3 → 5.20.0

package/src/utils/cron.js

@@ -1,126 +1,82 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const cron = require('node-cron');
-
-const CRON_FILE = path.join(os.homedir(), '.natureco', 'cron.json');
-const CRON_LOGS_DIR = path.join(os.homedir(), '.natureco', 'cron-logs');
-
-function ensureCronDirs() {
-  const dir = path.dirname(CRON_FILE);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  if (!fs.existsSync(CRON_LOGS_DIR)) {
-    fs.mkdirSync(CRON_LOGS_DIR, { recursive: true });
-  }
-}
-
-function loadCronJobs() {
-  ensureCronDirs();
-  if (!fs.existsSync(CRON_FILE)) {
-    return [];
-  }
-  try {
-    const data = fs.readFileSync(CRON_FILE, 'utf-8');
-    return JSON.parse(data);
-  } catch {
-    return [];
-  }
-}
-
-function saveCronJobs(jobs) {
-  ensureCronDirs();
-  fs.writeFileSync(CRON_FILE, JSON.stringify(jobs, null, 2), 'utf-8');
-}
-
-function addCronJob(job) {
-  const jobs = loadCronJobs();
-  const id = Date.now().toString(36) + Math.random().toString(36).slice(2);
-  const newJob = {
-    id,
-    ...job,
-    enabled: true,
-    createdAt: new Date().toISOString(),
-  };
-  jobs.push(newJob);
-  saveCronJobs(jobs);
-  return newJob;
-}
-
-function removeCronJob(id) {
-  const jobs = loadCronJobs();
-  const filtered = jobs.filter(j => j.id !== id);
-  saveCronJobs(filtered);
-  return filtered.length < jobs.length;
-}
-
-function updateCronJob(id, updates) {
-  const jobs = loadCronJobs();
-  const index = jobs.findIndex(j => j.id === id);
-  if (index === -1) return false;
-  jobs[index] = { ...jobs[index], ...updates };
-  saveCronJobs(jobs);
-  return true;
-}
-
-function getCronJob(id) {
-  const jobs = loadCronJobs();
-  return jobs.find(j => j.id === id);
-}
-
-function parseCronSchedule(schedule) {
-  // Basit zamanlama formatlarını cron expression'a çevir
-  if (schedule.startsWith('every ')) {
-    const parts = schedule.split(' ');
-    if (parts[2] === 'hours') {
-      const hours = parseInt(parts[1]);
-      return `0 */${hours} * * *`;
-    }
-    if (parts[2] === 'minutes') {
-      const minutes = parseInt(parts[1]);
-      return `*/${minutes} * * * *`;
-    }
-  }
-  
-  if (schedule.startsWith('daily at ')) {
-    const time = schedule.replace('daily at ', '');
-    const [hour, minute = '0'] = time.split(':');
-    return `${minute} ${hour} * * *`;
-  }
-  
-  // Zaten cron expression ise olduğu gibi döndür
-  return schedule;
-}
-
-function validateCronExpression(expression) {
-  return cron.validate(expression);
-}
-
-function logCronOutput(jobId, output) {
-  const logFile = path.join(CRON_LOGS_DIR, `${jobId}.log`);
-  const timestamp = new Date().toISOString();
-  const logEntry = `[${timestamp}]\n${output}\n\n`;
-  fs.appendFileSync(logFile, logEntry, 'utf-8');
-}
-
-function getCronLog(jobId) {
-  const logFile = path.join(CRON_LOGS_DIR, `${jobId}.log`);
-  if (!fs.existsSync(logFile)) {
-    return null;
-  }
-  return fs.readFileSync(logFile, 'utf-8');
-}
-
-module.exports = {
-  loadCronJobs,
-  saveCronJobs,
-  addCronJob,
-  removeCronJob,
-  updateCronJob,
-  getCronJob,
-  parseCronSchedule,
-  validateCronExpression,
-  logCronOutput,
-  getCronLog,
-};
+/**
+ * cron — Scheduled task monitoring (cron-like expressions)
+ *
+ * Format (standard cron): min hour dom mon dow
+ *   e.g., "every 5 min" -> minute field = "star/5"
+ * Checks if a task should run based on its schedule.
+ */
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const CRON_FILE = path.join(os.homedir(), '.natureco', 'cron-jobs.json');
+
+function parseCron(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) return null;
+  const [min, hour, dom, mon, dow] = parts;
+  return { min, hour, dom, mon, dow };
+}
+
+function matchesField(value, pattern) {
+  if (pattern === '*') return true;
+  if (pattern.startsWith('*/')) {
+    const step = parseInt(pattern.slice(2), 10);
+    return value % step === 0;
+  }
+  if (pattern.includes(',')) return pattern.split(',').some(p => matchesField(value, p));
+  if (pattern.includes('-')) {
+    const [lo, hi] = pattern.split('-').map(Number);
+    return value >= lo && value <= hi;
+  }
+  return parseInt(pattern, 10) === value;
+}
+
+function shouldRun(expr) {
+  const parsed = parseCron(expr);
+  if (!parsed) return false;
+  const now = new Date();
+  return (
+    matchesField(now.getMinutes(), parsed.min) &&
+    matchesField(now.getHours(), parsed.hour) &&
+    matchesField(now.getDate(), parsed.dom) &&
+    matchesField(now.getMonth() + 1, parsed.mon) &&
+    matchesField(now.getDay(), parsed.dow)
+  );
+}
+
+function loadJobs() {
+  try {
+    if (fs.existsSync(CRON_FILE)) return JSON.parse(fs.readFileSync(CRON_FILE, 'utf8'));
+  } catch {}
+  return [];
+}
+
+function addJob(job) {
+  const jobs = loadJobs();
+  const entry = {
+    id: `cron_${Date.now()}`,
+    schedule: job.schedule,
+    command: job.command,
+    description: job.description || '',
+    createdAt: Date.now(),
+    lastRun: null,
+    enabled: true,
+  };
+  jobs.push(entry);
+  const dir = path.dirname(CRON_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(CRON_FILE, JSON.stringify(jobs, null, 2));
+  return entry;
+}
+
+function removeJob(id) {
+  const jobs = loadJobs().filter(j => j.id !== id);
+  const dir = path.dirname(CRON_FILE);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(CRON_FILE, JSON.stringify(jobs, null, 2));
+  return true;
+}
+
+module.exports = { parseCron, shouldRun, loadJobs, addJob, removeJob };

package/src/utils/effort-levels.js

@@ -0,0 +1,42 @@
+/**
+ * effort-levels — Effort level control (Claude Code: low/medium/high)
+ *
+ * Controls token budget, iteration limits, and tool breadth:
+ *   low:    quick answers, 2 tool iterations, 1024 max_tokens, minimal tools
+ *   medium: balanced, 5 iterations, 2048 max_tokens, standard tools (default)
+ *   high:   thorough, 12 iterations, 4096 max_tokens, all tools
+ */
+
+const LEVELS = { low: 'low', medium: 'medium', high: 'high' };
+
+const CONFIG = {
+  low: {
+    maxTokens: 1024,
+    maxToolIterations: 2,
+    temperature: 0.1,
+    toolBreadth: 'minimal',
+  },
+  medium: {
+    maxTokens: 2048,
+    maxToolIterations: 5,
+    temperature: 0.3,
+    toolBreadth: 'standard',
+  },
+  high: {
+    maxTokens: 4096,
+    maxToolIterations: 12,
+    temperature: 0.5,
+    toolBreadth: 'all',
+  },
+};
+
+function getLevel(cfg = {}) {
+  const level = (cfg.effort || cfg.effortLevel || 'medium').toLowerCase();
+  return LEVELS[level] || 'medium';
+}
+
+function getConfig(level) {
+  return CONFIG[level] || CONFIG.medium;
+}
+
+module.exports = { LEVELS, CONFIG, getLevel, getConfig };

package/src/utils/fallback-chain.js

@@ -0,0 +1,72 @@
+/**
+ * fallback-chain — Multi-model fallback chain (3 models max)
+ *
+ * Config:
+ *   "models": ["gpt-4", "claude-3", "gemini-pro"]
+ *   "fallback": {
+ *     "enabled": true,
+ *     "onError": true,
+ *     "onRateLimit": true,
+ *     "onTimeout": true
+ *   }
+ *
+ * Returns which model to use for each turn, rotating through the chain
+ * when errors occur.
+ */
+
+class FallbackChain {
+  constructor() {
+    this.models = [];
+    this.currentIndex = 0;
+    this.config = { onError: true, onRateLimit: true, onTimeout: true };
+    this.fallbacksUsed = 0;
+    this.history = [];
+  }
+
+  configure(models, config = {}) {
+    this.models = Array.isArray(models) ? models.filter(Boolean) : [];
+    this.currentIndex = 0;
+    this.fallbacksUsed = 0;
+    this.config = { ...this.config, ...config };
+    this.history = [];
+  }
+
+  get current() {
+    return this.models[this.currentIndex] || null;
+  }
+
+  get hasFallback() {
+    return this.currentIndex < this.models.length - 1;
+  }
+
+  get remaining() {
+    return Math.max(0, this.models.length - this.currentIndex - 1);
+  }
+
+  get list() {
+    return [...this.models];
+  }
+
+  recordError(model, error) {
+    this.history.push({ model, error: error.message || String(error), at: Date.now() });
+    if (this.hasFallback) {
+      this.currentIndex++;
+      this.fallbacksUsed++;
+      return { fallback: true, nextModel: this.current, from: model };
+    }
+    return { fallback: false, nextModel: null, from: model };
+  }
+
+  reset() {
+    this.currentIndex = 0;
+    this.fallbacksUsed = 0;
+  }
+}
+
+let _instance = null;
+function getFallbackChain() {
+  if (!_instance) _instance = new FallbackChain();
+  return _instance;
+}
+
+module.exports = { FallbackChain, getFallbackChain };

package/src/utils/file-history.js

@@ -0,0 +1,78 @@
+/**
+ * file-history — File change history with undo support
+ *
+ * Snapshots files before edits and stores them in .natureco/history/
+ * Supports undo via `file-restore` CLI command.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HISTORY_DIR = path.join(process.cwd(), '.natureco', 'history');
+const MAX_SNAPSHOTS_PER_FILE = 20;
+
+function ensureDir() {
+  fs.mkdirSync(HISTORY_DIR, { recursive: true });
+}
+
+function snapshotKey(filePath) {
+  const rel = path.relative(process.cwd(), path.resolve(filePath));
+  return rel.replace(/\//g, '__');
+}
+
+function getHistory(filePath) {
+  const key = snapshotKey(filePath);
+  const dir = path.join(HISTORY_DIR, key);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter(f => f.endsWith('.snap'))
+    .map(f => {
+      const ts = parseInt(f.replace('.snap', ''), 10);
+      const snapPath = path.join(dir, f);
+      return { timestamp: ts, size: fs.statSync(snapPath).size, file: f };
+    })
+    .sort((a, b) => b.timestamp - a.timestamp);
+}
+
+function snapshot(filePath, content) {
+  ensureDir();
+  const key = snapshotKey(filePath);
+  const dir = path.join(HISTORY_DIR, key);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `${Date.now()}.snap`), content || '');
+
+  // Prune old snapshots
+  const snaps = fs.readdirSync(dir).filter(f => f.endsWith('.snap')).sort();
+  while (snaps.length > MAX_SNAPSHOTS_PER_FILE) {
+    const old = snaps.shift();
+    try { fs.unlinkSync(path.join(dir, old)); } catch {}
+  }
+}
+
+function restore(filePath, timestamp) {
+  const key = snapshotKey(filePath);
+  const snapPath = path.join(HISTORY_DIR, key, `${timestamp}.snap`);
+  if (!fs.existsSync(snapPath)) return { error: 'Snapshot not found' };
+  const content = fs.readFileSync(snapPath, 'utf8');
+  fs.writeFileSync(path.resolve(filePath), content);
+  return { restored: true, filePath, timestamp, size: content.length };
+}
+
+function listAll() {
+  if (!fs.existsSync(HISTORY_DIR)) return [];
+  const results = [];
+  for (const entry of fs.readdirSync(HISTORY_DIR)) {
+    const dir = path.join(HISTORY_DIR, entry);
+    if (fs.statSync(dir).isDirectory()) {
+      const snaps = fs.readdirSync(dir).filter(f => f.endsWith('.snap'));
+      if (snaps.length > 0) {
+        const filePath = entry.replace(/__/g, '/');
+        results.push({ file: filePath, snapshots: snaps.length, latest: Math.max(...snaps.map(s => parseInt(s, 10))) });
+      }
+    }
+  }
+  return results;
+}
+
+module.exports = { snapshot, restore, getHistory, listAll };

package/src/utils/model-provider.js

@@ -0,0 +1,113 @@
+const _registry = new Map();
+const _instances = new Map();
+
+const PROVIDER_CONFIG_KEY = 'modelProvider';
+const DEFAULT_PROVIDER = 'auto';
+
+function registerProvider(name, providerClass) {
+  _registry.set(name, providerClass);
+}
+
+function getProviderNames() {
+  return Array.from(_registry.keys());
+}
+
+function getProvider(name) {
+  return _registry.get(name) || null;
+}
+
+function detectFamily(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';
+  if (url.includes('generativelanguage.googleapis.com') || url.includes('gemini')) return 'gemini';
+  return 'openai';
+}
+
+function getProviderFamily(name) {
+  const openaiCompat = ['openai', 'groq', 'openrouter', 'deepseek', 'mistral', 'together', 'fireworks', 'perplexity'];
+  if (openaiCompat.includes(name)) return 'openai';
+  return name;
+}
+
+function resolveProviderConfig(cfg) {
+  const env = process.env.NATURECO_MODEL_PROVIDER || '';
+  if (env && _registry.has(env)) return env;
+  if (cfg && cfg[PROVIDER_CONFIG_KEY] && _registry.has(cfg[PROVIDER_CONFIG_KEY])) {
+    return cfg[PROVIDER_CONFIG_KEY];
+  }
+  const family = detectFamily(cfg?.providerUrl, cfg?.providerModel);
+  const resolved = getProviderFamily(family);
+  if (_registry.has(resolved)) return resolved;
+  return DEFAULT_PROVIDER;
+}
+
+function getActiveProvider(cfg) {
+  const name = resolveProviderConfig(cfg);
+  if (name === 'auto') {
+    const family = detectFamily(cfg?.providerUrl, cfg?.providerModel);
+    const familyGroup = getProviderFamily(family);
+    const Cls = _registry.get(familyGroup);
+    if (Cls) return Cls;
+  }
+  const Cls = _registry.get(name);
+  if (!Cls) return getProvider('openai') || null;
+  return Cls;
+}
+
+const DEFAULT_ANTHROPIC_SYSTEM = 'You are a helpful AI assistant running inside the natureco CLI.';
+
+class ModelProvider {
+  constructor(config = {}) {
+    this.config = config;
+    this.name = 'base';
+  }
+
+  getEndpoint() {
+    throw new Error('Not implemented: getEndpoint');
+  }
+
+  buildRequest(messages, options = {}) {
+    throw new Error('Not implemented: buildRequest');
+  }
+
+  parseResponse(data) {
+    throw new Error('Not implemented: parseResponse');
+  }
+
+  normalizeTools(tools) {
+    return tools || [];
+  }
+
+  parseToolCalls(message) {
+    return message?.tool_calls || [];
+  }
+
+  extractSystem(messages) {
+    const systemMsg = messages.find(m => m.role === 'system');
+    return systemMsg?.content || '';
+  }
+}
+
+module.exports = {
+  ModelProvider,
+  registerProvider,
+  getProviderNames,
+  getProvider,
+  detectFamily,
+  getProviderFamily,
+  resolveProviderConfig,
+  getActiveProvider,
+  PROVIDER_CONFIG_KEY,
+  DEFAULT_PROVIDER,
+  DEFAULT_ANTHROPIC_SYSTEM,
+};

package/src/utils/permissions.js

@@ -0,0 +1,147 @@
+/**
+ * permissions — Granular tool-level allow/deny rules (Claude Code style)
+ *
+ * Config format (~/.natureco/config.json or .natureco/config.json):
+ *   "permissions": {
+ *     "Read(~/.ssh/**)": { "action": "deny", "reason": "SSH keys are sensitive" },
+ *     "Read(~/.aws/**)": "deny",
+ *     "Edit(.env*)": { "action": "ask", "reason": "Review env changes" },
+ *     "Bash(npm *)": "ask",
+ *     "Bash(rm *rf *)": "deny"
+ *   }
+ *
+ * Resolution order (first match wins):
+ *   1. Config permissions (deny > ask > allow)
+ *   2. Built-in high-risk patterns (assessRisk in code_v5)
+ *   3. Default: allow
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { matchGlob, flattenArgs } = require('./tool-hooks');
+
+function loadPermissionRules() {
+  const rules = [];
+  const sources = [
+    path.join(os.homedir(), '.natureco', 'config.json'),
+    path.join(process.cwd(), '.natureco', 'config.json'),
+  ];
+  for (const cfgPath of sources) {
+    try {
+      if (fs.existsSync(cfgPath)) {
+        const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+        if (cfg.permissions) {
+          for (const [pattern, value] of Object.entries(cfg.permissions)) {
+            const parsed = parsePermissionRule(pattern, value);
+            if (parsed) rules.push(parsed);
+          }
+        }
+      }
+    } catch {}
+  }
+  return rules;
+}
+
+function parsePermissionRule(pattern, value) {
+  const match = pattern.match(/^(\*|[a-zA-Z_]+)\((.+)\)$/);
+  if (!match && pattern !== '*') return null;
+  const toolName = match ? match[1] : '*';
+  const glob = match ? match[2] : '*';
+
+  let action, reason;
+  if (typeof value === 'string') {
+    action = value;
+  } else if (value && typeof value === 'object') {
+    action = value.action || 'ask';
+    reason = value.reason;
+  }
+  if (!['allow', 'deny', 'ask'].includes(action)) action = 'ask';
+
+  return { toolName, glob, action, reason, raw: pattern };
+}
+
+/**
+ * Check permissions for a tool call.
+ * Returns { action: 'allow'|'deny'|'ask', reason, rule }
+ */
+function checkPermission(toolName, args) {
+  const rules = loadPermissionRules();
+  const flat = flattenArgs(args);
+
+  for (const rule of rules) {
+    if (rule.toolName !== '*' && rule.toolName !== toolName) continue;
+    const matchesGlob = rule.glob === '*' || matchGlob(flat, rule.glob) || matchGlob(toolName, rule.glob);
+    if (!matchesGlob) continue;
+    if (rule.action === 'deny') {
+      return { action: 'deny', reason: rule.reason || `Engellendi: ${rule.raw}`, rule };
+    }
+    if (rule.action === 'ask') {
+      return { action: 'ask', reason: rule.reason || `Onay gerekli: ${rule.raw}`, rule };
+    }
+    if (rule.action === 'allow') {
+      return { action: 'allow', reason: '', rule };
+    }
+  }
+
+  return { action: 'allow', reason: '', rule: null };
+}
+
+/**
+ * Persistent permission approvals (session + disk cache).
+ */
+const _permSessionCache = new Map();
+
+function loadPersistentApprovals() {
+  try {
+    const f = path.join(os.homedir(), '.natureco', 'perm-approvals.json');
+    if (fs.existsSync(f)) return JSON.parse(fs.readFileSync(f, 'utf8'));
+  } catch {}
+  return {};
+}
+
+function savePersistentApproval(key) {
+  try {
+    const f = path.join(os.homedir(), '.natureco', 'perm-approvals.json');
+    const data = loadPersistentApprovals();
+    data[key] = { approved: true, at: Date.now() };
+    const dir = path.dirname(f);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(f, JSON.stringify(data, null, 2), { mode: 0o600 });
+  } catch {}
+}
+
+function isApproved(key) {
+  if (_permSessionCache.get(key) === true) return true;
+  const persistent = loadPersistentApprovals();
+  if (persistent[key]?.approved) {
+    _permSessionCache.set(key, true);
+    return true;
+  }
+  return false;
+}
+
+function markApproved(key, persistent = false) {
+  _permSessionCache.set(key, true);
+  if (persistent) savePersistentApproval(key);
+}
+
+/**
+ * Format a tool call for permission display.
+ */
+function formatPermissionPrompt(toolName, args, reason) {
+  const parts = Object.entries(args || {}).map(([k, v]) => {
+    const s = typeof v === 'string' ? v : JSON.stringify(v);
+    return s.length > 80 ? s.slice(0, 77) + '...' : s;
+  });
+  return `${toolName}(${parts.join(', ')})`;
+}
+
+module.exports = {
+  checkPermission,
+  loadPermissionRules,
+  isApproved,
+  markApproved,
+  formatPermissionPrompt,
+};