ayder-cli 2.2.7__tar.gz → 2.2.9__tar.gz

{ayder_cli-2.2.7 → ayder_cli-2.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ayder-cli
-Version: 2.2.7
+Version: 2.2.9
 Summary: AI agent for any LLMs
 Project-URL: Homepage, https://github.com/ayder/ayder-cli
 Project-URL: Repository, https://github.com/ayder/ayder-cli.git

{ayder_cli-2.2.7 → ayder_cli-2.2.9}/docs/config.toml.example

@@ -48,11 +48,12 @@
 #      `export OLLAMA_API_KEY="<key>"`. The api_key config field is INERT on the
 #      native path, so a missing env var ⇒ 401 Unauthorized.
 #
-# NOTE on `think`: on the native `ollama` driver, ayder hardcodes thinking ON
-#       (think=True) and does NOT forward the configured level — so a
-#       `think = "high"` below documents intent, but the "low/medium/high"
-#       granularity is not applied. The `openai` driver sends no reasoning-effort
-#       parameter at all.
+# NOTE on `think`: on the native `ollama` driver, ayder defaults thinking ON
+#       (think = true) and forwards either a boolean or Ollama's "low",
+#       "medium", "high" levels. If a selected model rejects thinking mode,
+#       ayder retries that request once with think=false. Set `think = false`
+#       in an [llm.*] profile for known non-thinking models. The `openai`
+#       driver sends no reasoning-effort parameter at all.
 #
 # NOTE on tuning knobs — which actually take effect depends on the DRIVER. These
 #       agents run on the native `ollama` driver, which ignores most of them:
@@ -60,17 +61,16 @@
 #         • max_output_tokens — NOT sent on the ollama path (Ollama sizes
 #                               generation itself); honored only by the
 #                               openai-family drivers as max_tokens. Default 4096.
-#         • think             — hardcoded ON for ollama (level ignored); openai
-#                               sends none.
+#         • think             — sent on the ollama path (default true; accepts
+#                               false or "low"/"medium"/"high"); openai sends
+#                               none.
 #         • num_ctx           — on ollama it is provisional only (the real window
 #                               is auto-detected from /api/show); on the openai
 #                               path it sizes the context-manager budget.
 #                               Default 65536.
-#       The per-agent temperature / max_output_tokens / think values below are
-#       therefore largely INERT on this Ollama pipeline — they are kept to
-#       document intent and to carry over if you switch an agent to an `openai`
-#       profile. To actually tune these, use the `openai` driver — see
-#       [llm.openai] below.
+#       The per-agent temperature / max_output_tokens values below are largely
+#       INERT on this Ollama pipeline; per-agent `think` is applied when the
+#       agent uses the native ollama driver.
 # =============================================================================
 
 config_version = "2.0"
@@ -154,6 +154,7 @@ driver = "ollama"
 base_url = "http://localhost:11434"  # route :cloud models through the LOCAL daemon (auth via ~/.ollama/id_ed25519, one-time `ollama signin`)
 model = "deepseek-v4-pro:cloud"    # orchestrator default; per-agent `model` overrides this
 num_ctx = 131072
+think = true                       # default; set false for known non-thinking models
 # To hit ollama.com directly instead, swap the line above for:
 #   base_url = "https://ollama.com"   # no /v1; then `export OLLAMA_API_KEY=<key>` (the api_key field is inert on this path)
 
@@ -162,6 +163,7 @@ driver = "ollama"
 base_url = "http://localhost:11434"
 model = "qwen3.6:35b-a3b-coding-nvfp4"
 num_ctx = 32768                     # keep modest: local VRAM is the constraint
+think = true                        # default; set false if the selected model rejects thinking
 
 # Budget/throughput alternative — swap any cloud agent's `provider` to this, or
 # point a duplicate reviewer at it for cheap parallel passes.

{ayder_cli-2.2.7 → ayder_cli-2.2.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ayder-cli"
-version = "2.2.7"
+version = "2.2.9"
 description = "AI agent for any LLMs"
 readme = "README.md"
 requires-python = ">=3.12"

{ayder_cli-2.2.7 → ayder_cli-2.2.9}/src/ayder_cli/core/config.py

@@ -2,7 +2,7 @@ import logging
 import tomllib
 from pathlib import Path
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
-from typing import Any, Callable, Dict
+from typing import Any, Callable, Dict, Literal
 
 logger = logging.getLogger(__name__)
 
@@ -319,6 +319,10 @@ class Config(BaseModel):
     max_history_messages: int = Field(default=0)
     prompt: str = Field(default="STANDARD")
     chat_protocol: str = Field(default="ollama")
+    # Ollama thinking mode. Defaults on because most local models in the
+    # primary path support it; set ``think = false`` in an [llm.*] profile for
+    # models that do not. Ollama also accepts "low", "medium", and "high".
+    think: bool | Literal["low", "medium", "high"] | None = Field(default=True)
     stop_sequences: list[str] = Field(default_factory=list)
     tool_tags: list[str] = Field(default_factory=lambda: ["core", "metadata"])
     temporal: TemporalConfig = Field(default_factory=TemporalConfig)
@@ -459,6 +463,25 @@ class Config(BaseModel):
             raise ValueError("max_history_messages must be non-negative (0 = unlimited)")
         return v
 
+    @field_validator("think", mode="before")
+    @classmethod
+    def validate_think(cls, v: Any) -> bool | Literal["low", "medium", "high"] | None:
+        if v is None or isinstance(v, bool):
+            return v
+        if isinstance(v, str):
+            normalized = v.strip().lower()
+            if normalized in {"true", "yes", "on", "1"}:
+                return True
+            if normalized in {"false", "no", "off", "0"}:
+                return False
+            if normalized == "low":
+                return "low"
+            if normalized == "medium":
+                return "medium"
+            if normalized == "high":
+                return "high"
+        raise ValueError("think must be true, false, low, medium, high, or null")
+
     @field_validator("agent_timeout")
     @classmethod
     def validate_agent_timeout(cls, v: int) -> int:

{ayder_cli-2.2.7 → ayder_cli-2.2.9}/src/ayder_cli/providers/impl/ollama.py

@@ -1,7 +1,7 @@
 """Ollama provider routed through per-family chat drivers."""
 
 import json
-from typing import Any, AsyncGenerator, Dict, List, Optional
+from typing import Any, AsyncGenerator, Dict, List, Literal, Optional
 
 from loguru import logger
 from ollama import AsyncClient
@@ -19,6 +19,8 @@ from ayder_cli.providers.impl.ollama_drivers.base import ChatDriver, DriverMode
 from ayder_cli.providers.impl.ollama_drivers.registry import DriverRegistry
 from ayder_cli.providers.impl.ollama_inspector import OllamaInspector
 
+ThinkOption = bool | Literal["low", "medium", "high"] | None
+
 
 class OllamaProvider(AIProvider):
     """Native wire-protocol provider for local Ollama models.
@@ -116,6 +118,50 @@ class OllamaProvider(AIProvider):
             ):
                 yield chunk
 
+    def _configured_think(self) -> ThinkOption:
+        """Return the configured Ollama think option.
+
+        ``Config`` defaults this to True. Tests often pass loose mocks without a
+        real ``think`` field; those should behave like the real default.
+        """
+        value = getattr(self.config, "think", True)
+        if value is None or isinstance(value, bool):
+            return value
+        if isinstance(value, str):
+            normalized = value.strip().lower()
+            if normalized in {"true", "yes", "on", "1"}:
+                return True
+            if normalized in {"false", "no", "off", "0"}:
+                return False
+            if normalized == "low":
+                return "low"
+            if normalized == "medium":
+                return "medium"
+            if normalized == "high":
+                return "high"
+        return True
+
+    @staticmethod
+    def _is_unsupported_thinking_error(exc: BaseException) -> bool:
+        """Return True when Ollama rejected the requested thinking mode."""
+        message = str(exc).lower()
+        if "think" not in message and "thinking" not in message:
+            return False
+        return any(
+            marker in message
+            for marker in (
+                "not support",
+                "unsupported",
+                "invalid",
+                "unknown field",
+                "unrecognized",
+            )
+        )
+
+    @staticmethod
+    def _chunk_committed(chunk: NormalizedStreamChunk) -> bool:
+        return bool(chunk.content or chunk.reasoning or chunk.tool_calls)
+
     async def _stream_with_driver(
         self,
         driver: ChatDriver,
@@ -145,6 +191,34 @@ class OllamaProvider(AIProvider):
         model: str,
         tools: list[dict[str, Any]] | None,
         options: dict[str, Any] | None,
+    ) -> AsyncGenerator[NormalizedStreamChunk, None]:
+        think = self._configured_think()
+        committed = False
+        try:
+            async for chunk in self._stream_native_once(
+                messages, model, tools, options, think
+            ):
+                if self._chunk_committed(chunk):
+                    committed = True
+                yield chunk
+        except BaseException as exc:
+            if committed or think is False or not self._is_unsupported_thinking_error(exc):
+                raise
+            logger.info(
+                f"Ollama model {model!r} rejected think={think!r}; retrying with think=False"
+            )
+            async for chunk in self._stream_native_once(
+                messages, model, tools, options, False
+            ):
+                yield chunk
+
+    async def _stream_native_once(
+        self,
+        messages: list[dict[str, Any]],
+        model: str,
+        tools: list[dict[str, Any]] | None,
+        options: dict[str, Any] | None,
+        think: ThinkOption,
     ) -> AsyncGenerator[NormalizedStreamChunk, None]:
         # Let Ollama size the context window from the model itself (recent
         # versions do this automatically); do not force num_ctx.
@@ -156,7 +230,7 @@ class OllamaProvider(AIProvider):
             messages=ollama_messages,
             tools=ollama_tools,
             keep_alive=-1,
-            think=True,
+            think=think,
             stream=True,
         )
 
@@ -202,6 +276,35 @@ class OllamaProvider(AIProvider):
         model: str,
         tools: list[dict[str, Any]] | None,
         options: dict[str, Any] | None,
+    ) -> AsyncGenerator[NormalizedStreamChunk, None]:
+        think = self._configured_think()
+        committed = False
+        try:
+            async for chunk in self._stream_in_content_once(
+                driver, messages, model, tools, options, think
+            ):
+                if self._chunk_committed(chunk):
+                    committed = True
+                yield chunk
+        except BaseException as exc:
+            if committed or think is False or not self._is_unsupported_thinking_error(exc):
+                raise
+            logger.info(
+                f"Ollama model {model!r} rejected think={think!r}; retrying with think=False"
+            )
+            async for chunk in self._stream_in_content_once(
+                driver, messages, model, tools, options, False
+            ):
+                yield chunk
+
+    async def _stream_in_content_once(
+        self,
+        driver: ChatDriver,
+        messages: list[dict[str, Any]],
+        model: str,
+        tools: list[dict[str, Any]] | None,
+        options: dict[str, Any] | None,
+        think: ThinkOption,
     ) -> AsyncGenerator[NormalizedStreamChunk, None]:
         # Let Ollama size the context window from the model itself; do not
         # force num_ctx.
@@ -213,7 +316,7 @@ class OllamaProvider(AIProvider):
             messages=ollama_messages,
             tools=None,
             keep_alive=-1,
-            think=True,
+            think=think,
             stream=True,
         )
 

ayder_cli-2.2.9/src/ayder_cli/tools/builtins/filesystem.py

@@ -0,0 +1,383 @@
+"""
+Filesystem tools for ayder-cli.
+"""
+
+import contextlib
+import json
+import logging
+import os
+import re
+import difflib
+import tempfile
+import threading
+
+from ayder_cli.core.context import ProjectContext
+from ayder_cli.core.result import ToolSuccess, ToolError
+
+logger = logging.getLogger(__name__)
+
+# Maximum file size allowed for read_file() to prevent DoS/memory exhaustion
+MAX_FILE_SIZE = 10 * 1024 * 1024  # 10 MB
+
+# The chat loop executes auto-approved tool calls concurrently (asyncio.to_thread),
+# so two edits targeting the same file race read-modify-write. Serialize per
+# resolved path; edits to different files still run in parallel.
+_PATH_LOCKS: dict[str, threading.Lock] = {}
+_PATH_LOCKS_GUARD = threading.Lock()
+
+
+def _path_lock(abs_path) -> threading.Lock:
+    with _PATH_LOCKS_GUARD:
+        return _PATH_LOCKS.setdefault(str(abs_path), threading.Lock())
+
+# Default page size for read_file when no explicit range is given. Mirrors
+# Claude Code's Read tool — large enough for most source files in one shot,
+# small enough that small-context LLMs don't drown.
+READ_FILE_DEFAULT_LINES = 2000
+
+
+def _format_size(n_bytes: int) -> str:
+    if n_bytes < 1024:
+        return f"{n_bytes}B"
+    if n_bytes < 1024 * 1024:
+        return f"{n_bytes / 1024:.1f}KB"
+    return f"{n_bytes / (1024 * 1024):.1f}MB"
+
+
+def read_file(
+    project_ctx: ProjectContext,
+    file_path: str,
+    start_line: int | None = None,
+    end_line: int | None = None,
+) -> str:
+    """Read a file with explicit pagination semantics.
+
+    Behavior:
+    - With no range: reads up to ``READ_FILE_DEFAULT_LINES`` starting at line 1.
+      If the file is longer, the result includes a footer naming the total
+      line count and the exact follow-up call needed to read the next page.
+    - With ``start_line`` / ``end_line``: reads that explicit slice (1-based,
+      inclusive). The same pagination footer is appended if more content
+      remains beyond the slice.
+    - The returned body always uses ``"<line_no>: <text>"`` formatting so the
+      caller can never confuse partial output for a complete file.
+    """
+    try:
+        abs_path = project_ctx.validate_path(file_path)
+
+        if not abs_path.exists():
+            rel_path = project_ctx.to_relative(abs_path)
+            return ToolError(f"Error: File '{rel_path}' does not exist.")
+
+        file_size = os.path.getsize(abs_path)
+        if file_size > MAX_FILE_SIZE:
+            rel_path = project_ctx.to_relative(abs_path)
+            return ToolError(
+                f"Error: File '{rel_path}' is too large "
+                f"({file_size / (1024 * 1024):.1f}MB). "
+                f"Maximum allowed size is {MAX_FILE_SIZE / (1024 * 1024):.0f}MB."
+            )
+
+        with open(abs_path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+
+        total_lines = len(lines)
+        rel_path = str(project_ctx.to_relative(abs_path))
+
+        explicit_range = start_line is not None or end_line is not None
+
+        if explicit_range:
+            start = int(start_line) if start_line else 1
+            end = int(end_line) if end_line else total_lines
+        else:
+            start = 1
+            end = min(total_lines, READ_FILE_DEFAULT_LINES)
+
+        start_idx = max(0, start - 1)
+        end_idx = min(total_lines, end)
+        selected = lines[start_idx:end_idx]
+
+        body = "".join(f"{start + i}: {line}" for i, line in enumerate(selected))
+
+        # Always append a footer so the caller never has to infer completeness
+        # from absence. Two shapes:
+        #   - more remaining → name the next call to make
+        #   - reached EOF    → explicit [COMPLETE] marker
+        last_returned = start_idx + len(selected)
+        more_remaining = last_returned < total_lines
+
+        if more_remaining:
+            footer = (
+                f"\n[FILE: {rel_path} | {total_lines} total lines, "
+                f"{_format_size(file_size)} | showing lines "
+                f"{start_idx + 1}-{last_returned}. "
+                f"To read more: read_file(file_path={rel_path!r}, "
+                f"start_line={last_returned + 1})]"
+            )
+        else:
+            footer = (
+                f"\n[FILE: {rel_path} | COMPLETE: {total_lines} lines, "
+                f"{_format_size(file_size)} | showing lines "
+                f"{start_idx + 1}-{last_returned}]"
+            )
+        return ToolSuccess(body + footer)
+
+    except ValueError as e:
+        return ToolError(f"Security Error: {str(e)}", "security")
+    except Exception as e:
+        return ToolError(f"Error reading file: {str(e)}", "execution")
+
+
+def file_explorer(project_ctx: ProjectContext, path: str = ".") -> str:
+    """List files in a directory or get metadata for a specific file."""
+    try:
+        abs_path = project_ctx.validate_path(path)
+        
+        if abs_path.is_dir():
+            files = [item.name for item in abs_path.iterdir()]
+            return ToolSuccess(json.dumps(files))
+            
+        elif abs_path.exists():
+            rel_path = project_ctx.to_relative(abs_path)
+            stat = abs_path.stat()
+            size_bytes = stat.st_size
+
+            # Human-readable size
+            if size_bytes < 1024:
+                size_human = f"{size_bytes}B"
+            elif size_bytes < 1024 * 1024:
+                size_human = f"{size_bytes / 1024:.1f}KB"
+            else:
+                size_human = f"{size_bytes / (1024 * 1024):.1f}MB"
+
+            # Line count (only for files)
+            line_count = None
+            if abs_path.is_file():
+                try:
+                    with open(abs_path, "r", encoding="utf-8", errors="replace") as f:
+                        line_count = sum(1 for _ in f)
+                except Exception:
+                    line_count = None
+
+            info = {
+                "path": str(rel_path),
+                "size_bytes": size_bytes,
+                "size_human": size_human,
+                "line_count": line_count,
+                "extension": abs_path.suffix or None,
+                "is_file": abs_path.is_file(),
+                "is_directory": abs_path.is_dir(),
+                "is_symlink": abs_path.is_symlink(),
+            }
+            return ToolSuccess(json.dumps(info, indent=2))
+        else:
+            rel_path = project_ctx.to_relative(abs_path)
+            return ToolError(f"Error: '{rel_path}' does not exist.")
+            
+    except ValueError as e:
+        return ToolError(f"Security Error: {str(e)}", "security")
+    except Exception as e:
+        return ToolError(f"Error exploring path: {str(e)}", "execution")
+
+
+def _finalize(
+    abs_path,
+    rel_path,
+    old_content: str,
+    new_content: str,
+    success_msg: str,
+    dry_run: bool,
+) -> str:
+    """Write *new_content* and return *success_msg*, or, when *dry_run* is set,
+    return a unified diff and write nothing."""
+    if dry_run:
+        if old_content == new_content:
+            return ToolSuccess(f"[DRY RUN] No changes would be made to {rel_path}.")
+        diff = "".join(
+            difflib.unified_diff(
+                old_content.splitlines(keepends=True),
+                new_content.splitlines(keepends=True),
+                fromfile=f"a/{rel_path}",
+                tofile=f"b/{rel_path}",
+            )
+        )
+        return ToolSuccess(f"[DRY RUN] No changes written to {rel_path}.\n{diff}")
+    # Atomic write: a crash mid-write must never leave a truncated target,
+    # and concurrent readers must see either the old or the new content.
+    tmp_fd, tmp_name = tempfile.mkstemp(
+        dir=str(abs_path.parent), prefix=f".{abs_path.name}.", suffix=".tmp"
+    )
+    try:
+        with os.fdopen(tmp_fd, "w", encoding="utf-8") as f:
+            f.write(new_content)
+        if abs_path.exists():
+            os.chmod(tmp_name, os.stat(abs_path).st_mode)
+        os.replace(tmp_name, str(abs_path))
+    except BaseException:
+        with contextlib.suppress(OSError):
+            os.unlink(tmp_name)
+        raise
+    return ToolSuccess(success_msg)
+
+
+_HINT_MIN_RATIO = 0.6
+_HINT_MAX_FILE_CHARS = 1_000_000
+_HINT_MAX_PREVIEW_CHARS = 300
+
+
+def _closest_match_hint(file_content: str, old_string: str) -> str:
+    """Locate the region most similar to a failed 'replace' target.
+
+    Returns a hint naming the line and a repr() of the region (so tabs,
+    trailing spaces, and other invisible mismatches become visible), or ''
+    when nothing is similar enough to be worth suggesting.
+    """
+    if len(file_content) > _HINT_MAX_FILE_CHARS:
+        return ""
+    lines = file_content.splitlines()
+    if not lines:
+        return ""
+    window_size = max(1, len(old_string.splitlines()))
+    matcher = difflib.SequenceMatcher(autojunk=False)
+    matcher.set_seq2(old_string)
+    best_ratio = 0.0
+    best_line = 0
+    best_window = ""
+    for i in range(max(1, len(lines) - window_size + 1)):
+        window = "\n".join(lines[i : i + window_size])
+        matcher.set_seq1(window)
+        if (
+            matcher.real_quick_ratio() <= best_ratio
+            or matcher.quick_ratio() <= best_ratio
+        ):
+            continue
+        ratio = matcher.ratio()
+        if ratio > best_ratio:
+            best_ratio, best_line, best_window = ratio, i + 1, window
+    if best_ratio < _HINT_MIN_RATIO:
+        return ""
+    preview = repr(best_window)
+    if len(preview) > _HINT_MAX_PREVIEW_CHARS:
+        preview = preview[:_HINT_MAX_PREVIEW_CHARS] + "…"
+    return (
+        f" Closest match at line {best_line} ({best_ratio:.0%} similar): "
+        f"{preview}. old_string must match the file byte-for-byte (repr shown: "
+        f"\\t = tab). Retry with the exact text, or dry_run=true to preview."
+    )
+
+
+def file_editor(
+    project_ctx: ProjectContext,
+    file_path: str,
+    operation: str,
+    content: str | None = None,
+    old_string: str | None = None,
+    new_string: str | None = None,
+    line_number: int | None = None,
+    replace_all: bool = False,
+    regex: bool = False,
+    dry_run: bool = False,
+) -> str:
+    """Modify files with specific operations."""
+    try:
+        abs_path = project_ctx.validate_path(file_path)
+        rel_path = project_ctx.to_relative(abs_path)
+
+        with _path_lock(abs_path):
+            if operation == "write":
+                if content is None:
+                    return ToolError("Error: 'content' parameter is required for 'write' operation.", "validation")
+                old_content = abs_path.read_text(encoding="utf-8") if abs_path.exists() else ""
+                if not dry_run:
+                    abs_path.parent.mkdir(parents=True, exist_ok=True)
+                return _finalize(
+                    abs_path, rel_path, old_content, content,
+                    f"Successfully wrote to {rel_path}", dry_run,
+                )
+
+            elif operation == "replace":
+                if old_string is None or new_string is None:
+                    return ToolError("Error: 'old_string' and 'new_string' are required for 'replace' operation.", "validation")
+                if not abs_path.exists():
+                    return ToolError(f"Error: File '{rel_path}' does not exist.")
+                with open(abs_path, "r", encoding="utf-8") as f:
+                    file_content = f.read()
+                if regex:
+                    try:
+                        pattern = re.compile(old_string)
+                    except re.error as e:
+                        return ToolError(f"Invalid regex pattern: {e}", "validation")
+                    count = sum(1 for _ in pattern.finditer(file_content))
+                else:
+                    count = file_content.count(old_string)
+                if count == 0:
+                    hint = "" if regex else _closest_match_hint(file_content, old_string)
+                    return ToolError(
+                        f"Error: 'old_string' not found in {rel_path}. No changes made.{hint}"
+                    )
+                if count > 1 and not replace_all:
+                    return ToolError(
+                        f"Error: 'old_string' is not unique (found {count} matches) in {rel_path}. "
+                        f"Pass replace_all=true to replace all occurrences, or add surrounding "
+                        f"context to make it unique. No changes made.",
+                        "validation",
+                    )
+                if regex:
+                    new_content = pattern.sub(new_string, file_content, count=0 if replace_all else 1)
+                else:
+                    new_content = (
+                        file_content.replace(old_string, new_string)
+                        if replace_all
+                        else file_content.replace(old_string, new_string, 1)
+                    )
+                noun = "occurrence" if count == 1 else "occurrences"
+                return _finalize(
+                    abs_path, rel_path, file_content, new_content,
+                    f"Successfully replaced {count} {noun} in {rel_path}", dry_run,
+                )
+
+            elif operation == "insert":
+                if line_number is None or content is None:
+                    return ToolError("Error: 'line_number' and 'content' are required for 'insert' operation.", "validation")
+                if not abs_path.exists():
+                    return ToolError(f"Error: File '{rel_path}' does not exist.")
+                with open(abs_path, "r", encoding="utf-8") as f:
+                    lines = f.readlines()
+                if line_number < 1:
+                    return ToolError("Error: line_number must be >= 1.", "validation")
+                old_content = "".join(lines)
+                idx = min(line_number - 1, len(lines))
+                ins = content
+                if ins and not ins.endswith("\n"):
+                    ins += "\n"
+                new_content = "".join(lines[:idx] + [ins] + lines[idx:])
+                return _finalize(
+                    abs_path, rel_path, old_content, new_content,
+                    f"Successfully inserted content at line {line_number} in {rel_path}", dry_run,
+                )
+
+            elif operation == "delete":
+                if line_number is None:
+                    return ToolError("Error: 'line_number' is required for 'delete' operation.", "validation")
+                if not abs_path.exists():
+                    return ToolError(f"Error: File '{rel_path}' does not exist.")
+                with open(abs_path, "r", encoding="utf-8") as f:
+                    lines = f.readlines()
+                if line_number < 1 or line_number > len(lines):
+                    return ToolError(f"Error: line_number {line_number} is out of range (1-{len(lines)}).", "validation")
+                old_content = "".join(lines)
+                deleted = lines[line_number - 1]
+                new_content = "".join(lines[: line_number - 1] + lines[line_number:])
+                preview = deleted.rstrip("\n")[:80]
+                return _finalize(
+                    abs_path, rel_path, old_content, new_content,
+                    f"Deleted line {line_number} from {rel_path}: '{preview}'", dry_run,
+                )
+
+            else:
+                return ToolError(f"Error: Unknown operation '{operation}'", "validation")
+
+    except ValueError as e:
+        return ToolError(f"Security Error: {str(e)}", "security")
+    except Exception as e:
+        return ToolError(f"Error executing file_editor: {str(e)}", "execution")