vtx-coding-agent 0.1.1__py3-none-any.whl

vtx/tools/edit.py

@@ -0,0 +1,261 @@
+import asyncio
+import difflib
+from pathlib import Path
+
+import aiofiles
+from pydantic import BaseModel, Field
+from rich.markup import escape
+
+from vtx import config
+from vtx.diff_display import DIFF_BG_PAD_MARKER, blend_hex
+
+from ..core.types import FileChanges
+from ._tool_utils import shorten_path
+from .base import BaseTool, ToolResult
+
+CONTEXT_LINES = 4
+
+
+class EditParams(BaseModel):
+    path: str = Field(description="Absolute path of the file to edit")
+    old_string: str = Field(description="The text to replace")
+    new_string: str = Field(
+        description="The text to replace it with (must be different from old_string)"
+    )
+    replace_all: bool = Field(
+        description="Replace all occurrences of old_string (default false)", default=False
+    )
+
+
+def _ellipsis(line_num_width: int, skipped: int) -> str:
+    return f" {''.rjust(line_num_width)} \u22ef {skipped} lines \u22ef"  # ⋯ N lines ⋯
+
+
+def generate_diff(
+    old_content: str, new_content: str, context_lines: int = CONTEXT_LINES
+) -> tuple[str, int, int]:
+    """
+    Generate a diff with line numbers and context.
+
+    Returns:
+        tuple: (diff_string, added_count, removed_count)
+
+    Format:
+        " 42   context line"    (space, num, three spaces = empty change marker)
+        " 42 - removed line"    (space, num, space-minus-space = removed)
+        " 42 + added line"      (space, num, space-plus-space = added)
+        "    ⋯ N lines ⋯"       (ellipsis = skipped lines with count)
+    """
+    old_lines = old_content.splitlines()
+    new_lines = new_content.splitlines()
+
+    matcher = difflib.SequenceMatcher(None, old_lines, new_lines)
+    opcodes = matcher.get_opcodes()
+
+    max_line_num = max(len(old_lines), len(new_lines))
+    line_num_width = len(str(max_line_num))
+
+    def _num(n: int) -> str:
+        return str(n).rjust(line_num_width)
+
+    output: list[str] = []
+    added, removed = 0, 0
+    last_was_change = False
+
+    for i, (tag, i1, i2, j1, j2) in enumerate(opcodes):
+        if tag == "equal":
+            equal_lines = old_lines[i1:i2]
+            next_is_change = i < len(opcodes) - 1 and opcodes[i + 1][0] != "equal"
+
+            if last_was_change or next_is_change:
+                if last_was_change and next_is_change:
+                    if len(equal_lines) > context_lines * 2:
+                        for idx, line in enumerate(equal_lines[:context_lines]):
+                            line_num = i1 + idx + 1
+                            output.append(f" {_num(line_num)}   {line}")
+                        skipped = len(equal_lines) - context_lines * 2
+                        output.append(_ellipsis(line_num_width, skipped))
+                        for idx, line in enumerate(equal_lines[-context_lines:]):
+                            line_num = i1 + len(equal_lines) - context_lines + idx + 1
+                            output.append(f" {_num(line_num)}   {line}")
+                    else:
+                        for idx, line in enumerate(equal_lines):
+                            line_num = i1 + idx + 1
+                            output.append(f" {_num(line_num)}   {line}")
+                elif last_was_change:
+                    if len(equal_lines) > context_lines:
+                        for idx, line in enumerate(equal_lines[:context_lines]):
+                            line_num = i1 + idx + 1
+                            output.append(f" {_num(line_num)}   {line}")
+                        skipped = len(equal_lines) - context_lines
+                        output.append(_ellipsis(line_num_width, skipped))
+                    else:
+                        for idx, line in enumerate(equal_lines):
+                            line_num = i1 + idx + 1
+                            output.append(f" {_num(line_num)}   {line}")
+                else:
+                    if len(equal_lines) > context_lines:
+                        skipped = len(equal_lines) - context_lines
+                        output.append(_ellipsis(line_num_width, skipped))
+                        for idx, line in enumerate(equal_lines[-context_lines:]):
+                            line_num = i1 + len(equal_lines) - context_lines + idx + 1
+                            output.append(f" {_num(line_num)}   {line}")
+                    else:
+                        for idx, line in enumerate(equal_lines):
+                            line_num = i1 + idx + 1
+                            output.append(f" {_num(line_num)}   {line}")
+
+            last_was_change = False
+
+        elif tag == "replace":
+            for idx, line in enumerate(old_lines[i1:i2]):
+                line_num = i1 + idx + 1
+                output.append(f" {_num(line_num)} - {line}")
+                removed += 1
+            for idx, line in enumerate(new_lines[j1:j2]):
+                line_num = j1 + idx + 1
+                output.append(f" {_num(line_num)} + {line}")
+                added += 1
+            last_was_change = True
+
+        elif tag == "delete":
+            for idx, line in enumerate(old_lines[i1:i2]):
+                line_num = i1 + idx + 1
+                output.append(f" {_num(line_num)} - {line}")
+                removed += 1
+            last_was_change = True
+
+        elif tag == "insert":
+            for idx, line in enumerate(new_lines[j1:j2]):
+                line_num = j1 + idx + 1
+                output.append(f" {_num(line_num)} + {line}")
+                added += 1
+            last_was_change = True
+
+    return "\n".join(output), added, removed
+
+
+def _parse_diff_line(line: str) -> tuple[str, str, str] | None:
+    """Parse a formatted diff line into (line_number_part, sign, content_part)."""
+    num_start = next((i for i, char in enumerate(line) if char.isdigit()), -1)
+    if num_start == -1:
+        return None
+
+    num_end = num_start
+    while num_end < len(line) and line[num_end].isdigit():
+        num_end += 1
+
+    sign_index = num_end + 1
+    if sign_index >= len(line):
+        return None
+
+    # Includes leading padding and the separator space after the line number.
+    line_number_part = line[:sign_index]
+    sign = line[sign_index]
+    content_part = line[sign_index + 1 :]
+    return line_number_part, sign, content_part
+
+
+def format_diff_display(diff: str) -> str:
+    colors = config.ui.colors
+    lines = diff.split("\n")
+    formatted = []
+
+    bg_added = blend_hex(colors.diff_added, colors.bg)
+    bg_removed = blend_hex(colors.diff_removed, colors.bg)
+
+    for line in lines:
+        if not line:
+            continue
+
+        truncated = line[:200] + "\u2026" if len(line) > 203 else line  # … ellipsis
+        parsed = _parse_diff_line(truncated)
+
+        if parsed and parsed[1] == "-":
+            line_num, sign, content_part = parsed
+            content = (
+                f"  [{colors.dim}]{escape(line_num)}[/{colors.dim}]"
+                f"[{colors.diff_removed}]{sign}{escape(content_part)}[/{colors.diff_removed}]"
+            )
+            formatted.append(f"[on {bg_removed}]{content}{DIFF_BG_PAD_MARKER}[/]")
+        elif parsed and parsed[1] == "+":
+            line_num, sign, content_part = parsed
+            content = (
+                f"  [{colors.dim}]{escape(line_num)}[/{colors.dim}]"
+                f"[{colors.diff_added}]{sign}{escape(content_part)}[/{colors.diff_added}]"
+            )
+            formatted.append(f"[on {bg_added}]{content}{DIFF_BG_PAD_MARKER}[/]")
+        elif "\u22ef" in line:
+            escaped = escape(truncated)
+            formatted.append(f"[{colors.dim}]{escaped}[/{colors.dim}]")
+        else:
+            escaped = escape(truncated)
+            formatted.append(f"[{colors.dim}]  {escaped}[/{colors.dim}]")
+
+    return "\n".join(formatted)
+
+
+class EditTool(BaseTool):
+    name = "edit"
+    tool_icon = "←"
+    params = EditParams
+    prompt_guidelines = ("Use edit for precise changes (NOT sed/awk)",)
+    description = (
+        "Edit a file by replacing exact text. The old_string must match exactly "
+        "(including whitespaces). Use this for precise, surgical edits."
+    )
+
+    def format_call(self, params: EditParams) -> str:
+        return shorten_path(params.path)
+
+    def format_preview(self, params: EditParams) -> str | None:
+        diff, _, _ = generate_diff(params.old_string, params.new_string)
+        return format_diff_display(diff)
+
+    async def execute(
+        self, params: EditParams, cancel_event: asyncio.Event | None = None
+    ) -> ToolResult:
+        file_path = Path(params.path)
+
+        if not file_path.exists():
+            msg = f"File not found: {file_path}"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        async with aiofiles.open(file_path, encoding="utf-8") as f:
+            content = await f.read()
+
+        if params.old_string not in content:
+            msg = "old_string not found in file"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        if params.replace_all:
+            new_content = content.replace(params.old_string, params.new_string)
+        else:
+            new_content = content.replace(params.old_string, params.new_string, 1)
+
+        async with aiofiles.open(file_path, "w", encoding="utf-8") as f:
+            await f.write(new_content)
+
+        diff, added, removed = generate_diff(content, new_content)
+        diff_display = format_diff_display(diff)
+
+        # Full diff for expanded view (no context truncation)
+        total_lines = max(content.count("\n"), new_content.count("\n")) + 1
+        diff_full, _, _ = generate_diff(content, new_content, context_lines=total_lines)
+        diff_full_display = format_diff_display(diff_full)
+
+        colors = config.ui.colors
+        result = f"Updated {file_path} +{added} -{removed}"
+        ui_summary = (
+            f"[{colors.diff_added}]+{added}[/{colors.diff_added}] "
+            f"[{colors.diff_removed}]-{removed}[/{colors.diff_removed}]"
+        )
+
+        return ToolResult(
+            success=True,
+            result=result,
+            ui_summary=ui_summary,
+            ui_details=diff_display,
+            ui_details_full=diff_full_display,
+            file_changes=FileChanges(path=str(file_path), added=added, removed=removed),
+        )

