natureco-cli 5.19.0 → 5.20.1

package/src/utils/session-search.js

@@ -0,0 +1,66 @@
+/**
+ * session-search — Full-text search across past sessions
+ *
+ * Sessions are stored in .natureco/sessions/ as JSON files.
+ * This utility indexes and searches them by keyword.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const SESSIONS_DIR = path.join(process.cwd(), '.natureco', 'sessions');
+
+function getSessions() {
+  if (!fs.existsSync(SESSIONS_DIR)) return [];
+  return fs.readdirSync(SESSIONS_DIR)
+    .filter(f => f.endsWith('.json'))
+    .map(f => {
+      const p = path.join(SESSIONS_DIR, f);
+      try {
+        return { id: f.replace('.json', ''), mtime: fs.statSync(p).mtimeMs, path: p };
+      } catch { return null; }
+    })
+    .filter(Boolean)
+    .sort((a, b) => b.mtime - a.mtime);
+}
+
+function search(query, maxResults = 10) {
+  const q = query.toLowerCase();
+  const results = [];
+  const sessions = getSessions();
+
+  for (const session of sessions) {
+    try {
+      const data = JSON.parse(fs.readFileSync(session.path, 'utf8'));
+      const messages = data.messages || [];
+      let score = 0;
+      const matches = [];
+
+      for (const msg of messages) {
+        const content = (msg.content || '').toLowerCase();
+        if (content.includes(q)) {
+          score++;
+          const snippet = content.slice(
+            Math.max(0, content.indexOf(q) - 40),
+            content.indexOf(q) + q.length + 40
+          );
+          matches.push({ role: msg.role, snippet });
+        }
+      }
+
+      if (score > 0) {
+        results.push({
+          id: session.id,
+          date: new Date(session.mtime).toISOString(),
+          score,
+          matches: matches.slice(0, 5),
+          firstMessage: data.messages?.[1]?.content?.slice(0, 80) || '',
+        });
+      }
+    } catch {}
+  }
+
+  return results.sort((a, b) => b.score - a.score).slice(0, maxResults);
+}
+
+module.exports = { search, getSessions };

package/src/utils/structured-output.js

@@ -0,0 +1,20 @@
+/**
+ * structured-output — JSON Schema-based structured output support
+ *
+ * Adds response_format to API calls when schema is provided.
+ * Config: { "response_format": { "type": "json_object", "schema": {...} } }
+ * Tool:  SetOutputSchema — defines JSON schema for subsequent responses
+ */
+
+function hasStructuredOutput(cfg) {
+  return !!(cfg.response_format || cfg.jsonSchema || cfg.structuredOutput);
+}
+
+function getResponseFormat(cfg) {
+  if (cfg.response_format) return cfg.response_format;
+  if (cfg.jsonSchema) return { type: 'json_object', schema: cfg.jsonSchema };
+  if (cfg.structuredOutput) return { type: 'json_object', schema: cfg.structuredOutput };
+  return null;
+}
+
+module.exports = { hasStructuredOutput, getResponseFormat };

package/src/utils/system-prompt.js

@@ -25,6 +25,7 @@ function buildTiers(opts) {
     userHome = '',
     hasHistory = false,
     memoryFacts = [],
+    projectRules = '',
   } = opts;
   const displayBot = botName || 'Asistan';
   const displayBoss = bossName || userName || 'kullanıcı';
@@ -68,9 +69,10 @@ function buildTiers(opts) {
     skillsIndexBlock,
   ].filter(Boolean).join('\n');
 
-  // ── CONTEXT TIER (soul + cross-session, built once per resume) ──────
+  // ── CONTEXT TIER (soul + project rules + cross-session, built once per resume) ──────
   const context = [
     !isSmallModel && soulSummary ? `=== KISISELIK DOSYALARI ===\n${soulSummary}` : '',
+    projectRules ? `=== PROJE KURALLARI (CLAUDE.md) ===\n${projectRules}\n=== PROJE KURALLARI BITTI ===` : '',
     crossSessionContext ? `=== GECMIS KONUSMALAR ===\n${crossSessionContext}` : '',
   ].filter(Boolean).join('\n');
 
@@ -107,4 +109,28 @@ function stableContextKey(stable, context) {
   return stable + '|||' + context;
 }
 
