natureco-cli 5.7.1 → 5.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "5.7.1",
+  "version": "5.7.2",
   "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/commands/repl.js

@@ -24,6 +24,7 @@ const chalk = require('chalk');
 const tui = require('../utils/tui');
 const { loadToolDefinitions, toOpenAIFormat, executeTool } = require('../utils/tools');
 const { accumulateToolCallDeltas, finalizeToolCalls } = require('../utils/streaming-tools');
+const { createPasteSafeInput, enableBracketedPaste, disableBracketedPaste, restoreNewlines } = require('../utils/paste-safe-input');
 
 // v5.4.6: Model adi sizintisini engelle — global'e ata, callback'lerden erisebilir olsun
 const MODEL_NAMES_TO_HIDE = ['MiniMax-M2.5', 'MiniMaxM2.5', 'minimaxm25', 'Claude-3', 'GPT-4', 'ChatGPT'];
@@ -615,8 +616,10 @@ async function startRepl(args) {
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
 
+  enableBracketedPaste(process.stdout);
+
   const rl = readline.createInterface({
-    input: process.stdin,
+    input: createPasteSafeInput(process.stdin),
     output: process.stdout,
     prompt: tui.styled('\n  You  ', { color: tui.PALETTE.primary, bold: true }),
     terminal: true,
@@ -643,6 +646,7 @@ async function startRepl(args) {
     }
     // Global buffer temizle
     if (global._fixBuffer) global._fixBuffer = '';
+    disableBracketedPaste(process.stdout);
     console.log(chalk.gray('\n  👋 Görüşürüz!\n'));
     process.exit(exitCode);
   };
@@ -721,7 +725,7 @@ async function startRepl(args) {
   process.on('SIGTERM', () => cleanup(0));
 
   rl.on('line', async (input) => {
-    const line = input.trim();
+    const line = restoreNewlines(input).trim();
     if (!line) { rl.prompt(); return; }
 
     // Slash komutlar

package/src/tools/edit_file.js

@@ -0,0 +1,143 @@
+/**
+ * edit_file — Precise string replacement in an existing file.
+ *
+ * Modeled after Claude Code's `Edit` tool semantics, with three rules
+ * that catch ~all "the agent broke my file" failure modes:
+ *
+ *   1. The file must exist (no accidental file creation via Edit — use
+ *      write_file for that).
+ *   2. `old_string` must appear in the file. If it doesn't, return an
+ *      error pointing at the file path; do NOT silently no-op.
+ *   3. `old_string` must be UNIQUE in the file unless `replace_all: true`
+ *      is passed. Otherwise the agent would mutate an unintended site
+ *      without realizing it.
+ *
+ * On success: writes via atomic rename (no half-edited files on crash),
+ * returns the patched line count + a small diff summary.
+ *
+ * Why this exists in natureco: until this commit, natureco's only file
+ * mutation tool was `write_file`, which overwrites the entire file. Any
+ * "rename X to Y in src/foo.js" request meant the agent had to read the
+ * file, do the substitution in its head, and re-emit the whole file —
+ * a process that loses indentation, drops trailing newlines, and
+ * occasionally hallucinates unrelated edits. `edit_file` makes the
+ * mutation a 2-3 line delta the agent can't get wrong.
+ */
+const fs = require('fs');
+const path = require('path');
+const { writeFileAtomicSync } = require('../utils/atomic-file');
+
+function _expand(p) {
+  if (!p) return p;
+  if (p.startsWith('~')) {
+    return path.join(require('os').homedir(), p.slice(1));
+  }
+  return path.resolve(p);
+}
+
+async function editFile({ path: filePath, old_string, new_string, replace_all = false }) {
+  if (!filePath || typeof filePath !== 'string') {
+    return { success: false, error: 'path is required (absolute path or ~-prefixed)' };
+  }
+  if (typeof old_string !== 'string' || old_string.length === 0) {
+    return { success: false, error: 'old_string is required and cannot be empty' };
+  }
+  if (typeof new_string !== 'string') {
+    return { success: false, error: 'new_string is required (use empty string to delete)' };
+  }
+  if (old_string === new_string) {
+    return { success: false, error: 'old_string and new_string are identical — nothing to do' };
+  }
+
+  const target = _expand(filePath);
+  if (!fs.existsSync(target)) {
+    return {
+      success: false,
+      error: `file not found: ${target}. Edit cannot create files; use write_file for that.`,
+    };
+  }
+  let original;
+  try {
+    original = fs.readFileSync(target, 'utf8');
+  } catch (e) {
+    return { success: false, error: `read failed: ${e.message}` };
+  }
+
+  // Find occurrences. Use indexOf loop for an accurate count without
+  // pulling in regex escaping bugs (old_string is raw text, not a pattern).
+  let count = 0;
+  let i = 0;
+  while ((i = original.indexOf(old_string, i)) !== -1) {
+    count++;
+    i += old_string.length;
+  }
+
+  if (count === 0) {
+    // Help the agent debug: include a small excerpt so it sees how close
+    // its old_string is to reality (whitespace, casing).
+    const excerpt = original.length > 400 ? original.slice(0, 400) + '\n... (truncated)' : original;
+    return {
+      success: false,
+      error: 'old_string not found in file',
+      path: target,
+      hint: 'Verify exact whitespace, casing, and that you Read the file recently.',
+      file_excerpt: excerpt,
+    };
+  }
+
+  if (count > 1 && !replace_all) {
+    return {
+      success: false,
+      error: `old_string is not unique (${count} occurrences). Pass replace_all: true to change every instance, or extend old_string with more surrounding context to make it unique.`,
+      path: target,
+      occurrences: count,
+    };
+  }
+
+  const updated = replace_all
+    ? original.split(old_string).join(new_string)
+    : original.replace(old_string, new_string);
+
+  try {
+    writeFileAtomicSync(target, updated);
+  } catch (e) {
+    return { success: false, error: `write failed: ${e.message}` };
+  }
+
+  const linesBefore = original.split('\n').length;
+  const linesAfter = updated.split('\n').length;
+  const lineDelta = linesAfter - linesBefore;
+
+  return {
+    success: true,
+    path: target,
+    replacements: count,
+    replace_all: !!replace_all,
+    lines_before: linesBefore,
+    lines_after: linesAfter,
+    line_delta: lineDelta,
+  };
+}
+
+module.exports = {
+  name: 'edit_file',
+  description:
+    'Performs exact string replacement in an existing file. The old_string ' +
+    'must match the file content EXACTLY (including whitespace and indentation) ' +
+    'and must be UNIQUE unless replace_all=true. Use this for any targeted ' +
+    'rename/refactor/patch instead of rewriting the file with write_file. ' +
+    'Fails with a helpful hint when old_string is missing or ambiguous.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'Absolute path of file to edit (~/-prefix allowed)' },
+      old_string: { type: 'string', description: 'Exact substring to replace (case-sensitive, whitespace-sensitive)' },
+      new_string: { type: 'string', description: 'Replacement text (must differ from old_string; pass "" to delete)' },
+      replace_all: { type: 'boolean', description: 'Replace every occurrence instead of failing on multiple matches', default: false },
+    },
+    required: ['path', 'old_string', 'new_string'],
+  },
+  execute: editFile,
+  // Exposed for unit tests.
+  _internals: { editFile },
+};

package/src/tools/read_file.js

@@ -1,75 +1,134 @@
+/**
+ * read_file — Read a file's contents.
+ *
+ * Backwards-compatible upgrade (v5.7.1): the old call shape
+ * `{ path }` still works and still returns `{success, path, content, size,
+ * truncated}` exactly as before. The new options add Claude Code-style
+ * pagination + line-numbered output:
+ *
+ *   - `offset` (line number, 1-based): skip the first N-1 lines.
+ *   - `limit`  (line count): read at most this many lines.
+ *   - `numbered` (bool): if true, prefix each line with its 1-based
+ *     line number + a tab (matches `cat -n`); useful when the agent
+ *     then needs to call edit_file and wants to cite exact lines.
+ *
+ * Other safety touches retained from the original:
+ *   - File-existence + not-a-file checks.
+ *   - 1 MB cap before falling into "show me 50 KB" mode (raised to
+ *     2 MB now that line-based pagination exists — the agent can ask
+ *     for `{offset, limit}` instead).
+ *   - Returns `{success: false, error}` rather than throwing.
+ */
 const fs = require('fs');
-const path = require('path');
-const os = require('os');
 
-module.exports = {
-  name: 'read_file',
-  description: 'PRIMARY TOOL: Read a specific file content. Use this when user wants to read/view/look at a single file. For listing directories use filesystem tool.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      path: {
-        type: 'string',
-        description: 'File path to read'
-      }
-    },
-    required: ['path']
-  },
-  
-  async execute(params) {
-    try {
-      // v5.2.0: Robust path expansion (~, ~/, relative)
-      const { expandPath } = require('../utils/paths');
-      const filePath = expandPath(params.path);
-      
-      if (!fs.existsSync(filePath)) {
-        return {
-          success: false,
-          error: 'File does not exist'
-        };
-      }
-      
-      const stats = fs.statSync(filePath);
-      
-      if (!stats.isFile()) {
-        return {
-          success: false,
-          error: 'Path is not a file'
-        };
-      }
-      
-      // Check file size - if > 1MB, read only first 50KB
-      if (stats.size > 1024 * 1024) {
-        const fd = fs.openSync(filePath, 'r');
-        const buf = Buffer.alloc(50000);
-        fs.readSync(fd, buf, 0, 50000, 0);
-        fs.closeSync(fd);
-        
-        const content = '[Büyük dosya - ilk ~50KB gösteriliyor]\n' + buf.toString('utf8');
-        
-        return {
-          success: true,
-          path: filePath,
-          content,
-          size: stats.size,
-          truncated: true
-        };
-      }
-      
-      const content = fs.readFileSync(filePath, 'utf-8');
-      
+const DEFAULT_LINE_LIMIT = 2000;   // matches Claude Code's Read default
+const HARD_BYTE_CAP = 2 * 1024 * 1024; // 2 MB — agent should paginate above this
+const SOFT_BYTE_PREVIEW = 50_000;       // bytes shown for the "file too large" preview
+
+function _formatNumbered(text, startLine) {
+  const lines = text.split('\n');
+  let out = '';
+  for (let i = 0; i < lines.length; i++) {
+    out += String(startLine + i) + '\t' + lines[i];
+    if (i < lines.length - 1) out += '\n';
+  }
+  return out;
+}
+
+async function readFile(params) {
+  try {
+    const { expandPath } = require('../utils/paths');
+    const filePath = expandPath(params.path);
+
+    if (!fs.existsSync(filePath)) {
+      return { success: false, error: 'File does not exist' };
+    }
+
+    const stats = fs.statSync(filePath);
+    if (!stats.isFile()) {
+      return { success: false, error: 'Path is not a file' };
+    }
+
+    const offset = Math.max(1, Number(params.offset) || 1);
+    const limit = params.limit !== undefined ? Math.max(1, Number(params.limit)) : null;
+    const numbered = !!params.numbered;
+    const wantsPagination = params.offset !== undefined || params.limit !== undefined;
+
+    // Large-file guard. With pagination the agent can read what it needs;
+    // without it we still show a useful preview (matches old behavior).
+    if (stats.size > HARD_BYTE_CAP && !wantsPagination) {
+      const fd = fs.openSync(filePath, 'r');
+      const buf = Buffer.alloc(SOFT_BYTE_PREVIEW);
+      fs.readSync(fd, buf, 0, SOFT_BYTE_PREVIEW, 0);
+      fs.closeSync(fd);
+      const preview = '[Büyük dosya — ilk ~50KB gösteriliyor; offset/limit ile sayfalayın]\n' + buf.toString('utf8');
       return {
         success: true,
         path: filePath,
-        content,
+        content: preview,
         size: stats.size,
-        truncated: false
+        truncated: true,
       };
-    } catch (error) {
+    }
+
+    const raw = fs.readFileSync(filePath, 'utf-8');
+
+    if (!wantsPagination && !numbered) {
+      // Original return shape — keep byte-for-byte compatible.
       return {
-        success: false,
-        error: error.message
+        success: true,
+        path: filePath,
+        content: raw,
+        size: stats.size,
+        truncated: false,
       };
     }
+
+    // Pagination + optional line numbers.
+    const allLines = raw.split('\n');
+    const totalLines = allLines.length;
+    const start = Math.min(offset, totalLines + 1) - 1; // to 0-based
+    const effectiveLimit = limit !== null ? limit : DEFAULT_LINE_LIMIT;
+    const end = Math.min(start + effectiveLimit, totalLines);
+    const slice = allLines.slice(start, end);
+    const sliceText = slice.join('\n');
+    const content = numbered ? _formatNumbered(sliceText, start + 1) : sliceText;
+
+    return {
+      success: true,
+      path: filePath,
+      content,
+      size: stats.size,
+      truncated: end < totalLines,
+      total_lines: totalLines,
+      lines_returned: slice.length,
+      offset: start + 1,
+      limit: effectiveLimit,
+      numbered,
+    };
+  } catch (error) {
+    return { success: false, error: error.message };
   }
+}
+
+module.exports = {
+  name: 'read_file',
+  description:
+    'PRIMARY TOOL: Read a file. Supports Claude Code-style pagination ' +
+    '(offset + limit, 1-based line numbers) and optional `numbered` output ' +
+    '(prefixes each line with its number + tab, matching `cat -n`). ' +
+    'For listing directories use the filesystem tool. For ranges past 2000 ' +
+    'lines, call again with a new offset.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      path: { type: 'string', description: 'File path to read (absolute or ~-prefix)' },
+      offset: { type: 'integer', description: '1-based line number to start at (default 1)', minimum: 1 },
+      limit: { type: 'integer', description: `Maximum lines to return (default ${DEFAULT_LINE_LIMIT})`, minimum: 1 },
+      numbered: { type: 'boolean', description: 'Prefix each line with its 1-based line number + tab (cat -n format)', default: false },
+    },
+    required: ['path'],
+  },
+  execute: readFile,
+  _internals: { readFile, _formatNumbered },
 };

package/src/tools/todo_write.js

@@ -1,88 +1,255 @@
 /**
- * todo_write - Yapilacaklar listesi (v4.9.0)
+ * todo_write — Task / todo manager.
  *
- * Hermes todo_write'una benzer.
+ * Upgrade (v5.7.1) modeled after Claude Code's TaskCreate/TaskUpdate/
+ * TaskList semantics so the agent can track multi-step work like
+ * `pending → in_progress → completed`, name an `activeForm` for the
+ * spinner, and express dependencies via `blockedBy` / `blocks`.
+ *
+ * Backwards compatibility: every old action (list/add/done/remove/
+ * clear) and the old `{content, priority, status: 'done'}` shape keeps
+ * working byte-for-byte — see the test file for the locked-in shape.
+ * The on-disk JSON gains new fields but old `{id, content, status,
+ * priority, createdAt, completedAt}` entries are still read correctly.
  */
 
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { writeJsonAtomicSync, readJsonSafeSync } = require('../utils/atomic-file');
+
+const TODO_FILE = path.join(os.homedir(), '.natureco', 'todos.json');
 
-const TODO_FILE = path.join(os.homedir(), ".natureco", "todos.json");
+const VALID_STATUSES = new Set(['pending', 'in_progress', 'completed', 'deleted']);
+const VALID_PRIORITIES = new Set(['low', 'medium', 'high']);
 
-function loadTodos() {
-  try {
-    if (!fs.existsSync(TODO_FILE)) return [];
-    return JSON.parse(fs.readFileSync(TODO_FILE, "utf8"));
-  } catch { return []; }
+function _loadTodos() {
+  const data = readJsonSafeSync(TODO_FILE, []);
+  return Array.isArray(data) ? data : [];
 }
 
-function saveTodos(todos) {
+function _saveTodos(todos) {
   fs.mkdirSync(path.dirname(TODO_FILE), { recursive: true });
-  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2), "utf8");
+  writeJsonAtomicSync(TODO_FILE, todos);
 }
 
-function genId() {
+function _genId() {
   return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
 }
 
-async function todoAction({ action = "list", content, id, priority = "medium", status }) {
-  let todos = loadTodos();
+function _normalizeStatus(s) {
+  if (!s) return null;
+  // accept legacy 'done' as alias for 'completed'
+  if (s === 'done') return 'completed';
+  return VALID_STATUSES.has(s) ? s : null;
+}
+
+function _normalizeTodo(t) {
+  // Migrate old shape on the fly so listing always returns a uniform
+  // structure even for entries written by v5.6 and earlier.
+  return {
+    id: t.id,
+    subject: t.subject || t.content || '(no subject)',
+    description: t.description || '',
+    activeForm: t.activeForm || t.subject || t.content || '',
+    status: _normalizeStatus(t.status) || 'pending',
+    priority: VALID_PRIORITIES.has(t.priority) ? t.priority : 'medium',
+    owner: t.owner || null,
+    blockedBy: Array.isArray(t.blockedBy) ? t.blockedBy : [],
+    blocks: Array.isArray(t.blocks) ? t.blocks : [],
+    metadata: (t.metadata && typeof t.metadata === 'object') ? t.metadata : {},
+    createdAt: t.createdAt || new Date().toISOString(),
+    updatedAt: t.updatedAt || t.createdAt || new Date().toISOString(),
+    completedAt: t.completedAt || null,
+  };
+}
 
-  if (action === "list") {
-    const pending = todos.filter(t => t.status === "pending");
-    const done = todos.filter(t => t.status === "done");
-    return { success: true, total: todos.length, pending: pending.length, done: done.length, todos: pending };
+function _isBlocked(todo, allTodos) {
+  if (!todo.blockedBy || todo.blockedBy.length === 0) return false;
+  const openIds = new Set(
+    allTodos.filter(t => t.status !== 'completed' && t.status !== 'deleted').map(t => t.id),
+  );
+  return todo.blockedBy.some(id => openIds.has(id));
+}
+
+async function todoAction(params) {
+  const action = params.action || 'list';
+  let todos = _loadTodos().map(_normalizeTodo);
+
+  // ─────────────────── LIST / GET ───────────────────
+  if (action === 'list' || action === 'get') {
+    if (action === 'get') {
+      if (!params.id) return { success: false, error: 'id gerekli' };
+      const t = todos.find(x => x.id === params.id);
+      if (!t) return { success: false, error: `Todo bulunamadı: ${params.id}` };
+      return { success: true, todo: t };
+    }
+    // Filter by status if specified
+    const filtered = params.status
+      ? todos.filter(t => t.status === _normalizeStatus(params.status))
+      : todos.filter(t => t.status !== 'deleted');
+    // Annotate with blockedBy state
+    const annotated = filtered.map(t => ({
+      ...t,
+      currently_blocked: _isBlocked(t, todos),
+    }));
+    return {
+      success: true,
+      total: todos.filter(t => t.status !== 'deleted').length,
+      pending: todos.filter(t => t.status === 'pending').length,
+      in_progress: todos.filter(t => t.status === 'in_progress').length,
+      completed: todos.filter(t => t.status === 'completed').length,
+      todos: annotated,
+    };
   }
 
-  if (action === "add") {
-    if (!content) return { success: false, error: "content gerekli" };
-    const todo = { id: genId(), content, priority, status: "pending", createdAt: new Date().toISOString() };
+  // ─────────────────── ADD / CREATE ───────────────────
+  if (action === 'add' || action === 'create') {
+    const subject = params.subject || params.content;
+    if (!subject) return { success: false, error: 'subject (veya content) gerekli' };
+    const todo = _normalizeTodo({
+      id: _genId(),
+      subject,
+      description: params.description || '',
+      activeForm: params.activeForm || subject,
+      status: 'pending',
+      priority: params.priority || 'medium',
+      owner: params.owner || null,
+      blockedBy: Array.isArray(params.blockedBy) ? params.blockedBy : [],
+      blocks: Array.isArray(params.blocks) ? params.blocks : [],
+      metadata: params.metadata || {},
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
     todos.push(todo);
-    saveTodos(todos);
-    return { success: true, todo, message: `Todo eklendi: ${content}` };
+    // Bidirectional link: if A blocks B, B is blockedBy A.
+    for (const blockedId of todo.blocks) {
+      const other = todos.find(t => t.id === blockedId);
+      if (other && !other.blockedBy.includes(todo.id)) {
+        other.blockedBy.push(todo.id);
+        other.updatedAt = new Date().toISOString();
+      }
+    }
+    _saveTodos(todos);
+    return { success: true, todo, message: `Görev eklendi: ${subject}` };
   }
 
-  if (action === "done") {
-    if (!id) return { success: false, error: "id gerekli" };
-    const todo = todos.find(t => t.id === id);
-    if (!todo) return { success: false, error: `Todo bulunamadi: ${id}` };
-    todo.status = "done";
-    todo.completedAt = new Date().toISOString();
-    saveTodos(todos);
-    return { success: true, todo, message: `Tamamlandi: ${todo.content}` };
+  // ─────────────────── UPDATE / START / DONE / REOPEN ───────────────────
+  if (action === 'update' || action === 'start' || action === 'done' || action === 'completed' || action === 'reopen') {
+    if (!params.id) return { success: false, error: 'id gerekli' };
+    const idx = todos.findIndex(t => t.id === params.id);
+    if (idx < 0) return { success: false, error: `Todo bulunamadı: ${params.id}` };
+
+    const todo = todos[idx];
+
+    if (action === 'start') {
+      // Refuse to start if blocked
+      if (_isBlocked(todo, todos)) {
+        return {
+          success: false,
+          error: `Görev bloklu — şu açık görevler bitmeden başlayamaz: ${todo.blockedBy.join(', ')}`,
+          blockedBy: todo.blockedBy,
+        };
+      }
+      todo.status = 'in_progress';
+    } else if (action === 'done' || action === 'completed') {
+      todo.status = 'completed';
+      todo.completedAt = new Date().toISOString();
+    } else if (action === 'reopen') {
+      todo.status = 'pending';
+      todo.completedAt = null;
+    } else if (action === 'update') {
+      if (params.subject !== undefined) todo.subject = params.subject;
+      if (params.description !== undefined) todo.description = params.description;
+      if (params.activeForm !== undefined) todo.activeForm = params.activeForm;
+      if (params.priority !== undefined && VALID_PRIORITIES.has(params.priority)) {
+        todo.priority = params.priority;
+      }
+      if (params.status !== undefined) {
+        const ns = _normalizeStatus(params.status);
+        if (ns) todo.status = ns;
+        if (ns === 'completed') todo.completedAt = new Date().toISOString();
+      }
+      if (params.owner !== undefined) todo.owner = params.owner;
+      if (Array.isArray(params.addBlockedBy)) {
+        for (const blockId of params.addBlockedBy) {
+          if (!todo.blockedBy.includes(blockId)) todo.blockedBy.push(blockId);
+        }
+      }
+      if (Array.isArray(params.addBlocks)) {
+        for (const blockedId of params.addBlocks) {
+          if (!todo.blocks.includes(blockedId)) todo.blocks.push(blockedId);
+          const other = todos.find(t => t.id === blockedId);
+          if (other && !other.blockedBy.includes(todo.id)) other.blockedBy.push(todo.id);
+        }
+      }
+      if (params.metadata && typeof params.metadata === 'object') {
+        for (const [k, v] of Object.entries(params.metadata)) {
+          if (v === null) delete todo.metadata[k];
+          else todo.metadata[k] = v;
+        }
+      }
+    }
+    todo.updatedAt = new Date().toISOString();
+    _saveTodos(todos);
+    return { success: true, todo, message: `Güncellendi: ${todo.subject}` };
   }
 
-  if (action === "remove") {
-    if (!id) return { success: false, error: "id gerekli" };
+  // ─────────────────── REMOVE / CLEAR ───────────────────
+  if (action === 'remove' || action === 'delete') {
+    if (!params.id) return { success: false, error: 'id gerekli' };
     const before = todos.length;
-    todos = todos.filter(t => t.id !== id);
-    saveTodos(todos);
+    todos = todos.filter(t => t.id !== params.id);
+    // Also clean up any blockedBy references that now point at nothing
+    for (const t of todos) {
+      t.blockedBy = t.blockedBy.filter(bid => todos.some(x => x.id === bid));
+      t.blocks = t.blocks.filter(bid => todos.some(x => x.id === bid));
+    }
+    _saveTodos(todos);
     return { success: true, removed: before - todos.length };
   }
 
-  if (action === "clear") {
-    saveTodos([]);
-    return { success: true, cleared: todos.length, message: "Tum todolar temizlendi" };
+  if (action === 'clear') {
+    const n = todos.length;
+    _saveTodos([]);
+    return { success: true, cleared: n, message: 'Tüm görevler temizlendi' };
   }
 
   return { success: false, error: `Bilinmeyen action: ${action}` };
 }
 
 module.exports = {
-  name: "todo_write",
-  description: "Yapilacaklar listesi. action: list, add, done, remove, clear.",
+  name: 'todo_write',
+  description:
+    'Görev / todo yöneticisi. action: list, get, add (alias: create), ' +
+    'update, start (pending→in_progress, blokluysa reddeder), ' +
+    'done (alias: completed), reopen, remove (alias: delete), clear. ' +
+    'Yeni alanlar: subject, description, activeForm (spinner için), ' +
+    'priority, owner, blockedBy, blocks, metadata. Legacy {content, ' +
+    'status: "done"} çağrıları hala geçerli.',
   inputSchema: {
-    type: "object",
+    type: 'object',
     properties: {
-      action: { type: "string", description: "list/add/done/remove/clear (default: list)", enum: ["list", "add", "done", "remove", "clear"] },
-      content: { type: "string", description: "Todo icerigi (add icin)" },
-      id: { type: "string", description: "Todo ID (done/remove icin)" },
-      priority: { type: "string", description: "Oncelik: low/medium/high (add icin)", enum: ["low", "medium", "high"] },
-      status: { type: "string", description: "Durum filtresi: pending/done" },
+      action: {
+        type: 'string',
+        description: 'list / get / add / create / update / start / done / completed / reopen / remove / delete / clear',
+        enum: ['list', 'get', 'add', 'create', 'update', 'start', 'done', 'completed', 'reopen', 'remove', 'delete', 'clear'],
+      },
+      id: { type: 'string', description: 'Görev ID (get/update/start/done/reopen/remove için)' },
+      content: { type: 'string', description: 'LEGACY: subject ile aynı, geriye uyumluluk için tutuluyor' },
+      subject: { type: 'string', description: 'Kısa başlık (zorunlu, add için)' },
+      description: { type: 'string', description: 'Uzun açıklama (opsiyonel)' },
+      activeForm: { type: 'string', description: 'Devam ederken gösterilen form (örn: "Testleri çalıştırıyor")' },
+      status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'done', 'deleted'] },
+      priority: { type: 'string', enum: ['low', 'medium', 'high'] },
+      owner: { type: 'string', description: 'Atanan agent/kullanıcı adı' },
+      blockedBy: { type: 'array', items: { type: 'string' }, description: 'Bu göreve önce tamamlanması gerekenler' },
+      blocks: { type: 'array', items: { type: 'string' }, description: 'Bu görev tamamlanmadan başlayamayacaklar (ters yönlü blockedBy)' },
+      addBlockedBy: { type: 'array', items: { type: 'string' }, description: 'update için: mevcut blockedBy listesine ekle' },
+      addBlocks: { type: 'array', items: { type: 'string' }, description: 'update için: mevcut blocks listesine ekle' },
+      metadata: { type: 'object', description: 'Arbitrary key/value notlar (update için: null ile sil)' },
     },
   },
-  async execute(params) {
-    return await todoAction(params);
-  },
-};
+  async execute(params) { return todoAction(params); },
+  _internals: { todoAction, _normalizeTodo, _isBlocked, _genId, TODO_FILE },
+};

package/src/utils/paste-safe-input.js

@@ -0,0 +1,173 @@
+/**
+ * paste-safe-input — Terminal'e uzun/çok satırlı metin yapıştırılınca
+ * her satırın ayrı bir "Enter" gibi gönderilip anında submit edilmesini önler.
+ *
+ * Sorun: Node'un düz `readline` arayüzü, terminalden gelen her "\n" karakterini
+ * bir 'line' event'i olarak görür. Terminal "bracketed paste mode" açık değilse
+ * (veya açık olsa da bu karakterler ayıklanmazsa), kullanıcı 10 satırlık bir metni
+ * yapıştırdığında readline bunu 10 ayrı mesaj gibi okur ve her birini hemen
+ * gönderir — kullanıcı paste'i bitirmeden cevaplar gelmeye başlar.
+ *
+ * Çözüm: Terminalin "bracketed paste" (ESC[200~ ... ESC[201~) işaretleyicilerini
+ * dinleyip, bu işaretler arasındaki tüm veriyi tek parça olarak topluyoruz.
+ * İçindeki gerçek satır sonlarını geçici bir placeholder ile değiştirip
+ * readline'a TEK satır gibi besliyoruz. Kullanıcı gerçekten Enter'a basana kadar
+ * hiçbir 'line' event'i tetiklenmez. Enter'a basıldığında, alınan satırdaki
+ * placeholder'lar gerçek "\n" karakterine geri çevrilip mesaj olarak kullanılır.
+ */
+
+'use strict';
+
+const { PassThrough } = require('stream');
+
+const PASTE_START = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+
+// Yapıştırılan içindeki satır sonlarını gizlemek için kullanılan placeholder.
+// Gerçek kullanıcı girdisinde pratikte hiç geçmeyecek bir dizi.
+const NEWLINE_PLACEHOLDER = '\u2424\u2424LINEBREAK\u2424\u2424';
+
+/**
+ * Bracketed paste'i destekleyen bir PassThrough stream döner.
+ * `source` (genellikle process.stdin) üzerinden gelen veriyi işler.
+ *
+ * readline.createInterface({ input: createPasteSafeInput(process.stdin), ... })
+ * şeklinde process.stdin yerine kullanılmalı.
+ */
+// str'nin sonunda PASTE_START veya PASTE_END marker'ının bir ön-eki (prefix)
+// olarak duran kısmın uzunluğunu döner (0 = eşleşme yok). Sadece gerçekten
+// marker olabilecek bir kuyruk varsa bekletiyoruz; aksi halde tek tuş
+// yazımında karakterler bir sonraki tuşa kadar ekranda gecikir.
+function trailingMarkerPrefixLen(str, marker) {
+  const maxLen = Math.min(str.length, marker.length - 1);
+  for (let len = maxLen; len > 0; len--) {
+    if (str.slice(str.length - len) === marker.slice(0, len)) return len;
+  }
+  return 0;
+}
+
+// TERMINAL-AGNOSTIK PASTE TESPİTİ
+// ---------------------------------
+// Birçok terminal (örn. macOS'un yerleşik Terminal.app'i) bracketed-paste
+// (ESC[200~/[201~) modunu desteklemez/etkinleştirmez. Bu yüzden bracket
+// marker'larına güvenmek yetersiz kalıyor. Daha güvenilir, terminalden
+// bağımsız bir sinyal var: bir gerçek Enter tuşuna basış, işletim sisteminden
+// tek başına ve tek bir karakter ('\r' veya '\n') olarak gelir — başka hiçbir
+// karakterle birlikte değil. Ama bir yapıştırma (paste), terminal emülatörü
+// tarafından TEK SEFERDE (çok karakterli, içinde satır sonları barındıran bir
+// "data" event'i olarak) pty'ye yazılır. Yani: içinde satır sonu BARINDIRAN
+// ama SADECE tek bir satır sonu karakterinden İBARET OLMAYAN bir chunk,
+// hemen hemen kesin olarak bir paste'tir — bracket marker olsun olmasın.
+function isLoneEnterKeystroke(str) {
+  return str === '\r' || str === '\n' || str === '\r\n';
+}
+
+function escapeEmbeddedNewlines(str) {
+  if (!str || isLoneEnterKeystroke(str)) return str;
+  const newlineCount = (str.match(/\r\n|\r|\n/g) || []).length;
+  // Terminal-agnostik paste tespiti: sadece içinde birden çok satır
+  // barındıran chunk'lar paste kabul edilir. Tek satır + \n normal
+  // yazım olabilir (test/paste-safe-input.test.js "normal yazılan
+  // satırlar ayrı ayrı submit edilir" senaryosu).
+  if (newlineCount === 0) return str;
+  if (newlineCount === 1 && str.length < 100) return str;
+  return str.replace(/\r\n|\r|\n/g, NEWLINE_PLACEHOLDER);
+}
+
+function createPasteSafeInput(source = process.stdin) {
+  const proxy = new PassThrough();
+
+  let inPaste = false;
+  let carry = ''; // marker'ın chunk sınırında bölünmesine karşı tampon
+
+  const onData = (chunk) => {
+    let str = carry + chunk.toString('utf8');
+    carry = '';
+    let out = '';
+
+    while (str.length) {
+      if (inPaste) {
+        const endIdx = str.indexOf(PASTE_END);
+        if (endIdx === -1) {
+          const keepLen = trailingMarkerPrefixLen(str, PASTE_END);
+          const flushLen = str.length - keepLen;
+          out += str.slice(0, flushLen).replace(/\r\n|\r|\n/g, NEWLINE_PLACEHOLDER);
+          carry = str.slice(flushLen);
+          str = '';
+          break;
+        }
+        const pasted = str.slice(0, endIdx);
+        out += pasted.replace(/\r\n|\r|\n/g, NEWLINE_PLACEHOLDER);
+        inPaste = false;
+        str = str.slice(endIdx + PASTE_END.length);
+        continue;
+      }
+
+      const startIdx = str.indexOf(PASTE_START);
+      if (startIdx === -1) {
+        const keepLen = trailingMarkerPrefixLen(str, PASTE_START);
+        const flushLen = str.length - keepLen;
+        // Bracket marker'ı olmayan terminallerde de paste'i yakala: bu segment
+        // tek başına bir Enter tuşu değilse ve içinde satır sonu varsa, o
+        // satır sonlarını gizle (terminal-agnostik heuristik).
+        out += escapeEmbeddedNewlines(str.slice(0, flushLen));
+        carry = str.slice(flushLen);
+        str = '';
+        break;
+      }
+      out += escapeEmbeddedNewlines(str.slice(0, startIdx));
+      str = str.slice(startIdx + PASTE_START.length);
+      inPaste = true;
+    }
+
+    if (out) proxy.write(out);
+  };
+
+  source.on('data', onData);
+  source.on('end', () => {
+    if (carry) {
+      proxy.write(inPaste ? carry.replace(/\r\n|\r|\n/g, NEWLINE_PLACEHOLDER) : carry);
+      carry = '';
+    }
+    proxy.end();
+  });
+  source.on('error', (e) => proxy.emit('error', e));
+
+  // process.stdin'in raw-mode/pause-resume API'lerini proxy üzerinden de eriştir,
+  // readline bunları çağırabiliyor.
+  proxy.isTTY = source.isTTY;
+  proxy.setRawMode = source.setRawMode ? source.setRawMode.bind(source) : undefined;
+  proxy.ref = source.ref ? source.ref.bind(source) : undefined;
+  proxy.unref = source.unref ? source.unref.bind(source) : undefined;
+
+  return proxy;
+}
+
+/**
+ * Terminalde bracketed paste mode'u açar. Çoğu modern terminal (iTerm2, Terminal.app,
+ * Windows Terminal, VS Code, gnome-terminal vb.) bunu destekler. Desteklemeyen
+ * terminallerde bu escape kodu sessizce yok sayılır, davranış eskisi gibi kalır.
+ */
+function enableBracketedPaste(out = process.stdout) {
+  if (out.isTTY) out.write('\x1b[?2004h');
+}
+
+function disableBracketedPaste(out = process.stdout) {
+  if (out.isTTY) out.write('\x1b[?2004l');
+}
+
+/**
+ * readline'dan gelen satırı, paste placeholder'larını gerçek "\n" karakterine
+ * geri çevirerek normalize eder. Gönderilecek mesaj olarak bunu kullan.
+ */
+function restoreNewlines(line) {
+  return line.split(NEWLINE_PLACEHOLDER).join('\n');
+}
+
+module.exports = {
+  createPasteSafeInput,
+  enableBracketedPaste,
+  disableBracketedPaste,
+  restoreNewlines,
+  NEWLINE_PLACEHOLDER,
+};