symphony-code 0.0.1__py3-none-any.whl

coding_agent/tools/read_file.py

@@ -0,0 +1,167 @@
+"""Read a text or image file."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import Field
+
+from coding_agent.config import ReadFileConfig
+from coding_agent.tools.base import ToolArgsModel, WorkspaceTool
+from core_ai.content import image_part_from_bytes, sniff_image_media_type
+
+DEFAULT_READ_FILE_CONFIG = ReadFileConfig()
+
+
+class ReadFileArgs(ToolArgsModel):
+    path: str = Field(
+        ...,
+        min_length=1,
+        description=(
+            "Path to a UTF-8 text file or image (png, jpeg, gif, webp, bmp, tiff). "
+            "Relative paths start at the working directory; absolute and ~ paths are allowed."
+        ),
+    )
+    offset: int = Field(
+        default=1,
+        ge=1,
+        description=(
+            "1-based line number to start reading from. Use to page "
+            "through large text files (e.g. offset=501 to read past the cap). "
+            "Ignored for images."
+        ),
+    )
+    limit: int = Field(
+        default=0,
+        ge=0,
+        description=(
+            "Maximum number of lines to return. 0 means no line cap; "
+            "the byte cap still applies. Ignored for images."
+        ),
+    )
+
+
+class ReadFileTool(WorkspaceTool):
+    name = "read_file"
+    description = (
+        "Read a file. UTF-8 text is returned with line numbers "
+        "(`   12|code`, capped at ~32KB; pass offset to page). Images (png, jpeg, "
+        "gif, webp, bmp, tiff) are returned as visual content the model can see. "
+        "Relative paths start at the working directory; absolute and ~ paths are allowed."
+    )
+    args_model = ReadFileArgs
+
+    def __init__(
+        self,
+        workspace: str | Path,
+        *,
+        config: ReadFileConfig = DEFAULT_READ_FILE_CONFIG,
+    ) -> None:
+        self.config = config
+        super().__init__(workspace, parallel=True)
+
+    def run(
+        self, path: str, offset: int = 1, limit: int = 0
+    ) -> str | list[dict[str, object]]:
+        try:
+            target = self.resolve_path(path)
+        except (TypeError, ValueError) as exc:
+            return f"error: {exc}"
+
+        if not isinstance(offset, int) or offset < 1:
+            return "error: offset must be an integer >= 1"
+        if not isinstance(limit, int) or limit < 0:
+            return "error: limit must be an integer >= 0"
+
+        if not target.exists():
+            return f"error: file not found: {path}"
+        if not target.is_file():
+            return f"error: not a file: {path}"
+
+        try:
+            size = target.stat().st_size
+            with target.open("rb") as handle:
+                header = handle.read(32)
+        except OSError as exc:
+            return f"error: failed to read {path}: {exc}"
+
+        media_type = sniff_image_media_type(header, filename=target.name)
+        if media_type:
+            return self.read_image(target, path, media_type, size)
+        return self.read_text(target, path, offset, limit)
+
+    def read_image(
+        self,
+        target: Path,
+        path: str,
+        media_type: str,
+        size: int,
+    ) -> str | list[dict[str, object]]:
+        if size > self.config.max_image_bytes:
+            return (
+                f"error: image exceeds {self.config.max_image_bytes:,} bytes: {path} "
+                f"({size:,} bytes)"
+            )
+        try:
+            payload = target.read_bytes()
+        except OSError as exc:
+            return f"error: failed to read {path}: {exc}"
+        media_type = sniff_image_media_type(payload, filename=target.name) or media_type
+        return [
+            {
+                "type": "text",
+                "text": f"Read image {path} ({media_type}, {size:,} bytes)",
+            },
+            image_part_from_bytes(
+                payload,
+                media_type=media_type,
+                filename=target.name,
+            ),
+        ]
+
+    def read_text(self, target: Path, path: str, offset: int, limit: int) -> str:
+        try:
+            with target.open("r", encoding="utf-8") as fh:
+                lines: list[str] = []
+                bytes_read = 0
+                collected = 0
+                truncated = False
+                for line_no, line in enumerate(fh, start=1):
+                    if line_no < offset:
+                        continue
+                    if limit and collected >= limit:
+                        break
+                    encoded = line.encode("utf-8")
+                    if bytes_read + len(encoded) > self.config.max_text_bytes:
+                        truncated = True
+                        break
+                    lines.append(line)
+                    bytes_read += len(encoded)
+                    collected += 1
+        except UnicodeDecodeError:
+            return f"error: file is not valid UTF-8 text: {path}"
+        except OSError as exc:
+            return f"error: failed to read {path}: {exc}"
+
+        text = numbered_text(lines, offset)
+        if truncated:
+            text += (
+                f"\n<output truncated at {bytes_read} bytes; "
+                f"read again with offset={offset + collected} to continue>"
+            )
+        return text
+
+
+def numbered_text(lines: list[str], start: int) -> str:
+    if not lines:
+        return ""
+    last = start + len(lines) - 1
+    width = max(4, len(str(last)))
+    rendered: list[str] = []
+    for index, line in enumerate(lines):
+        body = line[:-1] if line.endswith("\n") else line
+        rendered.append(f"{start + index:>{width}}|{body}")
+    text = "\n".join(rendered)
+    if lines[-1].endswith("\n"):
+        text += "\n"
+    return text

coding_agent/tools/search.py

@@ -0,0 +1,433 @@
+"""Unified search for file names and text content."""
+
+from __future__ import annotations
+
+import fnmatch
+import re
+import shutil
+import subprocess
+from functools import lru_cache
+from pathlib import Path
+from typing import Optional
+
+from pydantic import Field
+
+from coding_agent.config import SearchConfig
+from coding_agent.tools.base import ToolArgsModel, WorkspaceTool
+
+DEFAULT_SKIP_DIRS = {
+    ".git",
+    ".hg",
+    ".svn",
+    ".venv",
+    "venv",
+    "node_modules",
+    "__pycache__",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    "dist",
+    "build",
+    ".tox",
+}
+
+Rule = tuple[re.Pattern, bool, bool]  # (regex, dir_only, negated)
+
+
+def glob_to_regex(pattern: str) -> str:
+    """Convert a gitignore-style glob into a regex fragment.
+
+    ``*`` matches within a path segment, ``**`` crosses segments, and
+    ``?`` matches one non-slash character.
+    """
+    i = 0
+    n = len(pattern)
+    out: list[str] = []
+    while i < n:
+        c = pattern[i]
+        if c == "*":
+            if i + 1 < n and pattern[i + 1] == "*":
+                out.append(".*")
+                i += 2
+            else:
+                out.append("[^/]*")
+                i += 1
+        elif c == "?":
+            out.append("[^/]")
+            i += 1
+        else:
+            out.append(re.escape(c))
+            i += 1
+    return "".join(out)
+
+
+def parse_line(line: str) -> Rule | None:
+    """Parse one gitignore line into a rule, or None to skip it.
+
+    Supports the common subset: blank lines, ``#`` comments, ``!``
+    negation, trailing ``/`` for directory-only rules, and ``/``-anchored
+    patterns. Last matching rule wins.
+    """
+    line = line.strip()
+    if not line or line.startswith("#"):
+        return None
+    negated = False
+    if line.startswith("!"):
+        negated = True
+        line = line[1:].strip()
+    if not line:
+        return None
+    dir_only = line.endswith("/")
+    if dir_only:
+        line = line.rstrip("/")
+    anchored = line.startswith("/")
+    line = line.lstrip("/")
+    if anchored or "/" in line:
+        regex = re.compile(glob_to_regex(line))
+    else:
+        regex = re.compile(r"(?:.*/)?" + glob_to_regex(line))
+    return regex, dir_only, negated
+
+
+def is_matched(rules: tuple[Rule, ...], rel_path: str, is_dir: bool) -> bool | None:
+    """Last matching rule's ignore status, or None if no rule matched."""
+    result = None
+    for regex, dir_only, negated in rules:
+        if dir_only and not is_dir:
+            continue
+        if regex.fullmatch(rel_path):
+            result = not negated
+    return result
+
+
+def rel_ignored(rules: tuple[Rule, ...], rel_path: str) -> bool:
+    """Whether ``rel_path`` (posix) is ignored, checking each ancestor dir."""
+    if rel_path in (".", ""):
+        return False
+    parts = rel_path.split("/")
+    ignored = False
+    for i in range(1, len(parts) + 1):
+        candidate = "/".join(parts[:i])
+        m = is_matched(rules, candidate, i < len(parts))
+        if m is True:
+            ignored = True
+        elif m is False and not ignored:
+            ignored = False
+    return ignored
+
+
+@lru_cache(maxsize=128)
+def load_rules(
+    workspace: Path,
+) -> tuple[tuple[Path, tuple[Rule, ...]], ...]:
+    """Parse every .gitignore under the workspace, keyed by its parent dir."""
+    matchers: list[tuple[Path, tuple[Rule, ...]]] = []
+    if not workspace.exists():
+        return tuple(matchers)
+    for gif in workspace.rglob(".gitignore"):
+        if any(part in DEFAULT_SKIP_DIRS for part in gif.parts):
+            continue
+        try:
+            rules = tuple(filter(None, (parse_line(line) for line in gif.read_text(encoding="utf-8").splitlines())))
+        except (OSError, UnicodeDecodeError):
+            continue
+        matchers.append((gif.parent, rules))
+    return tuple(matchers)
+
+
+def is_ignored(path: Path, workspace: Path) -> bool:
+    """Whether ``path`` is matched by a .gitignore under ``workspace``."""
+    for base, rules in load_rules(workspace):
+        if path.is_relative_to(base) and rel_ignored(rules, path.relative_to(base).as_posix()):
+            return True
+    return False
+
+
+def _display_path(path: Path, base: Path) -> str:
+    try:
+        return path.relative_to(base).as_posix()
+    except ValueError:
+        return str(path)
+
+
+DEFAULT_SEARCH_CONFIG = SearchConfig()
+
+
+def find_rg() -> Optional[str]:
+    """Path to ripgrep, or ``None`` so search falls back to the Python walker."""
+    return shutil.which("rg")
+
+
+class RgUnavailable(Exception):
+    """ripgrep could not run this query; use the Python walker instead."""
+
+
+class SearchArgs(ToolArgsModel):
+    query: str = Field(..., min_length=1, description="Text or regular expression to search for.")
+    mode: str = Field(default="content", description="Search mode: 'content' or 'files'.")
+    path: str = Field(
+        default=".",
+        description="File or directory to search. Relative paths start at the working directory.",
+    )
+    glob: str = Field(default="", description="Optional file glob, for example '*.py'.")
+    regex: bool = Field(default=False, description="Interpret query as a regular expression.")
+    case_insensitive: bool = Field(default=False, description="Match without regard to case.")
+    max_results: int = Field(default=DEFAULT_SEARCH_CONFIG.default_max_results, ge=1)
+    max_line_chars: int = Field(default=DEFAULT_SEARCH_CONFIG.default_max_line_chars, ge=1)
+
+
+def _strip_dot(path: str) -> str:
+    return path[2:] if path.startswith("./") else path
+
+
+class SearchTool(WorkspaceTool):
+    name = "search"
+    description = (
+        "Search file names or text content. Returns file paths for mode=files "
+        "and path:line:content for mode=content. Supports literal or regex queries, "
+        "path/glob scoping, case-insensitive matching, and bounded output. "
+        "Relative paths start at the working directory. Uses ripgrep when installed."
+    )
+    args_model = SearchArgs
+
+    def __init__(
+        self,
+        workspace: str | Path,
+        *,
+        config: SearchConfig = DEFAULT_SEARCH_CONFIG,
+    ) -> None:
+        self.config = config
+        super().__init__(workspace, parallel=True)
+        properties = self.parameters["properties"]
+        properties["max_results"]["default"] = config.default_max_results
+        properties["max_line_chars"]["default"] = config.default_max_line_chars
+
+    def prepare_args(self, args: dict[str, object]) -> dict[str, object]:
+        prepared = super().prepare_args(args)
+        prepared.setdefault("max_results", self.config.default_max_results)
+        prepared.setdefault("max_line_chars", self.config.default_max_line_chars)
+        return prepared
+
+    def run(
+        self,
+        query: str,
+        mode: str = "content",
+        path: str = ".",
+        glob: str = "",
+        regex: bool = False,
+        case_insensitive: bool = False,
+        max_results: int = DEFAULT_SEARCH_CONFIG.default_max_results,
+        max_line_chars: int = DEFAULT_SEARCH_CONFIG.default_max_line_chars,
+    ) -> str:
+        mode = mode.strip().lower()
+        if mode not in {"content", "files"}:
+            return "error: mode must be 'content' or 'files'"
+        try:
+            root = self.resolve_path(path)
+        except (TypeError, ValueError) as exc:
+            return f"error: {exc}"
+        if not root.exists():
+            return f"error: path not found: {path}"
+
+        flags = re.IGNORECASE if case_insensitive else 0
+        try:
+            matcher = re.compile(query if regex else re.escape(query), flags)
+        except re.error as exc:
+            return f"error: invalid regex: {exc}"
+
+        limit = max(1, max_results)
+        line_cap = max(1, max_line_chars)
+        base = root if root.is_dir() else root.parent
+
+        rg = find_rg() if root.is_dir() else None
+        if rg is not None:
+            try:
+                results = self._rg_search(
+                    rg, root, mode=mode, query=query, glob=glob, regex=regex,
+                    case_insensitive=case_insensitive, matcher=matcher,
+                    limit=limit, line_cap=line_cap,
+                )
+            except RgUnavailable:
+                results = self._python_search(root, base, mode, glob, matcher, limit, line_cap)
+        else:
+            results = self._python_search(root, base, mode, glob, matcher, limit, line_cap)
+
+        if not results:
+            return f"no {mode} matches for {query!r}"
+        suffix = " (capped)" if len(results) >= limit else ""
+        return f"{len(results)} {mode} matches{suffix}\n" + "\n".join(results)
+
+    def _rg_search(
+        self,
+        rg: str,
+        root: Path,
+        *,
+        mode: str,
+        query: str,
+        glob: str,
+        regex: bool,
+        case_insensitive: bool,
+        matcher: re.Pattern,
+        limit: int,
+        line_cap: int,
+    ) -> list[str]:
+        """Search ``root`` (a directory) with ripgrep. Output matches the Python walker.
+
+        ripgrep already skips hidden files, binary files, and gitignored paths;
+        ``--no-require-git`` applies .gitignore outside a git checkout too, and
+        the default skip directories are excluded explicitly.
+        """
+        command = [rg, "--color=never", "--sort=path", "--no-require-git", "--no-messages"]
+        for name in sorted(DEFAULT_SKIP_DIRS):
+            command += ["--glob", f"!{name}/"]
+        if glob:
+            command += ["--glob", glob]
+        if mode == "files":
+            command.append("--files")
+        else:
+            command += ["--line-number", "--with-filename", "--no-heading", "--null"]
+            if case_insensitive:
+                command.append("--ignore-case")
+            if not regex:
+                command.append("--fixed-strings")
+            command += ["--regexp", query]
+        command.append(".")
+
+        results: list[str] = []
+        try:
+            process = subprocess.Popen(
+                command, cwd=root, stdin=subprocess.DEVNULL,
+                stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+            )
+        except OSError as exc:
+            raise RgUnavailable(str(exc)) from exc
+        if process.stdout is None:
+            process.kill()
+            process.wait()
+            raise RgUnavailable("rg produced no output stream")
+        capped = False
+        try:
+            for raw in process.stdout:
+                line = raw.decode("utf-8", errors="replace").rstrip("\r\n")
+                if mode == "files":
+                    relative = _strip_dot(line)
+                    if not matcher.search(relative):
+                        continue
+                    results.append(relative)
+                else:
+                    path, sep, rest = line.partition("\0")
+                    line_no, sep2, content = rest.partition(":")
+                    if not sep or not sep2 or not line_no.isdigit():
+                        continue
+                    content = content.rstrip()
+                    if len(content) > line_cap:
+                        content = content[:line_cap] + "…"
+                    results.append(f"{_strip_dot(path)}:{line_no}:{content}")
+                if len(results) >= limit:
+                    capped = True
+                    break
+        finally:
+            if capped:
+                process.kill()
+            process.stdout.close()
+            code = process.wait()
+        # 0 = matches, 1 = no matches. Anything else (e.g. a regex ripgrep
+        # does not support) falls back to Python's re semantics.
+        if not capped and code not in (0, 1):
+            raise RgUnavailable(f"rg exited with {code}")
+        return results
+
+    def _python_search(
+        self,
+        root: Path,
+        base: Path,
+        mode: str,
+        glob: str,
+        matcher: re.Pattern,
+        limit: int,
+        line_cap: int,
+    ) -> list[str]:
+        results: list[str] = []
+        if mode == "files":
+            for file_path in self._iter_files(root, glob, base):
+                relative = _display_path(file_path, base)
+                if matcher.search(relative):
+                    results.append(relative)
+                    if len(results) >= limit:
+                        break
+        else:
+            for file_path in self._iter_files(root, glob, base):
+                relative = _display_path(file_path, base)
+                for line_no, line in self._iter_text_lines(file_path):
+                    if not matcher.search(line):
+                        continue
+                    content = line.rstrip()
+                    if len(content) > line_cap:
+                        content = content[:line_cap] + "…"
+                    results.append(f"{relative}:{line_no}:{content}")
+                    if len(results) >= limit:
+                        break
+                if len(results) >= limit:
+                    break
+        return results
+
+    def _iter_files(self, root: Path, glob_pattern: str, base: Path):
+        if root.is_file():
+            yield from self._yield_file(root, glob_pattern, base)
+            return
+        # Depth-first in path order, the same order as ``rg --sort=path``.
+        try:
+            children = sorted(root.iterdir(), key=lambda path: path.name)
+        except OSError:
+            return
+        for child in children:
+            if child.is_dir():
+                if self._searchable_dir(child, base):
+                    yield from self._iter_files(child, glob_pattern, base)
+                continue
+            yield from self._yield_file(child, glob_pattern, base)
+
+    def _yield_file(self, candidate: Path, glob_pattern: str, base: Path):
+        if not candidate.is_file() or not self._searchable(candidate, base):
+            return
+        relative = _display_path(candidate, base)
+        if glob_pattern and not (
+            fnmatch.fnmatch(candidate.name, glob_pattern)
+            or fnmatch.fnmatch(relative, glob_pattern)
+        ):
+            return
+        yield candidate
+
+    def _relative_parts(self, path: Path, base: Path) -> tuple[str, ...]:
+        try:
+            return path.relative_to(base).parts
+        except ValueError:
+            return path.parts
+
+    def _searchable_dir(self, path: Path, base: Path) -> bool:
+        relative_parts = self._relative_parts(path, base)
+        if any(part in DEFAULT_SKIP_DIRS for part in relative_parts):
+            return False
+        if any(part.startswith(".") for part in relative_parts):
+            return False
+        return not is_ignored(path, base)
+
+    def _searchable(self, path: Path, base: Path) -> bool:
+        relative_parts = self._relative_parts(path, base)
+        if any(part in DEFAULT_SKIP_DIRS for part in relative_parts):
+            return False
+        if any(part.startswith(".") for part in relative_parts):
+            return False
+        return not is_ignored(path, base)
+
+    def _iter_text_lines(self, path: Path):
+        try:
+            with path.open("rb") as handle:
+                sample = handle.read(self.config.binary_sniff_bytes)
+            if b"\x00" in sample:
+                return
+            text = path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            return
+        for line_no, line in enumerate(text.splitlines(), start=1):
+            yield line_no, line