vtx/tools/find.py

@@ -0,0 +1,132 @@
+import asyncio
+import os
+
+from pydantic import BaseModel, Field
+
+from ..core.types import ToolResult
+from ..tools_manager import ensure_tool
+from ._tool_utils import (
+    ToolCancelledError,
+    communicate_or_cancel,
+    shorten_path,
+    truncate_lines_by_bytes,
+)
+from .base import BaseTool
+
+MAX_RESULTS = 100
+MAX_OUTPUT_BYTES = 20 * 1024
+
+
+class FindParams(BaseModel):
+    pattern: str = Field(
+        description="Glob pattern to match files, e.g. '*.py', '**/*.json', or 'src/**/*.spec.ts'"
+    )
+    path: str | None = Field(
+        description="Directory to search in (default: current directory)", default=None
+    )
+
+
+class FindTool(BaseTool):
+    name = "find"
+    tool_icon = "*"
+    params = FindParams
+    mutating = False
+    prompt_guidelines = ("Use find to search for files by name/glob (NOT find or ls via bash)",)
+    description = (
+        "Search for files by glob pattern using fd. "
+        "Returns matching file paths relative to the search directory, "
+        "sorted by modification time."
+        f"Respects .gitignore. Truncated to {MAX_RESULTS} results."
+    )
+
+    def format_call(self, params: FindParams) -> str:
+        pattern = params.pattern.replace('"', '\\"')
+        parts = [f'"{pattern}"']
+        if params.path:
+            parts.append(f"in {shorten_path(params.path)}")
+        return " ".join(parts)
+
+    async def execute(
+        self, params: FindParams, cancel_event: asyncio.Event | None = None
+    ) -> ToolResult:
+        fd_path = await ensure_tool("fd", silent=True)
+        if not fd_path:
+            msg = "fd is not available and could not be downloaded"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        search_path = params.path or os.getcwd()
+        if not os.path.isabs(search_path):
+            search_path = os.path.join(os.getcwd(), search_path)
+
+        if not os.path.exists(search_path):
+            msg = f"Path not found: {search_path}"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        args = [
+            fd_path,
+            "--glob",
+            "--color=never",
+            "--hidden",
+            "--max-results",
+            str(MAX_RESULTS),
+            params.pattern,
+            search_path,
+        ]
+
+        proc = await asyncio.create_subprocess_exec(
+            *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+        )
+
+        try:
+            stdout, stderr = await communicate_or_cancel(proc, cancel_event)
+        except ToolCancelledError:
+            return ToolResult(success=False, result="Search aborted")
+
+        exit_code = proc.returncode
+        output = stdout.decode("utf-8", errors="replace").strip()
+        error_output = stderr.decode("utf-8", errors="replace").strip()
+
+        if exit_code not in (0, 1) and not output:
+            msg = f"fd failed: {error_output}"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        if not output:
+            return ToolResult(
+                success=True,
+                result="No files found matching pattern",
+                ui_summary="[dim]No files found[/dim]",
+            )
+
+        lines = [line.strip() for line in output.split("\n") if line.strip()]
+
+        # Relativize and collect mtime for sorting
+        files: list[tuple[str, float]] = []
+        for line in lines:
+            if line.startswith(search_path):
+                rel = line[len(search_path) :].lstrip(os.sep)
+                rel = rel if rel else line
+            else:
+                rel = os.path.relpath(line, search_path)
+            try:
+                mtime = os.path.getmtime(line)
+            except OSError:
+                mtime = 0.0
+            files.append((rel, mtime))
+
+        files.sort(key=lambda f: f[1], reverse=True)
+
+        relativized = [f[0] for f in files]
+        truncated = len(relativized) >= MAX_RESULTS
+
+        result_text, _ = truncate_lines_by_bytes(relativized, MAX_OUTPUT_BYTES)
+
+        if truncated:
+            result_text += (
+                f"\n\n[{MAX_RESULTS} results limit reached; "
+                "refine the pattern or path for more specific results]"
+            )
+
+        count = len(relativized)
+        display = f"[dim]({count} files)[/dim]"
+
+        return ToolResult(success=True, result=result_text, ui_summary=display)

