natureco-cli 5.19.0 → 5.20.1

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

package/src/utils/plan-mode.js

@@ -0,0 +1,164 @@
+/**
+ * plan-mode — Plan Mode (Claude Code EnterPlanMode/ExitPlanMode)
+ *
+ * Plan mode lets the model research, explore, and create a plan
+ * without making any changes. All write/destructive operations are blocked.
+ *
+ * Tools:
+ *   EnterPlanMode — switch to plan-only mode
+ *   ExitPlanMode — exit plan mode, present plan to user
+ *
+ * State transitions:
+ *   NORMAL → (EnterPlanMode) → PLANNING → (ExitPlanMode) → REVIEW → (approve) → NORMAL
+ *                                                                     → (reject) → PLANNING
+ */
+
+const STATE = {
+  NORMAL: 'normal',
+  PLANNING: 'planning',
+  REVIEW: 'review',
+};
+
+class PlanMode {
+  constructor() {
+    this.state = STATE.NORMAL;
+    this.plan = null;
+    this.steps = [];
+    this.filesRead = [];
+    this.commandsRun = [];
+    this.planHistory = [];
+  }
+
+  enter() {
+    if (this.state !== STATE.NORMAL) return false;
+    this.state = STATE.PLANNING;
+    this.plan = null;
+    this.steps = [];
+    this.filesRead = [];
+    this.commandsRun = [];
+    return true;
+  }
+
+  exit(planContent) {
+    if (this.state !== STATE.PLANNING) return false;
+    this.plan = planContent;
+    this.state = STATE.REVIEW;
+    this.planHistory.push({
+      plan: planContent,
+      steps: [...this.steps],
+      at: Date.now(),
+    });
+    return true;
+  }
+
+  approve() {
+    if (this.state !== STATE.REVIEW) return false;
+    this.state = STATE.NORMAL;
+    return true;
+  }
+
+  reject() {
+    if (this.state !== STATE.REVIEW) return false;
+    this.state = STATE.PLANNING;
+    return true;
+  }
+
+  isPlanning() {
+    return this.state === STATE.PLANNING;
+  }
+
+  inReview() {
+    return this.state === STATE.REVIEW;
+  }
+
+  isNormal() {
+    return this.state === STATE.NORMAL;
+  }
+
+  getSystemPrompt() {
+    if (this.state === STATE.PLANNING) {
+      return [
+        'You are in PLAN MODE. You MUST NOT make any changes to files or execute destructive commands.',
+        'You can: read files, search code, browse the web, explore the codebase.',
+        'You MUST NOT: write/edit files, run git commands that change history, install packages, or execute destructive bash commands.',
+        'Create a detailed step-by-step plan. When ready, use ExitPlanMode to present your plan.',
+        '',
+        'Plan format (markdown):',
+        '## Plan: <title>',
+        '### Step 1: <action>',
+        '  - Files: <paths>',
+        '  - Changes: <description>',
+        '### Step 2: ...',
+      ].join('\n');
+    }
+    return '';
+  }
+
+  /**
+   * Check if a tool is allowed in current mode.
+   * Returns { allowed, reason }
+   */
+  checkTool(toolName, args) {
+    if (this.state !== STATE.PLANNING) return { allowed: true };
+
+    const writeTools = new Set([
+      'write_file', 'edit_file', 'edit', 'write',
+      'file_write', 'file_edit', 'rename_file', 'delete_file',
+      'move_file', 'copy_file', 'create_file',
+    ]);
+    const destructiveBash = [
+      'rm', 'mv', 'cp', 'dd', 'mkfs', 'format', '>', '>>', '|',
+      'chmod', 'chown', 'ln', 'git push', 'git commit', 'git merge',
+      'git rebase', 'git reset', 'npm publish', 'npm install',
+      'pip install', 'brew install', 'apt', 'yum', 'dnf',
+    ];
+
+    if (writeTools.has(toolName)) {
+      return { allowed: false, reason: 'Plan modunda dosya değişikliği yasaktır. Önce ExitPlanMode ile çıkıp onay alın.' };
+    }
+
+    if (toolName === 'bash' || toolName === 'execute_command') {
+      const cmd = (args.command || args.cmd || '').trim();
+      for (const pattern of destructiveBash) {
+        if (cmd.includes(pattern)) {
+          return { allowed: false, reason: `Plan modunda yasaklı komut: ${pattern}` };
+        }
+      }
+    }
+
+    if (toolName === 'browser') {
+      return { allowed: false, reason: 'Plan modunda browser yasaktır.' };
+    }
+
+    return { allowed: true };
+  }
+
+  /**
+   * Record a read/search tool call for the plan summary.
+   */
+  recordTool(toolName, args) {
+    if (this.state === STATE.PLANNING) {
+      if (toolName === 'read_file' || toolName === 'file_search' || toolName === 'grep_search') {
+        const target = args.filePath || args.pattern || args.path || '';
+        if (target && !this.filesRead.includes(target)) {
+          this.filesRead.push(target);
+        }
+      }
+      if (toolName === 'bash' || toolName === 'execute_command') {
+        const cmd = (args.command || args.cmd || '').trim();
+        if (cmd && !this.commandsRun.includes(cmd)) {
+          this.commandsRun.push(cmd);
+        }
+      }
+    }
+  }
+}
+
+// Singleton
+let _instance = null;
+function getPlanMode() {
+  if (!_instance) _instance = new PlanMode();
+  return _instance;
+}
+
+module.exports = { PlanMode, getPlanMode, STATE };

