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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ayder-cli
-Version: 2.2.8
+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.8 → ayder_cli-2.2.9}/pyproject.toml

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

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")