-module.exports = { buildTiers, assemble, stableContextKey };
+/**
+ * CLAUDE.md auto-discover — proje kökünden oku.
+ * Cwd'den başlayıp parent dizinlere doğru CLAUDE.md arar.
+ */
+function discoverProjectRules(cwd) {
+  try {
+    const fs = require('fs');
+    const path = require('path');
+    let dir = path.resolve(cwd || process.cwd());
+    // En fazla 5 seviye yukarı çık
+    for (let i = 0; i < 5; i++) {
+      const candidate = path.join(dir, 'CLAUDE.md');
+      if (fs.existsSync(candidate)) {
+        const content = fs.readFileSync(candidate, 'utf8').trim();
+        if (content.length > 0) return content;
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break; // kök dizine ulaştık
+      dir = parent;
+    }
+  } catch {}
+  return '';
+}
+
+module.exports = { buildTiers, assemble, stableContextKey, discoverProjectRules };

package/src/utils/tasks.js

@@ -0,0 +1,132 @@
+/**
+ * tasks — Background task management (Claude Code: TaskCreate/TaskList/TaskStop)
+ *
+ * Tasks run as child processes with status tracking.
+ * Tools: CreateTask, ListTasks, StopTask, GetTaskResult
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const TASKS_FILE = path.join(os.homedir(), '.natureco', 'tasks.json');
+
+class TaskManager {
+  constructor() {
+    this.tasks = new Map();
+    this._load();
+  }
+
+  create(command, opts = {}) {
+    const id = `task_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const task = {
+      id,
+      command,
+      status: 'running',
+      createdAt: Date.now(),
+      completedAt: null,
+      exitCode: null,
+      stdout: '',
+      stderr: '',
+      cwd: opts.cwd || process.cwd(),
+    };
+    this.tasks.set(id, task);
+    this._save();
+
+    const proc = spawn(command, [], {
+      shell: true,
+      cwd: task.cwd,
+      timeout: opts.timeout || 300000,
+      env: { ...process.env, ...opts.env },
+    });
+
+    proc.stdout.on('data', data => { task.stdout += data.toString(); });
+    proc.stderr.on('data', data => { task.stderr += data.toString(); });
+    proc.on('close', code => {
+      task.status = code === 0 ? 'completed' : 'failed';
+      task.exitCode = code;
+      task.completedAt = Date.now();
+      this._save();
+    });
+    proc.on('error', err => {
+      task.status = 'failed';
+      task.stderr += err.message;
+      task.completedAt = Date.now();
+      this._save();
+    });
+
+    task._process = proc;
+    return { id, status: 'running' };
+  }
+
+  list() {
+    return Array.from(this.tasks.values()).map(t => ({
+      id: t.id,
+      status: t.status,
+      command: t.command.slice(0, 80),
+      createdAt: t.createdAt,
+      completedAt: t.completedAt,
+    }));
+  }
+
+  get(id) {
+    const task = this.tasks.get(id);
+    if (!task) return null;
+    return {
+      id: task.id,
+      command: task.command,
+      status: task.status,
+      stdout: task.stdout,
+      stderr: task.stderr,
+      exitCode: task.exitCode,
+      createdAt: task.createdAt,
+      completedAt: task.completedAt,
+    };
+  }
+
+  stop(id) {
+    const task = this.tasks.get(id);
+    if (!task || task.status !== 'running') return { error: 'Task not found or not running' };
+    if (task._process) {
+      task._process.kill('SIGTERM');
+      setTimeout(() => { if (task._process) task._process.kill('SIGKILL'); }, 5000);
+    }
+    task.status = 'stopped';
+    task.completedAt = Date.now();
+    this._save();
+    return { id, status: 'stopped' };
+  }
+
+  _save() {
+    try {
+      const data = Array.from(this.tasks.values()).map(t => ({
+        id: t.id, command: t.command, status: t.status,
+        createdAt: t.createdAt, completedAt: t.completedAt,
+        exitCode: t.exitCode, stdout: t.stdout, stderr: t.stderr,
+      }));
+      const dir = path.dirname(TASKS_FILE);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(TASKS_FILE, JSON.stringify(data, null, 2));
+    } catch {}
+  }
+
+  _load() {
+    try {
+      if (fs.existsSync(TASKS_FILE)) {
+        const data = JSON.parse(fs.readFileSync(TASKS_FILE, 'utf8'));
+        for (const t of data) {
+          this.tasks.set(t.id, { ...t, _process: null });
+        }
+      }
+    } catch {}
+  }
+}
+
+let _instance = null;
+function getTaskManager() {
+  if (!_instance) _instance = new TaskManager();
+  return _instance;
+}
+
+module.exports = { TaskManager, getTaskManager };

package/src/utils/tool-hooks.js

@@ -0,0 +1,154 @@
+/**
+ * tool-hooks — Pattern-based pre/post tool execution hooks (Claude Code style)
+ *
+ * Hooks defined in config under `toolHooks` key:
+ *   pre:  { "ToolName(pattern)": "allow" | "deny" | "ask" }
+ *   post: { "ToolName(pattern)": "notify" | "record" }
+ *
+ * Pattern syntax:
+ *   Bash(git *)        — Bash tool, args start with "git"
+ *   Read(src/**)       — Read tool, path starts with "src/"
+ *   Write(.env*)       — Write tool, path starts with ".env"
+ *   Edit(*)            — Edit tool, any path
+ *   *                  — All tools
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function loadRules() {
+  const rules = { pre: [], post: [] };
+  try {
+    const cfgPath = path.join(os.homedir(), '.natureco', 'config.json');
+    if (fs.existsSync(cfgPath)) {
+      const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+      if (cfg.toolHooks) {
+        if (cfg.toolHooks.pre) {
+          for (const [pattern, action] of Object.entries(cfg.toolHooks.pre)) {
+            rules.pre.push(parseRule(pattern, action));
+          }
+        }
+        if (cfg.toolHooks.post) {
+          for (const [pattern, action] of Object.entries(cfg.toolHooks.post)) {
+            rules.post.push(parseRule(pattern, action));
+          }
+        }
+      }
+    }
+  } catch {}
+  // Check project-level hooks.json
+  try {
+    const projectCfg = path.join(process.cwd(), '.natureco', 'hooks.json');
+    if (fs.existsSync(projectCfg)) {
+      const pCfg = JSON.parse(fs.readFileSync(projectCfg, 'utf8'));
+      if (pCfg.pre) {
+        for (const [pattern, action] of Object.entries(pCfg.pre)) {
+          rules.pre.push(parseRule(pattern, action));
+        }
+      }
+      if (pCfg.post) {
+        for (const [pattern, action] of Object.entries(pCfg.post)) {
+          rules.post.push(parseRule(pattern, action));
+        }
+      }
+    }
+  } catch {}
+  return rules;
+}
+
+function parseRule(pattern, action) {
+  // Pattern: ToolName(glob) or * for all
+  const match = pattern.match(/^(\*|[a-zA-Z_]+)\((.+)\)$/);
+  let toolName = '*';
+  let glob = '*';
+  if (match) {
+    toolName = match[1];
+    glob = match[2];
+  } else if (pattern !== '*') {
+    toolName = pattern;
+  }
+  return { toolName, glob, action, raw: pattern };
+}
+
+function matchGlob(str, glob) {
+  if (glob === '*') return true;
+  // Both * and ** match .* since we're matching flat arg strings, not file paths
+  const escaped = glob
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*/g, '.*')
+    .replace(/\*/g, '.*');
+  return new RegExp('^' + escaped + '$').test(str);
+}
+
+function flattenArgs(args) {
+  if (typeof args === 'string') return args;
+  if (args === null || args === undefined) return '';
+  const parts = [];
+  for (const [k, v] of Object.entries(args)) {
+    if (typeof v === 'string') parts.push(v);
+    else if (Array.isArray(v)) parts.push(...v.filter(x => typeof x === 'string'));
+    else if (typeof v === 'object' && v !== null) parts.push(JSON.stringify(v));
+  }
+  return parts.join(' ');
+}
+
+function matchRule(rule, toolName, args) {
+  if (rule.toolName !== '*' && rule.toolName !== toolName) return false;
+  // Try matching against flattened args first, then tool name
+  const flat = flattenArgs(args);
+  return matchGlob(flat, rule.glob) || matchGlob(toolName, rule.glob);
+}
+
+/**
+ * Check pre-hooks before tool execution.
+ * Returns { action: 'allow'|'deny'|'ask', rule, reason }
+ */
+function checkPreHooks(toolName, args) {
+  const rules = loadRules();
+  for (const rule of rules.pre) {
+    if (matchRule(rule, toolName, args)) {
+      if (rule.action === 'deny') {
+        return { action: 'deny', rule, reason: `Hook engelledi: ${rule.raw}` };
+      }
+      if (rule.action === 'ask') {
+        return { action: 'ask', rule, reason: `Hook onay gerektiriyor: ${rule.raw}` };
+      }
+      if (rule.action === 'allow') {
+        return { action: 'allow', rule, reason: '' };
+      }
+    }
+  }
+  return { action: 'allow', rule: null, reason: '' };
+}
+
+/**
+ * Run post-hooks after tool execution.
+ * Returns enriched result or original.
+ */
+function runPostHooks(toolName, args, result) {
+  const rules = loadRules();
+  for (const rule of rules.post) {
+    if (matchRule(rule, toolName, args)) {
+      try {
+        const hook = require(path.join(os.homedir(), '.natureco', 'hooks', rule.action));
+        if (typeof hook === 'function') {
+          return hook({ toolName, args, result }) || result;
+        }
+      } catch {}
+    }
+  }
+  return result;
+}
+
+/**
+ * Convert args to string for CLI permission display.
+ */
+function permissionSummary(rule, toolName, args) {
+  const argsStr = Object.entries(args || {})
+    .map(([k, v]) => `${k}=${String(v).slice(0, 60)}`)
+    .join(', ');
+  return `${toolName}(${argsStr}) — ${rule.raw}`;
+}
+
+module.exports = { checkPreHooks, runPostHooks, loadRules, matchGlob, matchRule, permissionSummary, flattenArgs };