package/src/utils/provider-detect.js

@@ -2,46 +2,21 @@
  * 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.
+ * v5.22.0: Delegates real detection to model-provider.js's detectFamily.
+ * Keeps convenience predicates (isAnthropic, isMiniMax, etc.) and
+ * buildChatEndpoint for backward compatibility.
  */
 
-/**
- * Family of an inference provider.
- *
- * @typedef {'openai'|'anthropic'|'groq'|'openrouter'|'deepseek'|'mistral'
- *           |'together'|'fireworks'|'perplexity'|'ollama'|'minimax'} ProviderName
- */
+const { detectFamily } = require('./model-provider');
 
 /**
+ * Canonical detection — delegates to model-provider.
  * @param {string} providerUrl
  * @param {string} [model]
- * @returns {ProviderName}
+ * @returns {string}
  */
 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';
+  return detectFamily(providerUrl, model);
 }
 
 /** Convenience predicates — each one short-circuits on hostname only. */

package/src/utils/sandbox.js

@@ -0,0 +1,60 @@
+/**
+ * sandbox — Lightweight command execution sandbox
+ *
+ * Levels: none | basic | strict
+ *
+ * - none: no restrictions
+ * - basic: timeout + cwd restriction
+ * - strict: timeout + cwd + no-network + env cleanup
+ */
+
+const path = require('path');
+const os = require('os');
+
+const SANDBOX_LEVELS = { none: 0, basic: 1, strict: 2 };
+
+function getLevel(cfg = {}) {
+  const level = (cfg.sandbox || cfg.sandboxLevel || 'none').toLowerCase();
+  return SANDBOX_LEVELS[level] !== undefined ? level : 'none';
+}
+
+function isPathAllowed(targetPath, cwd) {
+  if (!targetPath) return true;
+  const abs = path.resolve(targetPath);
+  // Always allow /tmp and project directory
+  if (abs.startsWith('/tmp/') || abs.startsWith('/private/tmp/')) return true;
+  if (cwd && abs.startsWith(path.resolve(cwd))) return true;
+  return false;
+}
+
+function isNetworkCommand(cmd) {
+  const networkPatterns = [
+    'curl ', 'wget ', 'nc ', 'ncat ', 'ssh ', 'scp ', 'rsync',
+    'pip install', 'npm install', 'yarn add', 'pnpm add',
+    'apt-get', 'apt ', 'yum ', 'dnf ', 'brew install',
+    'git clone', 'git fetch', 'git pull',
+    'docker pull', 'docker run',
+  ];
+  const lower = cmd.toLowerCase();
+  return networkPatterns.some(p => lower.includes(p));
+}
+
+function getSandboxEnv(level) {
+  if (level === 'strict') {
+    return {
+      PATH: process.env.PATH || '',
+      HOME: os.homedir(),
+      TMPDIR: os.tmpdir(),
+      NODE_ENV: 'development',
+    };
+  }
+  return undefined; // Use parent env
+}
+
+function getTimeout(level, defaultTimeout = 30000) {
+  if (level === 'strict') return 10000;
+  if (level === 'basic') return defaultTimeout;
+  return 0; // no timeout
+}
+
+module.exports = { getLevel, isPathAllowed, isNetworkCommand, getSandboxEnv, getTimeout, SANDBOX_LEVELS };

package/src/utils/search-provider.js

@@ -0,0 +1,62 @@
+const PROVIDER_CONFIG_KEY = 'searchProvider';
+const DEFAULT_PROVIDER = 'tavily';
+
+const _registry = new Map();
+
+function registerProvider(name, providerClass) {
+  _registry.set(name, providerClass);
+}
+
+function getProviderNames() {
+  return Array.from(_registry.keys());
+}
+
+function getProvider(name) {
+  return _registry.get(name) || null;
+}
+
+function resolveProviderConfig(cfg) {
+  const env = process.env.NATURECO_SEARCH_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];
+  }
+  return DEFAULT_PROVIDER;
+}
+
+function getActiveProvider(cfg) {
+  const name = resolveProviderConfig(cfg);
+  const Cls = getProvider(name);
+  if (!Cls) return getProvider(DEFAULT_PROVIDER);
+  return Cls;
+}
+
+class SearchProvider {
+  constructor(config = {}) {
+    this.config = config;
+    this.name = 'base';
+  }
+
+  async search(query, options = {}) {
+    throw new Error('Not implemented: search');
+  }
+
+  normalizeResults(rawResults) {
+    return (rawResults || []).map(r => ({
+      title: r.title || '',
+      snippet: r.snippet || r.content || r.text || '',
+      url: r.url || '',
+    }));
+  }
+}
+
+module.exports = {
+  SearchProvider,
+  registerProvider,
+  getProviderNames,
+  getProvider,
+  resolveProviderConfig,
+  getActiveProvider,
+  PROVIDER_CONFIG_KEY,
+  DEFAULT_PROVIDER,
+};