vtx/tools/read.py

@@ -0,0 +1,238 @@
+import asyncio
+from datetime import datetime
+from pathlib import Path
+
+import aiofiles
+from pydantic import BaseModel, Field
+
+from ..core.types import ImageContent
+from ..tools_manager import ensure_tool
+from ._read_image import is_image_file, read_and_process_image
+from ._tool_utils import ToolCancelledError, communicate_or_cancel, shorten_path
+from .base import BaseTool, ToolResult
+
+MAX_CHARS_PER_LINE = 2000
+MAX_LINES_PER_FILE = 2000
+DIRECTORY_DEPTH_ROW_LIMIT = 200
+MAX_DIRECTORY_ROWS = 1000
+
+
+class ReadParams(BaseModel):
+    path: str = Field(description="Absolute path of the file or directory to read")
+    offset: int | None = Field(
+        description="Line number to start reading from. "
+        "Only provide if the file is too large to read at once.",
+        default=None,
+    )
+    limit: int | None = Field(
+        description="Number of lines to read. "
+        "Only provide if the file is too large to read at once.",
+        default=None,
+    )
+
+
+class ReadTool(BaseTool):
+    name = "read"
+    tool_icon = "→"
+    params = ReadParams
+    mutating = False
+    prompt_guidelines = ("Use read to view files (NOT cat/head/tail)",)
+    description = (
+        "Read the contents of a file or directory. "
+        f"File reads truncate to {MAX_LINES_PER_FILE} lines and "
+        f"{MAX_CHARS_PER_LINE} chars per line. "
+        "Use offset/limit to paginate large files. "
+        "Supports reading jpg/jpeg/png/gif/webp images."
+    )
+
+    def format_call(self, params: ReadParams) -> str:
+        path = shorten_path(params.path)
+        if params.offset or params.limit:
+            start = params.offset or 1
+            end = (start + params.limit - 1) if params.limit else "?"
+            return f"{path}:{start}-{end}"
+        return path
+
+    async def read_file(self, file_path: Path, offset: int | None, limit: int | None) -> str:
+        lines = []
+        start = (offset - 1) if offset else 0
+        effective_limit = min(limit, MAX_LINES_PER_FILE) if limit else MAX_LINES_PER_FILE
+        line_number = 0
+
+        async with aiofiles.open(file_path, encoding="utf-8") as f:
+            async for line in f:
+                line_number += 1
+                if line_number <= start:
+                    continue
+                if len(lines) == effective_limit:
+                    if effective_limit == MAX_LINES_PER_FILE:
+                        lines.append(f"[output truncated after {MAX_LINES_PER_FILE} lines]")
+                    break
+
+                if len(line) > MAX_CHARS_PER_LINE:
+                    line = (
+                        line[:MAX_CHARS_PER_LINE]
+                        + f" [output truncated after {MAX_CHARS_PER_LINE} chars]\n"
+                    )
+                lines.append(f"{line_number:6d}\t{line}")
+
+        return "".join(lines)
+
+    def _format_directory_entry(self, entry_path: Path, relative: Path) -> str:
+        modified = datetime.fromtimestamp(entry_path.stat().st_mtime)
+        timestamp = f"{modified.day:2d} {modified.strftime('%b %H:%M')}"
+        display = relative.as_posix()
+        if entry_path.is_dir():
+            display += "/"
+        return f"{timestamp}  {display}"
+
+    async def _list_directory_entries(
+        self,
+        fd_path: str,
+        dir_path: Path,
+        max_depth: int,
+        max_results: int,
+        cancel_event: asyncio.Event | None,
+    ) -> list[str]:
+        proc = await asyncio.create_subprocess_exec(
+            fd_path,
+            "--hidden",
+            "--color=never",
+            "--max-depth",
+            str(max_depth),
+            "--max-results",
+            str(max_results),
+            ".",
+            str(dir_path),
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+
+        stdout, stderr = await communicate_or_cancel(proc, cancel_event)
+        output = stdout.decode("utf-8", errors="replace").strip()
+        error_output = stderr.decode("utf-8", errors="replace").strip()
+
+        if proc.returncode not in (0, 1):
+            raise RuntimeError(f"fd failed: {error_output or 'unknown error'}")
+
+        if not output:
+            return []
+
+        entries: list[str] = []
+        for line in output.split("\n"):
+            if not line.strip():
+                continue
+
+            entry_path = Path(line)
+            if entry_path.is_absolute():
+                try:
+                    relative = entry_path.relative_to(dir_path)
+                except ValueError:
+                    relative = entry_path
+            else:
+                relative = entry_path
+                entry_path = dir_path / entry_path
+
+            entries.append(self._format_directory_entry(entry_path, relative))
+
+        return entries
+
+    async def read_directory(
+        self, dir_path: Path, cancel_event: asyncio.Event | None = None
+    ) -> ToolResult:
+        fd_path = await ensure_tool("fd", silent=True)
+        if not fd_path:
+            msg = "fd is not available and could not be downloaded"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        try:
+            for max_depth in (3, 2):
+                entries = await self._list_directory_entries(
+                    fd_path,
+                    dir_path,
+                    max_depth=max_depth,
+                    max_results=DIRECTORY_DEPTH_ROW_LIMIT + 1,
+                    cancel_event=cancel_event,
+                )
+                if len(entries) <= DIRECTORY_DEPTH_ROW_LIMIT:
+                    result = "\n".join(entries) if entries else "(empty directory)"
+                    return ToolResult(
+                        success=True,
+                        result=result,
+                        ui_summary=f"[dim]({len(entries)} entries)[/dim]",
+                    )
+
+            entries = await self._list_directory_entries(
+                fd_path,
+                dir_path,
+                max_depth=1,
+                max_results=MAX_DIRECTORY_ROWS + 1,
+                cancel_event=cancel_event,
+            )
+        except ToolCancelledError:
+            return ToolResult(
+                success=False, result="Read aborted", ui_summary="[yellow]Read aborted[/yellow]"
+            )
+        except RuntimeError as e:
+            msg = str(e)
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        truncated = len(entries) > MAX_DIRECTORY_ROWS
+        visible_entries = entries[:MAX_DIRECTORY_ROWS]
+        result = "\n".join(visible_entries) if visible_entries else "(empty directory)"
+        if truncated:
+            result += f"\n[output truncated after {MAX_DIRECTORY_ROWS} lines]"
+
+        shown = min(len(entries), MAX_DIRECTORY_ROWS)
+        return ToolResult(
+            success=True, result=result, ui_summary=f"[dim]({shown} entries shown)[/dim]"
+        )
+
+    async def execute(
+        self, params: ReadParams, cancel_event: asyncio.Event | None = None
+    ) -> ToolResult:
+        file_path = Path(params.path)
+
+        if not file_path.exists():
+            msg = "Path not found"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        if file_path.is_dir():
+            return await self.read_directory(file_path, cancel_event)
+
+        if not file_path.is_file():
+            msg = "Path is not a file or directory"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        if is_image_file(str(file_path)):
+            try:
+                base64_data, mime_type, resize_note = read_and_process_image(str(file_path))
+
+                text_note = f"Read image file [{mime_type}]"
+                if resize_note:
+                    text_note += f" {resize_note}"
+
+                display_note = "[dim]Read image[/dim]"
+                if resize_note:
+                    display_note = f"{display_note} {resize_note}"
+
+                return ToolResult(
+                    success=True,
+                    result=text_note,
+                    images=[ImageContent(data=base64_data, mime_type=mime_type)],
+                    ui_summary=display_note,
+                )
+            except Exception as e:
+                msg = f"Failed to read image: {e}"
+                return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        try:
+            content = await self.read_file(file_path, params.offset, params.limit)
+        except OSError as e:
+            msg = f"Failed to read: {e}"
+            return ToolResult(success=False, result=msg, ui_summary=f"[red]{msg}[/red]")
+
+        lines_read = len(content.splitlines()) if content else 0
+        return ToolResult(
+            success=True, result=content, ui_summary=f"[dim]({lines_read} lines)[/dim]"
+        )