package/src/utils/tools.js

@@ -8,6 +8,12 @@
 const fs = require('fs');
 const path = require('path');
 const { globalRegistry } = require('./registry');
+const sandbox = require('./sandbox');
+
+// Lazy config read — avoids circular deps
+function _getSandboxLevel() {
+  try { return sandbox.getLevel(require('./config').getConfig()); } catch { return 'none'; }
+}
 
 const TOOLS_DIR = path.join(__dirname, '..', 'tools');
 
@@ -294,6 +300,16 @@ async function executeTool(toolName, args, toolDefs) {
       return { error: `${toolName} şu anda kullanılamıyor (check_fn engelledi)` };
     }
   }
+
+  // Sandbox restrictions for bash/shell_command
+  if (toolName === 'bash' || toolName === 'shell_command') {
+    const level = _getSandboxLevel();
+    const cmd = (args && args.command) || '';
+    if (level === 'strict' && sandbox.isNetworkCommand(cmd)) {
+      return { error: 'strict sandbox: network komutları engellendi. Daha düşük sandbox seviyesi kullanın.' };
+    }
+  }
+
   try {
     const result = await tool.execute(args || {});
     return { result };

package/src/utils/ultra-review.js

@@ -0,0 +1,59 @@
+/**
+ * ultra-review — Multi-agent code review
+ *
+ * Spawns parallel review agents focused on different aspects:
+ *   - Security: secret scanning, injection risks
+ *   - Style: code conventions, formatting
+ *   - Logic: correctness, edge cases
+ *   - Performance: optimization opportunities
+ *
+ * Uses natureco's existing agent system for reviews.
+ */
+
+const path = require('path');
+
+const REVIEW_FOCUS = {
+  security: {
+    name: 'Security Review',
+    prompt: 'Review the following code for security issues: secret exposure, injection vulnerabilities, unsafe deserialization, path traversal, command injection. Return issues with severity (high/medium/low) and line references.',
+  },
+  style: {
+    name: 'Style Review',
+    prompt: 'Review the following code for style issues: naming conventions, formatting consistency, code organization, documentation quality, adherence to project conventions.',
+  },
+  logic: {
+    name: 'Logic Review',
+    prompt: 'Review the following code for logic issues: correctness, edge cases, error handling, race conditions, type safety, off-by-one errors, boundary conditions.',
+  },
+  performance: {
+    name: 'Performance Review',
+    prompt: 'Review the following code for performance issues: unnecessary allocations, O(n²) algorithms, memory leaks, blocking operations, caching opportunities, bundle size impact.',
+  },
+};
+
+function reviewFile(filePath, content) {
+  const issues = [];
+  for (const [focus, info] of Object.entries(REVIEW_FOCUS)) {
+    issues.push({
+      focus,
+      title: info.name,
+      prompt: info.prompt,
+      file: filePath,
+    });
+  }
+  return { file: filePath, size: content.length, reviews: issues };
+}
+
+function reviewDiff(diffContent) {
+  const issues = [];
+  for (const [focus, info] of Object.entries(REVIEW_FOCUS)) {
+    issues.push({
+      focus,
+      title: info.name,
+      prompt: info.prompt + `\n\nDiff:\n${diffContent.slice(0, 8000)}`,
+    });
+  }
+  return { reviews: issues };
+}
+
+module.exports = { reviewFile, reviewDiff, REVIEW_FOCUS };